@studious-lms/server 1.0.6 → 1.0.8

package/src/lib/fileUpload.ts

@@ -1,8 +1,8 @@
 import { TRPCError } from "@trpc/server";
 import { v4 as uuidv4 } from "uuid";
-import { uploadFile as uploadToGCS, getSignedUrl } from "./googleCloudStorage";
-import { generateThumbnail, storeThumbnail, generateMediaThumbnail } from "./thumbnailGenerator";
-import { prisma } from "./prisma";
+import { uploadFile as uploadToGCS, getSignedUrl } from "./googleCloudStorage.js";
+import { generateThumbnail, storeThumbnail, generateMediaThumbnail } from "./thumbnailGenerator.js";
+import { prisma } from "./prisma.js";
 
 export interface FileData {
   name: string;
@@ -39,22 +39,22 @@ export async function uploadFile(
     const fileExtension = file.name.split('.').pop();
     const uniqueFilename = `${uuidv4()}.${fileExtension}`;
     
-    // Construct the full path
+  //   // Construct the full path
     const filePath = directory 
       ? `${directory}/${uniqueFilename}`
       : uniqueFilename;
     
-    // Upload to Google Cloud Storage
+  //   // Upload to Google Cloud Storage
     const uploadedPath = await uploadToGCS(file.data, filePath, file.type);
     
-    // Generate and store thumbnail if supported
+  //   // Generate and store thumbnail if supported
     let thumbnailId: string | undefined;
     try {
-      // Convert base64 to buffer for thumbnail generation
+  //     // Convert base64 to buffer for thumbnail generation
       const base64Data = file.data.split(',')[1];
       const fileBuffer = Buffer.from(base64Data, 'base64');
       
-      // Generate thumbnail directly from buffer
+  //     // Generate thumbnail directly from buffer
       const thumbnailBuffer = await generateMediaThumbnail(fileBuffer, file.type);
       if (thumbnailBuffer) {
         // Store thumbnail in a thumbnails directory
@@ -65,9 +65,10 @@ export async function uploadFile(
         // Create thumbnail file record
         const thumbnailFile = await prisma.file.create({
           data: {
-            name: `${file.name}_thumb.jpg`,
+            name: `${file.name}_thumb.jpg${Math.random()}`,
             type: 'image/jpeg',
             path: thumbnailPath,
+            // path: '/dummyPath' + Math.random().toString(36).substring(2, 15),
             user: {
               connect: { id: userId }
             }
@@ -81,6 +82,8 @@ export async function uploadFile(
     }
     
     // Create file record in database
+
+    // const uploadedPath = '/dummyPath' + Math.random().toString(36).substring(2, 15);
     const fileRecord = await prisma.file.create({
       data: {
         name: file.name,
@@ -90,6 +93,11 @@ export async function uploadFile(
         user: {
           connect: { id: userId }
         },
+        ...(directory && {
+          folder: {
+            connect: {id: directory},
+          },
+        }),
         ...(thumbnailId && {
           thumbnail: {
             connect: { id: thumbnailId }
@@ -112,7 +120,8 @@ export async function uploadFile(
       path: uploadedPath,
       thumbnailId: thumbnailId
     };
-  } catch (error) {
+  }
+   catch (error) {
     console.error('Error uploading file:', error);
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',

package/src/lib/thumbnailGenerator.ts

@@ -1,6 +1,6 @@
 import sharp from 'sharp';
-import { prisma } from './prisma';
-import { uploadFile, deleteFile, getSignedUrl } from './googleCloudStorage';
+import { prisma } from './prisma.js';
+import { uploadFile, deleteFile, getSignedUrl } from './googleCloudStorage.js';
 
 // Thumbnail size configuration
 const THUMBNAIL_WIDTH = 200;

package/src/middleware/auth.ts

@@ -1,6 +1,6 @@
 import { TRPCError } from '@trpc/server';
-import { prisma } from '../lib/prisma';
-import type { MiddlewareContext } from '../types/trpc';
+import { prisma } from '../lib/prisma.js';
+import type { MiddlewareContext } from '../types/trpc.js';
 
 export const createAuthMiddleware = (t: any) => {
 
@@ -43,8 +43,6 @@ export const createAuthMiddleware = (t: any) => {
         });
       }
 
-      console.log(user)
-
       return next({
         ctx: {
           ...ctx,

package/src/middleware/logging.ts

@@ -1,5 +1,5 @@
-import type { MiddlewareContext } from '../types/trpc';
-import { logger } from '../utils/logger';
+import type { MiddlewareContext } from '../types/trpc.js';
+import { logger } from '../utils/logger.js';
 
 export const createLoggingMiddleware = (t: any) => {
   return t.middleware(async ({ path, type, next, ctx }: MiddlewareContext) => {

package/src/routers/_app.ts

@@ -1,16 +1,18 @@
-import { createTRPCRouter } from "../trpc";
-import { classRouter } from "./class";
-import { announcementRouter } from "./announcement";
-import { assignmentRouter } from "./assignment";
-import { userRouter } from "./user";
-import { createCallerFactory } from "../trpc";
+import { createTRPCRouter } from "../trpc.js";
+import { classRouter } from "./class.js";
+import { announcementRouter } from "./announcement.js";
+import { assignmentRouter } from "./assignment.js";
+import { userRouter } from "./user.js";
+import { createCallerFactory } from "../trpc.js";
 import type { inferRouterInputs, inferRouterOutputs } from "@trpc/server";
-import { sectionRouter } from "./section";
-import { attendanceRouter } from "./attendance";
-import { eventRouter } from "./event";
-import { authRouter } from "./auth";
-import { agendaRouter } from "./agenda";
-import { fileRouter } from "./file";
+import { sectionRouter } from "./section.js";
+import { attendanceRouter } from "./attendance.js";
+import { eventRouter } from "./event.js";
+import { authRouter } from "./auth.js";
+import { agendaRouter } from "./agenda.js";
+import { fileRouter } from "./file.js";
+import { folderRouter } from "./folder.js";
+import { notificationRouter } from "./notifications.js";
 
 export const appRouter = createTRPCRouter({
   class: classRouter,
@@ -23,7 +25,9 @@ export const appRouter = createTRPCRouter({
   auth: authRouter,
   agenda: agendaRouter,
   file: fileRouter,
-});
+  folder: folderRouter,
+  notification: notificationRouter,
+}); 
 
 // Export type router type definition
 export type AppRouter = typeof appRouter;

package/src/routers/agenda.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure } from "../trpc";
-import { prisma } from "../lib/prisma";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import { prisma } from "../lib/prisma.js";
 import { TRPCError } from "@trpc/server";
 import { addDays, startOfDay, endOfDay } from "date-fns";
 

package/src/routers/announcement.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedClassMemberProcedure, protectedTeacherProcedure, protectedProcedure } from "../trpc";
-import { prisma } from "../lib/prisma";
+import { createTRPCRouter, protectedClassMemberProcedure, protectedTeacherProcedure, protectedProcedure } from "../trpc.js";
+import { prisma } from "../lib/prisma.js";
 import { TRPCError } from "@trpc/server";
 
 const AnnouncementSelect = {

package/src/routers/assignment.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure, protectedClassMemberProcedure, protectedTeacherProcedure } from "../trpc";
+import { createTRPCRouter, protectedProcedure, protectedClassMemberProcedure, protectedTeacherProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma";
-import { uploadFiles, type UploadedFile } from "../lib/fileUpload";
-import { deleteFile } from "../lib/googleCloudStorage";
+import { prisma } from "../lib/prisma.js";
+import { uploadFiles, type UploadedFile } from "../lib/fileUpload.js";
+import { deleteFile } from "../lib/googleCloudStorage.js";
 
 const fileSchema = z.object({
   name: z.string(),
@@ -18,6 +18,7 @@ const createAssignmentSchema = z.object({
   instructions: z.string(),
   dueDate: z.string(),
   files: z.array(fileSchema).optional(),
+  existingFileIds: z.array(z.string()).optional(),
   maxGrade: z.number().optional(),
   graded: z.boolean().optional(),
   weight: z.number().optional(),
@@ -25,6 +26,7 @@ const createAssignmentSchema = z.object({
   type: z.enum(['HOMEWORK', 'QUIZ', 'TEST', 'PROJECT', 'ESSAY', 'DISCUSSION', 'PRESENTATION', 'LAB', 'OTHER']).optional(),
   markSchemeId: z.string().optional(),
   gradingBoundaryId: z.string().optional(),
+  inProgress: z.boolean().optional(),
 });
 
 const updateAssignmentSchema = z.object({
@@ -34,12 +36,14 @@ const updateAssignmentSchema = z.object({
   instructions: z.string().optional(),
   dueDate: z.string().optional(),
   files: z.array(fileSchema).optional(),
+  existingFileIds: z.array(z.string()).optional(),
   removedAttachments: z.array(z.string()).optional(),
   maxGrade: z.number().optional(),
   graded: z.boolean().optional(),
   weight: z.number().optional(),
   sectionId: z.string().nullable().optional(),
   type: z.enum(['HOMEWORK', 'QUIZ', 'TEST', 'PROJECT', 'ESSAY', 'DISCUSSION', 'PRESENTATION', 'LAB', 'OTHER']).optional(),
+  inProgress: z.boolean().optional(),
 });
 
 const deleteAssignmentSchema = z.object({
@@ -58,6 +62,7 @@ const submissionSchema = z.object({
   submissionId: z.string(),
   submit: z.boolean().optional(),
   newAttachments: z.array(fileSchema).optional(),
+  existingFileIds: z.array(z.string()).optional(),
   removedAttachments: z.array(z.string()).optional(),
 });
 
@@ -68,6 +73,7 @@ const updateSubmissionSchema = z.object({
   return: z.boolean().optional(),
   gradeReceived: z.number().nullable().optional(),
   newAttachments: z.array(fileSchema).optional(),
+  existingFileIds: z.array(z.string()).optional(),
   removedAttachments: z.array(z.string()).optional(),
   rubricGrades: z.array(z.object({
     criteriaId: z.string(),
@@ -81,7 +87,7 @@ export const assignmentRouter = createTRPCRouter({
   create: protectedProcedure
     .input(createAssignmentSchema)
     .mutation(async ({ ctx, input }) => {
-      const { classId, title, instructions, dueDate, files, maxGrade, graded, weight, sectionId, type, markSchemeId, gradingBoundaryId } = input;
+      const { classId, title, instructions, dueDate, files, existingFileIds, maxGrade, graded, weight, sectionId, type, markSchemeId, gradingBoundaryId, inProgress } = input;
 
       if (!ctx.user) {
         throw new TRPCError({
@@ -107,20 +113,24 @@ export const assignmentRouter = createTRPCRouter({
         });
       }
 
-      const rubric = await prisma.markScheme.findUnique({
-        where: { id: markSchemeId },
-        select: {
-          structured: true,
-        }
-      });
+      let computedMaxGrade = maxGrade;
+      if (markSchemeId) {
+        const rubric = await prisma.markScheme.findUnique({
+          where: { id: markSchemeId },
+          select: {
+            structured: true,
+          }
+        });
 
-      const parsedRubric = JSON.parse(rubric?.structured || "{}");
+        const parsedRubric = JSON.parse(rubric?.structured || "{}");
 
-      // Calculate max grade from rubric criteria levels
-      const computedMaxGrade = parsedRubric.criteria.reduce((acc: number, criterion: any) => {
-        const maxPoints = Math.max(...criterion.levels.map((level: any) => level.points));
-        return acc + maxPoints;
-      }, 0);
+        // Calculate max grade from rubric criteria levels
+        computedMaxGrade = parsedRubric.criteria.reduce((acc: number, criterion: any) => {
+          const maxPoints = Math.max(...criterion.levels.map((level: any) => level.points));
+          return acc + maxPoints;
+        }, 0);
+      }
+      console.log(markSchemeId, gradingBoundaryId);
 
       // Create assignment with submissions for all students
       const assignment = await prisma.assignment.create({
@@ -132,6 +142,7 @@ export const assignmentRouter = createTRPCRouter({
           graded,
           weight,
           type,
+          inProgress: inProgress || false,
           class: {
             connect: { id: classId }
           },
@@ -197,11 +208,12 @@ export const assignmentRouter = createTRPCRouter({
           }
         }
       });
+
       // Upload files if provided
       let uploadedFiles: UploadedFile[] = [];
       if (files && files.length > 0) {
         // Store files in a class and assignment specific directory
-        uploadedFiles = await uploadFiles(files, ctx.user.id, `class/${classId}/assignment/${assignment.id}`);
+        uploadedFiles = await uploadFiles(files, ctx.user.id);
       }
 
       // Update assignment with new file attachments
@@ -226,12 +238,24 @@ export const assignmentRouter = createTRPCRouter({
         });
       }
 
+      // Connect existing files if provided
+      if (existingFileIds && existingFileIds.length > 0) {
+        await prisma.assignment.update({
+          where: { id: assignment.id },
+          data: {
+            attachments: {
+              connect: existingFileIds.map(fileId => ({ id: fileId }))
+            }
+          }
+        });
+      }
+
       return assignment;
     }),
   update: protectedProcedure
     .input(updateAssignmentSchema)
     .mutation(async ({ ctx, input }) => {
-      const { id, title, instructions, dueDate, files, maxGrade, graded, weight, sectionId, type } = input;
+      const { id, title, instructions, dueDate, files, existingFileIds, maxGrade, graded, weight, sectionId, type, inProgress } = input;
 
       if (!ctx.user) {
         throw new TRPCError({
@@ -252,6 +276,8 @@ export const assignmentRouter = createTRPCRouter({
               id: true,
               name: true,
               type: true,
+              path: true,
+              size: true,
               thumbnail: {
                 select: {
                   path: true
@@ -279,7 +305,7 @@ export const assignmentRouter = createTRPCRouter({
       let uploadedFiles: UploadedFile[] = [];
       if (files && files.length > 0) {
         // Store files in a class and assignment specific directory
-        uploadedFiles = await uploadFiles(files, ctx.user.id, `class/${assignment.classId}/assignment/${id}`);
+        uploadedFiles = await uploadFiles(files, ctx.user.id);
       }
 
       // Update assignment
@@ -293,6 +319,7 @@ export const assignmentRouter = createTRPCRouter({
           ...(graded !== undefined && { graded }),
           ...(weight && { weight }),
           ...(type && { type }),
+          ...(inProgress !== undefined && { inProgress }),
           ...(sectionId !== undefined && {
             section: sectionId ? {
               connect: { id: sectionId }
@@ -315,6 +342,11 @@ export const assignmentRouter = createTRPCRouter({
               }))
             }
           }),
+          ...(existingFileIds && existingFileIds.length > 0 && {
+            attachments: {
+              connect: existingFileIds.map(fileId => ({ id: fileId }))
+            }
+          }),
           ...(input.removedAttachments && input.removedAttachments.length > 0 && {
             attachments: {
               deleteMany: {
@@ -348,7 +380,11 @@ export const assignmentRouter = createTRPCRouter({
               id: true,
               name: true,
               type: true,
-              thumbnail: true
+              thumbnail: true,
+              size: true,
+              path: true,
+              uploadedAt: true,
+              thumbnailId: true,
             }
           },
           section: true,
@@ -497,6 +533,7 @@ export const assignmentRouter = createTRPCRouter({
               type: true,
               size: true,
               path: true,
+              uploadedAt: true,
               thumbnailId: true,
             }
           },
@@ -740,7 +777,7 @@ export const assignmentRouter = createTRPCRouter({
         });
       }
 
-      const { submissionId, submit, newAttachments, removedAttachments } = input;
+      const { submissionId, submit, newAttachments, existingFileIds, removedAttachments } = input;
 
       const submission = await prisma.submission.findFirst({
         where: {
@@ -837,7 +874,7 @@ export const assignmentRouter = createTRPCRouter({
       let uploadedFiles: UploadedFile[] = [];
       if (newAttachments && newAttachments.length > 0) {
         // Store files in a class and assignment specific directory
-        uploadedFiles = await uploadFiles(newAttachments, ctx.user.id, `class/${submission.assignment.classId}/assignment/${submission.assignmentId}/submission/${submission.id}`);
+        uploadedFiles = await uploadFiles(newAttachments, ctx.user.id);
       }
 
       // Update submission with new file attachments
@@ -862,6 +899,18 @@ export const assignmentRouter = createTRPCRouter({
         });
       }
 
+      // Connect existing files if provided
+      if (existingFileIds && existingFileIds.length > 0) {
+        await prisma.submission.update({
+          where: { id: submission.id },
+          data: {
+            attachments: {
+              connect: existingFileIds.map(fileId => ({ id: fileId }))
+            }
+          }
+        });
+      }
+
       // Delete removed attachments if any
       if (removedAttachments && removedAttachments.length > 0) {
         const filesToDelete = submission.attachments.filter((file) => 
@@ -1003,7 +1052,7 @@ export const assignmentRouter = createTRPCRouter({
         });
       }
 
-      const { submissionId, return: returnSubmission, gradeReceived, newAttachments, removedAttachments, rubricGrades } = input;
+      const { submissionId, return: returnSubmission, gradeReceived, newAttachments, existingFileIds, removedAttachments, rubricGrades } = input;
 
       const submission = await prisma.submission.findFirst({
         where: {
@@ -1093,7 +1142,7 @@ export const assignmentRouter = createTRPCRouter({
       let uploadedFiles: UploadedFile[] = [];
       if (newAttachments && newAttachments.length > 0) {
         // Store files in a class and assignment specific directory
-        uploadedFiles = await uploadFiles(newAttachments, ctx.user.id, `class/${submission.assignment.classId}/assignment/${submission.assignmentId}/submission/${submission.id}/annotations`);
+        uploadedFiles = await uploadFiles(newAttachments, ctx.user.id);
       }
 
       // Update submission with new file attachments
@@ -1118,6 +1167,18 @@ export const assignmentRouter = createTRPCRouter({
         });
       }
 
+      // Connect existing files if provided
+      if (existingFileIds && existingFileIds.length > 0) {
+        await prisma.submission.update({
+          where: { id: submission.id },
+          data: {
+            annotations: {
+              connect: existingFileIds.map(fileId => ({ id: fileId }))
+            }
+          }
+        });
+      }
+
       // Delete removed attachments if any
       if (removedAttachments && removedAttachments.length > 0) {
         const filesToDelete = submission.annotations.filter((file) => 
@@ -1552,7 +1613,6 @@ export const assignmentRouter = createTRPCRouter({
 
       return updatedAssignment;
     }),
-
     attachGradingBoundary: protectedTeacherProcedure
     .input(z.object({
       assignmentId: z.string(),

package/src/routers/attendance.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma";
+import { prisma } from "../lib/prisma.js";
 
 const attendanceSchema = z.object({
   eventId: z.string().optional(),

package/src/routers/auth.ts

@@ -1,10 +1,11 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure, publicProcedure } from "../trpc";
+import { createTRPCRouter, protectedProcedure, publicProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma";
+import { prisma } from "../lib/prisma.js";
 import { v4 as uuidv4 } from 'uuid';
 import { compare, hash } from "bcryptjs";
-import { transport } from "../utils/email";
+import { transport } from "../utils/email.js";
+import { prismaWrapper } from "../utils/prismaWrapper.js";
 
 const loginSchema = z.object({
   username: z.string(),
@@ -28,20 +29,23 @@ export const authRouter = createTRPCRouter({
       const { username, email, password } = input;
 
       // Check if username already exists
-      const existingUser = await prisma.user.findFirst({
-        where: { 
-          OR: [
-            { username },
-            { email }
-          ]
-        },
-        select: {
-          id: true,
-          username: true,
-          email: true,
-          verified: true,
-        }
-      });
+      const existingUser = await prismaWrapper.findFirst(
+        () => prisma.user.findFirst({
+          where: { 
+            OR: [
+              { username },
+              { email }
+            ]
+          },
+          select: {
+            id: true,
+            username: true,
+            email: true,
+            verified: true,
+          }
+        }),
+        'checking for existing user during registration'
+      );
 
       if (existingUser && existingUser.verified) {
         if (existingUser.username === username) {
@@ -57,44 +61,59 @@ export const authRouter = createTRPCRouter({
           });
         }
       } else if (existingUser && !existingUser.verified) {
-        await prisma.session.deleteMany({
-          where: { userId: existingUser.id },
-        });
-
-        await prisma.user.delete({
-          where: { id: existingUser.id },
-        });
+        await prismaWrapper.deleteMany(
+          () => prisma.session.deleteMany({
+            where: { userId: existingUser.id },
+          }),
+          'deleting existing sessions for unverified user'
+        );
+
+        await prismaWrapper.delete(
+          () => prisma.user.delete({
+            where: { id: existingUser.id },
+          }),
+          'deleting unverified user'
+        );
       }
 
       // Create new user
-      const user = await prisma.user.create({
-        data: {
-          username,
-          email,
-          password: await hash(password, 10),
-          profile: {},
-        },
-        select: {
-          id: true,
-          username: true,
-          email: true,
-        }
-      });
+      const user = await prismaWrapper.create(
+        async () => await prisma.user.create({
+          data: {
+            username,
+            email,
+            password: await hash(password, 10),
+            profile: {},
+            verified: true, // temporary
+          },
+          select: {
+            id: true,
+            username: true,
+            email: true,
+          }
+        }),
+        'creating new user during registration'
+      );
 
-      const verificationToken = await prisma.session.create({
-        data: {
-          id: uuidv4(),
-          userId: user.id,
-          expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 30),
-        },
-      });
+      const verificationToken = await prismaWrapper.create(
+        () => prisma.session.create({
+          data: {
+            id: uuidv4(),
+            userId: user.id,
+            expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 30),
+          },
+        }),
+        'creating verification token'
+      );
 
-      await transport.sendMail({
-        from: 'noreply@studious.sh',
-        to: user.email,
-        subject: 'Verify your email',
-        text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
-      });
+      // await transport.sendMail({
+      //   from: 'noreply@studious.sh',
+      //   to: user.email,
+      //   subject: 'Verify your email',
+      //   text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
+      // });
+
+      console.log(`${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`)
 
       return {
         user: {
@@ -127,7 +146,7 @@ export const authRouter = createTRPCRouter({
         });
       }
 
-      if (await compare(password, user.password)) {
+      if (!(await compare(password, user.password))) {
         throw new TRPCError({
           code: "UNAUTHORIZED",
           message: "Invalid username or password",
@@ -218,6 +237,8 @@ export const authRouter = createTRPCRouter({
           select: {
             id: true,
             email: true,
+            role: true,
+            schoolId: true,
           },
         });
 
@@ -240,12 +261,12 @@ export const authRouter = createTRPCRouter({
           },
         });
         
-        await transport.sendMail({
-          from: 'noreply@studious.sh',
-          to: user.email,
-          subject: 'Verify your email',
-          text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
-        });
+        // await transport.sendMail({
+        //   from: 'noreply@studious.sh',
+        //   to: user.email,
+        //   subject: 'Verify your email',
+        //   text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
+        // });
 
         return { success: true };
       }),
@@ -281,6 +302,11 @@ export const authRouter = createTRPCRouter({
           },
         });
 
+        // Clean up the verification token
+        await prisma.session.delete({
+          where: { id: token },
+        });
+
         return { success: true };
       }),
 });