@studious-lms/server 1.2.53 → 1.4.0

package/dist/routers/assignment.js

@@ -1,14 +1,11 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="9445d0f9-5b75-544c-b244-e7442f7ff432")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="6ca6683e-2a89-5dab-a4c5-bf0292654572")}catch(e){}}();
 import { z } from "zod";
 import { createTRPCRouter, protectedProcedure, protectedClassMemberProcedure, protectedTeacherProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
 import { createDirectUploadFiles, confirmDirectUpload, updateUploadProgress } from "../lib/fileUpload.js";
-import { deleteFile } from "../lib/googleCloudStorage.js";
-import { sendNotifications } from "../lib/notificationHandler.js";
-import { logger } from "../utils/logger.js";
-import { gradeWorksheetPipeline } from "../server/pipelines/gradeWorksheet.js";
+import { assignmentExists, getDueToday, getAssignment, getSubmission, getSubmissionById, getSubmissions, createAssignmentRecord, updateAssignmentRecord, deleteAssignmentRecord, updateSubmissionRecord, updateSubmissionAsTeacherRecord, attachAssignmentToEventRecord, detachAssignmentFromEventRecord, getAvailableEventsForAssignment, attachMarkSchemeRecord, detachMarkSchemeRecord, attachGradingBoundaryRecord, detachGradingBoundaryRecord, reorderAssignmentRecord, moveAssignmentRecord, } from "../services/assignment.js";
 // DEPRECATED: This schema is no longer used - files are uploaded directly to GCS
 // Use directFileSchema instead
 // New schema for direct file uploads (no base64 data)
@@ -135,1897 +132,110 @@ const updateUploadProgressSchema = z.object({
     fileId: z.string(),
     progress: z.number().min(0).max(100),
 });
-// Helper function to get unified list of sections and assignments for a class
-async function getUnifiedList(tx, classId) {
-    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 },
-        }),
-    ]);
-    // Combine and sort by order
-    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));
-    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) {
-    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') {
-            sections.push(orderData);
-        }
-        else {
-            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)
     reorder: protectedTeacherProcedure
         .input(z.object({
         classId: z.string(),
         movedId: z.string(),
-        // 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 }) => {
-        const { classId, movedId, position, targetId } = input;
-        const moved = await prisma.assignment.findFirst({
-            where: { id: movedId, classId },
-            select: { id: true, classId: true },
-        });
-        if (!moved) {
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'Assignment 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 unified = await getUnifiedList(tx, classId);
-            // Find moved item and target in unified list
-            const movedIdx = unified.findIndex(item => item.id === movedId && item.type === 'assignment');
-            if (movedIdx === -1) {
-                throw new TRPCError({ code: 'NOT_FOUND', message: 'Assignment not found in unified list' });
-            }
-            // Build list without moved item
-            const withoutMoved = unified.filter(item => !(item.id === movedId && item.type === 'assignment'));
-            let next = [];
-            if (position === 'start') {
-                next = [{ id: movedId, type: 'assignment' }, ...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: 'assignment' }];
-            }
-            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: 'assignment' },
-                        ...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: 'assignment' },
-                        ...withoutMoved.slice(targetIdx + 1).map(item => ({ id: item.id, type: item.type })),
-                    ];
-                }
-            }
-            // 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;
-    }),
-    order: protectedTeacherProcedure
-        .input(z.object({
-        id: z.string(),
-        classId: z.string(),
-        order: z.number(),
+        targetId: z.string().optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        // Deprecated: prefer `reorder`. For backward-compatibility, set the order then normalize unified list.
-        const { id, order } = input;
-        const current = await prisma.assignment.findUnique({
-            where: { id },
-            select: { id: true, classId: true },
-        });
-        if (!current) {
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'Assignment not found' });
-        }
-        const updated = await prisma.$transaction(async (tx) => {
-            await tx.assignment.update({ where: { id }, data: { order } });
-            // Normalize entire unified list
-            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;
-    }),
+        .mutation(({ ctx, input }) => reorderAssignmentRecord(ctx.user.id, {
+        classId: input.classId,
+        movedId: input.movedId,
+        position: input.position,
+        targetId: input.targetId,
+    })),
     exists: protectedClassMemberProcedure
-        .input(z.object({
-        id: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({ code: 'UNAUTHORIZED', message: 'User must be authenticated' });
-        }
-        const assignment = await prisma.assignment.findUnique({
-            where: { id: input.id },
-        });
-        return assignment ? true : false;
-    }),
+        .input(z.object({ id: z.string() }))
+        .query(({ input }) => assignmentExists(input.id)),
     move: protectedTeacherProcedure
         .input(z.object({
         id: z.string(),
         classId: z.string(),
         targetSectionId: z.string().nullable().optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        const { id } = input;
-        const targetSectionId = (input.targetSectionId ?? null) || null; // normalize empty string to null
-        const moved = await prisma.assignment.findUnique({
-            where: { id },
-            select: { id: true, classId: true, sectionId: true },
-        });
-        if (!moved) {
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'Assignment not found' });
-        }
-        const updated = await prisma.$transaction(async (tx) => {
-            // Update sectionId first
-            await tx.assignment.update({ where: { id }, data: { sectionId: targetSectionId } });
-            // The unified list ordering remains the same, just the assignment's sectionId changed
-            // 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;
-    }),
+        .mutation(({ ctx, input }) => moveAssignmentRecord(ctx.user.id, {
+        id: input.id,
+        classId: input.classId,
+        targetSectionId: (input.targetSectionId ?? null) || null,
+    })),
     create: protectedTeacherProcedure
         .input(createAssignmentSchema)
-        .mutation(async ({ ctx, input }) => {
-        const { classId, id, title, instructions, dueDate, files, existingFileIds, aiPolicyLevel, acceptFiles, acceptExtendedResponse, acceptWorksheet, worksheetIds, gradeWithAI, studentIds, maxGrade, graded, weight, sectionId, type, markSchemeId, gradingBoundaryId, inProgress } = input;
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        // 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 && 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);
-        }
-        // 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: {
-                    ...(id && { id }),
-                    title,
-                    instructions,
-                    dueDate: new Date(dueDate),
-                    maxGrade: markSchemeId ? computedMaxGrade : maxGrade,
-                    graded,
-                    weight,
-                    type,
-                    ...(aiPolicyLevel && { aiPolicyLevel }),
-                    acceptFiles,
-                    acceptExtendedResponse,
-                    acceptWorksheet,
-                    ...(worksheetIds && {
-                        worksheets: {
-                            connect: worksheetIds.map(id => ({ id }))
-                        }
-                    }),
-                    gradeWithAI,
-                    ...(studentIds && {
-                        assignedTo: {
-                            connect: studentIds.map(id => ({ id }))
-                        }
-                    }),
-                    order: 0, // Set to 0 to place at top
-                    inProgress: inProgress || false,
-                    class: {
-                        connect: { id: classId }
-                    },
-                    ...(sectionId && {
-                        section: {
-                            connect: { id: sectionId }
-                        }
-                    }),
-                    ...(markSchemeId && {
-                        markScheme: {
-                            connect: { id: markSchemeId }
-                        }
-                    }),
-                    ...(gradingBoundaryId && {
-                        gradingBoundary: {
-                            connect: { id: gradingBoundaryId }
-                        }
-                    }),
-                    submissions: {
-                        create: submissionData
-                    },
-                    teacher: {
-                        connect: { id: teacherId }
-                    }
-                },
-                select: {
-                    id: true,
-                    title: true,
-                    instructions: true,
-                    dueDate: true,
-                    maxGrade: true,
-                    graded: true,
-                    weight: true,
-                    type: true,
-                    attachments: {
-                        select: {
-                            id: true,
-                            name: true,
-                            type: true,
-                        }
-                    },
-                    section: {
-                        select: {
-                            id: true,
-                            name: true
-                        }
-                    },
-                    teacher: {
-                        select: {
-                            id: true,
-                            username: true
-                        }
-                    },
-                    class: {
-                        select: {
-                            id: true,
-                            name: true
-                        }
-                    }
-                }
-            });
-            // 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
-        });
-        // Handle file operations outside transaction
-        const fileOperations = [];
-        // Process direct upload files
-        if (files && files.length > 0) {
-            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 (existingFileIds && existingFileIds.length > 0) {
-            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:', error);
-        });
-        return assignment;
-    }),
+        .mutation(({ ctx, input }) => createAssignmentRecord(ctx.user.id, input)),
     update: protectedTeacherProcedure
         .input(updateAssignmentSchema)
