@studious-lms/server 1.1.19 → 1.1.21

package/dist/routers/assignment.js

@@ -2,20 +2,23 @@ import { z } from "zod";
 import { createTRPCRouter, protectedProcedure, protectedClassMemberProcedure, protectedTeacherProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
-import { uploadFiles } from "../lib/fileUpload.js";
+import { createDirectUploadFiles, confirmDirectUpload, updateUploadProgress } from "../lib/fileUpload.js";
 import { deleteFile } from "../lib/googleCloudStorage.js";
-const fileSchema = z.object({
+// 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)
+const directFileSchema = z.object({
     name: z.string(),
     type: z.string(),
     size: z.number(),
-    data: z.string(), // base64 encoded file data
+    // No data field - for direct file uploads
 });
 const createAssignmentSchema = z.object({
     classId: z.string(),
     title: z.string(),
     instructions: z.string(),
     dueDate: z.string(),
-    files: z.array(fileSchema).optional(),
+    files: z.array(directFileSchema).optional(), // Use direct file schema
     existingFileIds: z.array(z.string()).optional(),
     maxGrade: z.number().optional(),
     graded: z.boolean().optional(),
@@ -32,7 +35,7 @@ const updateAssignmentSchema = z.object({
     title: z.string().optional(),
     instructions: z.string().optional(),
     dueDate: z.string().optional(),
-    files: z.array(fileSchema).optional(),
+    files: z.array(directFileSchema).optional(), // Use direct file schema
     existingFileIds: z.array(z.string()).optional(),
     removedAttachments: z.array(z.string()).optional(),
     maxGrade: z.number().optional(),
@@ -55,7 +58,7 @@ const submissionSchema = z.object({
     classId: z.string(),
     submissionId: z.string(),
     submit: z.boolean().optional(),
-    newAttachments: z.array(fileSchema).optional(),
+    newAttachments: z.array(directFileSchema).optional(), // Use direct file schema
     existingFileIds: z.array(z.string()).optional(),
     removedAttachments: z.array(z.string()).optional(),
 });
@@ -65,7 +68,7 @@ const updateSubmissionSchema = z.object({
     submissionId: z.string(),
     return: z.boolean().optional(),
     gradeReceived: z.number().nullable().optional(),
-    newAttachments: z.array(fileSchema).optional(),
+    newAttachments: z.array(directFileSchema).optional(), // Use direct file schema
     existingFileIds: z.array(z.string()).optional(),
     removedAttachments: z.array(z.string()).optional(),
     feedback: z.string().optional(),
@@ -76,6 +79,31 @@ const updateSubmissionSchema = z.object({
         comments: z.string(),
     })).optional(),
 });
+// New schemas for direct upload functionality
+const getAssignmentUploadUrlsSchema = z.object({
+    assignmentId: z.string(),
+    classId: z.string(),
+    files: z.array(directFileSchema),
+});
+const getSubmissionUploadUrlsSchema = z.object({
+    submissionId: z.string(),
+    classId: z.string(),
+    files: z.array(directFileSchema),
+});
+const confirmAssignmentUploadSchema = z.object({
+    fileId: z.string(),
+    uploadSuccess: z.boolean(),
+    errorMessage: z.string().optional(),
+});
+const confirmSubmissionUploadSchema = z.object({
+    fileId: z.string(),
+    uploadSuccess: z.boolean(),
+    errorMessage: z.string().optional(),
+});
+const updateUploadProgressSchema = z.object({
+    fileId: z.string(),
+    progress: z.number().min(0).max(100),
+});
 export const assignmentRouter = createTRPCRouter({
     order: protectedTeacherProcedure
         .input(z.object({
@@ -98,7 +126,7 @@ export const assignmentRouter = createTRPCRouter({
         targetSectionId: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
-        const { id, targetSectionId, } = input;
+        const { id, targetSectionId } = input;
         const assignments = await prisma.assignment.findMany({
             where: { sectionId: targetSectionId },
         });
@@ -251,11 +279,13 @@ export const assignmentRouter = createTRPCRouter({
             }
         });
         await Promise.all(stack.map(({ where, data }) => prisma.assignment.update({ where, data })));
-        // Upload files if provided
+        // NOTE: Files are now handled via direct upload endpoints
+        // The files field in the schema is for metadata only
+        // Actual file uploads should use getAssignmentUploadUrls endpoint
         let uploadedFiles = [];
         if (files && files.length > 0) {
-            // Store files in a class and assignment specific directory
-            uploadedFiles = await uploadFiles(files, ctx.user.id);
+            // Create direct upload files instead of processing base64
+            uploadedFiles = await createDirectUploadFiles(files, ctx.user.id, undefined, assignment.id);
         }
         // Update assignment with new file attachments
         if (uploadedFiles.length > 0) {
@@ -336,11 +366,11 @@ export const assignmentRouter = createTRPCRouter({
                 message: "Assignment not found",
             });
         }
-        // Upload new files if provided
+        // NOTE: Files are now handled via direct upload endpoints
         let uploadedFiles = [];
         if (files && files.length > 0) {
-            // Store files in a class and assignment specific directory
-            uploadedFiles = await uploadFiles(files, ctx.user.id);
+            // Create direct upload files instead of processing base64
+            uploadedFiles = await createDirectUploadFiles(files, ctx.user.id, undefined, input.id);
         }
         // Update assignment
         const updatedAssignment = await prisma.assignment.update({
@@ -740,6 +770,7 @@ export const assignmentRouter = createTRPCRouter({
                     select: {
                         id: true,
                         username: true,
+                        profile: true,
                     },
                 },
                 assignment: {
@@ -874,7 +905,7 @@ export const assignmentRouter = createTRPCRouter({
         let uploadedFiles = [];
         if (newAttachments && newAttachments.length > 0) {
             // Store files in a class and assignment specific directory
-            uploadedFiles = await uploadFiles(newAttachments, ctx.user.id);
+            uploadedFiles = await createDirectUploadFiles(newAttachments, ctx.user.id, undefined, undefined, submission.id);
         }
         // Update submission with new file attachments
         if (uploadedFiles.length > 0) {
@@ -1139,7 +1170,7 @@ export const assignmentRouter = createTRPCRouter({
         let uploadedFiles = [];
         if (newAttachments && newAttachments.length > 0) {
             // Store files in a class and assignment specific directory
-            uploadedFiles = await uploadFiles(newAttachments, ctx.user.id);
+            uploadedFiles = await createDirectUploadFiles(newAttachments, ctx.user.id, undefined, undefined, submission.id);
         }
         // Update submission with new file attachments
         if (uploadedFiles.length > 0) {
@@ -1665,4 +1696,201 @@ export const assignmentRouter = createTRPCRouter({
         });
         return updatedAssignment;
     }),
+    // New direct upload endpoints
+    getAssignmentUploadUrls: protectedTeacherProcedure
+        .input(getAssignmentUploadUrlsSchema)
+        .mutation(async ({ ctx, input }) => {
+        const { assignmentId, classId, files } = input;
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to upload files",
+            });
+        }
+        // Verify user is a teacher of the class
+        const classData = await prisma.class.findFirst({
+            where: {
+                id: classId,
+                teachers: {
+                    some: {
+                        id: ctx.user.id,
+                    },
+                },
+            },
+        });
+        if (!classData) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "Class not found or you are not a teacher",
+            });
+        }
+        // Verify assignment exists and belongs to the class
+        const assignment = await prisma.assignment.findFirst({
+            where: {
+                id: assignmentId,
+                classId: classId,
+            },
+        });
+        if (!assignment) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "Assignment not found",
+            });
+        }
+        // Create direct upload files
+        const directUploadFiles = await createDirectUploadFiles(files, ctx.user.id, undefined, // No specific directory
+        assignmentId);
+        return {
+            success: true,
+            uploadFiles: directUploadFiles,
+        };
+    }),
+    getSubmissionUploadUrls: protectedClassMemberProcedure
+        .input(getSubmissionUploadUrlsSchema)
+        .mutation(async ({ ctx, input }) => {
+        const { submissionId, classId, files } = input;
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to upload files",
+            });
+        }
+        // Verify submission exists and user has access
+        const submission = await prisma.submission.findFirst({
+            where: {
+                id: submissionId,
+                assignment: {
+                    classId: classId,
+                },
+            },
+            include: {
+                assignment: {
+                    include: {
+                        class: {
+                            include: {
+                                students: true,
+                                teachers: true,
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        if (!submission) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "Submission not found",
+            });
+        }
+        // Check if user is the student who owns the submission or a teacher of the class
+        const isStudent = submission.studentId === ctx.user.id;
+        const isTeacher = submission.assignment.class.teachers.some(teacher => teacher.id === ctx.user?.id);
+        if (!isStudent && !isTeacher) {
+            throw new TRPCError({
+                code: "FORBIDDEN",
+                message: "You don't have permission to upload files to this submission",
+            });
+        }
+        // Create direct upload files
+        const directUploadFiles = await createDirectUploadFiles(files, ctx.user.id, undefined, // No specific directory
+        undefined, // No assignment ID
+        submissionId);
+        return {
+            success: true,
+            uploadFiles: directUploadFiles,
+        };
+    }),
+    confirmAssignmentUpload: protectedTeacherProcedure
+        .input(confirmAssignmentUploadSchema)
+        .mutation(async ({ ctx, input }) => {
+        const { fileId, uploadSuccess, errorMessage } = input;
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in",
+            });
+        }
+        // Verify file belongs to user and is an assignment file
+        const file = await prisma.file.findFirst({
+            where: {
+                id: fileId,
+                userId: ctx.user.id,
+                assignment: {
+                    isNot: null,
+                },
+            },
+        });
+        if (!file) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "File not found or you don't have permission",
+            });
+        }
+        await confirmDirectUpload(fileId, uploadSuccess, errorMessage);
+        return {
+            success: true,
+            message: uploadSuccess ? "Upload confirmed successfully" : "Upload failed",
+        };
+    }),
+    confirmSubmissionUpload: protectedClassMemberProcedure
+        .input(confirmSubmissionUploadSchema)
+        .mutation(async ({ ctx, input }) => {
+        const { fileId, uploadSuccess, errorMessage } = input;
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in",
+            });
+        }
+        // Verify file belongs to user and is a submission file
+        const file = await prisma.file.findFirst({
+            where: {
+                id: fileId,
+                userId: ctx.user.id,
+                submission: {
+                    isNot: null,
+                },
+            },
+        });
+        if (!file) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "File not found or you don't have permission",
+            });
+        }
+        await confirmDirectUpload(fileId, uploadSuccess, errorMessage);
+        return {
+            success: true,
+            message: uploadSuccess ? "Upload confirmed successfully" : "Upload failed",
+        };
+    }),
+    updateUploadProgress: protectedProcedure
+        .input(updateUploadProgressSchema)
+        .mutation(async ({ ctx, input }) => {
+        const { fileId, progress } = input;
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in",
+            });
+        }
+        // Verify file belongs to user
+        const file = await prisma.file.findFirst({
+            where: {
+                id: fileId,
+                userId: ctx.user.id,
+            },
+        });
+        if (!file) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "File not found or you don't have permission",
+            });
+        }
+        await updateUploadProgress(fileId, progress);
+        return {
+            success: true,
+            progress,
+        };
+    }),
 });

