@studious-lms/server 1.1.22 → 1.1.24

package/src/routers/assignment.ts

@@ -113,6 +113,18 @@ const confirmSubmissionUploadSchema = z.object({
   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),
@@ -741,7 +753,6 @@ export const assignmentRouter = createTRPCRouter({
             select: {
               id: true,
               username: true,
-              profile: true,
             },
           },
           assignment: {
@@ -848,7 +859,12 @@ export const assignmentRouter = createTRPCRouter({
             select: {
               id: true,
               username: true,
-              profile: true,
+              profile: {
+                select: {
+                  displayName: true,
+                  profilePicture: true,
+                }
+              }
             },
           },
           assignment: {
@@ -1270,31 +1286,13 @@ export const assignmentRouter = createTRPCRouter({
         });
       }
 
-      let uploadedFiles: UploadedFile[] = [];
+      // 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.",
         });
       }
 
@@ -2054,6 +2052,109 @@ export const assignmentRouter = createTRPCRouter({
       };
     }),
 
+  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/src/routers/folder.ts

@@ -793,4 +793,113 @@ 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: typeof folder | null = 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/src/seedDatabase.ts

@@ -5,7 +5,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
@@ -95,7 +94,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/src/utils/logger.ts

@@ -26,24 +26,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 {
@@ -51,7 +34,6 @@ class Logger {
   private isDevelopment: boolean;
   private mode: LogMode;
   private levelColors: Record<LogLevel, string>;
-  private levelBgColors: Record<LogLevel, string>;
   private levelEmojis: Record<LogLevel, string>;
 
   private constructor() {
@@ -69,13 +51,6 @@ class Logger {
       [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]: '⚠️',
@@ -120,12 +95,10 @@ class Logger {
   private formatMessage(logMessage: LogMessage): string {
     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;
     

package/tests/setup.ts

@@ -5,7 +5,6 @@ import { logger } from '../src/utils/logger';
 import { appRouter } from '../src/routers/_app';
 import { createTRPCContext } from '../src/trpc';
 import { Session } from '@prisma/client';
-import { clearDatabase } from '../src/seedDatabase';
 
 const getCaller = async (token: string) => {
   const ctx = await createTRPCContext({
@@ -20,8 +19,15 @@ const getCaller = async (token: string) => {
 
   // Before the entire test suite runs
   beforeAll(async () => {
-
-    await clearDatabase();
+  //   // Run migrations so the test DB has the latest schema
+  //   try {
+  //     logger.info('Setting up test database');
+  //     execSync('rm -f prisma/test.db');
+  //     execSync('npx prisma db push --force-reset --schema=prisma/schema.prisma');
+    
+  //   } catch (error) {
+  //     logger.error('Error initializing test database');
+  //   }
 
     logger.info('Getting caller');