-        .mutation(async ({ ctx, input }) => {
-        const { id, title, instructions, dueDate, files, existingFileIds, worksheetIds, aiPolicyLevel, maxGrade, graded, weight, sectionId, type, inProgress, acceptFiles, acceptExtendedResponse, acceptWorksheet, gradeWithAI, studentIds } = input;
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        // 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,
-                },
-            }),
-            prisma.class.findFirst({
-                where: {
-                    assignments: {
-                        some: { id }
-                    }
-                },
-                include: {
-                    students: {
-                        select: { id: true }
-                    }
-                }
-            })
-        ]);
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found",
-            });
-        }
-        // 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));
-            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);
-                        }));
-                    }
-                }
-            });
-        }
-        // 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 }))
-                        }
-                    }),
-                    ...(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 }
-                            }
-                        }
-                    }),
-                },
-                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
-        });
-        // Handle rubric max grade calculation outside transaction
-        if (updatedAssignment.markSchemeId) {
-            prisma.markScheme.findUnique({
-                where: { id: updatedAssignment.markSchemeId },
-                select: {
-                    structured: true,
-                }
-            }).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;
-    }),
+        .mutation(({ ctx, input }) => updateAssignmentRecord(ctx.user.id, input)),
     delete: protectedProcedure
         .input(deleteAssignmentSchema)
