feat: delete workspace

2024-08-30 22:28:07 +01:00
parent 5c8a1c5069
commit a06500a949
19 changed files with 1647 additions and 365 deletions
--- a/src/server/db/migrations/0002_clever_robin_chapel.sql
+++ b/src/server/db/migrations/0002_clever_robin_chapel.sql
@@ -0,0 +1,66 @@
+DROP TABLE IF EXISTS "account";--> statement-breakpoint
+DROP TABLE IF EXISTS "session";--> statement-breakpoint
+DROP TABLE IF EXISTS "verificationToken";--> statement-breakpoint
+ALTER TABLE "board" DROP CONSTRAINT "board_workspaceId_workspace_id_fk";
+--> statement-breakpoint
+ALTER TABLE "_card_workspace_members" DROP CONSTRAINT "_card_workspace_members_cardId_card_id_fk";
+--> statement-breakpoint
+ALTER TABLE "card" DROP CONSTRAINT "card_listId_list_id_fk";
+--> statement-breakpoint
+ALTER TABLE "_card_labels" DROP CONSTRAINT IF EXISTS "_card_labels_cardId_card_id_fk";
+--> statement-breakpoint
+ALTER TABLE "_card_labels" DROP CONSTRAINT IF EXISTS "_card_labels_labelId_label_id_fk";
+--> statement-breakpoint
+ALTER TABLE "label" DROP CONSTRAINT "label_boardId_board_id_fk";
+--> statement-breakpoint
+ALTER TABLE "list" DROP CONSTRAINT "list_boardId_board_id_fk";
+--> statement-breakpoint
+ALTER TABLE "workspace_members" DROP CONSTRAINT "workspace_members_workspaceId_workspace_id_fk";
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "board" ADD CONSTRAINT "board_workspaceId_workspace_id_fk" FOREIGN KEY ("workspaceId") REFERENCES "workspace"("id") ON DELETE cascade ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "_card_workspace_members" ADD CONSTRAINT "_card_workspace_members_workspaceMemberId_workspace_members_id_fk" FOREIGN KEY ("workspaceMemberId") REFERENCES "workspace_members"("id") ON DELETE CASCADE ON UPDATE NO ACTION;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "card" ADD CONSTRAINT "card_listId_list_id_fk" FOREIGN KEY ("listId") REFERENCES "list"("id") ON DELETE cascade ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "_card_labels" ADD CONSTRAINT "_card_labels_cardId_card_id_fk" FOREIGN KEY ("cardId") REFERENCES "card"("id") ON DELETE CASCADE;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "_card_labels" ADD CONSTRAINT "_card_labels_labelId_label_id_fk" FOREIGN KEY ("labelId") REFERENCES "label"("id") ON DELETE CASCADE;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "label" ADD CONSTRAINT "label_boardId_board_id_fk" FOREIGN KEY ("boardId") REFERENCES "board"("id") ON DELETE cascade ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "list" ADD CONSTRAINT "list_boardId_board_id_fk" FOREIGN KEY ("boardId") REFERENCES "board"("id") ON DELETE cascade ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "workspace_members" ADD CONSTRAINT "workspace_members_workspaceId_workspace_id_fk" FOREIGN KEY ("workspaceId") REFERENCES "workspace"("id") ON DELETE cascade ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
--- a/src/server/db/migrations/meta/0002_snapshot.json
+++ b/src/server/db/migrations/meta/0002_snapshot.json
--- a/src/server/db/migrations/meta/_journal.json
+++ b/src/server/db/migrations/meta/_journal.json
@@ -15,6 +15,13 @@
      "when": 1713021051974,
      "tag": "0001_stale_mattie_franklin",
      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "5",
+      "when": 1724967733894,
+      "tag": "0002_clever_robin_chapel",
+      "breakpoints": true
    }
  ]
-}
+}
--- a/src/server/db/repository/board.repo.ts
+++ b/src/server/db/repository/board.repo.ts
@@ -144,7 +144,7 @@ export const update = async (
  return data;
 };

