@studious-lms/server 1.1.24 → 1.1.26

package/dist/routers/auth.js

@@ -146,7 +146,7 @@ export const authRouter = createTRPCRouter({
             },
         };
     }),
-    logout: publicProcedure
+    logout: protectedProcedure
         .mutation(async ({ ctx }) => {
         if (!ctx.user) {
             throw new TRPCError({

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

@@ -1 +1 @@
-{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/routers/file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsVrB,CAAC"}
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/routers/file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyVrB,CAAC"}

package/dist/routers/file.js

@@ -295,13 +295,16 @@ export const fileRouter = createTRPCRouter({
                 message: "File does not belong to this class",
             });
         }
-        // Delete files from storage
+        // Delete files from storage (only if they were actually uploaded)
         try {
-            // Delete the main file
-            await deleteFile(file.path);
-            // Delete thumbnail if it exists
-            if (file.thumbnail) {
-                await deleteFile(file.thumbnail.path);
+            // Only delete from GCS if the file was successfully uploaded
+            if (file.uploadStatus === 'COMPLETED') {
+                // Delete the main file
+                await deleteFile(file.path);
+                // Delete thumbnail if it exists
+                if (file.thumbnail) {
+                    await deleteFile(file.thumbnail.path);
+                }
             }
         }
         catch (error) {

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

@@ -1 +1 @@
-{"version":3,"file":"labChat.d.ts","sourceRoot":"","sources":["../../src/routers/labChat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAkBxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAonBxB,CAAC"}
+{"version":3,"file":"labChat.d.ts","sourceRoot":"","sources":["../../src/routers/labChat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAonBxB,CAAC"}

package/dist/routers/labChat.js

@@ -6,8 +6,7 @@ import { TRPCError } from '@trpc/server';
 import { inferenceClient, sendAIMessage } from '../utils/inference.js';
 import { logger } from '../utils/logger.js';
 import { isAIUser } from '../utils/aiUser.js';
-// DEPRECATED: uploadFile removed - use direct upload instead
-// import { uploadFile } from '../lib/googleCloudStorage.js';
+import { bucket } from '../lib/googleCloudStorage.js';
 import { createPdf } from "../lib/jsonConversion.js";
 import { v4 as uuidv4 } from "uuid";
 export const labChatRouter = createTRPCRouter({
@@ -833,16 +832,25 @@ WHEN CREATING COURSE MATERIALS (docs field):
                                 .replace(/\s+/g, '_')
                                 .substring(0, 50);
                             const filename = `${sanitizedTitle}_${uuidv4().substring(0, 8)}.pdf`;
+                            const filePath = `class/generated/${fullLabChat.classId}/${filename}`;
                             logger.info(`PDF ${i + 1} generated successfully`, { labChatId, title: doc.title });
-                            // DEPRECATED: Base64 upload removed - use direct upload instead
-                            // const gcpResult = await uploadFile(Buffer.from(pdfBytes).toString('base64'), `class/generated/${fullLabChat.classId}/${filename}`, 'application/pdf');
+                            // Upload directly to Google Cloud Storage
+                            const gcsFile = bucket.file(filePath);
+                            await gcsFile.save(Buffer.from(pdfBytes), {
+                                metadata: {
+                                    contentType: 'application/pdf',
+                                }
+                            });
                             logger.info(`PDF ${i + 1} uploaded successfully`, { labChatId, filename });
                             const file = await prisma.file.create({
                                 data: {
                                     name: filename,
-                                    path: `class/generated/${fullLabChat.classId}/${filename}`,
+                                    path: filePath,
                                     type: 'application/pdf',
+                                    size: pdfBytes.length,
                                     userId: fullLabChat.createdById,
+                                    uploadStatus: 'COMPLETED',
+                                    uploadedAt: new Date(),
                                 },
                             });
                             attachmentIds.push(file.id);

package/dist/routers/notifications.d.ts

@@ -30,9 +30,9 @@ export declare const notificationRouter: import("@trpc/server").TRPCBuiltRouter<
             title: string;
             content: string;
             createdAt: Date;
-            read: boolean;
-            receiverId: string;
             senderId: string | null;
+            receiverId: string;
+            read: boolean;
         })[];
         meta: object;
     }>;
@@ -52,9 +52,9 @@ export declare const notificationRouter: import("@trpc/server").TRPCBuiltRouter<
             title: string;
             content: string;
             createdAt: Date;
-            read: boolean;
-            receiverId: string;
             senderId: string | null;
+            receiverId: string;
+            read: boolean;
         }) | null;
         meta: object;
     }>;
@@ -69,9 +69,9 @@ export declare const notificationRouter: import("@trpc/server").TRPCBuiltRouter<
             title: string;
             content: string;
             createdAt: Date;
-            read: boolean;
-            receiverId: string;
             senderId: string | null;
+            receiverId: string;
+            read: boolean;
         };
         meta: object;
     }>;
@@ -93,9 +93,9 @@ export declare const notificationRouter: import("@trpc/server").TRPCBuiltRouter<
             title: string;
             content: string;
             createdAt: Date;
-            read: boolean;
-            receiverId: string;
             senderId: string | null;
+            receiverId: string;
+            read: boolean;
         };
         meta: object;
     }>;

package/dist/routers/section.d.ts

@@ -31,6 +31,22 @@ export declare const sectionRouter: import("@trpc/server").TRPCBuiltRouter<{
         };
         meta: object;
     }>;
