@studious-lms/server 1.1.0 → 1.1.2

package/dist/routers/section.d.ts

@@ -20,11 +20,14 @@ export declare const sectionRouter: import("@trpc/server").TRPCBuiltRouter<{
         input: {
             name: string;
             classId: string;
+            color?: string | undefined;
         };
         output: {
             id: string;
             name: string;
+            color: string | null;
             classId: string;
+            order: number | null;
         };
         meta: object;
     }>;
@@ -33,11 +36,25 @@ export declare const sectionRouter: import("@trpc/server").TRPCBuiltRouter<{
             id: string;
             name: string;
             classId: string;
+            color?: string | undefined;
         };
         output: {
             id: string;
             name: string;
+            color: string | null;
             classId: string;
+            order: number | null;
+        };
+        meta: object;
+    }>;
+    reOrder: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+            classId: string;
+            order: number;
+        };
+        output: {
+            id: string;
         };
         meta: object;
     }>;

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;AAqBxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoHxB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwMxB,CAAC"}

package/dist/routers/section.js

@@ -5,11 +5,13 @@ import { prisma } from "../lib/prisma.js";
 const createSectionSchema = z.object({
     classId: z.string(),
     name: z.string(),
+    color: z.string().optional(),
 });
 const updateSectionSchema = z.object({
     id: z.string(),
     classId: z.string(),
     name: z.string(),
+    color: z.string().optional(),
 });
 const deleteSectionSchema = z.object({
     id: z.string(),
@@ -45,11 +47,41 @@ export const sectionRouter = createTRPCRouter({
         const section = await prisma.section.create({
             data: {
                 name: input.name,
+                order: 0,
                 class: {
                     connect: { id: input.classId },
                 },
+                ...(input.color && {
+                    color: input.color,
+                }),
             },
         });
+        // 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 }))
+        ]);
         return section;
     }),
     update: protectedProcedure
@@ -82,10 +114,51 @@ export const sectionRouter = createTRPCRouter({
             where: { id: input.id },
             data: {
                 name: input.name,
+                ...(input.color && {
+                    color: input.color,
+                }),
             },
         });
         return section;
     }),
