shiyue/kan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: switch card router to use supabase

Browse Source
This commit is contained in:
Henry
2024-04-16 22:24:12 +01:00
parent 69af62e032
commit bfb5e49981
2 changed files with 154 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
src/server/api/routers/card.ts
View File

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

16
src/views/card/index.tsx
View File

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