@studious-lms/server 1.1.24 → 1.1.26

package/dist/routers/announcement.js

@@ -2,6 +2,8 @@ import { z } from "zod";
 import { createTRPCRouter, protectedClassMemberProcedure, protectedTeacherProcedure, protectedProcedure } from "../trpc.js";
 import { prisma } from "../lib/prisma.js";
 import { TRPCError } from "@trpc/server";
+import { sendNotifications } from "../lib/notificationHandler.js";
+import { logger } from "../utils/logger.js";
 const AnnouncementSelect = {
     id: true,
     teacher: {
@@ -38,9 +40,25 @@ export const announcementRouter = createTRPCRouter({
         remarks: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
+        const classId = input.classId;
+        const remarks = input.remarks;
+        const classData = await prisma.class.findUnique({
+            where: { id: classId },
+            include: {
+                students: {
+                    select: { id: true }
+                }
+            }
+        });
+        if (!classData) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "Class not found",
+            });
+        }
         const announcement = await prisma.announcement.create({
             data: {
-                remarks: input.remarks,
+                remarks: remarks,
                 teacher: {
                     connect: {
                         id: ctx.user?.id,
@@ -48,12 +66,18 @@ export const announcementRouter = createTRPCRouter({
                 },
                 class: {
                     connect: {
-                        id: input.classId,
+                        id: classId,
                     },
                 },
             },
             select: AnnouncementSelect,
         });
+        sendNotifications(classData.students.map(student => student.id), {
+            title: `🔔 Announcement for ${classData.name}`,
+            content: remarks
+        }).catch(error => {
+            logger.error('Failed to send announcement notifications:');
+        });
         return {
             announcement,
         };

package/dist/routers/assignment.d.ts

@@ -17,6 +17,37 @@ export declare const assignmentRouter: import("@trpc/server").TRPCBuiltRouter<{
     };
     transformer: false;
 }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    reorder: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            movedId: string;
+            position: "start" | "end" | "before" | "after";
+            targetId?: string | undefined;
+        };
+        output: {
+            type: import(".prisma/client").$Enums.AssignmentType;
+            id: string;
+            title: string;
+            dueDate: Date;
+            maxGrade: number | null;
+            classId: string;
+            eventId: string | null;
+            markSchemeId: string | null;
+            gradingBoundaryId: string | null;
+            instructions: string;
+            weight: number;
+            graded: boolean;
+            sectionId: string | null;
+            template: boolean;
+            createdAt: Date | null;
+            modifiedAt: Date | null;
+            teacherId: string;
+            inProgress: boolean;
+            order: number | null;
+        } | null;
+        meta: object;
+    }>;
     order: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             [x: string]: unknown;
@@ -44,7 +75,7 @@ export declare const assignmentRouter: import("@trpc/server").TRPCBuiltRouter<{
             teacherId: string;
             inProgress: boolean;
             order: number | null;
-        };
+        } | null;
         meta: object;
     }>;
     move: import("@trpc/server").TRPCMutationProcedure<{
@@ -52,7 +83,7 @@ export declare const assignmentRouter: import("@trpc/server").TRPCBuiltRouter<{
             [x: string]: unknown;
             classId: string;
             id: string;
-            targetSectionId: string;
+            targetSectionId?: string | null | undefined;
         };
         output: {
             type: import(".prisma/client").$Enums.AssignmentType;
@@ -74,7 +105,7 @@ export declare const assignmentRouter: import("@trpc/server").TRPCBuiltRouter<{
             teacherId: string;
             inProgress: boolean;
             order: number | null;
-        };
+        } | null;
         meta: object;
     }>;
     create: import("@trpc/server").TRPCMutationProcedure<{
@@ -474,6 +505,18 @@ export declare const assignmentRouter: import("@trpc/server").TRPCBuiltRouter<{
             student: {
                 id: string;
                 username: string;
+                profile: {
+                    id: string;
+                    location: string | null;
+                    userId: string;
+                    createdAt: Date;
+                    displayName: string | null;
+                    bio: string | null;
+                    website: string | null;
+                    profilePicture: string | null;
+                    profilePictureThumbnail: string | null;
+                    updatedAt: Date;
+                } | null;
             };
             attachments: {
                 path: string;
@@ -594,8 +637,16 @@ export declare const assignmentRouter: import("@trpc/server").TRPCBuiltRouter<{
                 id: string;
                 username: string;
                 profile: {
+                    id: string;
+                    location: string | null;
+                    userId: string;
+                    createdAt: Date;
                     displayName: string | null;
+                    bio: string | null;
+                    website: string | null;
                     profilePicture: string | null;
+                    profilePictureThumbnail: string | null;
+                    updatedAt: Date;
                 } | null;
             };
             attachments: {

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

@@ -1 +1 @@
-{"version":3,"file":"assignment.d.ts","sourceRoot":"","sources":["../../src/routers/assignment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAA2B,KAAK,gBAAgB,EAAgE,MAAM,sBAAsB,CAAC;AAgIpJ,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2gE3B,CAAC"}
+{"version":3,"file":"assignment.d.ts","sourceRoot":"","sources":["../../src/routers/assignment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAA2B,KAAK,gBAAgB,EAAgE,MAAM,sBAAsB,CAAC;AAqKpJ,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0nE3B,CAAC"}

package/dist/routers/assignment.js

@@ -4,6 +4,8 @@ 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";
 // 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)
@@ -114,7 +116,100 @@ 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
+async function normalizeUnifiedList(tx, classId, orderedItems) {
+    await Promise.all(orderedItems.map((item, index) => {
+        if (item.type === 'section') {
+            return tx.section.update({ where: { id: item.id }, data: { order: index + 1 } });
+        }
+        else {
+            return tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
+        }
+    }));
+}
 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 } });
+        });
+        return result;
+    }),
     order: protectedTeacherProcedure
         .input(z.object({
         id: z.string(),
@@ -122,37 +217,49 @@ export const assignmentRouter = createTRPCRouter({
         order: z.number(),
     }))
         .mutation(async ({ ctx, input }) => {
+        // Deprecated: prefer `reorder`. For backward-compatibility, set the order then normalize unified list.
         const { id, order } = input;
-        const assignment = await prisma.assignment.update({
+        const current = await prisma.assignment.findUnique({
             where: { id },
-            data: { order },
+            select: { id: true, classId: true },
         });
-        return assignment;
+        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 } });
+        });
+        return updated;
     }),
     move: protectedTeacherProcedure
         .input(z.object({
         id: z.string(),
         classId: z.string(),
-        targetSectionId: z.string(),
+        targetSectionId: z.string().nullable().optional(),
     }))
         .mutation(async ({ ctx, input }) => {
-        const { id, targetSectionId } = input;
-        const assignments = await prisma.assignment.findMany({
-            where: { sectionId: targetSectionId },
-        });
-        const stack = assignments.sort((a, b) => (a.order || 0) - (b.order || 0)).map((assignment, index) => ({
-            id: assignment.id,
-            order: index + 1,
-        })).map((assignment) => ({
-            where: { id: assignment.id },
-            data: { order: assignment.order },
-        }));
-        await Promise.all(stack.map(({ where, data }) => prisma.assignment.update({ where, data })));
-        const assignment = await prisma.assignment.update({
+        const { id } = input;
+        const targetSectionId = (input.targetSectionId ?? null) || null; // normalize empty string to null
+        const moved = await prisma.assignment.findUnique({
             where: { id },
-            data: { sectionId: targetSectionId, order: 0 },
+            select: { id: true, classId: true, sectionId: true },
         });
-        return assignment;
+        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 } });
+        });
+        return updated;
     }),
     create: protectedProcedure
         .input(createAssignmentSchema)
