@studious-lms/server 1.1.22 → 1.1.24

package/dist/routers/assignment.d.ts

@@ -474,18 +474,6 @@ export declare const assignmentRouter: import("@trpc/server").TRPCBuiltRouter<{
             student: {
                 id: string;
                 username: string;
-                profile: {
-                    id: string;
-                    location: string | null;
-                    userId: string;
-                    createdAt: Date;
-                    displayName: string | null;
-                    bio: string | null;
-                    website: string | null;
-                    profilePicture: string | null;
-                    profilePictureThumbnail: string | null;
-                    updatedAt: Date;
-                } | null;
             };
             attachments: {
                 path: string;
@@ -606,16 +594,8 @@ export declare const assignmentRouter: import("@trpc/server").TRPCBuiltRouter<{
                 id: string;
                 username: string;
                 profile: {
-                    id: string;
-                    location: string | null;
-                    userId: string;
-                    createdAt: Date;
                     displayName: string | null;
-                    bio: string | null;
-                    website: string | null;
                     profilePicture: string | null;
-                    profilePictureThumbnail: string | null;
-                    updatedAt: Date;
                 } | null;
             };
             attachments: {
@@ -1587,6 +1567,37 @@ export declare const assignmentRouter: import("@trpc/server").TRPCBuiltRouter<{
         };
         meta: object;
     }>;
+    getAnnotationUploadUrls: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            files: {
+                type: string;
+                name: string;
+                size: number;
+            }[];
+            submissionId: string;
+        };
+        output: {
+            success: boolean;
+            uploadFiles: DirectUploadFile[];
+        };
+        meta: object;
+    }>;
+    confirmAnnotationUpload: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            fileId: string;
+            uploadSuccess: boolean;
+            errorMessage?: string | undefined;
+        };
+        output: {
+            success: boolean;
+            message: string;
+        };
+        meta: object;
+    }>;
     updateUploadProgress: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             fileId: string;

