@studious-lms/server 1.1.24 → 1.2.26

package/dist/routers/section.d.ts

@@ -31,6 +31,22 @@ export declare const sectionRouter: import("@trpc/server").TRPCBuiltRouter<{
         };
         meta: object;
     }>;
+    reorder: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            classId: string;
+            movedId: string;
+            position: "start" | "end" | "before" | "after";
+            targetId?: string | undefined;
+        };
+        output: {
+            id: string;
+            name: string;
+            color: string | null;
+            classId: string;
+            order: number | null;
+        } | null;
+        meta: object;
+    }>;
     update: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             id: string;

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

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

package/dist/routers/section.js

@@ -56,34 +56,119 @@ export const sectionRouter = createTRPCRouter({
                 }),
             },
         });
-        // find all root items in the class and reorder them
-        const sections = await prisma.section.findMany({
-            where: {
-                classId: input.classId,
-            },
-        });
-        const assignments = await prisma.assignment.findMany({
-            where: {
-                classId: input.classId,
-                sectionId: null,
-            },
-        });
-        const stack = [...sections, ...assignments].sort((a, b) => (a.order || 0) - (b.order || 0)).map((item, index) => ({
-            id: item.id,
-            order: index + 1,
-        })).map((item) => ({
-            where: { id: item.id },
-            data: { order: item.order },
-        }));
-        // Update sections and assignments with their new order
-        await Promise.all([
-            ...stack.filter(item => sections.some(s => s.id === item.where.id))
-                .map(({ where, data }) => prisma.section.update({ where, data })),
-            ...stack.filter(item => assignments.some(a => a.id === item.where.id))
-                .map(({ where, data }) => prisma.assignment.update({ where, data }))
+        // Insert new section at top of unified list (sections + assignments) and normalize
+        const [sections, assignments] = await Promise.all([
+            prisma.section.findMany({
+                where: { classId: input.classId },
+                select: { id: true, order: true },
+            }),
+            prisma.assignment.findMany({
+                where: { classId: input.classId },
+                select: { id: true, order: true },
+            }),
         ]);
+        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));
+        const withoutNew = unified.filter(item => !(item.id === section.id && item.type === 'section'));
+        const reindexed = [{ id: section.id, type: 'section' }, ...withoutNew.map(item => ({ id: item.id, type: item.type }))];
+        await Promise.all(reindexed.map((item, index) => {
+            if (item.type === 'section') {
+                return prisma.section.update({ where: { id: item.id }, data: { order: index + 1 } });
+            }
+            else {
+                return prisma.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
+            }
+        }));
         return section;
     }),
+    reorder: protectedProcedure
+        .input(z.object({
+        classId: z.string(),
+        movedId: z.string(), // Section ID
+        // 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 }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        const { classId, movedId, position, targetId } = input;
+        const moved = await prisma.section.findFirst({
+            where: { id: movedId, classId },
+            select: { id: true, classId: true },
+        });
+        if (!moved) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Section 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 [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 },
+                }),
+            ]);
+            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));
+            const movedIdx = unified.findIndex(item => item.id === movedId && item.type === 'section');
+            if (movedIdx === -1) {
+                throw new TRPCError({ code: 'NOT_FOUND', message: 'Section not found in unified list' });
+            }
+            const withoutMoved = unified.filter(item => !(item.id === movedId && item.type === 'section'));
+            let next = [];
+            if (position === 'start') {
+                next = [{ id: movedId, type: 'section' }, ...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: 'section' }];
+            }
+            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: 'section' },
+                        ...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: 'section' },
+                        ...withoutMoved.slice(targetIdx + 1).map(item => ({ id: item.id, type: item.type })),
+                    ];
+                }
+            }
+            // Normalize to 1..n
+            await Promise.all(next.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 } });
+                }
+            }));
+            return tx.section.findUnique({ where: { id: movedId } });
+        });
+        return result;
+    }),
     update: protectedProcedure
         .input(updateSectionSchema)
         .mutation(async ({ ctx, input }) => {
@@ -151,11 +236,35 @@ export const sectionRouter = createTRPCRouter({
                 message: "Class not found or you are not a teacher",
             });
         }
-        await prisma.section.update({
-            where: { id: input.id },
-            data: {
-                order: input.order,
-            },
+        // Update order and normalize unified list
+        await prisma.$transaction(async (tx) => {
+            await tx.section.update({
+                where: { id: input.id },
+                data: { order: input.order },
+            });
+            // Normalize entire unified list
+            const [sections, assignments] = await Promise.all([
+                tx.section.findMany({
+                    where: { classId: input.classId },
+                    select: { id: true, order: true },
+                }),
+                tx.assignment.findMany({
+                    where: { classId: input.classId },
+                    select: { id: true, order: true },
+                }),
+            ]);
+            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));
+            await Promise.all(unified.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 } });
+                }
+            }));
         });
         return { id: input.id };
     }),

