@studious-lms/server 1.1.24 → 1.2.26

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) {

package/dist/routers/auth.js

@@ -146,7 +146,7 @@ export const authRouter = createTRPCRouter({
             },
         };
     }),
-    logout: publicProcedure
+    logout: protectedProcedure
         .mutation(async ({ ctx }) => {
         if (!ctx.user) {
             throw new TRPCError({

package/dist/routers/file.d.ts

@@ -62,6 +62,7 @@ export declare const fileRouter: import("@trpc/server").TRPCBuiltRouter<{
             folderId: string | null;
             conversationId: string | null;
             messageId: string | null;
+            announcementId: string | null;
             schoolDevelopementProgramId: string | null;
         };
         meta: object;
@@ -103,6 +104,7 @@ export declare const fileRouter: import("@trpc/server").TRPCBuiltRouter<{
             folderId: string | null;
             conversationId: string | null;
             messageId: string | null;
+            announcementId: string | null;
             schoolDevelopementProgramId: string | null;
         };
         meta: object;

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

@@ -1 +1 @@
-{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/routers/file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsVrB,CAAC"}
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/routers/file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyVrB,CAAC"}

package/dist/routers/file.js

@@ -295,13 +295,16 @@ export const fileRouter = createTRPCRouter({
                 message: "File does not belong to this class",
             });
         }
-        // Delete files from storage
+        // Delete files from storage (only if they were actually uploaded)
         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) {

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

@@ -1 +1 @@
-{"version":3,"file":"labChat.d.ts","sourceRoot":"","sources":["../../src/routers/labChat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAkBxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAonBxB,CAAC"}
+{"version":3,"file":"labChat.d.ts","sourceRoot":"","sources":["../../src/routers/labChat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAonBxB,CAAC"}

package/dist/routers/labChat.js

@@ -6,8 +6,7 @@ import { TRPCError } from '@trpc/server';
 import { inferenceClient, sendAIMessage } from '../utils/inference.js';
 import { logger } from '../utils/logger.js';
 import { isAIUser } from '../utils/aiUser.js';
-// DEPRECATED: uploadFile removed - use direct upload instead
-// import { uploadFile } from '../lib/googleCloudStorage.js';
+import { bucket } from '../lib/googleCloudStorage.js';
 import { createPdf } from "../lib/jsonConversion.js";
 import { v4 as uuidv4 } from "uuid";
 export const labChatRouter = createTRPCRouter({
@@ -833,16 +832,25 @@ WHEN CREATING COURSE MATERIALS (docs field):
                                 .replace(/\s+/g, '_')
                                 .substring(0, 50);
                             const filename = `${sanitizedTitle}_${uuidv4().substring(0, 8)}.pdf`;
+                            const filePath = `class/generated/${fullLabChat.classId}/${filename}`;
                             logger.info(`PDF ${i + 1} generated successfully`, { labChatId, title: doc.title });
-                            // DEPRECATED: Base64 upload removed - use direct upload instead
-                            // const gcpResult = await uploadFile(Buffer.from(pdfBytes).toString('base64'), `class/generated/${fullLabChat.classId}/${filename}`, 'application/pdf');
+                            // Upload directly to Google Cloud Storage
+                            const gcsFile = bucket.file(filePath);
+                            await gcsFile.save(Buffer.from(pdfBytes), {
+                                metadata: {
+                                    contentType: 'application/pdf',
+                                }
+                            });
                             logger.info(`PDF ${i + 1} uploaded successfully`, { labChatId, filename });
                             const file = await prisma.file.create({
                                 data: {
                                     name: filename,
-                                    path: `class/generated/${fullLabChat.classId}/${filename}`,
+                                    path: filePath,
                                     type: 'application/pdf',
+                                    size: pdfBytes.length,
                                     userId: fullLabChat.createdById,
+                                    uploadStatus: 'COMPLETED',
+                                    uploadedAt: new Date(),
                                 },
                             });
                             attachmentIds.push(file.id);

package/dist/routers/notifications.d.ts

@@ -30,9 +30,9 @@ export declare const notificationRouter: import("@trpc/server").TRPCBuiltRouter<
             title: string;
             content: string;
             createdAt: Date;
-            read: boolean;
-            receiverId: string;
             senderId: string | null;
+            receiverId: string;
+            read: boolean;
         })[];
         meta: object;
     }>;
@@ -52,9 +52,9 @@ export declare const notificationRouter: import("@trpc/server").TRPCBuiltRouter<
             title: string;
             content: string;
             createdAt: Date;
-            read: boolean;
-            receiverId: string;
             senderId: string | null;
+            receiverId: string;
+            read: boolean;
         }) | null;
         meta: object;
     }>;
@@ -69,9 +69,9 @@ export declare const notificationRouter: import("@trpc/server").TRPCBuiltRouter<
             title: string;
             content: string;
             createdAt: Date;
-            read: boolean;
-            receiverId: string;
             senderId: string | null;
+            receiverId: string;
+            read: boolean;
         };
         meta: object;
     }>;
@@ -93,9 +93,9 @@ export declare const notificationRouter: import("@trpc/server").TRPCBuiltRouter<
             title: string;
             content: string;
             createdAt: Date;
-            read: boolean;
-            receiverId: string;
             senderId: string | null;
+            receiverId: string;
+            read: boolean;
         };
         meta: object;
     }>;