-        .mutation(async ({ ctx, input }) => {
-        const { id, classId } = input;
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        // Get the assignment with all related files
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id,
-                teacherId: ctx.user.id,
-            },
-            include: {
-                attachments: {
-                    include: {
-                        thumbnail: true
-                    }
-                },
-                submissions: {
-                    include: {
-                        attachments: {
-                            include: {
-                                thumbnail: true
-                            }
-                        },
-                        annotations: {
-                            include: {
-                                thumbnail: true
-                            }
-                        }
-                    }
-                }
-            }
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found",
-            });
-        }
-        // Delete all files from storage
-        const filesToDelete = [
-            ...assignment.attachments,
-            ...assignment.submissions.flatMap(sub => [...sub.attachments, ...sub.annotations])
-        ];
-        // 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) {
-                        await deleteFile(file.thumbnail.path);
-                    }
-                }
-            }
-            catch (error) {
-                console.warn(`Failed to delete file ${file.path}:`, error);
-            }
-        }));
-        // Delete the assignment (this will cascade delete all related records)
-        await prisma.assignment.delete({
-            where: { id },
-        });
-        return {
-            id,
-        };
-    }),
+        .mutation(({ ctx, input }) => deleteAssignmentRecord(ctx.user.id, input.id, input.classId)),
     get: protectedClassMemberProcedure
         .input(getAssignmentSchema)
-        .query(async ({ ctx, input }) => {
-        const { id, classId } = input;
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const assignment = await prisma.assignment.findUnique({
-            where: {
-                id,
-                // classId,
-            },
-            include: {
-                submissions: {
-                    select: {
-                        student: {
-                            select: {
-                                id: true,
-                                username: true
-                            }
-                        }
-                    }
-                },
-                attachments: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                        size: true,
-                        path: true,
-                        uploadedAt: true,
-                        thumbnailId: true,
-                    }
-                },
-                section: {
-                    select: {
-                        id: true,
-                        name: true,
-                    }
-                },
-                teacher: {
-                    select: {
-                        id: true,
-                        username: true
-                    }
-                },
-                worksheets: {
-                    select: {
-                        id: true,
-                        name: true,
-                    }
-                },
-                class: {
-                    select: {
-                        id: true,
-                        name: true
-                    }
-                },
-                eventAttached: {
-                    select: {
-                        id: true,
-                        name: true,
-                        startTime: true,
-                        endTime: true,
-                        location: true,
-                        remarks: true,
-                        color: true,
-                    }
-                },
-                markScheme: {
-                    select: {
-                        id: true,
-                        structured: true,
-                    }
-                },
-                gradingBoundary: {
-                    select: {
-                        id: true,
-                        structured: true,
-                    }
-                }
-            }
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found",
-            });
-        }
-        const sections = await prisma.section.findMany({
-            where: {
-                classId: assignment.classId,
-            },
-            select: {
-                id: true,
-                name: true,
-            },
-        });
-        return { ...assignment, sections };
-    }),
+        .query(({ input }) => getAssignment(input.id, input.classId)),
     getSubmission: protectedClassMemberProcedure
