@studious-lms/server 1.2.32 → 1.2.34

package/dist/routers/assignment.js

@@ -75,6 +75,7 @@ const submissionSchema = z.object({
     submissionId: z.string(),
     submit: z.boolean().optional(),
     newAttachments: z.array(directFileSchema).optional(), // Use direct file schema
+    extendedResponse: z.string().optional(),
     existingFileIds: z.array(z.string()).optional(),
     removedAttachments: z.array(z.string()).optional(),
 });
@@ -150,15 +151,38 @@ async function getUnifiedList(tx, classId) {
     return unified;
 }
 // Helper function to normalize unified list to 1..n
+// Updated to batch updates to prevent timeouts with large lists
 async function normalizeUnifiedList(tx, classId, orderedItems) {
-    await Promise.all(orderedItems.map((item, index) => {
+    const BATCH_SIZE = 10; // Process 10 items at a time to avoid overwhelming the transaction
+    // Group items by type for more efficient updates
+    const sections = [];
+    const assignments = [];
+    orderedItems.forEach((item, index) => {
+        const orderData = { id: item.id, order: index + 1 };
         if (item.type === 'section') {
-            return tx.section.update({ where: { id: item.id }, data: { order: index + 1 } });
+            sections.push(orderData);
         }
         else {
-            return tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
+            assignments.push(orderData);
+        }
+    });
+    // Process updates in batches
+    const processBatch = async (items, type) => {
+        for (let i = 0; i < items.length; i += BATCH_SIZE) {
+            const batch = items.slice(i, i + BATCH_SIZE);
+            await Promise.all(batch.map(item => {
+                if (type === 'section') {
+                    return tx.section.update({ where: { id: item.id }, data: { order: item.order } });
+                }
+                else {
+                    return tx.assignment.update({ where: { id: item.id }, data: { order: item.order } });
+                }
+            }));
         }
-    }));
+    };
+    // Process sections and assignments sequentially to avoid transaction overload
+    await processBatch(sections, 'section');
+    await processBatch(assignments, 'assignment');
 }
 export const assignmentRouter = createTRPCRouter({
     // Reorder an assignment within the unified list (sections + assignments)
@@ -221,6 +245,9 @@ export const assignmentRouter = createTRPCRouter({
             // Normalize to 1..n
             await normalizeUnifiedList(tx, classId, next);
             return tx.assignment.findUnique({ where: { id: movedId } });
+        }, {
+            maxWait: 10000, // 10 seconds max wait time
+            timeout: 30000, // 30 seconds timeout for reordering operations
         });
         return result;
     }),
@@ -246,6 +273,9 @@ export const assignmentRouter = createTRPCRouter({
             const unified = await getUnifiedList(tx, current.classId);
             await normalizeUnifiedList(tx, current.classId, unified.map(item => ({ id: item.id, type: item.type })));
             return tx.assignment.findUnique({ where: { id } });
+        }, {
+            maxWait: 10000, // 10 seconds max wait time
+            timeout: 30000, // 30 seconds timeout for reordering operations
         });
         return updated;
     }),
@@ -272,6 +302,9 @@ export const assignmentRouter = createTRPCRouter({
             // No need to reorder since we're keeping the same position in the unified list
             // If frontend wants to change position, they should call reorder after move
             return tx.assignment.findUnique({ where: { id } });
+        }, {
+            maxWait: 5000, // 5 seconds max wait time
+            timeout: 10000, // 10 seconds timeout
         });
         return updated;
     }),
@@ -285,40 +318,51 @@ export const assignmentRouter = createTRPCRouter({
                 message: "User must be authenticated",
             });
         }