-export const destroy = async (
+export const softDelete = async (
  db: SupabaseClient<Database>,
  args: {
    boardId: number;
@@ -160,3 +160,12 @@ export const destroy = async (

  return result;
 };
+
+export const hardDelete = async (
+  db: SupabaseClient<Database>,
+  workspaceId: number,
+) => {
+  const result = db.from("board").delete().eq("workspaceId", workspaceId);
+
+  return result;
+};
--- a/src/server/db/repository/card.repo.ts
+++ b/src/server/db/repository/card.repo.ts
@@ -74,39 +74,6 @@ export const update = async (
  return data;
 };

-export const destroy = async (
-  db: SupabaseClient<Database>,
-  args: {
-    cardId: number;
-    deletedAt: string;
-    deletedBy: string;
-  },
-) => {
-  const result = await db
-    .from("card")
-    .update({ deletedAt: args.deletedAt, deletedBy: args.deletedBy })
-    .eq("id", args.cardId);
-
-  return result;
-};
-
-export const destroyAllByListIds = async (
-  db: SupabaseClient<Database>,
-  args: {
-    listIds: number[];
-    deletedAt: string;
-    deletedBy: string;
-  },
-) => {
-  const result = await db
-    .from("card")
-    .update({ deletedAt: args.deletedAt, deletedBy: args.deletedBy })
-    .in("listId", args.listIds)
-    .is("deletedAt", null);
-
-  return result;
-};
-
 export const getCardWithListByPublicId = async (
  db: SupabaseClient<Database>,
  cardPublicId: string,
@@ -168,28 +135,6 @@ export const bulkCreate = async (
  return data;
 };

-export const destroyCardLabelRelationship = async (
-  db: SupabaseClient<Database>,
-  args: { cardId: number; labelId: number },
-) => {
-  const result = await db
-    .from("_card_labels")
-    .delete()
-    .eq("cardId", args.cardId)
-    .eq("labelId", args.labelId);
-
-  return result;
-};
-
-export const destroyAllCardLabelRelationships = async (
-  db: SupabaseClient<Database>,
-  labelId: number,
-) => {
-  const result = await db.from("_card_labels").delete().eq("labelId", labelId);
-
-  return result;
-};
-
 export const createCardLabelRelationship = async (
  db: SupabaseClient<Database>,
  cardLabelRelationshipInput: { cardId: number; labelId: number },
@@ -217,19 +162,6 @@ export const getCardMemberRelationship = async (
  return data;
 };

-export const destroyCardMemberRelationship = async (
-  db: SupabaseClient<Database>,
-  args: { cardId: number; memberId: number },
-) => {
-  const result = await db
-    .from("_card_workspace_members")
-    .delete()
-    .eq("cardId", args.cardId)
-    .eq("workspaceMemberId", args.memberId);
-
-  return result;
-};
-
 export const createCardMemberRelationship = async (
  db: SupabaseClient<Database>,
  cardMemberRelationshipInput: { cardId: number; memberId: number },
@@ -353,3 +285,71 @@ export const pushIndex = async (

  return data;
 };
+
+export const softDelete = async (
+  db: SupabaseClient<Database>,
+  args: {
+    cardId: number;
+    deletedAt: string;
+    deletedBy: string;
+  },
+) => {
+  const result = await db
+    .from("card")
+    .update({ deletedAt: args.deletedAt, deletedBy: args.deletedBy })
+    .eq("id", args.cardId);
+
+  return result;
+};
+
+export const softDeleteAllByListIds = async (
+  db: SupabaseClient<Database>,
+  args: {
+    listIds: number[];
+    deletedAt: string;
+    deletedBy: string;
+  },
+) => {
+  const result = await db
+    .from("card")
+    .update({ deletedAt: args.deletedAt, deletedBy: args.deletedBy })
+    .in("listId", args.listIds)
+    .is("deletedAt", null);
+
+  return result;
+};
+
+export const hardDeleteCardMemberRelationship = async (
+  db: SupabaseClient<Database>,
+  args: { cardId: number; memberId: number },
+) => {
+  const result = await db
+    .from("_card_workspace_members")
+    .delete()
+    .eq("cardId", args.cardId)
+    .eq("workspaceMemberId", args.memberId);
+
+  return result;
+};
+
+export const hardDeleteCardLabelRelationship = async (
+  db: SupabaseClient<Database>,
+  args: { cardId: number; labelId: number },
+) => {
+  const result = await db
+    .from("_card_labels")
+    .delete()
+    .eq("cardId", args.cardId)
+    .eq("labelId", args.labelId);
+
+  return result;
+};
+
+export const hardDeleteAllCardLabelRelationships = async (
+  db: SupabaseClient<Database>,
+  labelId: number,
+) => {
+  const result = await db.from("_card_labels").delete().eq("labelId", labelId);
+
+  return result;
+};
--- a/src/server/db/repository/label.repo.ts
+++ b/src/server/db/repository/label.repo.ts
@@ -79,7 +79,7 @@ export const update = async (
  return data;
 };

-export const destroy = async (
+export const hardDelete = async (
  db: SupabaseClient<Database>,
  labelId: number,
 ) => {
--- a/src/server/db/repository/list.repo.ts
+++ b/src/server/db/repository/list.repo.ts
@@ -85,40 +85,6 @@ export const update = async (
  return data;
 };

-export const destroyAllByBoardId = async (
-  db: SupabaseClient<Database>,
-  args: {
-    boardId: number;
-    deletedAt: string;
-    deletedBy: string;
-  },
-) => {
-  const result = await db
-    .from("list")
-    .update({ deletedAt: args.deletedAt, deletedBy: args.deletedBy })
-    .eq("boardId", args.boardId)
-    .is("deletedAt", null);
-
-  return result;
-};
-
-export const destroyById = async (
-  db: SupabaseClient<Database>,
-  args: {
-    listId: number;
-    deletedAt: string;
-    deletedBy: string;
-  },
-) => {
-  const result = await db
-    .from("list")
-    .update({ deletedAt: args.deletedAt, deletedBy: args.deletedBy })
-    .eq("id", args.listId)
-    .is("deletedAt", null);
-
-  return result;
-};
-
 export const reorder = async (
  db: SupabaseClient<Database>,
  args: {
@@ -152,3 +118,37 @@ export const shiftIndex = async (

  return data;
 };
+
+export const softDeleteAllByBoardId = async (
+  db: SupabaseClient<Database>,
+  args: {
+    boardId: number;
+    deletedAt: string;
+    deletedBy: string;
+  },
+) => {
+  const result = await db
+    .from("list")
+    .update({ deletedAt: args.deletedAt, deletedBy: args.deletedBy })
+    .eq("boardId", args.boardId)
+    .is("deletedAt", null);
+
+  return result;
+};
+
+export const softDeleteById = async (
+  db: SupabaseClient<Database>,
+  args: {
+    listId: number;
+    deletedAt: string;
+    deletedBy: string;
+  },
+) => {
+  const result = await db
+    .from("list")
+    .update({ deletedAt: args.deletedAt, deletedBy: args.deletedBy })
+    .eq("id", args.listId)
+    .is("deletedAt", null);
+
+  return result;
+};
--- a/src/server/db/repository/workspace.repo.ts
+++ b/src/server/db/repository/workspace.repo.ts
@@ -127,3 +127,15 @@ export const getAllMembersByPublicIds = async (

  return data;
 };
+
+export const hardDelete = async (
+  db: SupabaseClient<Database>,
+  workspacePublicId: string,
+) => {
+  const result = db
+    .from("workspace")
+    .delete()
+    .eq("publicId", workspacePublicId);
+
+  return result;
+};
--- a/src/server/db/schema.ts
+++ b/src/server/db/schema.ts
@@ -12,217 +12,237 @@ import {
  bigint,
 } from "drizzle-orm/pg-core";

-export const importSourceEnum = pgEnum('source', ['trello']);
-export const importStatusEnum = pgEnum('status', ['started', 'success', 'failed']);
-export const memberRoleEnum = pgEnum('role', ['admin', 'member', 'guest']);
+export const importSourceEnum = pgEnum("source", ["trello"]);
+export const importStatusEnum = pgEnum("status", [
+  "started",
+  "success",
+  "failed",
+]);
+export const memberRoleEnum = pgEnum("role", ["admin", "member", "guest"]);

-export const boards = pgTable(
-  "board",
-  {
-    id: bigserial("id", { mode: "number" }).primaryKey(),
-    publicId: varchar("publicId", { length: 12 }).notNull().unique(),
-    name: varchar("name", { length: 255 }).notNull(),
-    createdBy: uuid("createdBy").notNull().references(() => users.id),
-    createdAt: timestamp("createdAt").defaultNow().notNull(),
-    updatedAt: timestamp("updatedAt"),
-    deletedAt: timestamp("deletedAt"),
-    deletedBy: uuid("deletedBy").references(() => users.id),
-    importId: bigint("importId", { mode: "number" }).references(() => imports.id),
-    workspaceId: bigint("workspaceId", { mode: "number" }).notNull().references(() => workspaces.id),
-  },
-);
+export const boards = pgTable("board", {
+  id: bigserial("id", { mode: "number" }).primaryKey(),
+  publicId: varchar("publicId", { length: 12 }).notNull().unique(),
+  name: varchar("name", { length: 255 }).notNull(),
+  createdBy: uuid("createdBy")
+    .notNull()
+    .references(() => users.id),
+  createdAt: timestamp("createdAt").defaultNow().notNull(),
+  updatedAt: timestamp("updatedAt"),
+  deletedAt: timestamp("deletedAt"),
+  deletedBy: uuid("deletedBy").references(() => users.id),
+  importId: bigint("importId", { mode: "number" }).references(() => imports.id),
+  workspaceId: bigint("workspaceId", { mode: "number" })
+    .notNull()
+    .references(() => workspaces.id, { onDelete: "cascade" }),
+});

 export const boardsRelations = relations(boards, ({ one, many }) => ({
-	createdBy: one(users, {
-		fields: [boards.createdBy],
-		references: [users.id],
-	}),
+  createdBy: one(users, {
+    fields: [boards.createdBy],
+    references: [users.id],
+  }),
  lists: many(lists),
  labels: many(labels),
  deletedBy: one(users, {
-		fields: [boards.deletedBy],
-		references: [users.id],
-	}),
+    fields: [boards.deletedBy],
+    references: [users.id],
+  }),
  import: one(imports, {
-		fields: [boards.importId],
-		references: [imports.id],
-	}),
+    fields: [boards.importId],
+    references: [imports.id],
+  }),
  workspace: one(workspaces, {
-		fields: [boards.workspaceId],
-		references: [workspaces.id],
-	}),
+    fields: [boards.workspaceId],
+    references: [workspaces.id],
+  }),
 }));

-export const imports = pgTable(
-  "import",
-  {
-    id: bigserial("id", { mode: "number" }).primaryKey(),
-    publicId: varchar("publicId", { length: 12 }).notNull().unique(),
-    source: importSourceEnum('source').notNull(),
-    status: importStatusEnum('status').notNull(),
-    createdBy: uuid("createdBy").notNull().references(() => users.id),
-    createdAt: timestamp("createdAt").defaultNow().notNull(),
-  },
-);
+export const imports = pgTable("import", {
+  id: bigserial("id", { mode: "number" }).primaryKey(),
+  publicId: varchar("publicId", { length: 12 }).notNull().unique(),
+  source: importSourceEnum("source").notNull(),
+  status: importStatusEnum("status").notNull(),
+  createdBy: uuid("createdBy")
+    .notNull()
+    .references(() => users.id),
+  createdAt: timestamp("createdAt").defaultNow().notNull(),
+});

 export const importsRelations = relations(imports, ({ one, many }) => ({
-	createdBy: one(users, {
-		fields: [imports.createdBy],
-		references: [users.id],
-	}),
+  createdBy: one(users, {
+    fields: [imports.createdBy],
+    references: [users.id],
+  }),
  boards: many(boards),
  cards: many(cards),
  lists: many(lists),
-  labels: many(labels)
+  labels: many(labels),
 }));

-export const labels = pgTable(
-  "label",
-  {
-    id: bigserial("id", { mode: "number" }).primaryKey(),
-    publicId: varchar("publicId", { length: 12 }).notNull().unique(),
-    name: varchar("name", { length: 255 }).notNull(),
-    colourCode: varchar("colourCode", { length: 12 }),
-    createdBy: uuid("createdBy").notNull().references(() => users.id),
-    createdAt: timestamp("createdAt").defaultNow().notNull(),
-    updatedAt: timestamp("updatedAt"),
-    boardId: bigint("boardId", { mode: "number" }).notNull().references(() => boards.id),
-    importId: bigint("importId", { mode: "number" }).references(() => imports.id),
-  }
-);
+export const labels = pgTable("label", {
+  id: bigserial("id", { mode: "number" }).primaryKey(),
+  publicId: varchar("publicId", { length: 12 }).notNull().unique(),
+  name: varchar("name", { length: 255 }).notNull(),
+  colourCode: varchar("colourCode", { length: 12 }),
+  createdBy: uuid("createdBy")
+    .notNull()
+    .references(() => users.id),
+  createdAt: timestamp("createdAt").defaultNow().notNull(),
+  updatedAt: timestamp("updatedAt"),
+  boardId: bigint("boardId", { mode: "number" })
+    .notNull()
+    .references(() => boards.id, { onDelete: "cascade" }),
+  importId: bigint("importId", { mode: "number" }).references(() => imports.id),
+});

 export const labelsRelations = relations(labels, ({ one, many }) => ({
-	createdBy: one(users, {
-		fields: [labels.createdBy],
-		references: [users.id],
-	}),
+  createdBy: one(users, {
+    fields: [labels.createdBy],
+    references: [users.id],
+  }),
  board: one(boards, {
-		fields: [labels.boardId],
-		references: [boards.id],
-	}),
+    fields: [labels.boardId],
+    references: [boards.id],
+  }),
  cards: many(cardsToLabels),
  import: one(imports, {
-		fields: [labels.importId],
-		references: [imports.id],
-	}),
+    fields: [labels.importId],
+    references: [imports.id],
+  }),
 }));

 export const cardsToLabels = pgTable(
  "_card_labels",
  {
-    cardId: bigint("cardId", { mode: "number" }).notNull().references(() => cards.id),
-    labelId: bigint("labelId", { mode: "number" }).notNull().references(() => labels.id),
-  }, (t) => ({
+    cardId: bigint("cardId", { mode: "number" })
+      .notNull()
+      .references(() => cards.id),
+    labelId: bigint("labelId", { mode: "number" })
+      .notNull()
+      .references(() => labels.id, { onDelete: "cascade" }),
+  },
+  (t) => ({
    pk: primaryKey(t.cardId, t.labelId),
  }),
 );

 export const cardToLabelsRelations = relations(cardsToLabels, ({ one }) => ({
-	card: one(cards, {
-		fields: [cardsToLabels.cardId],
-		references: [cards.id],
-	}),
+  card: one(cards, {
+    fields: [cardsToLabels.cardId],
+    references: [cards.id],
+  }),
  label: one(labels, {
-		fields: [cardsToLabels.labelId],
-		references: [labels.id],
-	}),
+    fields: [cardsToLabels.labelId],
+    references: [labels.id],
+  }),
 }));

 export const cardToWorkspaceMembers = pgTable(
  "_card_workspace_members",
  {
-    cardId: bigint("cardId", { mode: "number" }).notNull().references(() => cards.id),
-    workspaceMemberId: bigint("workspaceMemberId", { mode: "number" }).notNull().references(() => workspaceMembers.id),
-  }, (t) => ({
+    cardId: bigint("cardId", { mode: "number" })
+      .notNull()
+      .references(() => cards.id),
+    workspaceMemberId: bigint("workspaceMemberId", { mode: "number" })
+      .notNull()
+      .references(() => workspaceMembers.id, { onDelete: "cascade" }),
+  },
+  (t) => ({
    pk: primaryKey(t.cardId, t.workspaceMemberId),
  }),
 );

-export const cardToWorkspaceMembersRelations = relations(cardToWorkspaceMembers, ({ one }) => ({
-	card: one(cards, {
-		fields: [cardToWorkspaceMembers.cardId],
-		references: [cards.id],
-	}),
-  member: one(workspaceMembers, {
-		fields: [cardToWorkspaceMembers.workspaceMemberId],
-		references: [workspaceMembers.id],
-	}),
-}));
-
-export const lists = pgTable(
-  "list",
-  {
-    id: bigserial("id", { mode: "number" }).primaryKey(),
-    publicId: varchar("publicId", { length: 12 }).notNull().unique(),
-    name: varchar("name", { length: 255 }).notNull(),
-    index: integer("index").notNull(),
-    createdBy: uuid("createdBy").notNull().references(() => users.id),
-    createdAt: timestamp("createdAt").defaultNow().notNull(),
-    updatedAt: timestamp("updatedAt"),
-    deletedAt: timestamp("deletedAt"),
-    deletedBy: uuid("deletedBy").references(() => users.id),
-    boardId: bigint("boardId", { mode: "number" }).notNull().references(() => boards.id),
-    importId: bigint("importId", { mode: "number" }).references(() => imports.id),
-  }
+export const cardToWorkspaceMembersRelations = relations(
+  cardToWorkspaceMembers,
+  ({ one }) => ({
+    card: one(cards, {
+      fields: [cardToWorkspaceMembers.cardId],
+      references: [cards.id],
+    }),
+    member: one(workspaceMembers, {
+      fields: [cardToWorkspaceMembers.workspaceMemberId],
+      references: [workspaceMembers.id],
+    }),
+  }),
 );

+export const lists = pgTable("list", {
+  id: bigserial("id", { mode: "number" }).primaryKey(),
+  publicId: varchar("publicId", { length: 12 }).notNull().unique(),
+  name: varchar("name", { length: 255 }).notNull(),
+  index: integer("index").notNull(),
+  createdBy: uuid("createdBy")
+    .notNull()
+    .references(() => users.id),
+  createdAt: timestamp("createdAt").defaultNow().notNull(),
+  updatedAt: timestamp("updatedAt"),
+  deletedAt: timestamp("deletedAt"),
+  deletedBy: uuid("deletedBy").references(() => users.id),
+  boardId: bigint("boardId", { mode: "number" })
+    .notNull()
+    .references(() => boards.id, { onDelete: "cascade" }),
+  importId: bigint("importId", { mode: "number" }).references(() => imports.id),
+});
+
 export const listsRelations = relations(lists, ({ one, many }) => ({
-	createdBy: one(users, {
-		fields: [lists.createdBy],
-		references: [users.id],
-	}),
+  createdBy: one(users, {
+    fields: [lists.createdBy],
+    references: [users.id],
+  }),
  board: one(boards, {
-		fields: [lists.boardId],
-		references: [boards.id],
-	}),
+    fields: [lists.boardId],
+    references: [boards.id],
+  }),
  cards: many(cards),
  deletedBy: one(users, {
-		fields: [lists.deletedBy],
-		references: [users.id],
-	}),
+    fields: [lists.deletedBy],
+    references: [users.id],
+  }),
  import: one(imports, {
-		fields: [lists.importId],
-		references: [imports.id],
-	}),
+    fields: [lists.importId],
+    references: [imports.id],
+  }),
 }));