+        .input(z.object({ assignmentId: z.string(), classId: z.string() }))
+        .query(({ ctx, input }) => getSubmission(input.assignmentId, ctx.user.id)),
+    getSubmissionById: protectedClassMemberProcedure
+        .input(z.object({ classId: z.string(), submissionId: z.string() }))
+        .query(({ ctx, input }) => getSubmissionById(input.submissionId, input.classId, ctx.user.id)),
+    updateSubmission: protectedClassMemberProcedure
+        .input(submissionSchema)
+        .mutation(({ ctx, input }) => updateSubmissionRecord(ctx.user.id, {
+        submissionId: input.submissionId,
+        assignmentId: input.assignmentId,
+        classId: input.classId,
+        submit: input.submit,
+        newAttachments: input.newAttachments,
+        extendedResponse: input.extendedResponse,
+        existingFileIds: input.existingFileIds,
+        removedAttachments: input.removedAttachments,
+    })),
+    getSubmissions: protectedTeacherProcedure
+        .input(z.object({ assignmentId: z.string(), classId: z.string() }))
+        .query(({ ctx, input }) => getSubmissions(input.assignmentId, ctx.user.id)),
+    updateSubmissionAsTeacher: protectedTeacherProcedure
+        .input(updateSubmissionSchema)
+        .mutation(({ ctx, input }) => updateSubmissionAsTeacherRecord(ctx.user.id, {
+        submissionId: input.submissionId,
+        assignmentId: input.assignmentId,
+        classId: input.classId,
+        return: input.return,
+        gradeReceived: input.gradeReceived,
+        newAttachments: input.newAttachments,
+        existingFileIds: input.existingFileIds,
+        removedAttachments: input.removedAttachments,
+        rubricGrades: input.rubricGrades,
+        feedback: input.feedback,
+    })),
+    attachToEvent: protectedTeacherProcedure
+        .input(z.object({ assignmentId: z.string(), eventId: z.string() }))
+        .mutation(({ ctx, input }) => attachAssignmentToEventRecord(ctx.user.id, input.assignmentId, input.eventId)),
+    detachEvent: protectedTeacherProcedure
+        .input(z.object({ assignmentId: z.string() }))
+        .mutation(({ ctx, input }) => detachAssignmentFromEventRecord(ctx.user.id, input.assignmentId)),
+    getAvailableEvents: protectedTeacherProcedure
+        .input(z.object({ assignmentId: z.string() }))
+        .query(({ ctx, input }) => getAvailableEventsForAssignment(ctx.user.id, input.assignmentId)),
+    dueToday: protectedProcedure
+        .query(() => getDueToday()),
+    attachMarkScheme: protectedTeacherProcedure
         .input(z.object({
         assignmentId: z.string(),
-        classId: z.string(),
+        markSchemeId: z.string().nullable(),
     }))
-        .query(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const { assignmentId } = input;
-        const submission = await prisma.submission.findFirst({
-            where: {
-                assignmentId,
-                studentId: ctx.user.id,
-            },
-            include: {
-                attachments: true,
-                student: {
-                    select: {
-                        id: true,
-                        username: true,
-                        profile: true,
-                    },
-                },
-                assignment: {
-                    include: {
-                        class: true,
-                        markScheme: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        },
-                        worksheets: {
-                            select: {
-                                id: true,
-                                name: true,
-                            }
-                        },
-                        gradingBoundary: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        }
-                    },
-                },
-                annotations: true,
-            },
-        });
-        if (!submission) {
-            // Create a new submission if it doesn't exist
-            return await prisma.submission.create({
-                data: {
-                    assignment: {
-                        connect: { id: assignmentId },
-                    },
-                    student: {
-                        connect: { id: ctx.user.id },
-                    },
-                },
-                include: {
-                    attachments: true,
-                    annotations: true,
-                    student: {
-                        select: {
-                            id: true,
-                            username: true,
-                        },
-                    },
-                    assignment: {
-                        include: {
-                            class: true,
-                            markScheme: {
-                                select: {
-                                    id: true,
-                                    structured: true,
-                                }
-                            },
-                            gradingBoundary: {
-                                select: {
-                                    id: true,
-                                    structured: true,
-                                }
-                            }
-                        },
-                    },
-                },
-            });
-        }
-        return {
-            ...submission,
-            late: submission.assignment.dueDate < new Date(),
-        };
-    }),
-    getSubmissionById: protectedClassMemberProcedure
+        .mutation(({ ctx, input }) => attachMarkSchemeRecord(ctx.user.id, input.assignmentId, input.markSchemeId)),
+    detachMarkScheme: protectedTeacherProcedure
+        .input(z.object({ assignmentId: z.string() }))
+        .mutation(({ ctx, input }) => detachMarkSchemeRecord(ctx.user.id, input.assignmentId)),
+    attachGradingBoundary: protectedTeacherProcedure
         .input(z.object({
-        classId: z.string(),
-        submissionId: z.string(),
+        assignmentId: z.string(),
+        gradingBoundaryId: z.string().nullable(),
     }))