package/dist/routers/assignment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assignment.d.ts","sourceRoot":"","sources":["../../src/routers/assignment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAA2B,KAAK,gBAAgB,EAAgE,MAAM,sBAAsB,CAAC;AAoHpJ,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAk7D3B,CAAC"}
+{"version":3,"file":"assignment.d.ts","sourceRoot":"","sources":["../../src/routers/assignment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAA2B,KAAK,gBAAgB,EAAgE,MAAM,sBAAsB,CAAC;AAgIpJ,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2gE3B,CAAC"}

package/dist/routers/assignment.js

@@ -100,6 +100,16 @@ const confirmSubmissionUploadSchema = z.object({
     uploadSuccess: z.boolean(),
     errorMessage: z.string().optional(),
 });
+const getAnnotationUploadUrlsSchema = z.object({
+    submissionId: z.string(),
+    classId: z.string(),
+    files: z.array(directFileSchema),
+});
+const confirmAnnotationUploadSchema = z.object({
+    fileId: z.string(),
+    uploadSuccess: z.boolean(),
+    errorMessage: z.string().optional(),
+});
 const updateUploadProgressSchema = z.object({
     fileId: z.string(),
     progress: z.number().min(0).max(100),
@@ -668,7 +678,6 @@ export const assignmentRouter = createTRPCRouter({
                     select: {
                         id: true,
                         username: true,
-                        profile: true,
                     },
                 },
                 assignment: {
@@ -770,7 +779,12 @@ export const assignmentRouter = createTRPCRouter({
                     select: {
                         id: true,
                         username: true,
-                        profile: true,
+                        profile: {
+                            select: {
+                                displayName: true,
+                                profilePicture: true,
+                            }
+                        }
                     },
                 },
                 assignment: {
@@ -1167,30 +1181,13 @@ export const assignmentRouter = createTRPCRouter({
                 },
             });
         }
-        let uploadedFiles = [];
+        // NOTE: Teacher annotation files are now handled via direct upload endpoints
+        // Use getAnnotationUploadUrls and confirmAnnotationUpload endpoints instead
+        // The newAttachments field is deprecated for annotations
         if (newAttachments && newAttachments.length > 0) {
-            // Store files in a class and assignment specific directory
-            uploadedFiles = await createDirectUploadFiles(newAttachments, ctx.user.id, undefined, undefined, submission.id);
-        }
-        // Update submission with new file attachments
-        if (uploadedFiles.length > 0) {
-            await prisma.submission.update({
-                where: { id: submission.id },
-                data: {
-                    annotations: {
-                        create: uploadedFiles.map(file => ({
-                            name: file.name,
-                            type: file.type,
-                            size: file.size,
-                            path: file.path,
-                            ...(file.thumbnailId && {
-                                thumbnail: {
-                                    connect: { id: file.thumbnailId }
-                                }
-                            })
-                        }))
-                    }
-                }
+            throw new TRPCError({
+                code: "BAD_REQUEST",
+                message: "Direct file upload is deprecated. Use getAnnotationUploadUrls endpoint instead.",
             });
         }
         // Connect existing files if provided
@@ -1864,6 +1861,89 @@ export const assignmentRouter = createTRPCRouter({
             message: uploadSuccess ? "Upload confirmed successfully" : "Upload failed",
         };
     }),
+    getAnnotationUploadUrls: protectedTeacherProcedure
+        .input(getAnnotationUploadUrlsSchema)
+        .mutation(async ({ ctx, input }) => {
+        const { submissionId, classId, files } = input;
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to upload files",
+            });
+        }
+        // Verify submission exists and user is a teacher of the class
+        const submission = await prisma.submission.findFirst({
+            where: {
+                id: submissionId,
+                assignment: {
+                    classId: classId,
+                    class: {
+                        teachers: {
+                            some: {
+                                id: ctx.user.id,
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        if (!submission) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "Submission not found or you are not a teacher of this class",
+            });
+        }
+        // Create direct upload files for annotations
+        // Note: We pass submissionId as the 5th parameter, but these are annotations not submission files
+        // We need to store them separately, so we'll use a different approach
+        const directUploadFiles = await createDirectUploadFiles(files, ctx.user.id, undefined, // No specific directory
+        undefined, // No assignment ID
+        undefined // Don't link to submission yet (will be linked in confirmAnnotationUpload)
+        );
+        // Store the submissionId in the file record so we can link it to annotations later
+        await Promise.all(directUploadFiles.map(file => prisma.file.update({
+            where: { id: file.id },
+            data: {
+                annotationId: submissionId, // Store as annotation
+            }
+        })));
+        return {
+            success: true,
+            uploadFiles: directUploadFiles,
+        };
+    }),
+    confirmAnnotationUpload: protectedTeacherProcedure
+        .input(confirmAnnotationUploadSchema)
+        .mutation(async ({ ctx, input }) => {
+        const { fileId, uploadSuccess, errorMessage } = input;
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in",
+            });
+        }
+        // Verify file belongs to user and is an annotation file
+        const file = await prisma.file.findFirst({
+            where: {
+                id: fileId,
+                userId: ctx.user.id,
+                annotationId: {
+                    not: null,
+                },
+            },
+        });
+        if (!file) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "File not found or you don't have permission",
+            });
+        }
+        await confirmDirectUpload(fileId, uploadSuccess, errorMessage);
+        return {
+            success: true,
+            message: uploadSuccess ? "Annotation upload confirmed successfully" : "Annotation upload failed",
+        };
+    }),
     updateUploadProgress: protectedProcedure
         .input(updateUploadProgressSchema)
         .mutation(async ({ ctx, input }) => {

package/dist/routers/folder.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { type DirectUploadFile } from "../lib/fileUpload.js";
 export declare const folderRouter: import("@trpc/server").TRPCBuiltRouter<{
     ctx: import("../trpc.js").Context;
     meta: object;
@@ -316,5 +317,31 @@ export declare const folderRouter: import("@trpc/server").TRPCBuiltRouter<{
         }[];
         meta: object;
     }>;
+    getFolderUploadUrls: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            files: {
+                type: string;
+                name: string;
+                size: number;
+            }[];
+            folderId: string;
+        };
+        output: DirectUploadFile[];
+        meta: object;
+    }>;
+    confirmFolderUpload: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            fileId: string;
+            uploadSuccess: boolean;
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
 }>>;
 //# sourceMappingURL=folder.d.ts.map

