feat(cards): complete card management and sharing flow

Author: Harxhit

apps/backend/src/routes/cards.ts

@@ -2,12 +2,11 @@ import * as cardService from '../services/cardService'
 import { handleDbError } from '../utils/error.util.js';
 import { createCardSchema ,updateCardSchema, addPlatformLinkSchema} from '../validations/card.validation';
 
-import type { CardResponse } from '../services/cardService';
+import type { CardResponse, UpdateCardBody } from '../services/cardService';
 import type { Card } from '@devcard/shared';
 import type { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
 import { CardVisibility } from '@prisma/client';
 import { hashIp } from '../utils/refreshToken';
-import { id } from 'zod/v4/locales';
 
 export interface CreateCardBody {
   title: string;
@@ -16,10 +15,6 @@ export interface CreateCardBody {
   visibility?: CardVisibility
 }
 
-interface UpdateCardBody {
-  title?: string;
-  linkIds?: string[];
-}
 
 interface CardParams {
   id: string;
@@ -90,24 +85,28 @@ export async function cardRoutes(app: FastifyInstance): Promise<void> {
   });
 
   // ─── Update Card ───
-  app.put('/:id', async (request: FastifyRequest<{ Params: CardParams; Body: UpdateCardBody }>, reply: FastifyReply): Promise<CardResponse> => {
+  app.put('/:id/update', async (request: FastifyRequest<{ Params: CardParams; Body: UpdateCardBody }>, reply: FastifyReply) => {
     const userId = (request.user as { id: string }).id;
     const { id } = request.params;
 
     try {
       const parsed = updateCardSchema.safeParse(request.body)
       if (!parsed.success) {return reply.status(400).send({ error: 'Validation failed', details: parsed.error.flatten() })}
       const updated = await cardService.updateCard(app, userId, id, parsed.data)
-      if (!updated) {return reply.status(404).send({ error: 'Card not found' })}
-      return updated
+      return reply.status(200).send(updated)
     } catch (error: any) {
-      if (error?.code === 'OWNERSHIP') {return reply.status(403).send({ error: 'One or more links do not belong to your account' })}
-      return handleDbError(error, request, reply)
+      if(error.code === 'NOT_FOUND'){
+        return reply.status(404).send({
+          error: error.message,
+        });
+      }
+      app.log.error(error)
+      handleDbError(error,request,reply)
     }
   });
 
   // ─── Delete Card ───
-  app.delete('/:id', async (request: FastifyRequest<{ Params: CardParams }>, reply: FastifyReply): Promise<void> => {
+  app.delete('/:id/delete', async (request: FastifyRequest<{ Params: CardParams }>, reply: FastifyReply): Promise<void> => {
     const userId = (request.user as { id: string }).id;
     const { id } = request.params;
 
@@ -136,8 +135,14 @@ export async function cardRoutes(app: FastifyInstance): Promise<void> {
     try {
       const resp = await cardService.setDefaultCard(app, userId, id)
       if (!resp) {return reply.status(404).send({ error: 'Card not found' })}
-      return resp
-    } catch (error) {
+      return reply.status(200).send('Default card updated')
+    } catch (error:any) {
+      if(error.code === 'NOT_FOUND'){
+        return reply.status(404).send({
+          error: error.message,
+        });
+      }
+      app.log.error(error)
       return handleDbError(error, request, reply)
     }
   });

apps/backend/src/services/cardService.ts

@@ -1,4 +1,4 @@
-import { CardVisibility, Prisma } from '@prisma/client';
+import { Card, CardVisibility, Prisma } from '@prisma/client';
 
 import { generateUniqueSlug } from '../utils/slug';
 
@@ -11,6 +11,14 @@ type RawCard = { id: string; title: string; isDefault: boolean; cardLinks: CardL
 export type CardResponse = { id: string; title: string; isDefault: boolean; links: unknown[] };
 
 
+export interface UpdateCardBody{
+  title?:string; 
+  description?:string; 
+  visibility?: CardVisibility; 
+  qrEnabled?: boolean; 
+}
+
+
 function mapCard(card: RawCard): CardResponse {
   return {
     id: card.id,
@@ -106,50 +114,28 @@ export async function updateCard(
   app: FastifyInstance,
   userId: string,
   id: string,
-  body: { title?: string; linkIds?: string[] },
-): Promise<CardResponse | null> {
-  const existing = await app.prisma.card.findFirst({ where: { id, userId } });
-  if (!existing) {
-    return null;
-  }
-
-  if (body.title) {
-    await app.prisma.card.update({ where: { id }, data: { title: body.title } });
-  }
+  body: UpdateCardBody,
+): Promise<Card> {
+  const {title, description, visibility, qrEnabled} = body
 
-  if (body.linkIds) {
-    if (body.linkIds.length > 0) {
-      const ownedLinks = await app.prisma.platformLink.findMany({
-        where: { id: { in: body.linkIds }, userId },
-        select: { id: true },
-      });
-
-      if (ownedLinks.length !== body.linkIds.length) {
-        throw Object.assign(new Error('Link ownership mismatch'), { code: 'OWNERSHIP' });
-      }
+  const existing = await app.prisma.card.findFirst({ where: { id, userId } });
+    if (!existing) {
+      throw Object.assign(new Error('NotFound'), { code: 'NOT_FOUND' });
     }
 
-    const linkIds = body.linkIds;
-    await app.prisma.$transaction(async (tx: Prisma.TransactionClient) => {
-      await tx.cardLink.deleteMany({ where: { cardId: id } });
-      if (linkIds.length > 0) {
-        await tx.cardLink.createMany({
-          data: linkIds.map((linkId, index) => ({ cardId: id, platformLinkId: linkId, displayOrder: index })),
-        });
+  const updated = await app.prisma.card.update({
+      where: {
+        id, 
+      },
+      data:{
+        title, 
+        description, 
+        visibility, 
+        qrEnabled
       }
-    });
-  }
-
-  const updated = (await app.prisma.card.findUnique({
-    where: { id },
-    include: { cardLinks: { include: { platformLink: true }, orderBy: { displayOrder: 'asc' } } },
-  })) as unknown as RawCard | null;
-
-  if (!updated) {
-    return null;
-  }
+  })
 
-  return mapCard(updated);
+  return updated;
 }
 
 //Delete card service
@@ -184,9 +170,10 @@ export async function deleteCard(app: FastifyInstance, userId: string, id: strin
 //Set default card service
 export async function setDefaultCard(app: FastifyInstance, userId: string, id: string): Promise<{ message: string } | null> {
   const existing = await app.prisma.card.findFirst({ where: { id, userId } });
-  if (!existing) {
-    return null;
-  }
+
+    if (!existing) {
+      throw Object.assign(new Error('NotFound'), { code: 'NOT_FOUND' });
+    }
 
   await app.prisma.$transaction(async (tx: Prisma.TransactionClient) => {
     await tx.card.updateMany({ where: { userId }, data: { isDefault: false } });
@@ -251,6 +238,7 @@ export async function addPlatFormLinks(app: FastifyInstance, userId: string, id:
     })
 }
 
+//Shares card
 export async function shareCard(app: FastifyInstance, userId:string, id: string){
   const card = await app.prisma.card.findFirst({
     where:{
@@ -279,6 +267,7 @@ export async function shareCard(app: FastifyInstance, userId:string, id: string)
   }; 
 }
 
+//Gets share card
 export async function getSharedCard(app:FastifyInstance, slug:string){
   const card = await app.prisma.card.findUnique({
     where: {
@@ -303,6 +292,7 @@ export async function getSharedCard(app:FastifyInstance, slug:string){
   return card
 }
 
+//Genreate qr
 export async function genrateQr(app: FastifyInstance,userId:string, id: string){
   const card = await app.prisma.card.findFirst({
     where:{

apps/backend/src/validations/card.validation.ts

@@ -19,10 +19,23 @@ export const createCardSchema = z.object({
   visibility: z.nativeEnum(CardVisibility).optional(),
 });
 
-export const updateCardSchema = z.object({
-  title: z.string().min(1).max(100).optional(),
-  linkIds: z.array(z.string().uuid()).optional(),
-});
+export const updateCardSchema = z
+  .object({
+    title: z.string().min(1).max(100).optional(),
+    description: z.string().min(1).max(100).optional(),
+    visibility: z.nativeEnum(CardVisibility).optional(),
+    qrEnabled: z.boolean().optional(),
+  })
+  .refine(
+    (data) =>
+      data.title !== undefined ||
+      data.description !== undefined ||
+      data.visibility !== undefined ||
+      data.qrEnabled !== undefined,
+    {
+      message: 'At least one field must be provided',
+    }
+);
 
 export const addPlatformLinkSchema = z.object({
   platformLinkId: z.string().uuid({