-        // Get all students in the class
-        const classData = await prisma.class.findUnique({
-            where: { id: classId },
-            include: {
-                students: {
-                    select: { id: true }
+        // Pre-fetch data needed for the transaction (outside transaction scope)
+        const [classData, rubricData] = await Promise.all([
+            prisma.class.findUnique({
+                where: { id: classId },
+                include: {
+                    students: {
+                        select: { id: true }
+                    }
                 }
-            }
-        });
+            }),
+            markSchemeId ? prisma.markScheme.findUnique({
+                where: { id: markSchemeId },
+                select: {
+                    structured: true,
+                }
+            }) : null
+        ]);
         if (!classData) {
             throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "Class not found",
             });
         }
+        // Calculate max grade outside transaction
         let computedMaxGrade = maxGrade;
-        if (markSchemeId) {
-            const rubric = await prisma.markScheme.findUnique({
-                where: { id: markSchemeId },
-                select: {
-                    structured: true,
-                }
-            });
-            const parsedRubric = JSON.parse(rubric?.structured || "{}");
-            // Calculate max grade from rubric criteria levels
+        if (markSchemeId && rubricData) {
+            const parsedRubric = JSON.parse(rubricData.structured || "{}");
             computedMaxGrade = parsedRubric.criteria.reduce((acc, criterion) => {
                 const maxPoints = Math.max(...criterion.levels.map((level) => level.points));
                 return acc + maxPoints;
             }, 0);
         }
-        console.log(markSchemeId, gradingBoundaryId);
-        // Create assignment and place at top of its scope within a single transaction
+        console.log(studentIds);
+        // Prepare submission data outside transaction
+        const submissionData = studentIds && studentIds.length > 0
+            ? studentIds.map((studentId) => ({
+                student: { connect: { id: studentId } }
+            }))
+            : classData.students.map((student) => ({
+                student: { connect: { id: student.id } }
+            }));
         const teacherId = ctx.user.id;
+        // Minimal transaction - only for critical operations
         const assignment = await prisma.$transaction(async (tx) => {
+            // Create assignment with order 0 (will be at top)
             const created = await tx.assignment.create({
                 data: {
                     title,
@@ -328,7 +372,7 @@ export const assignmentRouter = createTRPCRouter({
                     graded,
                     weight,
                     type,
-                    ...(aiPolicyLevel !== undefined && { aiPolicyLevel }),
+                    ...(aiPolicyLevel && { aiPolicyLevel }),
                     acceptFiles,
                     acceptExtendedResponse,
                     acceptWorksheet,
@@ -343,7 +387,7 @@ export const assignmentRouter = createTRPCRouter({
                             connect: studentIds.map(id => ({ id }))
                         }
                     }),
-                    order: 1,
+                    order: 0, // Set to 0 to place at top
                     inProgress: inProgress || false,
                     class: {
                         connect: { id: classId }
@@ -364,11 +408,7 @@ export const assignmentRouter = createTRPCRouter({
                         }
                     }),
                     submissions: {
-                        create: classData.students.map((student) => ({
-                            student: {
-                                connect: { id: student.id }
-                            }
-                        }))
+                        create: submissionData
                     },
                     teacher: {
                         connect: { id: teacherId }
@@ -410,60 +450,79 @@ export const assignmentRouter = createTRPCRouter({
                     }
                 }
             });
-            // Insert new assignment at top of unified list and normalize
-            const unified = await getUnifiedList(tx, classId);
-            const withoutNew = unified.filter(item => !(item.id === created.id && item.type === 'assignment'));
-            const reindexed = [{ id: created.id, type: 'assignment' }, ...withoutNew.map(item => ({ id: item.id, type: item.type }))];
-            await normalizeUnifiedList(tx, classId, reindexed);
+            // Optimized reordering - only increment existing items by 1
+            // This is much faster than reordering everything
+            await tx.assignment.updateMany({
+                where: {
+                    classId: classId,
+                    id: { not: created.id },
+                },
+                data: {
+                    order: { increment: 1 }
+                }
+            });
+            await tx.section.updateMany({
+                where: {
+                    classId: classId,
+                },
+                data: {
+                    order: { increment: 1 }
+                }
+            });
+            // Update the created assignment to have order 1
+            await tx.assignment.update({
+                where: { id: created.id },
+                data: { order: 1 }
+            });
             return created;
+        }, {
+            maxWait: 10000, // Increased to 10 seconds max wait time
+            timeout: 20000, // Increased to 20 seconds timeout for safety
         });
-        // NOTE: Files are now handled via direct upload endpoints
-        // The files field in the schema is for metadata only
-        // Actual file uploads should use getAssignmentUploadUrls endpoint
-        let uploadedFiles = [];
+        // Handle file operations outside transaction
+        const fileOperations = [];
+        // Process direct upload files
         if (files && files.length > 0) {
-            // Create direct upload files instead of processing base64
-            uploadedFiles = await createDirectUploadFiles(files, ctx.user.id, undefined, assignment.id);
-        }
-        // Update assignment with new file attachments
-        if (uploadedFiles.length > 0) {
-            await prisma.assignment.update({
-                where: { id: assignment.id },
-                data: {
-                    attachments: {
-                        create: uploadedFiles.map(file => ({
-                            name: file.name,
-                            type: file.type,
-                            size: file.size,
-                            path: file.path,
-                            ...(file.thumbnailId && {
-                                thumbnail: {
-                                    connect: { id: file.thumbnailId }
-                                }
-                            })
-                        }))
-                    }
+            fileOperations.push(createDirectUploadFiles(files, ctx.user.id, undefined, assignment.id)
+                .then(uploadedFiles => {
+                if (uploadedFiles.length > 0) {
+                    return prisma.assignment.update({
+                        where: { id: assignment.id },
+                        data: {
+                            attachments: {
+                                create: uploadedFiles.map(file => ({
+                                    name: file.name,
+                                    type: file.type,
+                                    size: file.size,
+                                    path: file.path,
+                                }))
+                            }
+                        }
+                    });
                 }
-            });
+            }));
         }
-        // Connect existing files if provided
+        // Connect existing files
         if (existingFileIds && existingFileIds.length > 0) {
-            await prisma.assignment.update({
+            fileOperations.push(prisma.assignment.update({
                 where: { id: assignment.id },
                 data: {
                     attachments: {
                         connect: existingFileIds.map(fileId => ({ id: fileId }))
                     }
                 }
-            });
+            }));
         }
+        // Execute file operations in parallel
+        await Promise.all(fileOperations);
+        // Send notifications asynchronously (non-blocking)
         sendNotifications(classData.students.map(student => student.id), {
             title: `🔔 New assignment for ${classData.name}`,
             content: `The assignment "${title}" has been created in ${classData.name}.\n
         Due date: ${new Date(dueDate).toLocaleDateString()}.
         [Link to assignment](/class/${classId}/assignments/${assignment.id})`
         }).catch(error => {
-            logger.error('Failed to send assignment notifications:');
+            logger.error('Failed to send assignment notifications:', error);
         });
         return assignment;
     }),
@@ -477,185 +536,225 @@ export const assignmentRouter = createTRPCRouter({
                 message: "User must be authenticated",
             });
         }
-        // Get the assignment with current attachments
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id,
-                teacherId: ctx.user.id,
-            },
-            include: {
-                attachments: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                        path: true,
-                        size: true,
-                        uploadStatus: true,
-                        thumbnail: {
-                            select: {
-                                path: true
+        // Pre-fetch all necessary data outside transaction
+        const [assignment, classData] = await Promise.all([
+            prisma.assignment.findFirst({
+                where: {
+                    id,
+                    teacherId: ctx.user.id,
+                },
+                include: {
+                    attachments: {
+                        select: {
+                            id: true,
+                            name: true,
+                            type: true,
+                            path: true,
+                            size: true,
+                            uploadStatus: true,
+                            thumbnail: {
+                                select: {
+                                    path: true
+                                }
                             }
+                        },
+                    },
+                    class: {
+                        select: {
+                            id: true,
+                            name: true
                         }
                     },
+                    markScheme: true,
                 },
-                class: {
-                    select: {
-                        id: true,
-                        name: true
+            }),
+            prisma.class.findFirst({
+                where: {
+                    assignments: {
+                        some: { id }
                     }
                 },
-            },
-        });
+                include: {
+                    students: {
+                        select: { id: true }
+                    }
+                }
+            })
+        ]);
         if (!assignment) {
             throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "Assignment not found",
             });
         }
-        // NOTE: Files are now handled via direct upload endpoints
-        let uploadedFiles = [];
-        if (files && files.length > 0) {
-            // Create direct upload files instead of processing base64
-            uploadedFiles = await createDirectUploadFiles(files, ctx.user.id, undefined, input.id);
-        }
-        // Delete removed attachments from storage before updating database
+        // Prepare submission data outside transaction if needed
+        const submissionData = studentIds && studentIds.length > 0
+            ? studentIds.map((studentId) => ({
+                student: { connect: { id: studentId } }
+            }))
+            : classData?.students.map((student) => ({
+                student: { connect: { id: student.id } }
+            }));
+        // Handle file deletion operations outside transaction
+        const fileDeletionPromises = [];
         if (input.removedAttachments && input.removedAttachments.length > 0) {
             const filesToDelete = assignment.attachments.filter((file) => input.removedAttachments.includes(file.id));
-            // Delete files from storage (only if they were actually uploaded)
-            await Promise.all(filesToDelete.map(async (file) => {
-                try {
-                    // 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?.path) {
-                            await deleteFile(file.thumbnail.path);
-                        }
+            filesToDelete.forEach((file) => {
+                if (file.uploadStatus === 'COMPLETED') {
+                    fileDeletionPromises.push(deleteFile(file.path).catch(error => {
+                        console.warn(`Failed to delete file ${file.path}:`, error);
+                    }));
+                    if (file.thumbnail?.path) {
+                        fileDeletionPromises.push(deleteFile(file.thumbnail.path).catch(error => {
+                            console.warn(`Failed to delete thumbnail ${file.thumbnail.path}:`, error);
+                        }));
                     }
                 }
-                catch (error) {
-                    console.warn(`Failed to delete file ${file.path}:`, error);
-                }
-            }));
+            });
         }
-        // Update assignment
-        const updatedAssignment = await prisma.assignment.update({
-            where: { id },
-            data: {
-                ...(title && { title }),
-                ...(instructions && { instructions }),
-                ...(dueDate && { dueDate: new Date(dueDate) }),
-                ...(maxGrade && { maxGrade }),
-                ...(graded !== undefined && { graded }),
-                ...(weight && { weight }),
-                ...(type && { type }),
-                ...(inProgress !== undefined && { inProgress }),
-                ...(acceptFiles !== undefined && { acceptFiles }),
-                ...(acceptExtendedResponse !== undefined && { acceptExtendedResponse }),
-                ...(acceptWorksheet !== undefined && { acceptWorksheet }),
-                ...(gradeWithAI !== undefined && { gradeWithAI }),
-                ...(studentIds && {
-                    assignedTo: {
-                        connect: studentIds.map(id => ({ id }))
-                    }
-                }),
-                ...(aiPolicyLevel !== undefined && { aiPolicyLevel }),
-                ...(sectionId !== undefined && {
-                    section: sectionId ? {
-                        connect: { id: sectionId }
-                    } : {
-                        disconnect: true
-                    }
-                }),
-                ...(worksheetIds && {
-                    worksheets: {
-                        connect: worksheetIds.map(id => ({ id }))
-                    }
-                }),
-                ...(uploadedFiles.length > 0 && {
-                    attachments: {
-                        create: uploadedFiles.map(file => ({
-                            name: file.name,
-                            type: file.type,
-                            size: file.size,
-                            path: file.path,
-                            ...(file.thumbnailId && {
-                                thumbnail: {
-                                    connect: { id: file.thumbnailId }
-                                }
-                            })
-                        }))
-                    }
-                }),
-                ...(existingFileIds && existingFileIds.length > 0 && {
-                    attachments: {
-                        connect: existingFileIds.map(fileId => ({ id: fileId }))
-                    }
-                }),
-                ...(input.removedAttachments && input.removedAttachments.length > 0 && {
-                    attachments: {
-                        deleteMany: {
-                            id: { in: input.removedAttachments }
+        // Execute file deletions in parallel
+        await Promise.all(fileDeletionPromises);
+        // Prepare file upload operations
+        let uploadedFiles = [];
+        if (files && files.length > 0) {
+            uploadedFiles = await createDirectUploadFiles(files, ctx.user.id, undefined, input.id);
+        }
+        // Minimal transaction for database update
+        const updatedAssignment = await prisma.$transaction(async (tx) => {
+            return tx.assignment.update({
+                where: { id },
+                data: {
+                    ...(title && { title }),
+                    ...(instructions && { instructions }),
+                    ...(dueDate && { dueDate: new Date(dueDate) }),
+                    ...(maxGrade && { maxGrade }),
+                    ...(graded !== undefined && { graded }),
+                    ...(weight && { weight }),
+                    ...(type && { type }),
+                    ...(inProgress !== undefined && { inProgress }),
+                    ...(acceptFiles !== undefined && { acceptFiles }),
+                    ...(acceptExtendedResponse !== undefined && { acceptExtendedResponse }),
+                    ...(acceptWorksheet !== undefined && { acceptWorksheet }),
+                    ...(gradeWithAI !== undefined && { gradeWithAI }),
+                    ...(studentIds && {
+                        assignedTo: {
+                            set: [], // Clear existing
+                            connect: studentIds.map(id => ({ id }))
                         }
-                    }
-                }),
-            },
-            select: {
-                id: true,
-                title: true,
-                instructions: true,
-                dueDate: true,
-                maxGrade: true,
-                graded: true,
-                weight: true,
-                type: true,
-                createdAt: true,
-                submissions: {
-                    select: {
-                        student: {
-                            select: {
-                                id: true,
-                                username: true
+                    }),
+                    ...(submissionData && {
+                        submissions: {
+                            deleteMany: {}, // Clear existing submissions
+                            create: submissionData
+                        }
+                    }),
+                    ...(aiPolicyLevel !== undefined && { aiPolicyLevel }),
+                    ...(sectionId !== undefined && {
+                        section: sectionId ? {
+                            connect: { id: sectionId }
+                        } : {
+                            disconnect: true
+                        }
+                    }),
+                    ...(worksheetIds && {
+                        worksheets: {
+                            set: [], // Clear existing
+                            connect: worksheetIds.map(id => ({ id }))
+                        }
+                    }),
+                    ...(uploadedFiles.length > 0 && {
+                        attachments: {
+                            create: uploadedFiles.map(file => ({
+                                name: file.name,
+                                type: file.type,
+                                size: file.size,
+                                path: file.path,
+                                ...(file.thumbnailId && {
+                                    thumbnail: {
+                                        connect: { id: file.thumbnailId }
+                                    }
+                                })
+                            }))
+                        }
+                    }),
+                    ...(existingFileIds && existingFileIds.length > 0 && {
+                        attachments: {
+                            connect: existingFileIds.map(fileId => ({ id: fileId }))
+                        }
+                    }),
+                    ...(input.removedAttachments && input.removedAttachments.length > 0 && {
+                        attachments: {
+                            deleteMany: {
+                                id: { in: input.removedAttachments }
                             }
                         }
-                    }
-                },
-                attachments: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                        thumbnail: true,
-                        size: true,
-                        path: true,
-                        uploadedAt: true,
-                        thumbnailId: true,
-                    }
+                    }),
                 },
-                section: true,
-                teacher: true,
-                class: true
-            }
+                select: {
+                    id: true,
+                    title: true,
+                    instructions: true,
+                    dueDate: true,
+                    maxGrade: true,
+                    graded: true,
+                    weight: true,
+                    type: true,
+                    createdAt: true,
+                    markSchemeId: true,
+                    submissions: {
+                        select: {
+                            student: {
+                                select: {
+                                    id: true,
+                                    username: true
+                                }
+                            }
+                        }
+                    },
+                    attachments: {
+                        select: {
+                            id: true,
+                            name: true,
+                            type: true,
+                            thumbnail: true,
+                            size: true,
+                            path: true,
+                            uploadedAt: true,
+                            thumbnailId: true,
+                        }
+                    },
+                    section: true,
+                    teacher: true,
+                    class: true
+                }
+            });
+        }, {
+            maxWait: 5000, // 5 seconds max wait time
+            timeout: 10000, // 10 seconds timeout
         });
-        if (assignment.markSchemeId) {
-            const rubric = await prisma.markScheme.findUnique({
-                where: { id: assignment.markSchemeId },
+        // Handle rubric max grade calculation outside transaction
+        if (updatedAssignment.markSchemeId) {
+            prisma.markScheme.findUnique({
+                where: { id: updatedAssignment.markSchemeId },
                 select: {
                     structured: true,
                 }
-            });
-            const parsedRubric = JSON.parse(rubric?.structured || "{}");
-            const computedMaxGrade = parsedRubric.criteria.reduce((acc, criterion) => {
-                const maxPoints = Math.max(...criterion.levels.map((level) => level.points));
-                return acc + maxPoints;
-            }, 0);
-            await prisma.assignment.update({
-                where: { id },
-                data: {
-                    maxGrade: computedMaxGrade,
+            }).then(rubric => {
+                if (rubric) {
+                    const parsedRubric = JSON.parse(rubric.structured || "{}");
+                    const computedMaxGrade = parsedRubric.criteria?.reduce((acc, criterion) => {
+                        const maxPoints = Math.max(...criterion.levels.map((level) => level.points));
+                        return acc + maxPoints;
+                    }, 0) || 0;
+                    return prisma.assignment.update({
+                        where: { id },
+                        data: {
+                            maxGrade: computedMaxGrade,
+                        }
+                    });
                 }
+            }).catch(error => {
+                logger.error('Failed to update max grade from rubric:', error);
             });
         }
         return updatedAssignment;
@@ -783,6 +882,12 @@ export const assignmentRouter = createTRPCRouter({
                         username: true
                     }
                 },
+                worksheets: {
+                    select: {
+                        id: true,
+                        name: true,
+                    }
+                },
                 class: {
                     select: {
                         id: true,
@@ -866,6 +971,12 @@ export const assignmentRouter = createTRPCRouter({
                                 structured: true,
                             }
                         },
+                        worksheets: {
+                            select: {
+                                id: true,
+                                name: true,
+                            }
+                        },
                         gradingBoundary: {
                             select: {
                                 id: true,
@@ -973,6 +1084,12 @@ export const assignmentRouter = createTRPCRouter({
                                 id: true,
                                 structured: true,
                             }
+                        },
+                        worksheets: {
+                            select: {
+                                id: true,
+                                name: true,
+                            }
                         }
                     },
                 },
@@ -998,7 +1115,7 @@ export const assignmentRouter = createTRPCRouter({
                 message: "User must be authenticated",
             });
         }
-        const { submissionId, submit, newAttachments, existingFileIds, removedAttachments } = input;
+        const { submissionId, submit, newAttachments, existingFileIds, removedAttachments, extendedResponse } = input;
         const submission = await prisma.submission.findFirst({
             where: {
                 id: submissionId,
@@ -1157,6 +1274,7 @@ export const assignmentRouter = createTRPCRouter({
                         },
                     },
                 }),
+                ...(extendedResponse !== undefined && { extendedResponse }),
             },
             include: {
                 attachments: {