package/dist/routers/folder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"folder.d.ts","sourceRoot":"","sources":["../../src/routers/folder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiCxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0vBvB,CAAC"}
+{"version":3,"file":"folder.d.ts","sourceRoot":"","sources":["../../src/routers/folder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAA2B,KAAK,gBAAgB,EAAqB,MAAM,sBAAsB,CAAC;AA6BzG,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAu2BvB,CAAC"}

package/dist/routers/folder.js

@@ -726,4 +726,97 @@ export const folderRouter = createTRPCRouter({
         }
         return parents;
     }),
+    getFolderUploadUrls: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        folderId: z.string(),
+        files: z.array(directFileSchema),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, folderId, files } = input;
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to upload files",
+            });
+        }
+        // Verify user is a teacher of the class
+        const classData = await prisma.class.findFirst({
+            where: {
+                id: classId,
+                teachers: {
+                    some: {
+                        id: ctx.user.id,
+                    },
+                },
+            },
+        });
+        if (!classData) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "Class not found or you are not a teacher",
+            });
+        }
+        // Verify folder exists
+        const folder = await prisma.folder.findUnique({
+            where: {
+                id: folderId,
+            },
+        });
+        if (!folder) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "Folder not found",
+            });
+        }
+        // Verify folder belongs to the class by traversing parent hierarchy
+        // Only root folders have classId, child folders use parentFolderId
+        let currentFolder = folder;
+        let belongsToClass = false;
+        while (currentFolder) {
+            // Check if we've reached a root folder with the matching classId
+            if (currentFolder.classId === classId) {
+                belongsToClass = true;
+                break;
+            }
+            // If this folder has a parent, traverse up
+            if (currentFolder.parentFolderId) {
+                currentFolder = await prisma.folder.findUnique({
+                    where: { id: currentFolder.parentFolderId },
+                });
+            }
+            else {
+                // Reached a root folder without matching classId
+                break;
+            }
+        }
+        if (!belongsToClass) {
+            throw new TRPCError({
+                code: "FORBIDDEN",
+                message: "Folder does not belong to this class",
+            });
+        }
+        // Create direct upload files
+        const uploadFiles = await createDirectUploadFiles(files, ctx.user.id, folder.id);
+        return uploadFiles;
+    }),
+    confirmFolderUpload: protectedTeacherProcedure
+        .input(z.object({
+        fileId: z.string(),
+        uploadSuccess: z.boolean(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { fileId, uploadSuccess } = input;
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to confirm uploads",
+            });
+        }
+        // Import the confirmDirectUpload function
+        const { confirmDirectUpload } = await import("../lib/fileUpload.js");
+        // Confirm the upload
+        await confirmDirectUpload(fileId, uploadSuccess);
+        return { success: true };
+    }),
 });

package/dist/seedDatabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seedDatabase.d.ts","sourceRoot":"","sources":["../src/seedDatabase.ts"],"names":[],"mappings":"AAIA,wBAAsB,aAAa,kBAuClC;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;GAOjF;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;;;;;GAQnF;AAED,eAAO,MAAM,YAAY,qBAq+CxB,CAAC"}
+{"version":3,"file":"seedDatabase.d.ts","sourceRoot":"","sources":["../src/seedDatabase.ts"],"names":[],"mappings":"AAIA,wBAAsB,aAAa,kBAsClC;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;GAOjF;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;;;;;GAQnF;AAED,eAAO,MAAM,YAAY,qBAq+CxB,CAAC"}