@@ -195,100 +302,92 @@ export const assignmentRouter = createTRPCRouter({
             }, 0);
         }
         console.log(markSchemeId, gradingBoundaryId);
-        // find all assignments in the section it is in (or none) and reorder them
-        const assignments = await prisma.assignment.findMany({
-            where: {
-                classId: classId,
-                ...(sectionId && {
-                    sectionId: sectionId,
-                }),
-            },
-        });
-        const stack = assignments.sort((a, b) => (a.order || 0) - (b.order || 0)).map((assignment, index) => ({
-            id: assignment.id,
-            order: index + 1,
-        })).map((assignment) => ({
-            where: { id: assignment.id },
-            data: { order: assignment.order },
-        }));
-        // Create assignment with submissions for all students
-        const assignment = await prisma.assignment.create({
-            data: {
-                title,
-                instructions,
-                dueDate: new Date(dueDate),
-                maxGrade: markSchemeId ? computedMaxGrade : maxGrade,
-                graded,
-                weight,
-                type,
-                order: 0,
-                inProgress: inProgress || false,
-                class: {
-                    connect: { id: classId }
-                },
-                ...(sectionId && {
-                    section: {
-                        connect: { id: sectionId }
-                    }
-                }),
-                ...(markSchemeId && {
-                    markScheme: {
-                        connect: { id: markSchemeId }
-                    }
-                }),
-                ...(gradingBoundaryId && {
-                    gradingBoundary: {
-                        connect: { id: gradingBoundaryId }
-                    }
-                }),
-                submissions: {
-                    create: classData.students.map((student) => ({
-                        student: {
-                            connect: { id: student.id }
+        // Create assignment and place at top of its scope within a single transaction
+        const teacherId = ctx.user.id;
+        const assignment = await prisma.$transaction(async (tx) => {
+            const created = await tx.assignment.create({
+                data: {
+                    title,
+                    instructions,
+                    dueDate: new Date(dueDate),
+                    maxGrade: markSchemeId ? computedMaxGrade : maxGrade,
+                    graded,
+                    weight,
+                    type,
+                    order: 1,
+                    inProgress: inProgress || false,
+                    class: {
+                        connect: { id: classId }
+                    },
+                    ...(sectionId && {
+                        section: {
+                            connect: { id: sectionId }
                         }
-                    }))
-                },
-                teacher: {
-                    connect: { id: ctx.user.id }
-                }
-            },
-            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
+                    }),
+                    ...(markSchemeId && {
+                        markScheme: {
+                            connect: { id: markSchemeId }
+                        }
+                    }),
+                    ...(gradingBoundaryId && {
+                        gradingBoundary: {
+                            connect: { id: gradingBoundaryId }
+                        }
+                    }),
+                    submissions: {
+                        create: classData.students.map((student) => ({
+                            student: {
+                                connect: { id: student.id }
+                            }
+                        }))
+                    },
+                    teacher: {
+                        connect: { id: teacherId }
                     }
                 },
-                class: {
-                    select: {
-                        id: true,
-                        name: true
+                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
+                        }
                     }
                 }
-            }
+            });
+            // 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);
+            return created;
         });
-        await Promise.all(stack.map(({ where, data }) => prisma.assignment.update({ where, data })));
         // 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
@@ -329,6 +428,14 @@ export const assignmentRouter = createTRPCRouter({
                 }
             });
         }