-        .query(async ({ ctx, input }) => {
-        const { submissionId, classId } = input;
-        const submission = await prisma.submission.findFirst({
-            where: {
-                id: submissionId,
-                assignment: {
-                    classId,
-                    class: {
-                        OR: [
-                            {
-                                teachers: {
-                                    some: {
-                                        id: ctx.user?.id
-                                    }
-                                }
-                            },
-                            {
-                                students: {
-                                    some: {
-                                        id: ctx.user?.id
-                                    }
-                                }
-                            }
-                        ],
-                    }
-                },
-            },
-            include: {
-                attachments: true,
-                annotations: true,
-                student: {
-                    select: {
-                        id: true,
-                        username: true,
-                        profile: true,
-                    },
-                },
-                assignment: {
-                    include: {
-                        class: true,
-                        markScheme: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        },
-                        gradingBoundary: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        },
-                        worksheets: {
-                            select: {
-                                id: true,
-                                name: true,
-                            }
-                        }
-                    },
-                },
-            },
-        });
-        if (!submission) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Submission not found",
-            });
-        }
-        return {
-            ...submission,
-            late: submission.assignment.dueDate < new Date(),
-        };
-    }),
-    updateSubmission: protectedClassMemberProcedure
-        .input(submissionSchema)
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const { submissionId, submit, newAttachments, existingFileIds, removedAttachments, extendedResponse } = input;
-        const submission = await prisma.submission.findFirst({
-            where: {
-                id: submissionId,
-                OR: [
-                    {
-                        student: {
-                            id: ctx.user.id,
-                        },
-                    },
-                    {
-                        assignment: {
-                            class: {
-                                teachers: {
-                                    some: {
-                                        id: ctx.user.id,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            },
-            include: {
-                attachments: {
-                    include: {
-                        thumbnail: true
-                    }
-                },
-                assignment: {
-                    include: {
-                        class: true,
-                        markScheme: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        },
-                        gradingBoundary: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        }
-                    },
-                },
-            },
-        });
-        if (!submission) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Submission not found",
-            });
-        }
-        if (submit !== undefined) {
-            // Toggle submission status
-            if (submission.assignment.acceptWorksheet && submission.assignment.gradeWithAI) {
-                // Grade the submission with AI
-                const worksheetResponses = await prisma.studentWorksheetResponse.findMany({
-                    where: {
-                        submissionId: submission.id,
-                    },
-                });
-                for (const worksheetResponse of worksheetResponses) {
-                    // Run it in the background, non-blocking
-                    gradeWorksheetPipeline(worksheetResponse.id);
-                }
-            }
-            return await prisma.submission.update({
-                where: { id: submission.id },
-                data: {
-                    submitted: !submission.submitted,
-                    submittedAt: new Date(),
-                },
-                include: {
-                    attachments: true,
-                    student: {
-                        select: {
-                            id: true,
-                            username: true,
-                        },
-                    },
-                    assignment: {
-                        include: {
-                            class: true,
-                            markScheme: {
-                                select: {
-                                    id: true,
-                                    structured: true,
-                                }
-                            },
-                            gradingBoundary: {
-                                select: {
-                                    id: true,
-                                    structured: true,
-                                }
-                            }
-                        },
-                    },
-                },
-            });
-        }
-        let uploadedFiles = [];
-        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: {
-                    attachments: {
-                        create: uploadedFiles.map(file => ({
-                            name: file.name,
-                            type: file.type,
-                            size: file.size,
-                            path: file.path,
-                            ...(file.thumbnailId && {
-                                thumbnail: {
-                                    connect: { id: file.thumbnailId }
-                                }
-                            })
-                        }))
-                    }
-                }
-            });
-        }
-        // Connect existing files if provided
-        if (existingFileIds && existingFileIds.length > 0) {
-            await prisma.submission.update({
-                where: { id: submission.id },
-                data: {
-                    attachments: {
-                        connect: existingFileIds.map(fileId => ({ id: fileId }))
-                    }
-                }
-            });
-        }
-        // Delete removed attachments if any
-        if (removedAttachments && removedAttachments.length > 0) {
-            const filesToDelete = submission.attachments.filter((file) => 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);
-                        }
-                    }
-                }
-                catch (error) {
-                    console.warn(`Failed to delete file ${file.path}:`, error);
-                }
-            }));
-        }
-        // Update submission with attachments
-        return await prisma.submission.update({
-            where: { id: submission.id },
-            data: {
-                ...(removedAttachments && removedAttachments.length > 0 && {
-                    attachments: {
-                        deleteMany: {
-                            id: { in: removedAttachments },
-                        },
-                    },
-                }),
-                ...(extendedResponse !== undefined && { extendedResponse }),
-            },
-            include: {
-                attachments: {
-                    include: {
-                        thumbnail: true
-                    }
-                },
-                student: {
-                    select: {
-                        id: true,
-                        username: true,
-                    },
-                },
-                assignment: {
-                    include: {
-                        class: true,
-                        markScheme: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        },
-                        gradingBoundary: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        }
-                    },
-                },
-            },
-        });
-    }),
-    getSubmissions: protectedTeacherProcedure
-        .input(z.object({
-        assignmentId: z.string(),
-        classId: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const { assignmentId } = input;
-        const submissions = await prisma.submission.findMany({
-            where: {
-                assignment: {
-                    id: assignmentId,
-                    class: {
-                        teachers: {
-                            some: { id: ctx.user.id },
-                        },
-                    },
-                },
-            },
-            include: {
-                attachments: {
-                    include: {
-                        thumbnail: true
-                    }
-                },
-                student: {
-                    select: {
-                        id: true,
-                        username: true,
-                        profile: {
-                            select: {
-                                displayName: true,
-                                profilePicture: true,
-                                profilePictureThumbnail: true,
-                            },
-                        },
-                    },
-                },
-                assignment: {
-                    include: {
-                        class: true,
-                        markScheme: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        },
-                        gradingBoundary: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        }
-                    },
-                },
-            },
-        });
-        return submissions.map(submission => ({
-            ...submission,
-            late: submission.assignment.dueDate < new Date(),
-        }));
-    }),
-    updateSubmissionAsTeacher: protectedTeacherProcedure
-        .input(updateSubmissionSchema)
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const { submissionId, return: returnSubmission, gradeReceived, newAttachments, existingFileIds, removedAttachments, rubricGrades, feedback } = input;
-        const submission = await prisma.submission.findFirst({
-            where: {
-                id: submissionId,
-                assignment: {
-                    class: {
-                        teachers: {
-                            some: { id: ctx.user.id },
-                        },
-                    },
-                },
-            },
-            include: {
-                attachments: {
-                    include: {
-                        thumbnail: true
-                    }
-                },
-                annotations: {
-                    include: {
-                        thumbnail: true
-                    }
-                },
-                assignment: {
-                    include: {
-                        class: true,
-                        markScheme: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        },
-                        gradingBoundary: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        }
-                    },
-                },
-            },
-        });
-        if (!submission) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Submission not found",
-            });
-        }
-        if (returnSubmission !== undefined) {
-            // Toggle return status
-            return await prisma.submission.update({
-                where: { id: submissionId },
-                data: {
-                    returned: !submission.returned,
-                },
-                include: {
-                    attachments: true,
-                    student: {
-                        select: {
-                            id: true,
-                            username: true,
-                            profile: {
-                                select: {
-                                    displayName: true,
-                                    profilePicture: true,
-                                    profilePictureThumbnail: true,
-                                },
-                            },
-                        },
-                    },
-                    assignment: {
-                        include: {
-                            class: true,
-                            markScheme: {
-                                select: {
-                                    id: true,
-                                    structured: true,
-                                }
-                            },
-                            gradingBoundary: {
-                                select: {
-                                    id: true,
-                                    structured: true,
-                                }
-                            }
-                        },
-                    },
-                },
-            });
-        }
-        // 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) {
-            throw new TRPCError({
-                code: "BAD_REQUEST",
-                message: "Direct file upload is deprecated. Use getAnnotationUploadUrls endpoint instead.",
-            });
-        }
-        // Connect existing files if provided
-        if (existingFileIds && existingFileIds.length > 0) {
-            await prisma.submission.update({
-                where: { id: submission.id },
-                data: {
-                    annotations: {
-                        connect: existingFileIds.map(fileId => ({ id: fileId }))
-                    }
-                }
-            });
-        }
-        // Delete removed attachments if any
-        if (removedAttachments && removedAttachments.length > 0) {
-            const filesToDelete = submission.annotations.filter((file) => 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);
-                        }
-                    }
-                }
-                catch (error) {
-                    console.warn(`Failed to delete file ${file.path}:`, error);
-                }
-            }));
-        }
-        // Update submission with grade and attachments
-        return await prisma.submission.update({
-            where: { id: submissionId },
-            data: {
-                ...(gradeReceived !== undefined && { gradeReceived }),
-                ...(rubricGrades && { rubricState: JSON.stringify(rubricGrades) }),
-                ...(feedback && { teacherComments: feedback }),
-                ...(removedAttachments && removedAttachments.length > 0 && {
-                    annotations: {
-                        deleteMany: {
-                            id: { in: removedAttachments },
-                        },
-                    },
-                }),
-                ...(returnSubmission && { returned: returnSubmission }),
-            },
-            include: {
-                attachments: {
-                    include: {
-                        thumbnail: true
-                    }
-                },
-                annotations: {
-                    include: {
-                        thumbnail: true
-                    }
-                },
-                student: {
-                    select: {
-                        id: true,
-                        username: true,
-                        profile: {
-                            select: {
-                                displayName: true,
-                                profilePicture: true,
-                                profilePictureThumbnail: true,
-                            },
-                        },
-                    },
-                },
-                assignment: {
-                    include: {
-                        class: true,
-                        markScheme: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        },
-                        gradingBoundary: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        }
-                    },
-                },
-            },
-        });
-    }),
-    attachToEvent: protectedTeacherProcedure
-        .input(z.object({
-        assignmentId: z.string(),
-        eventId: z.string(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const { assignmentId, eventId } = input;
-        // Check if assignment exists and user is a teacher of the class
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id: assignmentId,
-                class: {
-                    teachers: {
-                        some: { id: ctx.user.id },
-                    },
-                },
-            },
-            include: {
-                class: true,
-            },
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found or you are not authorized",
-            });
-        }
-        // Check if event exists and belongs to the same class
-        const event = await prisma.event.findFirst({
-            where: {
-                id: eventId,
-                classId: assignment.classId,
-            },
-        });
-        if (!event) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Event not found or does not belong to the same class",
-            });
-        }
-        // Attach assignment to event
-        const updatedAssignment = await prisma.assignment.update({
-            where: { id: assignmentId },
-            data: {
-                eventAttached: {
-                    connect: { id: eventId }
-                }
-            },
-            include: {
-                attachments: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                    }
-                },
-                section: {
-                    select: {
-                        id: true,
-                        name: true
-                    }
-                },
-                teacher: {
-                    select: {
-                        id: true,
-                        username: true
-                    }
-                },
-                eventAttached: {
-                    select: {
-                        id: true,
-                        name: true,
-                        startTime: true,
-                        endTime: true,
-                        color: true,
-                    }
-                }
-            }
-        });
-        return { assignment: updatedAssignment };
-    }),
-    detachEvent: protectedTeacherProcedure
-        .input(z.object({
-        assignmentId: z.string(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const { assignmentId } = input;
-        // Check if assignment exists and user is a teacher of the class
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id: assignmentId,
-                class: {
-                    teachers: {
-                        some: { id: ctx.user.id },
-                    },
-                },
-            },
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found or you are not authorized",
-            });
-        }
-        // Detach assignment from event
-        const updatedAssignment = await prisma.assignment.update({
-            where: { id: assignmentId },
-            data: {
-                eventAttached: {
-                    disconnect: true
-                }
-            },
-            include: {
-                attachments: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                    }
-                },
-                section: {
-                    select: {
-                        id: true,
-                        name: true
-                    }
-                },
-                teacher: {
-                    select: {
-                        id: true,
-                        username: true
-                    }
-                },
-                eventAttached: {
-                    select: {
-                        id: true,
-                        name: true,
-                        startTime: true,
-                        endTime: true,
-                    }
-                }
-            }
-        });
-        return { assignment: updatedAssignment };
-    }),
-    getAvailableEvents: protectedTeacherProcedure
-        .input(z.object({
-        assignmentId: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const { assignmentId } = input;
-        // Get the assignment to find the class
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id: assignmentId,
-                class: {
-                    teachers: {
-                        some: { id: ctx.user.id },
-                    },
-                },
-            },
-            select: { classId: true }
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found or you are not authorized",
-            });
-        }
-        // Get all events for the class that don't already have this assignment attached
-        const events = await prisma.event.findMany({
-            where: {
-                classId: assignment.classId,
-                assignmentsAttached: {
-                    none: {
-                        id: assignmentId
-                    }
-                }
-            },
-            select: {
-                id: true,
-                name: true,
-                startTime: true,
-                endTime: true,
-                location: true,
-                remarks: true,
-                color: true,
-            },
-            orderBy: {
-                startTime: 'asc'
-            }
-        });
-        return { events };
-    }),
-    dueToday: protectedProcedure
-        .query(async ({ ctx }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const assignments = await prisma.assignment.findMany({
-            where: {
-                dueDate: {
-                    equals: new Date(),
-                },
-            },
-            select: {
-                id: true,
-                title: true,
-                dueDate: true,
-                type: true,
-                graded: true,
-                maxGrade: true,
-                class: {
-                    select: {
-                        id: true,
-                        name: true,
-                    }
-                }
-            }
-        });
-        return assignments.map(assignment => ({
-            ...assignment,
-            dueDate: assignment.dueDate.toISOString(),
-        }));
-    }),
-    attachMarkScheme: protectedTeacherProcedure
-        .input(z.object({
-        assignmentId: z.string(),
-        markSchemeId: z.string().nullable(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        const { assignmentId, markSchemeId } = input;
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id: assignmentId,
-            },
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found",
-            });
-        }
-        // If markSchemeId is provided, verify it exists
-        if (markSchemeId) {
-            const markScheme = await prisma.markScheme.findFirst({
-                where: {
-                    id: markSchemeId,
-                },
-            });
-            if (!markScheme) {
-                throw new TRPCError({
-                    code: "NOT_FOUND",
-                    message: "Mark scheme not found",
-                });
-            }
-        }
-        const updatedAssignment = await prisma.assignment.update({
-            where: { id: assignmentId },
-            data: {
-                markScheme: markSchemeId ? {
-                    connect: { id: markSchemeId },
-                } : {
-                    disconnect: true,
-                },
-            },
-            include: {
-                attachments: true,
-                section: true,
-                teacher: true,
-                eventAttached: true,
-                markScheme: true,
-            },
-        });
-        return updatedAssignment;
-    }),
-    detachMarkScheme: protectedTeacherProcedure
-        .input(z.object({
-        assignmentId: z.string(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        const { assignmentId } = input;
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id: assignmentId,
-            },
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found",
-            });
-        }
-        const updatedAssignment = await prisma.assignment.update({
-            where: { id: assignmentId },
-            data: {
-                markScheme: {
-                    disconnect: true,
-                },
-            },
-            include: {
-                attachments: true,
-                section: true,
-                teacher: true,
-                eventAttached: true,
-                markScheme: true,
-            },
-        });
-        return updatedAssignment;
-    }),
-    attachGradingBoundary: protectedTeacherProcedure
-        .input(z.object({
-        assignmentId: z.string(),
-        gradingBoundaryId: z.string().nullable(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        const { assignmentId, gradingBoundaryId } = input;
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id: assignmentId,
-            },
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found",
-            });
-        }
-        // If gradingBoundaryId is provided, verify it exists
-        if (gradingBoundaryId) {
-            const gradingBoundary = await prisma.gradingBoundary.findFirst({
-                where: {
-                    id: gradingBoundaryId,
-                },
-            });
-            if (!gradingBoundary) {
-                throw new TRPCError({
-                    code: "NOT_FOUND",
-                    message: "Grading boundary not found",
-                });
-            }
-        }
-        const updatedAssignment = await prisma.assignment.update({
-            where: { id: assignmentId },
-            data: {
-                gradingBoundary: gradingBoundaryId ? {
-                    connect: { id: gradingBoundaryId },
-                } : {
-                    disconnect: true,
-                },
-            },
-            include: {
-                attachments: true,
-                section: true,
-                teacher: true,
-                eventAttached: true,
-                gradingBoundary: true,
-            },
-        });
-        return updatedAssignment;
-    }),
+        .mutation(({ ctx, input }) => attachGradingBoundaryRecord(ctx.user.id, input.assignmentId, input.gradingBoundaryId)),
     detachGradingBoundary: protectedTeacherProcedure
-        .input(z.object({
-        classId: z.string(),
-        assignmentId: z.string(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        const { assignmentId } = input;
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id: assignmentId,
-            },
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found",
-            });
-        }
-        const updatedAssignment = await prisma.assignment.update({
-            where: { id: assignmentId },
-            data: {
-                gradingBoundary: {
-                    disconnect: true,
-                },
-            },
-            include: {
-                attachments: true,
-                section: true,
-                teacher: true,
-                eventAttached: true,
-                gradingBoundary: true,
-            },
-        });
-        return updatedAssignment;
-    }),
+        .input(z.object({ classId: z.string(), assignmentId: z.string() }))
+        .mutation(({ ctx, input }) => detachGradingBoundaryRecord(ctx.user.id, input.assignmentId)),
     // New direct upload endpoints
     getAssignmentUploadUrls: protectedTeacherProcedure
         .input(getAssignmentUploadUrlsSchema)
@@ -2308,4 +518,4 @@ export const assignmentRouter = createTRPCRouter({
     }),
 });
 //# sourceMappingURL=assignment.js.map
-//# debugId=9445d0f9-5b75-544c-b244-e7442f7ff432
+//# debugId=6ca6683e-2a89-5dab-a4c5-bf0292654572