+    reorder: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            classId: string;
+            movedId: string;
+            position: "start" | "end" | "before" | "after";
+            targetId?: string | undefined;
+        };
+        output: {
+            id: string;
+            name: string;
+            color: string | null;
+            classId: string;
+            order: number | null;
+        } | null;
+        meta: object;
+    }>;
     update: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             id: string;

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

@@ -1 +1 @@
-{"version":3,"file":"section.d.ts","sourceRoot":"","sources":["../../src/routers/section.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuBxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwMxB,CAAC"}
+{"version":3,"file":"section.d.ts","sourceRoot":"","sources":["../../src/routers/section.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuBxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkUxB,CAAC"}

package/dist/routers/section.js

@@ -56,34 +56,119 @@ export const sectionRouter = createTRPCRouter({
                 }),
             },
         });
-        // find all root items in the class and reorder them
-        const sections = await prisma.section.findMany({
-            where: {
-                classId: input.classId,
-            },
-        });
-        const assignments = await prisma.assignment.findMany({
-            where: {
-                classId: input.classId,
-                sectionId: null,
-            },
-        });
-        const stack = [...sections, ...assignments].sort((a, b) => (a.order || 0) - (b.order || 0)).map((item, index) => ({
-            id: item.id,
-            order: index + 1,
-        })).map((item) => ({
-            where: { id: item.id },
-            data: { order: item.order },
-        }));
-        // Update sections and assignments with their new order
-        await Promise.all([
-            ...stack.filter(item => sections.some(s => s.id === item.where.id))
-                .map(({ where, data }) => prisma.section.update({ where, data })),
-            ...stack.filter(item => assignments.some(a => a.id === item.where.id))
-                .map(({ where, data }) => prisma.assignment.update({ where, data }))
+        // Insert new section at top of unified list (sections + assignments) and normalize
+        const [sections, assignments] = await Promise.all([
+            prisma.section.findMany({
+                where: { classId: input.classId },
+                select: { id: true, order: true },
+            }),
+            prisma.assignment.findMany({
+                where: { classId: input.classId },
+                select: { id: true, order: true },
+            }),
         ]);
+        const unified = [
+            ...sections.map(s => ({ id: s.id, order: s.order, type: 'section' })),
+            ...assignments.map(a => ({ id: a.id, order: a.order, type: 'assignment' })),
+        ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
+        const withoutNew = unified.filter(item => !(item.id === section.id && item.type === 'section'));
+        const reindexed = [{ id: section.id, type: 'section' }, ...withoutNew.map(item => ({ id: item.id, type: item.type }))];
+        await Promise.all(reindexed.map((item, index) => {
+            if (item.type === 'section') {
+                return prisma.section.update({ where: { id: item.id }, data: { order: index + 1 } });
+            }
+            else {
+                return prisma.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
+            }
+        }));
         return section;
     }),
+    reorder: protectedProcedure
+        .input(z.object({
+        classId: z.string(),
+        movedId: z.string(), // Section ID
+        // One of: place at start/end of unified list, or relative to targetId (can be section or assignment)
+        position: z.enum(['start', 'end', 'before', 'after']),
+        targetId: z.string().optional(), // Can be a section ID or assignment ID
+    }))
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        const { classId, movedId, position, targetId } = input;
+        const moved = await prisma.section.findFirst({
+            where: { id: movedId, classId },
+            select: { id: true, classId: true },
+        });
+        if (!moved) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Section not found' });
+        }
+        if ((position === 'before' || position === 'after') && !targetId) {
+            throw new TRPCError({ code: 'BAD_REQUEST', message: 'targetId required for before/after' });
+        }
+        const result = await prisma.$transaction(async (tx) => {
+            const [sections, assignments] = await Promise.all([
+                tx.section.findMany({
+                    where: { classId },
+                    select: { id: true, order: true },
+                }),
+                tx.assignment.findMany({
+                    where: { classId },
+                    select: { id: true, order: true },
+                }),
+            ]);
+            const unified = [
+                ...sections.map(s => ({ id: s.id, order: s.order, type: 'section' })),
+                ...assignments.map(a => ({ id: a.id, order: a.order, type: 'assignment' })),
+            ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
+            const movedIdx = unified.findIndex(item => item.id === movedId && item.type === 'section');
+            if (movedIdx === -1) {
+                throw new TRPCError({ code: 'NOT_FOUND', message: 'Section not found in unified list' });
+            }
+            const withoutMoved = unified.filter(item => !(item.id === movedId && item.type === 'section'));
+            let next = [];
+            if (position === 'start') {
+                next = [{ id: movedId, type: 'section' }, ...withoutMoved.map(item => ({ id: item.id, type: item.type }))];
+            }
+            else if (position === 'end') {
+                next = [...withoutMoved.map(item => ({ id: item.id, type: item.type })), { id: movedId, type: 'section' }];
+            }
+            else {
+                const targetIdx = withoutMoved.findIndex(item => item.id === targetId);
+                if (targetIdx === -1) {
+                    throw new TRPCError({ code: 'BAD_REQUEST', message: 'targetId not found in unified list' });
+                }
+                if (position === 'before') {
+                    next = [
+                        ...withoutMoved.slice(0, targetIdx).map(item => ({ id: item.id, type: item.type })),
+                        { id: movedId, type: 'section' },
+                        ...withoutMoved.slice(targetIdx).map(item => ({ id: item.id, type: item.type })),
+                    ];
+                }
+                else {
+                    next = [
+                        ...withoutMoved.slice(0, targetIdx + 1).map(item => ({ id: item.id, type: item.type })),
+                        { id: movedId, type: 'section' },
+                        ...withoutMoved.slice(targetIdx + 1).map(item => ({ id: item.id, type: item.type })),
+                    ];
+                }
+            }
+            // Normalize to 1..n
+            await Promise.all(next.map((item, index) => {
+                if (item.type === 'section') {
+                    return tx.section.update({ where: { id: item.id }, data: { order: index + 1 } });
+                }
+                else {
+                    return tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
+                }
+            }));
+            return tx.section.findUnique({ where: { id: movedId } });
+        });
+        return result;
+    }),
     update: protectedProcedure
         .input(updateSectionSchema)
         .mutation(async ({ ctx, input }) => {
@@ -151,11 +236,35 @@ export const sectionRouter = createTRPCRouter({
                 message: "Class not found or you are not a teacher",
             });
         }
-        await prisma.section.update({
-            where: { id: input.id },
-            data: {
-                order: input.order,
-            },
+        // Update order and normalize unified list
+        await prisma.$transaction(async (tx) => {
+            await tx.section.update({
+                where: { id: input.id },
+                data: { order: input.order },
+            });
+            // Normalize entire unified list
+            const [sections, assignments] = await Promise.all([
+                tx.section.findMany({
+                    where: { classId: input.classId },
+                    select: { id: true, order: true },
+                }),
+                tx.assignment.findMany({
+                    where: { classId: input.classId },
+                    select: { id: true, order: true },
+                }),
+            ]);
+            const unified = [
+                ...sections.map(s => ({ id: s.id, order: s.order, type: 'section' })),
+                ...assignments.map(a => ({ id: a.id, order: a.order, type: 'assignment' })),
+            ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
+            await Promise.all(unified.map((item, index) => {
+                if (item.type === 'section') {
+                    return tx.section.update({ where: { id: item.id }, data: { order: index + 1 } });
+                }
+                else {
+                    return tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
+                }
+            }));
         });
         return { id: input.id };
     }),

package/dist/seedDatabase.d.ts

@@ -14,9 +14,9 @@ export declare function addNotification(userId: string, title: string, content:
     title: string;
     content: string;
     createdAt: Date;
-    read: boolean;
-    receiverId: string;
     senderId: string | null;
+    receiverId: string;
+    read: boolean;
 }>;
 export declare const seedDatabase: () => Promise<void>;
 //# sourceMappingURL=seedDatabase.d.ts.map

package/dist/seedDatabase.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"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"}

package/dist/seedDatabase.js

@@ -4,6 +4,7 @@ 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();
@@ -77,7 +78,7 @@ export const seedDatabase = async () => {
     ]);
     // 3. Create Students (realistic names)
     const students = await Promise.all([
-        createUser('alex.martinez@student.riverside.edu', 'student123', 'alex.martinez'),
+        createUser('alex.martinez@student.rverside.eidu', '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,6 +10,7 @@ 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;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"}
+{"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"}

package/dist/utils/logger.js

@@ -17,7 +17,24 @@ const colors = {
     magenta: '\x1b[35m',
     cyan: '\x1b[36m',
     white: '\x1b[37m',
-    gray: '\x1b[90m'
+    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'
 };
 class Logger {
     constructor() {
@@ -30,6 +47,12 @@ 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]: '⚠️',
@@ -70,9 +93,11 @@ 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;
-        const levelStr = color + `[${level.toUpperCase()}]` + colors.reset;
+        // Use background color for level badge like Vitest
+        const levelStr = colors.white + bgColor + ` ${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.24",
+  "version": "1.1.26",
   "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": "node dist/seedDatabase.js"
+    "seed": "tsx src/seedDatabase.ts"
   },
   "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 } from "./googleCloudStorage.js";
+import { getSignedUrl, objectExists } from "./googleCloudStorage.js";
 import { generateMediaThumbnail } from "./thumbnailGenerator.js";
 import { prisma } from "./prisma.js";
 import { logger } from "../utils/logger.js";
@@ -182,7 +182,11 @@ export async function createDirectUploadFile(
       uploadSessionId
     };
   } catch (error) {
-    console.error('Error creating direct upload file:', error);
+    logger.error('Error creating direct upload file:', {error: error instanceof Error ? {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    } : error});
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
       message: 'Failed to create direct upload file',
@@ -202,17 +206,53 @@ 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: uploadSuccess ? 'COMPLETED' : 'FAILED',
-      uploadProgress: uploadSuccess ? 100 : 0,
+      uploadStatus: actualUploadSuccess ? 'COMPLETED' : 'FAILED',
+      uploadProgress: actualUploadSuccess ? 100 : 0,
     };
     
-    if (!uploadSuccess && errorMessage) {
-      updateData.uploadError = errorMessage;
+    if (!actualUploadSuccess && actualErrorMessage) {
+      updateData.uploadError = actualErrorMessage;
       updateData.uploadRetryCount = { increment: 1 };
     }
     
-    if (uploadSuccess) {
+    if (actualUploadSuccess) {
       updateData.uploadedAt = new Date();
     }
     
@@ -221,7 +261,7 @@ export async function confirmDirectUpload(
       data: updateData
     });
   } catch (error) {
-    console.error('Error confirming direct upload:', error);
+    logger.error('Error confirming direct upload:', {error});
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
       message: 'Failed to confirm upload',
@@ -239,15 +279,29 @@ 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: Math.min(100, Math.max(0, progress))
+        uploadProgress: clamped
       }
     });
   } catch (error) {
-    console.error('Error updating upload progress:', error);
+    logger.error('Error updating upload progress:', {error: error instanceof Error ? {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    } : error});  
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
       message: 'Failed to update upload progress',
@@ -277,7 +331,11 @@ export async function createDirectUploadFiles(
     );
     return await Promise.all(uploadPromises);
   } catch (error) {
-    console.error('Error creating direct upload files:', error);
+    logger.error('Error creating direct upload files:', {error: error instanceof Error ? {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    } : error});
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
       message: 'Failed to create direct upload files',

package/src/lib/googleCloudStorage.ts

@@ -62,4 +62,23 @@ 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',
+    });
+  }
 }