package/dist/seedDatabase.js

@@ -4,7 +4,6 @@ import { logger } from "./utils/logger.js";
 export async function clearDatabase() {
     // Delete in order to respect foreign key constraints
     // Delete notifications first (they reference users)
-    logger.info('Clearing database');
     await prisma.notification.deleteMany();
     // Delete chat-related records
     await prisma.mention.deleteMany();
@@ -78,7 +77,7 @@ export const seedDatabase = async () => {
     ]);
     // 3. Create Students (realistic names)
     const students = await Promise.all([
-        createUser('alex.martinez@student.rverside.eidu', 'student123', 'alex.martinez'),
+        createUser('alex.martinez@student.riverside.edu', 'student123', 'alex.martinez'),
         createUser('sophia.williams@student.riverside.edu', 'student123', 'sophia.williams'),
         createUser('james.brown@student.riverside.edu', 'student123', 'james.brown'),
         createUser('olivia.taylor@student.riverside.edu', 'student123', 'olivia.taylor'),

package/dist/utils/logger.d.ts

@@ -10,7 +10,6 @@ declare class Logger {
     private isDevelopment;
     private mode;
     private levelColors;
-    private levelBgColors;
     private levelEmojis;
     private constructor();
     static getInstance(): Logger;

package/dist/utils/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA,oBAAY,QAAQ;IAClB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;IACf,KAAK,UAAU;CAChB;AAED,KAAK,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAyC3D,cAAM,MAAM;IACV,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,WAAW,CAA2B;IAC9C,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,WAAW,CAA2B;IAE9C,OAAO;WA8BO,WAAW,IAAI,MAAM;IAO5B,OAAO,CAAC,IAAI,EAAE,OAAO;IAI5B,OAAO,CAAC,SAAS;IAsBjB,OAAO,CAAC,aAAa;IAmBrB,OAAO,CAAC,GAAG;IAqCJ,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAInD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAInD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIpD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAG5D;AAED,eAAO,MAAM,MAAM,QAAuB,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA,oBAAY,QAAQ;IAClB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;IACf,KAAK,UAAU;CAChB;AAED,KAAK,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAwB3D,cAAM,MAAM;IACV,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,WAAW,CAA2B;IAC9C,OAAO,CAAC,WAAW,CAA2B;IAE9C,OAAO;WAuBO,WAAW,IAAI,MAAM;IAO5B,OAAO,CAAC,IAAI,EAAE,OAAO;IAI5B,OAAO,CAAC,SAAS;IAsBjB,OAAO,CAAC,aAAa;IAiBrB,OAAO,CAAC,GAAG;IAqCJ,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAInD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAInD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIpD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAG5D;AAED,eAAO,MAAM,MAAM,QAAuB,CAAC"}

package/dist/utils/logger.js

@@ -17,24 +17,7 @@ const colors = {
     magenta: '\x1b[35m',
     cyan: '\x1b[36m',
     white: '\x1b[37m',
-    gray: '\x1b[90m',
-    // Background colors
-    bgRed: '\x1b[41m',
-    bgGreen: '\x1b[42m',
-    bgYellow: '\x1b[43m',
-    bgBlue: '\x1b[44m',
-    bgMagenta: '\x1b[45m',
-    bgCyan: '\x1b[46m',
-    bgWhite: '\x1b[47m',
-    bgGray: '\x1b[100m',
-    // Bright background colors
-    bgBrightRed: '\x1b[101m',
-    bgBrightGreen: '\x1b[102m',
-    bgBrightYellow: '\x1b[103m',
-    bgBrightBlue: '\x1b[104m',
-    bgBrightMagenta: '\x1b[105m',
-    bgBrightCyan: '\x1b[106m',
-    bgBrightWhite: '\x1b[107m'
+    gray: '\x1b[90m'
 };
 class Logger {
     constructor() {
@@ -47,12 +30,6 @@ class Logger {
             [LogLevel.ERROR]: colors.red,
             [LogLevel.DEBUG]: colors.magenta
         };
-        this.levelBgColors = {
-            [LogLevel.INFO]: colors.bgBlue,
-            [LogLevel.WARN]: colors.bgYellow,
-            [LogLevel.ERROR]: colors.bgRed,
-            [LogLevel.DEBUG]: colors.bgMagenta
-        };
         this.levelEmojis = {
             [LogLevel.INFO]: 'ℹ️',
             [LogLevel.WARN]: '⚠️',
@@ -93,11 +70,9 @@ class Logger {
     formatMessage(logMessage) {
         const { level, message, timestamp, context } = logMessage;
         const color = this.levelColors[level];
-        const bgColor = this.levelBgColors[level];
         const emoji = this.levelEmojis[level];
         const timestampStr = colors.gray + `[${timestamp}]` + colors.reset;
-        // Use background color for level badge like Vitest
-        const levelStr = colors.white + bgColor + ` ${level.toUpperCase()} ` + colors.reset;
+        const levelStr = color + `[${level.toUpperCase()}]` + colors.reset;
         const emojiStr = emoji + ' ';
         const messageStr = colors.bright + message + colors.reset;
         const contextStr = context

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studious-lms/server",
-  "version": "1.1.22",
+  "version": "1.1.24",
   "description": "Backend server for Studious application",
   "main": "dist/exportType.js",
   "types": "dist/exportType.d.ts",
@@ -18,7 +18,7 @@
     "generate": "npx prisma generate",
     "prepublishOnly": "npm run generate && npm run build",
     "test": "vitest",
-    "seed": "tsx src/seedDatabase.ts"
+    "seed": "node dist/seedDatabase.js"
   },
   "dependencies": {
     "@google-cloud/storage": "^7.16.0",

package/src/lib/fileUpload.ts

@@ -1,6 +1,6 @@
 import { TRPCError } from "@trpc/server";
 import { v4 as uuidv4 } from "uuid";
-import { getSignedUrl, objectExists } from "./googleCloudStorage.js";
+import { getSignedUrl } from "./googleCloudStorage.js";
 import { generateMediaThumbnail } from "./thumbnailGenerator.js";
 import { prisma } from "./prisma.js";
 import { logger } from "../utils/logger.js";
@@ -182,11 +182,7 @@ export async function createDirectUploadFile(
       uploadSessionId
     };
   } catch (error) {
-    logger.error('Error creating direct upload file:', {error: error instanceof Error ? {
-      name: error.name,
-      message: error.message,
-      stack: error.stack,
-    } : error});
+    console.error('Error creating direct upload file:', error);
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
       message: 'Failed to create direct upload file',
@@ -206,53 +202,17 @@ export async function confirmDirectUpload(
   errorMessage?: string
 ): Promise<void> {
   try {
-    // First fetch the file record to get the object path
-    const fileRecord = await prisma.file.findUnique({
-      where: { id: fileId },
-      select: { path: true }
-    });
-
-    if (!fileRecord) {
-      throw new TRPCError({
-        code: 'NOT_FOUND',
-        message: 'File record not found',
-      });
-    }
-
-    let actualUploadSuccess = uploadSuccess;
-    let actualErrorMessage = errorMessage;
-
-    // If uploadSuccess is true, verify the object actually exists in GCS
-    if (uploadSuccess) {
-      try {
-        const exists = await objectExists(process.env.GOOGLE_CLOUD_BUCKET_NAME!, fileRecord.path);
-        if (!exists) {
-          actualUploadSuccess = false;
-          actualErrorMessage = 'File upload reported as successful but object not found in Google Cloud Storage';
-          logger.error(`File upload verification failed for ${fileId}: object ${fileRecord.path} not found in GCS`);
-        }
-      } catch (error) {
-        logger.error(`Error verifying file existence in GCS for ${fileId}:`, {error: error instanceof Error ? {
-          name: error.name,
-          message: error.message,
-          stack: error.stack,
-        } : error});
-        actualUploadSuccess = false;
-        actualErrorMessage = 'Failed to verify file existence in Google Cloud Storage';
-      }
-    }
-
     const updateData: any = {
-      uploadStatus: actualUploadSuccess ? 'COMPLETED' : 'FAILED',
-      uploadProgress: actualUploadSuccess ? 100 : 0,
+      uploadStatus: uploadSuccess ? 'COMPLETED' : 'FAILED',
+      uploadProgress: uploadSuccess ? 100 : 0,
     };
     
-    if (!actualUploadSuccess && actualErrorMessage) {
-      updateData.uploadError = actualErrorMessage;
+    if (!uploadSuccess && errorMessage) {
+      updateData.uploadError = errorMessage;
       updateData.uploadRetryCount = { increment: 1 };
     }
     
-    if (actualUploadSuccess) {
+    if (uploadSuccess) {
       updateData.uploadedAt = new Date();
     }
     
@@ -261,7 +221,7 @@ export async function confirmDirectUpload(
       data: updateData
     });
   } catch (error) {
-    logger.error('Error confirming direct upload:', {error});
+    console.error('Error confirming direct upload:', error);
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
       message: 'Failed to confirm upload',
@@ -279,29 +239,15 @@ export async function updateUploadProgress(
   progress: number
 ): Promise<void> {
   try {
-    // await prisma.file.update({
-    //   where: { id: fileId },
-    //   data: {
-    //     uploadStatus: 'UPLOADING',
-    //     uploadProgress: Math.min(100, Math.max(0, progress))
-    //   }
-    // });
-    const current = await prisma.file.findUnique({ where: { id: fileId }, select: { uploadStatus: true } });
-    if (!current || ['COMPLETED','FAILED','CANCELLED'].includes(current.uploadStatus as string)) return;
-    const clamped = Math.min(100, Math.max(0, progress));
     await prisma.file.update({
       where: { id: fileId },
       data: {
         uploadStatus: 'UPLOADING',
-        uploadProgress: clamped
+        uploadProgress: Math.min(100, Math.max(0, progress))
       }
     });
   } catch (error) {
-    logger.error('Error updating upload progress:', {error: error instanceof Error ? {
-      name: error.name,
-      message: error.message,
-      stack: error.stack,
-    } : error});  
+    console.error('Error updating upload progress:', error);
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
       message: 'Failed to update upload progress',
@@ -331,11 +277,7 @@ export async function createDirectUploadFiles(
     );
     return await Promise.all(uploadPromises);
   } catch (error) {
-    logger.error('Error creating direct upload files:', {error: error instanceof Error ? {
-      name: error.name,
-      message: error.message,
-      stack: error.stack,
-    } : error});
+    console.error('Error creating direct upload files:', error);
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
       message: 'Failed to create direct upload files',

package/src/lib/googleCloudStorage.ts

@@ -62,23 +62,4 @@ export async function deleteFile(filePath: string): Promise<void> {
       message: 'Failed to delete file from storage',
     });
   }
-}
-
-/**
- * Checks if an object exists in Google Cloud Storage
- * @param bucketName The name of the bucket (unused, uses default bucket)
- * @param objectPath The path of the object to check
- * @returns Promise<boolean> True if the object exists, false otherwise
- */
-export async function objectExists(bucketName: string, objectPath: string): Promise<boolean> {
-  try {
-    const [exists] = await bucket.file(objectPath).exists();
-    return exists;
-  } catch (error) {
-    console.error('Error checking if object exists in Google Cloud Storage:', error);
-    throw new TRPCError({
-      code: 'INTERNAL_SERVER_ERROR',
-      message: 'Failed to check object existence',
-    });
-  }
 }