package/dist/seedDatabase.d.ts

@@ -14,9 +14,9 @@ export declare function addNotification(userId: string, title: string, content:
     title: string;
     content: string;
     createdAt: Date;
-    read: boolean;
-    receiverId: string;
     senderId: string | null;
+    receiverId: string;
+    read: boolean;
 }>;
 export declare const seedDatabase: () => Promise<void>;
 //# sourceMappingURL=seedDatabase.d.ts.map

package/dist/seedDatabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seedDatabase.d.ts","sourceRoot":"","sources":["../src/seedDatabase.ts"],"names":[],"mappings":"AAIA,wBAAsB,aAAa,kBAsClC;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;GAOjF;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;;;;;GAQnF;AAED,eAAO,MAAM,YAAY,qBAq+CxB,CAAC"}
+{"version":3,"file":"seedDatabase.d.ts","sourceRoot":"","sources":["../src/seedDatabase.ts"],"names":[],"mappings":"AAIA,wBAAsB,aAAa,kBAuClC;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;GAOjF;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;;;;;GAQnF;AAED,eAAO,MAAM,YAAY,qBAq+CxB,CAAC"}

package/dist/seedDatabase.js

@@ -4,6 +4,7 @@ import { logger } from "./utils/logger.js";
 export async function clearDatabase() {
     // Delete in order to respect foreign key constraints
     // Delete notifications first (they reference users)
+    logger.info('Clearing database');
     await prisma.notification.deleteMany();
     // Delete chat-related records
     await prisma.mention.deleteMany();
@@ -77,7 +78,7 @@ export const seedDatabase = async () => {
     ]);
     // 3. Create Students (realistic names)
     const students = await Promise.all([
-        createUser('alex.martinez@student.riverside.edu', 'student123', 'alex.martinez'),
+        createUser('alex.martinez@student.rverside.eidu', 'student123', 'alex.martinez'),
         createUser('sophia.williams@student.riverside.edu', 'student123', 'sophia.williams'),
         createUser('james.brown@student.riverside.edu', 'student123', 'james.brown'),
         createUser('olivia.taylor@student.riverside.edu', 'student123', 'olivia.taylor'),

package/dist/utils/logger.d.ts

@@ -10,6 +10,7 @@ declare class Logger {
     private isDevelopment;
     private mode;
     private levelColors;
+    private levelBgColors;
     private levelEmojis;
     private constructor();
     static getInstance(): Logger;

package/dist/utils/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA,oBAAY,QAAQ;IAClB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;IACf,KAAK,UAAU;CAChB;AAED,KAAK,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAwB3D,cAAM,MAAM;IACV,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,WAAW,CAA2B;IAC9C,OAAO,CAAC,WAAW,CAA2B;IAE9C,OAAO;WAuBO,WAAW,IAAI,MAAM;IAO5B,OAAO,CAAC,IAAI,EAAE,OAAO;IAI5B,OAAO,CAAC,SAAS;IAsBjB,OAAO,CAAC,aAAa;IAiBrB,OAAO,CAAC,GAAG;IAqCJ,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAInD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAInD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIpD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAG5D;AAED,eAAO,MAAM,MAAM,QAAuB,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA,oBAAY,QAAQ;IAClB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;IACf,KAAK,UAAU;CAChB;AAED,KAAK,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAyC3D,cAAM,MAAM;IACV,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,WAAW,CAA2B;IAC9C,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,WAAW,CAA2B;IAE9C,OAAO;WA8BO,WAAW,IAAI,MAAM;IAO5B,OAAO,CAAC,IAAI,EAAE,OAAO;IAI5B,OAAO,CAAC,SAAS;IAsBjB,OAAO,CAAC,aAAa;IAmBrB,OAAO,CAAC,GAAG;IAqCJ,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAInD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAInD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIpD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAG5D;AAED,eAAO,MAAM,MAAM,QAAuB,CAAC"}

package/dist/utils/logger.js

@@ -17,7 +17,24 @@ const colors = {
     magenta: '\x1b[35m',
     cyan: '\x1b[36m',
     white: '\x1b[37m',
-    gray: '\x1b[90m'
+    gray: '\x1b[90m',
+    // Background colors
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgBlue: '\x1b[44m',
+    bgMagenta: '\x1b[45m',
+    bgCyan: '\x1b[46m',
+    bgWhite: '\x1b[47m',
+    bgGray: '\x1b[100m',
+    // Bright background colors
+    bgBrightRed: '\x1b[101m',
+    bgBrightGreen: '\x1b[102m',
+    bgBrightYellow: '\x1b[103m',
+    bgBrightBlue: '\x1b[104m',
+    bgBrightMagenta: '\x1b[105m',
+    bgBrightCyan: '\x1b[106m',
+    bgBrightWhite: '\x1b[107m'
 };
 class Logger {
     constructor() {
@@ -30,6 +47,12 @@ class Logger {
             [LogLevel.ERROR]: colors.red,
             [LogLevel.DEBUG]: colors.magenta
         };
+        this.levelBgColors = {
+            [LogLevel.INFO]: colors.bgBlue,
+            [LogLevel.WARN]: colors.bgYellow,
+            [LogLevel.ERROR]: colors.bgRed,
+            [LogLevel.DEBUG]: colors.bgMagenta
+        };
         this.levelEmojis = {
             [LogLevel.INFO]: 'ℹ️',
             [LogLevel.WARN]: '⚠️',
@@ -70,9 +93,11 @@ class Logger {
     formatMessage(logMessage) {
         const { level, message, timestamp, context } = logMessage;
         const color = this.levelColors[level];
+        const bgColor = this.levelBgColors[level];
         const emoji = this.levelEmojis[level];
         const timestampStr = colors.gray + `[${timestamp}]` + colors.reset;
-        const levelStr = color + `[${level.toUpperCase()}]` + colors.reset;
+        // Use background color for level badge like Vitest
+        const levelStr = colors.white + bgColor + ` ${level.toUpperCase()} ` + colors.reset;
         const emojiStr = emoji + ' ';
         const messageStr = colors.bright + message + colors.reset;
         const contextStr = context

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studious-lms/server",
-  "version": "1.1.24",
+  "version": "1.2.26",
   "description": "Backend server for Studious application",
   "main": "dist/exportType.js",
   "types": "dist/exportType.d.ts",
@@ -18,7 +18,7 @@
     "generate": "npx prisma generate",
     "prepublishOnly": "npm run generate && npm run build",
     "test": "vitest",
-    "seed": "node dist/seedDatabase.js"
+    "seed": "tsx src/seedDatabase.ts"
   },
   "dependencies": {
     "@google-cloud/storage": "^7.16.0",

package/prisma/migrations/20251109122857_annuoncements_comments/migration.sql

@@ -0,0 +1,30 @@
+-- AlterTable
+ALTER TABLE "public"."Announcement" ADD COLUMN     "modifiedAt" TIMESTAMP(3);
+
+-- AlterTable
+ALTER TABLE "public"."File" ADD COLUMN     "announcementId" TEXT;
+
+-- CreateTable
+CREATE TABLE "public"."AnnouncementComment" (
+    "id" TEXT NOT NULL,
+    "content" TEXT NOT NULL,
+    "authorId" TEXT NOT NULL,
+    "announcementId" TEXT NOT NULL,
+    "parentCommentId" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "modifiedAt" TIMESTAMP(3),
+
+    CONSTRAINT "AnnouncementComment_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "public"."File" ADD CONSTRAINT "File_announcementId_fkey" FOREIGN KEY ("announcementId") REFERENCES "public"."Announcement"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."AnnouncementComment" ADD CONSTRAINT "AnnouncementComment_authorId_fkey" FOREIGN KEY ("authorId") REFERENCES "public"."User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."AnnouncementComment" ADD CONSTRAINT "AnnouncementComment_announcementId_fkey" FOREIGN KEY ("announcementId") REFERENCES "public"."Announcement"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."AnnouncementComment" ADD CONSTRAINT "AnnouncementComment_parentCommentId_fkey" FOREIGN KEY ("parentCommentId") REFERENCES "public"."AnnouncementComment"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/prisma/migrations/20251109135555_reactions_announcements_comments/migration.sql

@@ -0,0 +1,35 @@
+-- CreateEnum
+CREATE TYPE "public"."ReactionType" AS ENUM ('THUMBSUP', 'CELEBRATE', 'CARE', 'HEART', 'IDEA', 'HAPPY');
+
+-- CreateTable
+CREATE TABLE "public"."Reaction" (
+    "id" TEXT NOT NULL,
+    "type" "public"."ReactionType" NOT NULL,
+    "userId" TEXT NOT NULL,
+    "announcementId" TEXT,
+    "commentId" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "Reaction_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "Reaction_announcementId_idx" ON "public"."Reaction"("announcementId");
+
+-- CreateIndex
+CREATE INDEX "Reaction_commentId_idx" ON "public"."Reaction"("commentId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Reaction_userId_announcementId_key" ON "public"."Reaction"("userId", "announcementId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Reaction_userId_commentId_key" ON "public"."Reaction"("userId", "commentId");
+
+-- AddForeignKey
+ALTER TABLE "public"."Reaction" ADD CONSTRAINT "Reaction_userId_fkey" FOREIGN KEY ("userId") REFERENCES "public"."User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."Reaction" ADD CONSTRAINT "Reaction_announcementId_fkey" FOREIGN KEY ("announcementId") REFERENCES "public"."Announcement"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."Reaction" ADD CONSTRAINT "Reaction_commentId_fkey" FOREIGN KEY ("commentId") REFERENCES "public"."AnnouncementComment"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/prisma/schema.prisma

@@ -42,6 +42,15 @@ enum UploadStatus {
   CANCELLED
 }
 
+enum ReactionType {
+  THUMBSUP
+  CELEBRATE
+  CARE
+  HEART
+  IDEA
+  HAPPY
+}
+
 model School {
   id          String      @id @default(uuid())
   name        String
@@ -89,6 +98,8 @@ model User {
   sentMessages Message[] @relation("SentMessages")
   mentions Mention[] @relation("UserMentions")
   createdLabChats LabChat[] @relation("CreatedLabChats")
+  announcementComments AnnouncementComment[]
+  reactions Reaction[]
 
 }
 
@@ -207,6 +218,9 @@ model File {
   messageId String?
   message Message? @relation("MessageAttachments", fields: [messageId], references: [id], onDelete: Cascade)
 
+  announcement Announcement? @relation("AnnouncementAttachments", fields: [announcementId], references: [id], onDelete: Cascade)
+  announcementId String?
+
   schools      School[]
 
   schoolDevelopementProgram SchoolDevelopementProgram? @relation("SchoolDevelopementProgramSupportingDocumentation", fields: [schoolDevelopementProgramId], references: [id], onDelete: Cascade)
@@ -251,8 +265,44 @@ model Announcement {
   teacher User @relation(fields: [teacherId], references: [id])
   teacherId String
   createdAt DateTime @default(now())
+  modifiedAt DateTime? @updatedAt
   class   Class @relation(fields: [classId], references: [id], onDelete: Cascade)
   classId String
+  attachments File[] @relation("AnnouncementAttachments")
+  comments AnnouncementComment[]
+  reactions Reaction[]
+}
+
+model AnnouncementComment {
+  id            String @id @default(uuid())
+  content       String
+  author        User @relation(fields: [authorId], references: [id], onDelete: Cascade)
+  authorId      String
+  announcement  Announcement @relation(fields: [announcementId], references: [id], onDelete: Cascade)
+  announcementId String
+  parentComment AnnouncementComment? @relation("CommentReplies", fields: [parentCommentId], references: [id], onDelete: Cascade)
+  parentCommentId String?
+  replies       AnnouncementComment[] @relation("CommentReplies")
+  reactions     Reaction[]
+  createdAt     DateTime @default(now())
+  modifiedAt    DateTime? @updatedAt
+}
+
+model Reaction {
+  id            String @id @default(uuid())
+  type          ReactionType
+  user          User @relation(fields: [userId], references: [id], onDelete: Cascade)
+  userId        String
+  announcement  Announcement? @relation(fields: [announcementId], references: [id], onDelete: Cascade)
+  announcementId String?
+  comment       AnnouncementComment? @relation(fields: [commentId], references: [id], onDelete: Cascade)
+  commentId     String?
+  createdAt     DateTime @default(now())
+  
+  @@unique([userId, announcementId])
+  @@unique([userId, commentId])
+  @@index([announcementId])
+  @@index([commentId])
 }
 
 model Submission {

package/src/lib/fileUpload.ts

@@ -1,6 +1,6 @@
 import { TRPCError } from "@trpc/server";
 import { v4 as uuidv4 } from "uuid";
-import { getSignedUrl } from "./googleCloudStorage.js";
+import { getSignedUrl, objectExists } from "./googleCloudStorage.js";
 import { generateMediaThumbnail } from "./thumbnailGenerator.js";
 import { prisma } from "./prisma.js";
 import { logger } from "../utils/logger.js";
@@ -102,7 +102,8 @@ export async function createDirectUploadFile(
   userId: string,
   directory?: string,
   assignmentId?: string,
-  submissionId?: string
+  submissionId?: string,
+  announcementId?: string
 ): Promise<DirectUploadFile> {
   try {
     // Validate file extension matches MIME type
@@ -167,6 +168,11 @@ export async function createDirectUploadFile(
           submission: {
             connect: { id: submissionId }
           }
+        }),
+        ...(announcementId && {
+          announcement: {
+            connect: { id: announcementId }
+          }
         })
       },
     });
@@ -182,7 +188,11 @@ export async function createDirectUploadFile(
       uploadSessionId
     };
   } catch (error) {
-    console.error('Error creating direct upload file:', error);
+    logger.error('Error creating direct upload file:', {error: error instanceof Error ? {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    } : error});
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
       message: 'Failed to create direct upload file',
@@ -202,17 +212,53 @@ export async function confirmDirectUpload(
   errorMessage?: string
 ): Promise<void> {
   try {
+    // First fetch the file record to get the object path
+    const fileRecord = await prisma.file.findUnique({
+      where: { id: fileId },
+      select: { path: true }
+    });
+
+    if (!fileRecord) {
+      throw new TRPCError({
+        code: 'NOT_FOUND',
+        message: 'File record not found',
+      });
+    }
+
+    let actualUploadSuccess = uploadSuccess;
+    let actualErrorMessage = errorMessage;
+
+    // If uploadSuccess is true, verify the object actually exists in GCS
+    if (uploadSuccess) {
+      try {
+        const exists = await objectExists(process.env.GOOGLE_CLOUD_BUCKET_NAME!, fileRecord.path);
+        if (!exists) {
+          actualUploadSuccess = false;
+          actualErrorMessage = 'File upload reported as successful but object not found in Google Cloud Storage';
+          logger.error(`File upload verification failed for ${fileId}: object ${fileRecord.path} not found in GCS`);
+        }
+      } catch (error) {
+        logger.error(`Error verifying file existence in GCS for ${fileId}:`, {error: error instanceof Error ? {
+          name: error.name,
+          message: error.message,
+          stack: error.stack,
+        } : error});
+        actualUploadSuccess = false;
+        actualErrorMessage = 'Failed to verify file existence in Google Cloud Storage';
+      }
+    }
+
     const updateData: any = {
-      uploadStatus: uploadSuccess ? 'COMPLETED' : 'FAILED',
-      uploadProgress: uploadSuccess ? 100 : 0,
+      uploadStatus: actualUploadSuccess ? 'COMPLETED' : 'FAILED',
+      uploadProgress: actualUploadSuccess ? 100 : 0,
     };
     
-    if (!uploadSuccess && errorMessage) {
-      updateData.uploadError = errorMessage;
+    if (!actualUploadSuccess && actualErrorMessage) {
+      updateData.uploadError = actualErrorMessage;
       updateData.uploadRetryCount = { increment: 1 };
     }
     
-    if (uploadSuccess) {
+    if (actualUploadSuccess) {
       updateData.uploadedAt = new Date();
     }
     
@@ -221,7 +267,7 @@ export async function confirmDirectUpload(
       data: updateData
     });
   } catch (error) {
-    console.error('Error confirming direct upload:', error);
+    logger.error('Error confirming direct upload:', {error});
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
       message: 'Failed to confirm upload',
@@ -239,15 +285,29 @@ export async function updateUploadProgress(
   progress: number
 ): Promise<void> {
   try {
+    // await prisma.file.update({
+    //   where: { id: fileId },
+    //   data: {
+    //     uploadStatus: 'UPLOADING',
+    //     uploadProgress: Math.min(100, Math.max(0, progress))
+    //   }
+    // });
+    const current = await prisma.file.findUnique({ where: { id: fileId }, select: { uploadStatus: true } });
+    if (!current || ['COMPLETED','FAILED','CANCELLED'].includes(current.uploadStatus as string)) return;
+    const clamped = Math.min(100, Math.max(0, progress));
     await prisma.file.update({
       where: { id: fileId },
       data: {
         uploadStatus: 'UPLOADING',
-        uploadProgress: Math.min(100, Math.max(0, progress))
+        uploadProgress: clamped
       }
     });
   } catch (error) {
-    console.error('Error updating upload progress:', error);
+    logger.error('Error updating upload progress:', {error: error instanceof Error ? {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    } : error});  
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
       message: 'Failed to update upload progress',
@@ -269,15 +329,20 @@ export async function createDirectUploadFiles(
   userId: string,
   directory?: string,
   assignmentId?: string,
-  submissionId?: string
+  submissionId?: string,
+  announcementId?: string
 ): Promise<DirectUploadFile[]> {
   try {
     const uploadPromises = files.map(file => 
-      createDirectUploadFile(file, userId, directory, assignmentId, submissionId)
+      createDirectUploadFile(file, userId, directory, assignmentId, submissionId, announcementId)
     );
     return await Promise.all(uploadPromises);
   } catch (error) {
-    console.error('Error creating direct upload files:', error);
+    logger.error('Error creating direct upload files:', {error: error instanceof Error ? {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    } : error});
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
       message: 'Failed to create direct upload files',