+    reOrder: protectedProcedure
+        .input(z.object({
+        id: z.string(),
+        classId: z.string(),
+        order: z.number(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        // Verify user is a teacher of the class
+        const classData = await prisma.class.findFirst({
+            where: {
+                id: input.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",
+            });
+        }
+        await prisma.section.update({
+            where: { id: input.id },
+            data: {
+                order: input.order,
+            },
+        });
+        return { id: input.id };
+    }),
     delete: protectedProcedure
         .input(deleteSectionSchema)
         .mutation(async ({ ctx, input }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studious-lms/server",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Backend server for Studious application",
   "main": "dist/exportType.js",
   "types": "dist/exportType.d.ts",

package/prisma/migrations/20250919063704_init2/migration.sql

@@ -0,0 +1,24 @@
+-- DropForeignKey
+ALTER TABLE "Notification" DROP CONSTRAINT "Notification_receiverId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "UserProfile" DROP CONSTRAINT "UserProfile_userId_fkey";
+
+-- AlterTable
+ALTER TABLE "Assignment" ADD COLUMN     "order" INTEGER;
+
+-- AlterTable
+ALTER TABLE "Folder" ADD COLUMN     "color" TEXT DEFAULT '#3B82F6';
+
+-- AlterTable
+ALTER TABLE "Section" ADD COLUMN     "color" TEXT DEFAULT '#3B82F6',
+ADD COLUMN     "order" INTEGER;
+
+-- AlterTable
+ALTER TABLE "Submission" ADD COLUMN     "teacherComments" TEXT;
+
+-- AddForeignKey
+ALTER TABLE "UserProfile" ADD CONSTRAINT "UserProfile_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Notification" ADD CONSTRAINT "Notification_receiverId_fkey" FOREIGN KEY ("receiverId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/prisma/schema.prisma

@@ -132,6 +132,7 @@ model Folder {
   childFolders Folder[] @relation("ParentChildFolders")
   parentFolder Folder? @relation("ParentChildFolders", fields: [parentFolderId], references: [id])
   parentFolderId String?
+  color String? @default("#3B82F6")
   class Class? @relation("ClassFiles", fields: [classId], references: [id])
   classId String? @unique
 }
@@ -194,6 +195,7 @@ model Assignment {
   eventId       String?
   markScheme    MarkScheme? @relation(fields: [markSchemeId], references: [id], onDelete: Cascade)
   markSchemeId  String?
+  order         Int?
   gradingBoundary GradingBoundary? @relation(fields: [gradingBoundaryId], references: [id], onDelete: Cascade)
   gradingBoundaryId String?
 }
@@ -227,6 +229,7 @@ model Submission {
   gradeReceived Int?
 
   rubricState String?
+  teacherComments String?
 
   submittedAt DateTime?
   submitted   Boolean? @default(false)
@@ -239,6 +242,8 @@ model Section {
   classId   String
   class     Class @relation(fields: [classId], references: [id], onDelete: Cascade)
   assignments Assignment[]
+  color String? @default("#3B82F6")
+  order Int?
 }
 
 model Session {

package/src/routers/assignment.ts

@@ -84,6 +84,59 @@ const updateSubmissionSchema = z.object({
 });
 
 export const assignmentRouter = createTRPCRouter({
+  order: protectedTeacherProcedure
+    .input(z.object({
+      id: z.string(),
+      classId: z.string(),
+      order: z.number(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { id, order } = input;
+
+      const assignment = await prisma.assignment.update({
+        where: { id },
+        data: { order },
+      });
+
+      return assignment;
+    }),
+
+    move: protectedTeacherProcedure
+    .input(z.object({
+      id: z.string(),
+      classId: z.string(),
+      targetSectionId: z.string(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { id, targetSectionId,  } = input;
+
+
+      const assignments = await prisma.assignment.findMany({
+        where: { sectionId: targetSectionId },
+      });
+
+      const stack = assignments.sort((a, b) => (a.order || 0) - (b.order || 0)).map((assignment, index) => ({
+        id: assignment.id,
+        order: index + 1,
+      })).map((assignment) => ({
+        where: { id: assignment.id },
+        data: { order: assignment.order },
+      }));
+
+      await Promise.all(
+        stack.map(({ where, data }) =>
+          prisma.assignment.update({ where, data })
+        )
+      );
+
+      const assignment = await prisma.assignment.update({
+        where: { id },
+        data: { sectionId: targetSectionId, order: 0 },
+      });
+
+      return assignment;
+    }),
+
   create: protectedProcedure
     .input(createAssignmentSchema)
     .mutation(async ({ ctx, input }) => {
@@ -132,16 +185,35 @@ export const assignmentRouter = createTRPCRouter({
       }
       console.log(markSchemeId, gradingBoundaryId);
 
+      // find all assignments in the section it is in (or none) and reorder them
+      const assignments = await prisma.assignment.findMany({
+        where: {
+          classId: classId,
+          ...(sectionId && {
+            sectionId: sectionId,
+          }),
+        },
+      });
+
+      const stack = assignments.sort((a, b) => (a.order || 0) - (b.order || 0)).map((assignment, index) => ({
+        id: assignment.id,
+        order: index + 1,
+      })).map((assignment) => ({
+        where: { id: assignment.id },
+        data: { order: assignment.order },
+      }));
+
       // Create assignment with submissions for all students
       const assignment = await prisma.assignment.create({
         data: {
           title,
           instructions,
           dueDate: new Date(dueDate),
-          maxGrade: markSchemeId ?  computedMaxGrade : maxGrade,
+          maxGrade: markSchemeId ? computedMaxGrade : maxGrade,
           graded,
           weight,
           type,
+          order: 0,
           inProgress: inProgress || false,
           class: {
             connect: { id: classId }
@@ -156,7 +228,7 @@ export const assignmentRouter = createTRPCRouter({
               connect: { id: markSchemeId }
             }
           }),
-          ...(gradingBoundaryId && {  
+          ...(gradingBoundaryId && {
             gradingBoundary: {
               connect: { id: gradingBoundaryId }
             }
@@ -209,6 +281,12 @@ export const assignmentRouter = createTRPCRouter({
         }
       });
 
+      await Promise.all(
+        stack.map(({ where, data }) =>
+          prisma.assignment.update({ where, data })
+        )
+      );
+
       // Upload files if provided
       let uploadedFiles: UploadedFile[] = [];
       if (files && files.length > 0) {
@@ -478,7 +556,7 @@ export const assignmentRouter = createTRPCRouter({
         try {
           // Delete the main file
           await deleteFile(file.path);
-          
+
           // Delete thumbnail if it exists
           if (file.thumbnail) {
             await deleteFile(file.thumbnail.path);
@@ -493,7 +571,7 @@ export const assignmentRouter = createTRPCRouter({
         where: { id },
       });
 
-      return { 
+      return {
         id,
       };
     }),
@@ -595,7 +673,7 @@ export const assignmentRouter = createTRPCRouter({
           id: true,
           name: true,
         },
-      }); 
+      });
 
       return { ...assignment, sections };
     }),
@@ -913,7 +991,7 @@ export const assignmentRouter = createTRPCRouter({
 
       // Delete removed attachments if any
       if (removedAttachments && removedAttachments.length > 0) {
-        const filesToDelete = submission.attachments.filter((file) => 
+        const filesToDelete = submission.attachments.filter((file) =>
           removedAttachments.includes(file.id)
         );
 
@@ -922,7 +1000,7 @@ export const assignmentRouter = createTRPCRouter({
           try {
             // Delete the main file
             await deleteFile(file.path);
-            
+
             // Delete thumbnail if it exists
             if (file.thumbnail?.path) {
               await deleteFile(file.thumbnail.path);
@@ -1181,7 +1259,7 @@ export const assignmentRouter = createTRPCRouter({
 
       // Delete removed attachments if any
       if (removedAttachments && removedAttachments.length > 0) {
-        const filesToDelete = submission.annotations.filter((file) => 
+        const filesToDelete = submission.annotations.filter((file) =>
           removedAttachments.includes(file.id)
         );
 
@@ -1190,7 +1268,7 @@ export const assignmentRouter = createTRPCRouter({
           try {
             // Delete the main file
             await deleteFile(file.path);
-            
+
             // Delete thumbnail if it exists
             if (file.thumbnail?.path) {
               await deleteFile(file.thumbnail.path);
@@ -1575,7 +1653,7 @@ export const assignmentRouter = createTRPCRouter({
 
       return updatedAssignment;
     }),
-    detachMarkScheme: protectedTeacherProcedure
+  detachMarkScheme: protectedTeacherProcedure
     .input(z.object({
       assignmentId: z.string(),
     }))
@@ -1594,7 +1672,7 @@ export const assignmentRouter = createTRPCRouter({
           message: "Assignment not found",
         });
       }
-      
+
       const updatedAssignment = await prisma.assignment.update({
         where: { id: assignmentId },
         data: {
@@ -1613,7 +1691,7 @@ export const assignmentRouter = createTRPCRouter({
 
       return updatedAssignment;
     }),
-    attachGradingBoundary: protectedTeacherProcedure
+  attachGradingBoundary: protectedTeacherProcedure
     .input(z.object({
       assignmentId: z.string(),
       gradingBoundaryId: z.string().nullable(),

package/src/routers/class.ts

@@ -128,6 +128,7 @@ export const classRouter = createTRPCRouter({
               dueDate: true,
               createdAt: true,
               weight: true,
+              order: true,
               graded: true,
               maxGrade: true,
               instructions: true,
@@ -172,7 +173,7 @@ export const classRouter = createTRPCRouter({
       if (!classData) {
         throw new Error('Class not found');
       }
-
+      
       const formattedClassData = {
         ...classData,
         assignments: classData.assignments.map(assignment => ({

package/src/routers/folder.ts

@@ -14,6 +14,7 @@ const fileSchema = z.object({
 const createFolderSchema = z.object({
   name: z.string(),
   parentFolderId: z.string().optional(),
+  color: z.string().optional(),
 });
 
 const uploadFilesToFolderSchema = z.object({
@@ -29,7 +30,7 @@ export const folderRouter = createTRPCRouter({
   create: protectedTeacherProcedure
     .input(createFolderSchema)
     .mutation(async ({ ctx, input }) => {
-      const { classId, name } = input;
+      const { classId, name, color } = input;
       let parentFolderId = input.parentFolderId || null;
 
       if (!ctx.user) {
@@ -75,6 +76,9 @@ export const folderRouter = createTRPCRouter({
               class: {
                 connect: { id: classId },
               },
+              ...(color && {
+                color: color,
+              }),
             },
           });
         }
@@ -104,6 +108,9 @@ export const folderRouter = createTRPCRouter({
               connect: { id: parentFolderId },
             },
           }),
+          ...(color && {
+            color: color,
+          }),
         },
         include: {
           files: {
@@ -317,6 +324,7 @@ export const folderRouter = createTRPCRouter({
             select: {
               id: true,
               name: true,
+              color: true,
               _count: {
                 select: {
                   files: true,
@@ -391,6 +399,7 @@ export const folderRouter = createTRPCRouter({
             select: {
               id: true,
               name: true,
+              color: true,
               files: {
                 select: {
                   id: true,
@@ -682,14 +691,15 @@ export const folderRouter = createTRPCRouter({
       return updatedFolder;
     }),
 
-  rename: protectedTeacherProcedure
+  update: protectedTeacherProcedure
     .input(z.object({
       folderId: z.string(),
-      newName: z.string(),
+      name: z.string(),
+      color: z.string().optional(),
       classId: z.string(),
     }))
     .mutation(async ({ ctx, input }) => {
-      const { folderId, newName, classId } = input;
+      const { folderId, name, color, classId } = input;
 
       // Get the folder
       const folder = await prisma.folder.findFirst({
@@ -706,7 +716,7 @@ export const folderRouter = createTRPCRouter({
       }
 
       // Validate new name
-      if (!newName.trim()) {
+      if (!name.trim()) {
         throw new TRPCError({
           code: "BAD_REQUEST",
           message: "Folder name cannot be empty",
@@ -717,7 +727,10 @@ export const folderRouter = createTRPCRouter({
       const updatedFolder = await prisma.folder.update({
         where: { id: folderId },
         data: {
-          name: newName.trim(),
+          name: name.trim(),
+          ...(color && {
+            color: color,
+          }),
         },
         include: {
           files: {

package/src/routers/section.ts

@@ -6,12 +6,14 @@ import { prisma } from "../lib/prisma.js";
 const createSectionSchema = z.object({
   classId: z.string(),
   name: z.string(),
+  color: z.string().optional(),
 });
 
 const updateSectionSchema = z.object({
   id: z.string(),
   classId: z.string(),
   name: z.string(),
+  color: z.string().optional(),
 });
 
 const deleteSectionSchema = z.object({
@@ -52,12 +54,50 @@ export const sectionRouter = createTRPCRouter({
       const section = await prisma.section.create({
         data: {
           name: input.name,
+          order: 0,
           class: {
             connect: { id: input.classId },
           },
+          ...(input.color && {
+            color: input.color,
+          }),
         },
       });
 
+      // 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 })
+          )
+      ]);
+
       return section;
     }),
 
@@ -94,12 +134,58 @@ export const sectionRouter = createTRPCRouter({
         where: { id: input.id },
         data: {
           name: input.name,
+          ...(input.color && {
+            color: input.color,
+          }),
         },
       });
 
       return section;
     }),
 
+  reOrder: protectedProcedure
+    .input(z.object({
+      id: z.string(),
+      classId: z.string(),
+      order: z.number(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "User must be authenticated",
+        });
+      }
+
+      // Verify user is a teacher of the class
+      const classData = await prisma.class.findFirst({
+        where: {
+          id: input.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",
+        });
+      }
+
+      await prisma.section.update({
+        where: { id: input.id },
+        data: {
+          order: input.order,
+        },
+      });
+
+      return { id: input.id };
+    }),
+
   delete: protectedProcedure
     .input(deleteSectionSchema)
     .mutation(async ({ ctx, input }) => {