refactor: add relation names to schema (#56)

packages/db/src/schema/auth.ts

@@ -81,5 +81,6 @@ export const apiKeyRelations = relations(apikey, ({ one }) => ({
   user: one(users, {
     fields: [apikey.userId],
     references: [users.id],
+    relationName: "apiKeyUser",
   }),
 }));

packages/db/src/schema/boards.ts

@@ -60,19 +60,23 @@ export const boardsRelations = relations(boards, ({ one, many }) => ({
   createdBy: one(users, {
     fields: [boards.createdBy],
     references: [users.id],
+    relationName: "boardCreatedByUser",
   }),
   lists: many(lists),
   labels: many(labels),
   deletedBy: one(users, {
     fields: [boards.deletedBy],
     references: [users.id],
+    relationName: "boardDeletedByUser",
   }),
   import: one(imports, {
     fields: [boards.importId],
     references: [imports.id],
+    relationName: "boardImport",
   }),
   workspace: one(workspaces, {
     fields: [boards.workspaceId],
     references: [workspaces.id],
+    relationName: "boardWorkspace",
   }),
 }));

packages/db/src/schema/cards.ts

@@ -61,20 +61,24 @@ export const cardsRelations = relations(cards, ({ one, many }) => ({
   createdBy: one(users, {
     fields: [cards.createdBy],
     references: [users.id],
+    relationName: "cardsCreatedByUser",
   }),
   list: one(lists, {
     fields: [cards.listId],
     references: [lists.id],
+    relationName: "cardsList",
   }),
   deletedBy: one(users, {
     fields: [cards.deletedBy],
     references: [users.id],
+    relationName: "cardsDeletedByUser",
   }),
   labels: many(cardsToLabels),
   members: many(cardToWorkspaceMembers),
   import: one(imports, {
     fields: [cards.importId],
     references: [imports.id],
+    relationName: "cardsImport",
   }),
   comments: many(comments),
   activities: many(cardActivities),
@@ -90,10 +94,15 @@ export const cardActivities = pgTable("card_activity", {
   fromIndex: integer("fromIndex"),
   toIndex: integer("toIndex"),
   fromListId: bigint("fromListId", { mode: "number" }).references(
-    () => lists.id, { onDelete: "cascade" },
+    () => lists.id,
+    { onDelete: "cascade" },
   ),
-  toListId: bigint("toListId", { mode: "number" }).references(() => lists.id, { onDelete: "cascade" }),
+  toListId: bigint("toListId", { mode: "number" }).references(() => lists.id, {
-  labelId: bigint("labelId", { mode: "number" }).references(() => labels.id, { onDelete: "cascade" }),
+    onDelete: "cascade",
+  }),
+  labelId: bigint("labelId", { mode: "number" }).references(() => labels.id, {
+    onDelete: "cascade",
+  }),
   workspaceMemberId: bigint("workspaceMemberId", {
     mode: "number",
   }).references(() => workspaceMembers.id, { onDelete: "cascade" }),
@@ -106,7 +115,8 @@ export const cardActivities = pgTable("card_activity", {
     .references(() => users.id, { onDelete: "cascade" }),
   createdAt: timestamp("createdAt").defaultNow().notNull(),
   commentId: bigint("commentId", { mode: "number" }).references(
-    () => comments.id, { onDelete: "cascade" },
+    () => comments.id,
+    { onDelete: "cascade" },
   ),
   fromComment: text("fromComment"),
   toComment: text("toComment"),
@@ -116,34 +126,42 @@ export const cardActivitiesRelations = relations(cardActivities, ({ one }) => ({
   card: one(cards, {
     fields: [cardActivities.cardId],
     references: [cards.id],
+    relationName: "cardActivitiesCard",
   }),
   fromList: one(lists, {
     fields: [cardActivities.fromListId],
     references: [lists.id],
+    relationName: "cardActivitiesFromList",
   }),
   toList: one(lists, {
     fields: [cardActivities.toListId],
     references: [lists.id],
+    relationName: "cardActivitiesToList",
   }),
   label: one(labels, {
     fields: [cardActivities.labelId],
     references: [labels.id],
+    relationName: "cardActivitiesLabel",
   }),
   workspaceMember: one(workspaceMembers, {
     fields: [cardActivities.workspaceMemberId],
     references: [workspaceMembers.id],
+    relationName: "cardActivitiesWorkspaceMember",
   }),
   user: one(users, {
     fields: [cardActivities.createdBy],
     references: [users.id],
+    relationName: "cardActivitiesUser",
   }),
   member: one(workspaceMembers, {
     fields: [cardActivities.workspaceMemberId],
     references: [workspaceMembers.id],
+    relationName: "cardActivitiesMember",
   }),
   comment: one(comments, {
     fields: [cardActivities.commentId],
     references: [comments.id],
+    relationName: "cardActivitiesComment",
   }),
 }));
 
@@ -164,10 +182,12 @@ export const cardToLabelsRelations = relations(cardsToLabels, ({ one }) => ({
   card: one(cards, {
     fields: [cardsToLabels.cardId],
     references: [cards.id],
+    relationName: "cardToLabelsCard",
   }),
   label: one(labels, {
     fields: [cardsToLabels.labelId],
     references: [labels.id],
+    relationName: "cardToLabelsLabel",
   }),
 }));
 
@@ -190,10 +210,12 @@ export const cardToWorkspaceMembersRelations = relations(
     card: one(cards, {
       fields: [cardToWorkspaceMembers.cardId],
       references: [cards.id],
+      relationName: "cardToWorkspaceMembersCard",
     }),
     member: one(workspaceMembers, {
       fields: [cardToWorkspaceMembers.workspaceMemberId],
       references: [workspaceMembers.id],
+      relationName: "cardToWorkspaceMembersMember",
     }),
   }),
 );
@@ -211,20 +233,25 @@ export const comments = pgTable("card_comments", {
   createdAt: timestamp("createdAt").defaultNow().notNull(),
   updatedAt: timestamp("updatedAt"),
   deletedAt: timestamp("deletedAt"),
-  deletedBy: uuid("deletedBy").references(() => users.id, { onDelete: "cascade" }),
+  deletedBy: uuid("deletedBy").references(() => users.id, {
+    onDelete: "cascade",
+  }),
 }).enableRLS();
 
 export const commentsRelations = relations(comments, ({ one }) => ({
   card: one(cards, {
     fields: [comments.cardId],
     references: [cards.id],
+    relationName: "commentsCard",
   }),
   createdBy: one(users, {
     fields: [comments.createdBy],
     references: [users.id],
+    relationName: "commentsCreatedByUser",
   }),
   deletedBy: one(users, {
     fields: [comments.deletedBy],
     references: [users.id],
+    relationName: "commentsDeletedByUser",
   }),
 }));

packages/db/src/schema/feedback.ts

@@ -26,5 +26,6 @@ export const feedbackRelations = relations(feedback, ({ one }) => ({
   createdBy: one(users, {
     fields: [feedback.createdBy],
     references: [users.id],
+    relationName: "feedbackCreatedByUser",
   }),
 }));

packages/db/src/schema/imports.ts

@@ -36,6 +36,7 @@ export const importsRelations = relations(imports, ({ one, many }) => ({
   createdBy: one(users, {
     fields: [imports.createdBy],
     references: [users.id],
+    relationName: "importsCreatedByUser",
   }),
   boards: many(boards),
   cards: many(cards),

packages/db/src/schema/labels.ts

@@ -35,10 +35,12 @@ export const labelsRelations = relations(labels, ({ one, many }) => ({
   createdBy: one(users, {
     fields: [labels.createdBy],
     references: [users.id],
+    relationName: "labelsCreatedByUser",
   }),
   deletedBy: one(users, {
     fields: [labels.deletedBy],
     references: [users.id],
+    relationName: "labelsDeletedByUser",
   }),
   board: one(boards, {
     fields: [labels.boardId],
@@ -48,5 +50,6 @@ export const labelsRelations = relations(labels, ({ one, many }) => ({
   import: one(imports, {
     fields: [labels.importId],
     references: [imports.id],
+    relationName: "labelsImport",
   }),
 }));

packages/db/src/schema/lists.ts

@@ -36,18 +36,22 @@ export const listsRelations = relations(lists, ({ one, many }) => ({
   createdBy: one(users, {
     fields: [lists.createdBy],
     references: [users.id],
+    relationName: "listsCreatedByUser",
   }),
   board: one(boards, {
     fields: [lists.boardId],
     references: [boards.id],
+    relationName: "listsBoard",
   }),
   cards: many(cards),
   deletedBy: one(users, {
     fields: [lists.deletedBy],
     references: [users.id],
+    relationName: "listsDeletedByUser",
   }),
   import: one(imports, {
     fields: [lists.importId],
     references: [imports.id],
+    relationName: "listsImport",
   }),
 }));

packages/db/src/schema/users.ts

@@ -29,11 +29,31 @@ export const users = pgTable("user", {
 }).enableRLS();
 
 export const usersRelations = relations(users, ({ many }) => ({
-  boards: many(boards),
+  deletedBoards: many(boards, {
-  cards: many(cards),
+    relationName: "boardDeletedByUser",
+  }),
+  boards: many(boards, {
+    relationName: "boardCreatedByUser",
+  }),
+  deletedCards: many(cards, {
+    relationName: "cardsDeletedByUser",
+  }),
+  cards: many(cards, {
+    relationName: "cardsCreatedByUser",
+  }),
   imports: many(imports),
-  lists: many(lists),
+  deletedLists: many(lists, {
-  workspaces: many(workspaces),
+    relationName: "listsDeletedByUser",
+  }),
+  lists: many(lists, {
+    relationName: "listsCreatedByUser",
+  }),
+  deletedWorkspaces: many(workspaces, {
+    relationName: "workspaceDeletedByUser",
+  }),
+  workspaces: many(workspaces, {
+    relationName: "workspaceCreatedByUser",
+  }),
   apiKeys: many(apikey),
 }));
 
@@ -43,18 +63,22 @@ export const usersToWorkspacesRelations = relations(
     addedBy: one(users, {
       fields: [workspaceMembers.createdBy],
       references: [users.id],
+      relationName: "usersToWorkspacesAddedByUser",
     }),
     deletedBy: one(users, {
       fields: [workspaceMembers.deletedBy],
       references: [users.id],
+      relationName: "usersToWorkspacesDeletedByUser",
     }),
     user: one(users, {
       fields: [workspaceMembers.userId],
       references: [users.id],
+      relationName: "usersToWorkspacesUser",
     }),
     workspace: one(workspaces, {
       fields: [workspaceMembers.workspaceId],
       references: [workspaces.id],
+      relationName: "usersToWorkspacesWorkspace",
     }),
   }),
 );

packages/db/src/schema/workspaces.ts

@@ -46,7 +46,16 @@ export const workspaces = pgTable("workspace", {
 }).enableRLS();
 
 export const workspaceRelations = relations(workspaces, ({ one, many }) => ({
-  user: one(users, { fields: [workspaces.createdBy], references: [users.id] }),
+  user: one(users, {
+    fields: [workspaces.createdBy],
+    references: [users.id],
+    relationName: "workspaceCreatedByUser",
+  }),
+  deletedBy: one(users, {
+    fields: [workspaces.deletedBy],
+    references: [users.id],
+    relationName: "workspaceDeletedByUser",
+  }),
   members: many(workspaceMembers),
   boards: many(boards),
 }));
@@ -74,10 +83,12 @@ export const workspaceMembersRelations = relations(
     user: one(users, {
       fields: [workspaceMembers.userId],
       references: [users.id],
+      relationName: "workspaceMembersUser",
     }),
     workspace: one(workspaces, {
       fields: [workspaceMembers.workspaceId],
       references: [workspaces.id],
+      relationName: "workspaceMembersWorkspace",
     }),
   }),
 );