package/dist/routers/auth.js

@@ -113,7 +113,7 @@ export const authRouter = createTRPCRouter({
         if (!user) {
             throw new TRPCError({
                 code: "UNAUTHORIZED",
-                message: "Invalid username or password",
+                message: "user doesn't exists.",
             });
         }
         if (!(await compare(password, user.password))) {

package/dist/routers/file.d.ts

@@ -49,6 +49,15 @@ export declare const fileRouter: import("@trpc/server").TRPCBuiltRouter<{
             userId: string | null;
             thumbnailId: string | null;
             annotationId: string | null;
+            uploadStatus: import(".prisma/client").$Enums.UploadStatus;
+            uploadUrl: string | null;
+            uploadExpiresAt: Date | null;
+            uploadSessionId: string | null;
+            uploadProgress: number | null;
+            uploadError: string | null;
+            uploadRetryCount: number;
+            isOrphaned: boolean;
+            cleanupAt: Date | null;
             classDraftId: string | null;
             folderId: string | null;
             conversationId: string | null;
@@ -81,6 +90,15 @@ export declare const fileRouter: import("@trpc/server").TRPCBuiltRouter<{
             userId: string | null;
             thumbnailId: string | null;
             annotationId: string | null;
+            uploadStatus: import(".prisma/client").$Enums.UploadStatus;
+            uploadUrl: string | null;
+            uploadExpiresAt: Date | null;
+            uploadSessionId: string | null;
+            uploadProgress: number | null;
+            uploadError: string | null;
+            uploadRetryCount: number;
+            isOrphaned: boolean;
+            cleanupAt: Date | null;
             classDraftId: string | null;
             folderId: string | null;
             conversationId: string | null;

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsVrB,CAAC"}

package/dist/routers/folder.d.ts

@@ -208,7 +208,6 @@ export declare const folderRouter: import("@trpc/server").TRPCBuiltRouter<{
                 type: string;
                 name: string;
                 size: number;
-                data: string;
             }[];
             folderId: string;
         };

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

@@ -1 +1 @@
-{"version":3,"file":"folder.d.ts","sourceRoot":"","sources":["../../src/routers/folder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA6BxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0vBvB,CAAC"}
+{"version":3,"file":"folder.d.ts","sourceRoot":"","sources":["../../src/routers/folder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiCxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0vBvB,CAAC"}

package/dist/routers/folder.js

@@ -2,21 +2,24 @@ import { z } from "zod";
 import { createTRPCRouter, protectedProcedure, protectedClassMemberProcedure, protectedTeacherProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
-import { uploadFiles } from "../lib/fileUpload.js";
-const fileSchema = z.object({
-    name: z.string(),
-    type: z.string(),
-    size: z.number(),
-    data: z.string(), // base64 encoded file data
-});
+import { createDirectUploadFiles } from "../lib/fileUpload.js";
+// DEPRECATED: This schema is no longer used - files are uploaded directly to GCS
+// Use directFileSchema instead
 const createFolderSchema = z.object({
     name: z.string(),
     parentFolderId: z.string().optional(),
     color: z.string().optional(),
 });
+// New schema for direct file uploads (no base64 data)
+const directFileSchema = z.object({
+    name: z.string(),
+    type: z.string(),
+    size: z.number(),
+    // No data field - for direct file uploads
+});
 const uploadFilesToFolderSchema = z.object({
     folderId: z.string(),
-    files: z.array(fileSchema),
+    files: z.array(directFileSchema), // Use direct file schema
 });
 const getRootFolderSchema = z.object({
     classId: z.string(),
@@ -431,7 +434,7 @@ export const folderRouter = createTRPCRouter({
             });
         }
         // Upload files
-        const uploadedFiles = await uploadFiles(files, ctx.user.id, folder.id);
+        const uploadedFiles = await createDirectUploadFiles(files, ctx.user.id, folder.id);
         // Create file records in database
         //   const fileRecords = await prisma.file.createMany({
         //     data: uploadedFiles.map(file => ({

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;AAiBxB,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;AAkBxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAonBxB,CAAC"}

package/dist/routers/labChat.js

@@ -6,7 +6,8 @@ import { TRPCError } from '@trpc/server';
 import { inferenceClient, sendAIMessage } from '../utils/inference.js';
 import { logger } from '../utils/logger.js';
 import { isAIUser } from '../utils/aiUser.js';
-import { uploadFile } from '../lib/googleCloudStorage.js';
+// DEPRECATED: uploadFile removed - use direct upload instead
+// import { uploadFile } from '../lib/googleCloudStorage.js';
 import { createPdf } from "../lib/jsonConversion.js";
 import { v4 as uuidv4 } from "uuid";
 export const labChatRouter = createTRPCRouter({
@@ -833,7 +834,8 @@ WHEN CREATING COURSE MATERIALS (docs field):
                                 .substring(0, 50);
                             const filename = `${sanitizedTitle}_${uuidv4().substring(0, 8)}.pdf`;
                             logger.info(`PDF ${i + 1} generated successfully`, { labChatId, title: doc.title });
-                            const gcpResult = await uploadFile(Buffer.from(pdfBytes).toString('base64'), `class/generated/${fullLabChat.classId}/${filename}`, 'application/pdf');
+                            // DEPRECATED: Base64 upload removed - use direct upload instead
+                            // const gcpResult = await uploadFile(Buffer.from(pdfBytes).toString('base64'), `class/generated/${fullLabChat.classId}/${filename}`, 'application/pdf');
                             logger.info(`PDF ${i + 1} uploaded successfully`, { labChatId, filename });
                             const file = await prisma.file.create({
                                 data: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studious-lms/server",
-  "version": "1.1.19",
+  "version": "1.1.21",
   "description": "Backend server for Studious application",
   "main": "dist/exportType.js",
   "types": "dist/exportType.d.ts",

package/prisma/migrations/20251020151505_add_upload_tracking_fields/migration.sql

@@ -0,0 +1,57 @@
+-- CreateEnum
+CREATE TYPE "public"."UploadStatus" AS ENUM ('PENDING', 'UPLOADING', 'COMPLETED', 'FAILED', 'CANCELLED');
+
+-- AlterTable
+ALTER TABLE "public"."File" ADD COLUMN     "cleanupAt" TIMESTAMP(3),
+ADD COLUMN     "conversationId" TEXT,
+ADD COLUMN     "isOrphaned" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN     "messageId" TEXT,
+ADD COLUMN     "schoolDevelopementProgramId" TEXT,
+ADD COLUMN     "uploadError" TEXT,
+ADD COLUMN     "uploadExpiresAt" TIMESTAMP(3),
+ADD COLUMN     "uploadProgress" INTEGER,
+ADD COLUMN     "uploadRetryCount" INTEGER NOT NULL DEFAULT 0,
+ADD COLUMN     "uploadSessionId" TEXT,
+ADD COLUMN     "uploadStatus" "public"."UploadStatus" NOT NULL DEFAULT 'PENDING',
+ADD COLUMN     "uploadUrl" TEXT;
+
+-- CreateTable
+CREATE TABLE "public"."SchoolDevelopementProgram" (
+    "id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "type" TEXT NOT NULL,
+    "address" TEXT NOT NULL,
+    "city" TEXT NOT NULL,
+    "country" TEXT NOT NULL,
+    "numberOfStudents" INTEGER NOT NULL,
+    "numberOfTeachers" INTEGER NOT NULL,
+    "website" TEXT,
+    "contactName" TEXT,
+    "contactRole" TEXT,
+    "contactEmail" TEXT,
+    "contactPhone" TEXT DEFAULT '',
+    "eligibilityInformation" TEXT,
+    "whyHelp" TEXT,
+    "additionalInformation" TEXT,
+    "submittedAt" TIMESTAMP(3) DEFAULT CURRENT_TIMESTAMP,
+    "reviewedAt" TIMESTAMP(3),
+    "status" TEXT NOT NULL DEFAULT 'PENDING',
+
+    CONSTRAINT "SchoolDevelopementProgram_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "public"."EarlyAccessRequest" (
+    "id" TEXT NOT NULL,
+    "email" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "institutionSize" TEXT NOT NULL,
+
+    CONSTRAINT "EarlyAccessRequest_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "public"."File" ADD CONSTRAINT "File_messageId_fkey" FOREIGN KEY ("messageId") REFERENCES "public"."Message"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."File" ADD CONSTRAINT "File_schoolDevelopementProgramId_fkey" FOREIGN KEY ("schoolDevelopementProgramId") REFERENCES "public"."SchoolDevelopementProgram"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/prisma/schema.prisma

@@ -34,6 +34,14 @@ enum UserRole {
   NONE
 }
 
+enum UploadStatus {
+  PENDING
+  UPLOADING
+  COMPLETED
+  FAILED
+  CANCELLED
+}
+
 model School {
   id          String      @id @default(uuid())
   name        String
@@ -163,6 +171,17 @@ model File {
   userId     String?
   uploadedAt DateTime? @default(now())
 
+  // Upload tracking fields
+  uploadStatus UploadStatus @default(PENDING)
+  uploadUrl    String?
+  uploadExpiresAt DateTime?
+  uploadSessionId String?
+  uploadProgress Int?
+  uploadError   String?
+  uploadRetryCount Int @default(0)
+  isOrphaned Boolean @default(false)
+  cleanupAt  DateTime?
+
   // Thumbnail relationship
   thumbnail   File?  @relation("Thumbnail", fields: [thumbnailId], references: [id])
   thumbnailId String? @unique