fix: swich from insertId to returning

src/server/api/routers/card.ts

@@ -48,28 +48,30 @@ export const cardRouter = createTRPCRouter({
           createdBy: userId,
           listId: list.id,
           index: latestCard ? latestCard.index + 1 : 0
-        });
+        }).returning({ id: cards.id });
 
-        if (newCard.insertId && input.labelsPublicIds.length) {
+        const newCardId = newCard[0]?.id;
+
+        if (newCardId && input.labelsPublicIds.length) {
           const labels = await tx.query.labels.findMany({
             where: inArray(cards.publicId, input.labelsPublicIds),
           });
 
           if (!labels.length) return;
 
-          const labelsInsert = labels.map((label) => ({ cardId: Number(newCard.insertId), labelId: label.id }))
+          const labelsInsert = labels.map((label) => ({ cardId: newCardId, labelId: label.id }))
 
           await tx.insert(cardsToLabels).values(labelsInsert);
         }
 
-        if (newCard.insertId && input.memberPublicIds.length) {
+        if (newCardId && input.memberPublicIds.length) {
           const members = await tx.query.workspaceMembers.findMany({
             where: inArray(workspaceMembers.publicId, input.memberPublicIds),
           });
 
           if (!members.length) return;
 
-          const membersInsert = members.map((member) => ({ cardId: Number(newCard.insertId), workspaceMemberId: member.id}))
+          const membersInsert = members.map((member) => ({ cardId: newCardId, workspaceMemberId: member.id}))
 
           await tx.insert(cardToWorkspaceMembers).values(membersInsert);
         }

src/server/api/routers/import.ts

@@ -94,7 +94,9 @@ export const importRouter = createTRPCRouter({
           source: 'trello',
           createdBy: userId,
           status: 'started'
-        })
+        }).returning({ id: imports.id });
+
+        const newImportId = newImport[0]?.id;
 
         let boardsCreated = 0;
 
@@ -126,11 +128,13 @@ export const importRouter = createTRPCRouter({
               publicId: generateUID(),
               name: data.name,
               createdBy: userId,
-              importId: newImport.insertId,
+              importId: newImportId,
               workspaceId: workspace.id
-            });
+            }).returning({ id: boards.id });
 
-            if (!newBoard?.insertId) return;
+            const newBoardId = newBoard[0]?.id
+
+            if (!newBoardId) return;
 
             let listIndex = 0;
 
@@ -139,20 +143,22 @@ export const importRouter = createTRPCRouter({
                 publicId: generateUID(),
                 name: list.name,
                 createdBy: userId,
-                boardId: Number(newBoard.insertId),
+                boardId: newBoardId,
                 index: listIndex,
-                importId: newImport.insertId
-              });
+                importId: newImportId
+              }).returning({ id: lists.id });
 
-              if (list.cards.length) {
+              const newListId = newList[0]?.id
+
+              if (list.cards.length && newListId) {
                 const cardsInsert = list.cards.map((card, index) => ({ 
                   publicId: generateUID(),
                   title: card.name,
                   description: card.description,
                   createdBy: userId,
-                  listId: Number(newList.insertId),
+                  listId: newListId,
                   index,
-                  importId: newImport.insertId
+                  importId: newImportId
                 }))
 
                 await tx.insert(cards).values(cardsInsert);
@@ -165,10 +171,10 @@ export const importRouter = createTRPCRouter({
           boardsCreated ++
         }
 
-        if (boardsCreated > 0) {
+        if (boardsCreated > 0 && newImportId) {
           await ctx.db.update(imports)
             .set({ status: 'success' })
-            .where(eq(imports.id, Number(newImport.insertId)))
+            .where(eq(imports.id, newImportId))
         }
 
         return { boardsCreated }

src/server/api/routers/label.ts

@@ -43,11 +43,15 @@ export const labelRouter = createTRPCRouter({
           colourCode: input.colourCode,
           createdBy: userId,
           boardId: card.list.boardId,
-        });
+        }).returning({ id: labels.id });
+
+        const newLabelId = newLabel[0]?.id
+
+        if (!newLabelId) return;
 
         return tx.insert(cardsToLabels).values({
           cardId: card.id,
-          labelId: Number(newLabel.insertId),
+          labelId: newLabelId,
         });
       })
     }),

src/server/api/routers/workspace.ts

@@ -79,18 +79,22 @@ export const workspaceRouter = createTRPCRouter({
         name: input.name,
         slug: input.name.toLowerCase(),
         createdBy: userId,
-      });
+      }).returning({ id: workspaces.id });
+
+      const workspaceId = workspace[0]?.id;
+
+      if (!workspaceId) return;
 
       await ctx.db.insert(workspaceMembers).values({
         publicId: generateUID(),
         userId,
-        workspaceId: Number(workspace.insertId),
+        workspaceId: workspaceId,
         createdBy: userId,
         role: 'admin'
       })
 
       return ctx.db.query.workspaces.findFirst({
-        where: eq(workspaces.id, Number(workspace.insertId)),
+        where: eq(workspaces.id, workspaceId),
         columns: {
           publicId: true,
           name: true,