-export const cards = pgTable(
-  "card",
-  {
-    id: bigserial("id", { mode: "number" }).primaryKey(),
-    publicId: varchar("publicId", { length: 12 }).notNull().unique(),
-    title: varchar("title", { length: 255 }).notNull(),
-    description: text("description"),
-    index: integer("index").notNull(),
-    createdBy: uuid("createdBy").notNull().references(() => users.id),
-    createdAt: timestamp("createdAt").defaultNow().notNull(),
-    updatedAt: timestamp("updatedAt"),
-    deletedAt: timestamp("deletedAt"),
-    deletedBy: uuid("deletedBy").references(() => users.id),
-    listId: bigint("listId", { mode: "number" }).notNull().references(() => lists.id),
-    importId: bigint("importId", { mode: "number" }).references(() => imports.id),
-  }
-);
+export const cards = pgTable("card", {
+  id: bigserial("id", { mode: "number" }).primaryKey(),
+  publicId: varchar("publicId", { length: 12 }).notNull().unique(),
+  title: varchar("title", { length: 255 }).notNull(),
+  description: text("description"),
+  index: integer("index").notNull(),
+  createdBy: uuid("createdBy")
+    .notNull()
+    .references(() => users.id),
+  createdAt: timestamp("createdAt").defaultNow().notNull(),
+  updatedAt: timestamp("updatedAt"),
+  deletedAt: timestamp("deletedAt"),
+  deletedBy: uuid("deletedBy").references(() => users.id),
+  listId: bigint("listId", { mode: "number" })
+    .notNull()
+    .references(() => lists.id, { onDelete: "cascade" }),
+  importId: bigint("importId", { mode: "number" }).references(() => imports.id),
+});

 export const cardsRelations = relations(cards, ({ one, many }) => ({
-	createdBy: one(users, {
-		fields: [cards.createdBy],
-		references: [users.id],
-	}),
+  createdBy: one(users, {
+    fields: [cards.createdBy],
+    references: [users.id],
+  }),
  list: one(lists, {
-		fields: [cards.listId],
-		references: [lists.id],
-	}),
+    fields: [cards.listId],
+    references: [lists.id],
+  }),
  deletedBy: one(users, {
-		fields: [cards.deletedBy],
-		references: [users.id],
-	}),
+    fields: [cards.deletedBy],
+    references: [users.id],
+  }),
  labels: many(cardsToLabels),
  members: many(cardToWorkspaceMembers),
  import: one(imports, {
-		fields: [cards.importId],
-		references: [imports.id],
-	}),
+    fields: [cards.importId],
+    references: [imports.id],
+  }),
 }));

 export const users = pgTable("user", {
@@ -241,51 +261,55 @@ export const usersRelations = relations(users, ({ many }) => ({
  workspaces: many(workspaces),
 }));

-export const workspaces = pgTable(
-  "workspace",
-  {
-    id: bigserial("id", { mode: "number" }).primaryKey(),
-    publicId: varchar("publicId", { length: 12 }).notNull().unique(),
-    name: varchar("name", { length: 255 }).notNull(),
-    slug: varchar("slug", { length: 255 }).notNull().unique(),  
-    createdBy: uuid("createdBy").notNull().references(() => users.id),
-    createdAt: timestamp("createdAt").defaultNow().notNull(),
-    updatedAt: timestamp("updatedAt"),
-    deletedAt: timestamp("deletedAt"),
-    deletedBy: uuid("deletedBy").references(() => users.id),
-  }
-);
+export const workspaces = pgTable("workspace", {
+  id: bigserial("id", { mode: "number" }).primaryKey(),
+  publicId: varchar("publicId", { length: 12 }).notNull().unique(),
+  name: varchar("name", { length: 255 }).notNull(),
+  slug: varchar("slug", { length: 255 }).notNull().unique(),
+  createdBy: uuid("createdBy")
+    .notNull()
+    .references(() => users.id),
+  createdAt: timestamp("createdAt").defaultNow().notNull(),
+  updatedAt: timestamp("updatedAt"),
+  deletedAt: timestamp("deletedAt"),
+  deletedBy: uuid("deletedBy").references(() => users.id),
+});

 export const workspaceRelations = relations(workspaces, ({ one, many }) => ({
  user: one(users, { fields: [workspaces.createdBy], references: [users.id] }),
-  members: many(workspaceMembers)
+  members: many(workspaceMembers),
 }));

-export const workspaceMembers = pgTable(
-  "workspace_members",
-  {
-    id: bigserial("id", { mode: "number" }).primaryKey(),
-    publicId: varchar("publicId", { length: 12 }).notNull().unique(),
-    userId: uuid("userId").notNull().references(() => users.id),
-    workspaceId: bigint("workspaceId", { mode: "number" }).notNull().references(() => workspaces.id),
-    createdBy: uuid("createdBy").notNull(),
-    createdAt: timestamp("createdAt").defaultNow().notNull(),
-    updatedAt: timestamp("updatedAt"),
-    deletedAt: timestamp("deletedAt"),
-    role: memberRoleEnum('role').notNull(),
-  },
+export const workspaceMembers = pgTable("workspace_members", {
+  id: bigserial("id", { mode: "number" }).primaryKey(),
+  publicId: varchar("publicId", { length: 12 }).notNull().unique(),
+  userId: uuid("userId")
+    .notNull()
+    .references(() => users.id),
+  workspaceId: bigint("workspaceId", { mode: "number" })
+    .notNull()
+    .references(() => workspaces.id, { onDelete: "cascade" }),
+  createdBy: uuid("createdBy").notNull(),
+  createdAt: timestamp("createdAt").defaultNow().notNull(),
+  updatedAt: timestamp("updatedAt"),
+  deletedAt: timestamp("deletedAt"),
+  role: memberRoleEnum("role").notNull(),
+});
+
+export const usersToWorkspacesRelations = relations(
+  workspaceMembers,
+  ({ one }) => ({
+    addedBy: one(users, {
+      fields: [workspaceMembers.createdBy],
+      references: [users.id],
+    }),
+    user: one(users, {
+      fields: [workspaceMembers.userId],
+      references: [users.id],
+    }),
+    workspace: one(workspaces, {
+      fields: [workspaceMembers.workspaceId],
+      references: [workspaces.id],
+    }),
+  }),
 );
-
-export const usersToWorkspacesRelations = relations(workspaceMembers, ({ one }) => ({
-  addedBy: one(users, { fields: [workspaceMembers.createdBy], references: [users.id] }),
-	user: one(users, {
-		fields: [workspaceMembers.userId],
-		references: [users.id],
-	}),
-  workspace: one(workspaces, {
-		fields: [workspaceMembers.workspaceId],
-		references: [workspaces.id],
-	}),
-}));
-
-