+        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:');
+        });
         return assignment;
     }),
     update: protectedProcedure
@@ -355,6 +462,7 @@ export const assignmentRouter = createTRPCRouter({
                         type: true,
                         path: true,
                         size: true,
+                        uploadStatus: true,
                         thumbnail: {
                             select: {
                                 path: true
@@ -382,6 +490,27 @@ export const assignmentRouter = createTRPCRouter({
             // 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
+        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);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.warn(`Failed to delete file ${file.path}:`, error);
+                }
+            }));
+        }
         // Update assignment
         const updatedAssignment = await prisma.assignment.update({
             where: { id },
@@ -536,14 +665,17 @@ export const assignmentRouter = createTRPCRouter({
             ...assignment.attachments,
             ...assignment.submissions.flatMap(sub => [...sub.attachments, ...sub.annotations])
         ];
-        // Delete files from storage
+        // Delete files from storage (only if they were actually uploaded)
         await Promise.all(filesToDelete.map(async (file) => {
             try {
-                // Delete the main file
-                await deleteFile(file.path);
-                // Delete thumbnail if it exists
-                if (file.thumbnail) {
-                    await deleteFile(file.thumbnail.path);
+                // Only delete from GCS if the file was successfully uploaded
+                if (file.uploadStatus === 'COMPLETED') {
+                    // Delete the main file
+                    await deleteFile(file.path);
+                    // Delete thumbnail if it exists
+                    if (file.thumbnail) {
+                        await deleteFile(file.thumbnail.path);
+                    }
                 }
             }
             catch (error) {
@@ -678,6 +810,7 @@ export const assignmentRouter = createTRPCRouter({
                     select: {
                         id: true,
                         username: true,
+                        profile: true,
                     },
                 },
                 assignment: {
@@ -779,12 +912,7 @@ export const assignmentRouter = createTRPCRouter({
                     select: {
                         id: true,
                         username: true,
-                        profile: {
-                            select: {
-                                displayName: true,
-                                profilePicture: true,
-                            }
-                        }
+                        profile: true,
                     },
                 },
                 assignment: {
@@ -956,14 +1084,17 @@ export const assignmentRouter = createTRPCRouter({
         // Delete removed attachments if any
         if (removedAttachments && removedAttachments.length > 0) {
             const filesToDelete = submission.attachments.filter((file) => removedAttachments.includes(file.id));
-            // Delete files from storage
+            // Delete files from storage (only if they were actually uploaded)
             await Promise.all(filesToDelete.map(async (file) => {
                 try {
-                    // Delete the main file
-                    await deleteFile(file.path);
-                    // Delete thumbnail if it exists
-                    if (file.thumbnail?.path) {
-                        await deleteFile(file.thumbnail.path);
+                    // Only delete from GCS if the file was successfully uploaded
+                    if (file.uploadStatus === 'COMPLETED') {
+                        // Delete the main file
+                        await deleteFile(file.path);
+                        // Delete thumbnail if it exists
+                        if (file.thumbnail?.path) {
+                            await deleteFile(file.thumbnail.path);
+                        }
                     }
                 }
                 catch (error) {
@@ -1204,14 +1335,17 @@ export const assignmentRouter = createTRPCRouter({
         // Delete removed attachments if any
         if (removedAttachments && removedAttachments.length > 0) {
             const filesToDelete = submission.annotations.filter((file) => removedAttachments.includes(file.id));
-            // Delete files from storage
+            // Delete files from storage (only if they were actually uploaded)
             await Promise.all(filesToDelete.map(async (file) => {
                 try {
-                    // Delete the main file
-                    await deleteFile(file.path);
-                    // Delete thumbnail if it exists
-                    if (file.thumbnail?.path) {
-                        await deleteFile(file.thumbnail.path);
+                    // Only delete from GCS if the file was successfully uploaded
+                    if (file.uploadStatus === 'COMPLETED') {
+                        // Delete the main file
+                        await deleteFile(file.path);
+                        // Delete thumbnail if it exists
+                        if (file.thumbnail?.path) {
+                            await deleteFile(file.thumbnail.path);
+                        }
                     }
                 }
                 catch (error) {