feat: switch card router to use supabase

src/server/api/routers/card.ts

@@ -90,35 +90,53 @@ export const cardRouter = createTRPCRouter({
           labelPublicId: z.string().min(12),
         }),
       )
-      .mutation(({ ctx, input }) => {
+      .mutation(async ({ ctx, input }) => {
         const userId = ctx.user?.id;
 
         if (!userId) return;
 
-        return ctx.db.transaction(async (tx) => {
+        const card = await ctx.supabase
-          const card = await tx.query.cards.findFirst({
+          .from('card')
-            where: and(eq(cards.publicId, input.cardPublicId), isNull(cards.deletedAt)),
+          .select(`id`)
-          });
+          .eq('publicId', input.cardPublicId)
+          .limit(1)
+          .single();
 
-          const label = await tx.query.labels.findFirst({
+        const label = await ctx.supabase
-            where: eq(labels.publicId, input.labelPublicId),
+          .from('label')
-          });
+          .select(`id`)
+          .eq('publicId', input.labelPublicId)
+          .limit(1)
+          .single();
 
-          if (!card || !label) return;
+        if (!card.data || !label.data) return;
 
-          const labelExists = await tx.query.cardsToLabels.findFirst({
+        const existingLabel = await ctx.supabase
-            where: and(eq(cardsToLabels.cardId, card.id), eq(cardsToLabels.labelId, label.id)),
+          .from('_card_labels')
-          });
+          .select()
+          .eq('cardId', card.data.id)
+          .eq('labelId', label.data.id)
+          .limit(1)
+          .single();
 
-          if (labelExists) {
+        if (existingLabel.data) {
-            return tx.delete(cardsToLabels).where(and(eq(cardsToLabels.cardId, card.id), eq(cardsToLabels.labelId, label.id)),);
+          await ctx.supabase
+            .from('_card_labels')
+            .delete()
+            .eq('cardId', card.data.id)
+            .eq('labelId', label.data.id);
+
+          return { newLabel: false };
         }
 
-          return tx.insert(cardsToLabels).values({
+        await ctx.supabase
-            cardId: card.id,
+          .from('_card_labels')
-            labelId: label.id,
+          .insert({
+            cardId: card.data.id,
+            labelId: label.data.id,
           });
-        })
+
+        return { newLabel: true };
       }),
     addOrRemoveMember: publicProcedure
       .input(
@@ -127,130 +145,111 @@ export const cardRouter = createTRPCRouter({
           workspaceMemberPublicId: z.string().min(12),
         }),
       )
-      .mutation(({ ctx, input }) => {
+      .mutation(async ({ ctx, input }) => {
         const userId = ctx.user?.id;
 
         if (!userId) return;
 
-        return ctx.db.transaction(async (tx) => {
+        const card = await ctx.supabase
-          const card = await tx.query.cards.findFirst({
+          .from('card')
-            where: and(eq(cards.publicId, input.cardPublicId), isNull(cards.deletedAt)),
+          .select(`id`)
-          });
+          .eq('publicId', input.cardPublicId)
+          .limit(1)
+          .single();
 
-          const member = await tx.query.workspaceMembers.findFirst({
+        const member = await ctx.supabase
-            where: eq(workspaceMembers.publicId, input.workspaceMemberPublicId),
+          .from('workspace_members')
-          });
+          .select(`id`)
+          .eq('publicId', input.workspaceMemberPublicId)
+          .limit(1)
+          .single();
         
-          if (!card || !member) return;
+        if (!card.data || !member.data) return;
 
-          const memberExists = await tx.query.cardToWorkspaceMembers.findFirst({
+        const existingMember = await ctx.supabase
-            where: and(eq(cardToWorkspaceMembers.cardId, card.id), eq(cardToWorkspaceMembers.workspaceMemberId, member.id)),
+          .from('_card_workspace_members')
-          });
+          .select()
+          .eq('cardId', card.data.id)
+          .eq('workspaceMemberId', member.data.id)
+          .limit(1)
+          .single();
 
-          if (memberExists) {
+        if (existingMember.data) {
-            return tx.delete(cardToWorkspaceMembers).where(and(eq(cardToWorkspaceMembers.cardId, card.id), eq(cardToWorkspaceMembers.workspaceMemberId, member.id)),);
+          await ctx.supabase
+            .from('_card_workspace_members')
+            .delete()
+            .eq('cardId', card.data.id)
+            .eq('workspaceMemberId', member.data.id);
+
+          return { newMember: false };
         }
 
-          return tx.insert(cardToWorkspaceMembers).values({
+        await ctx.supabase
-            cardId: card.id,
+          .from('_card_workspace_members')
-            workspaceMemberId: member.id,
+          .insert({
+            cardId: card.data.id,
+            workspaceMemberId: member.data.id,
           });
-        })
+
+        return { newMember: true };
       }),
     byId: publicProcedure
       .input(z.object({ id: z.string().min(12) }))
-      .query(({ ctx, input }) => 
+      .query(async ({ ctx, input }) => {
-        ctx.db.query.cards.findFirst({
+        const { data } = await ctx.supabase
-          with: {
+          .from('card')
-            labels: {
+          .select(`
-              columns: {
+            publicId,
-                labelId: false,
+            title,
-                cardId: false,
+            description,
-              },
+            labels:label (
-              with: {
+              publicId,
-                label: {
+              name,
-                  columns: {
+              colourCode
-                    publicId: true,
-                    name: true,
-                    colourCode: true,
-                  }
-                },
-              }
-            },
-            list: {
-              columns: {
-                publicId: true,
-              },
-              with: {
-                board: {
-                  columns: {
-                    publicId: true,
-                    name: true,
-                  },
-                  with: {
-                    labels: {
-                      columns: {
-                        publicId: true,
-                        colourCode: true,
-                        name: true,
-                      }
-                    },
-                    lists: {
-                      columns: {
-                        publicId: true,
-                        name: true,
-                      },
-                      where: isNull(lists.deletedAt)
-                    },
-                    workspace: {
-                      columns: {
-                        publicId: true,
-                      },
-                      with: {
-                        members: {
-                          columns: {
-                            publicId: true,
-                          },
-                          with: {
-                            user: {
-                              columns: {
-                                id: true,
-                                name: true,
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  },
-                }
-              }
-            },
-            members: {
-              columns: {
-                workspaceMemberId: false,
-                cardId: false,
-              },
-              with: {
-                member: {
-                  columns: {
-                    publicId: true,
-                  },
-                  with: {
-                    user: {
-                      columns: {
-                        id: true,
-                        name: true,
-                      }
-                    }
-                  }
-                },
-              }
-            },
-          },
-          where: and(eq(cards.publicId, input.id), isNull(cards.deletedAt)),
-        })
             ),
+            list (
+              publicId,
+              name,
+              board (
+                publicId,
+                name,
+                labels:label (
+                  publicId,
+                  colourCode,
+                  name
+                ),
+                lists:list (
+                  publicId,
+                  name
+                ),
+                workspace (
+                  publicId,
+                  members:workspace_members (
+                    publicId,
+                    user (
+                      id,
+                      name
+                    )
+                  )
+                )
+              )
+            ),
+            members:workspace_members (
+              publicId,
+              user (
+                id,
+                name
+              )
+            )
+          `)
+          .eq('publicId', input.id)
+          .is('deletedAt', null)
+          .is('list.board.lists.deletedAt', null)
+          .limit(1)
+          .single();
+
+        return data;
+      }),
     update: publicProcedure
       .input(
         z.object({ 
@@ -258,12 +257,18 @@ export const cardRouter = createTRPCRouter({
           title: z.string().min(1),
           description: z.string(),
         }))
-      .mutation(({ ctx, input }) => {
+      .mutation(async ({ ctx, input }) => {
         const userId = ctx.user?.id;
 
         if (!userId) return;
 
-        return ctx.db.update(cards).set({ title: input.title, description: input.description }).where(and(eq(cards.publicId, input.cardId), isNull(cards.deletedAt)));
+        const { data } = await ctx.supabase
+          .from('card')
+          .update({ title: input.title, description: input.description })
+          .eq('publicId', input.cardId)
+          .is('deletedAt', null);
+
+        return data;
       }),
     delete: publicProcedure
       .input(

src/views/card/index.tsx

@@ -31,19 +31,21 @@ export default function CardPage() {
     ? params.cardId[0]
     : params?.cardId;
 
-  const { data } = api.card.byId.useQuery({ id: cardId ?? "" });
+  const { data, error } = api.card.byId.useQuery({ id: cardId ?? "" });
 
-  const boardId = data?.list?.board?.publicId;
-  const labels = data?.list?.board?.labels;
-  const workspaceMembers = data?.list?.board?.workspace?.members;
   const board = data?.list?.board;
+  const boardId = board?.publicId;
+  const labels = board?.labels;
+  const workspaceMembers = board?.workspace?.members;
   const selectedLabels = data?.labels;
   const selectedMembers = data?.members;
 
+  console.log({ board: error });
+
   const formattedLabels =
     labels?.map((label) => {
       const isSelected = selectedLabels?.some(
-        (selectedLabel) => selectedLabel.label.publicId === label.publicId,
+        (selectedLabel) => selectedLabel.publicId === label.publicId,
       );
 
       return {
@@ -56,13 +58,13 @@ export default function CardPage() {
   const formattedLists =
     board?.lists.map((list) => ({
       ...list,
-      selected: list.publicId === data?.list.publicId,
+      selected: list.publicId === data?.list?.publicId,
     })) ?? [];
 
   const formattedMembers =
     workspaceMembers?.map((member) => {
       const isSelected = selectedMembers?.some(
-        (assignedMember) => assignedMember.member.publicId === member.publicId,
+        (assignedMember) => assignedMember.publicId === member.publicId,
       );
 
       return {