@studious-lms/server 1.0.6 → 1.0.8

package/dist/routers/file.d.ts

@@ -1,10 +1,11 @@
 import { z } from "zod";
 export declare const fileRouter: import("@trpc/server").TRPCBuiltRouter<{
-    ctx: import("../trpc").Context;
+    ctx: import("../trpc.js").Context;
     meta: object;
     errorShape: {
         data: {
             zodError: z.typeToFlattenedError<any, string> | null;
+            prismaError: import("../utils/prismaErrorHandler.js").PrismaErrorInfo | null;
             code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
             httpStatus: number;
             path?: string;
@@ -20,7 +21,76 @@ export declare const fileRouter: import("@trpc/server").TRPCBuiltRouter<{
             fileId: string;
         };
         output: {
-            signedUrl: string;
+            url: string;
+        };
+        meta: object;
+    }>;
+    move: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            fileId: string;
+            targetFolderId: string;
+        };
+        output: {
+            user: {
+                id: string;
+                username: string;
+            } | null;
+        } & {
+            path: string;
+            type: string;
+            id: string;
+            name: string;
+            size: number | null;
+            uploadedAt: Date | null;
+            assignmentId: string | null;
+            submissionId: string | null;
+            userId: string | null;
+            thumbnailId: string | null;
+            annotationId: string | null;
+            classDraftId: string | null;
+            folderId: string | null;
+        };
+        meta: object;
+    }>;
+    rename: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            fileId: string;
+            newName: string;
+        };
+        output: {
+            user: {
+                id: string;
+                username: string;
+            } | null;
+        } & {
+            path: string;
+            type: string;
+            id: string;
+            name: string;
+            size: number | null;
+            uploadedAt: Date | null;
+            assignmentId: string | null;
+            submissionId: string | null;
+            userId: string | null;
+            thumbnailId: string | null;
+            annotationId: string | null;
+            classDraftId: string | null;
+            folderId: string | null;
+        };
+        meta: object;
+    }>;
+    delete: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            fileId: string;
+        };
+        output: {
+            success: boolean;
         };
         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;AAOxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;GAwFrB,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/file.js

@@ -1,27 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fileRouter = void 0;
-const zod_1 = require("zod");
-const trpc_1 = require("../trpc");
-const server_1 = require("@trpc/server");
-const googleCloudStorage_1 = require("../lib/googleCloudStorage");
-const prisma_1 = require("../lib/prisma");
-exports.fileRouter = (0, trpc_1.createTRPCRouter)({
-    getSignedUrl: trpc_1.protectedProcedure
-        .input(zod_1.z.object({
-        fileId: zod_1.z.string(),
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure, protectedTeacherProcedure } from "../trpc.js";
+import { TRPCError } from "@trpc/server";
+import { getSignedUrl, deleteFile } from "../lib/googleCloudStorage.js";
+import { prisma } from "../lib/prisma.js";
+import { logger } from "../utils/logger.js";
+export const fileRouter = createTRPCRouter({
+    getSignedUrl: protectedProcedure
+        .input(z.object({
+        fileId: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         const { fileId } = input;
         const userId = ctx.user?.id;
         if (!userId) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "You must be logged in to access files",
             });
         }
         // Get file metadata from database
-        const file = await prisma_1.prisma.file.findUnique({
+        const file = await prisma.file.findUnique({
             where: { id: fileId },
             include: {
                 assignment: {
@@ -47,42 +45,272 @@ exports.fileRouter = (0, trpc_1.createTRPCRouter)({
                             }
                         }
                     }
+                },
+                annotations: {
+                    include: {
+                        student: true,
+                        assignment: {
+                            include: {
+                                class: {
+                                    include: {
+                                        teachers: true,
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                folder: {
+                    include: {
+                        class: {
+                            include: {
+                                students: true,
+                                teachers: true
+                            }
+                        }
+                    }
                 }
             }
         });
         if (!file) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "File does not exist",
             });
         }
-        // Check if user has access to the file
-        const hasAccess = 
-        // File owner
-        file.userId === userId ||
-            // Assignment file - student in class or teacher
-            (file.assignment && (file.assignment.class.students.some((s) => s.id === userId) ||
-                file.assignment.class.teachers.some((t) => t.id === userId))) ||
-            // Submission file - student who submitted or teacher of class
-            (file.submission && (file.submission.student.id === userId ||
-                file.submission.assignment.class.teachers.some((t) => t.id === userId)));
+        // Check if user has access to this file
+        let hasAccess = false;
+        let classId = null;
+        // Check if user is a teacher of the class
+        if (file.assignment?.class) {
+            classId = file.assignment.class.id;
+            hasAccess = file.assignment.class.teachers.some(teacher => teacher.id === userId) || false;
+        }
+        if (file.submission?.assignment?.classId) {
+            classId = file.submission.assignment.classId;
+            hasAccess = file.submission?.studentId === userId || false;
+            if (!hasAccess)
+                hasAccess = file.submission.assignment.class.teachers.some(teacher => teacher.id === userId) || false;
+        }
+        if (file.annotations?.assignment?.classId) {
+            classId = file.annotations?.assignment.classId;
+            hasAccess = file.annotations?.studentId === userId || false;
+            if (!hasAccess)
+                hasAccess = file.annotations.assignment.class.teachers.some(teacher => teacher.id === userId) || false;
+        }
+        // Check if user is the file owner
+        if (file.userId === userId) {
+            hasAccess = true;
+        }
+        // Check if file is in a folder and user has access to the class
+        if (file.folder?.class) {
+            hasAccess = hasAccess || file.folder.class.teachers.some(teacher => teacher.id === userId);
+            hasAccess = hasAccess || file.folder.class.students.some(student => student.id === userId);
+        }
         if (!hasAccess) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "FORBIDDEN",
                 message: "You do not have access to this file",
             });
         }
         try {
-            // Generate a signed URL with short expiration
-            const signedUrl = await (0, googleCloudStorage_1.getSignedUrl)(file.path);
-            return { signedUrl };
+            const signedUrl = await getSignedUrl(file.path);
+            return { url: signedUrl };
         }
         catch (error) {
-            console.error('Error generating signed URL:', error);
-            throw new server_1.TRPCError({
+            logger.error('Error generating signed URL:', error);
+            throw new TRPCError({
                 code: "INTERNAL_SERVER_ERROR",
-                message: "Failed to generate signed URL",
+                message: "Failed to generate download URL",
+            });
+        }
+    }),
+    move: protectedTeacherProcedure
+        .input(z.object({
+        fileId: z.string(),
+        targetFolderId: z.string(),
+        classId: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { fileId, targetFolderId } = input;
+        // Get the file
+        const file = await prisma.file.findUnique({
+            where: { id: fileId },
+            include: {
+                folder: {
+                    include: {
+                        class: true,
+                    },
+                },
+            },
+        });
+        if (!file) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "File not found",
+            });
+        }
+        // Get the target folder
+        const targetFolder = await prisma.folder.findUnique({
+            where: { id: targetFolderId },
+            include: {
+                class: true,
+            },
+        });
+        if (!targetFolder) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "Target folder not found",
             });
         }
+        // Move the file
+        const updatedFile = await prisma.file.update({
+            where: { id: fileId },
+            data: {
+                folderId: targetFolderId,
+            },
+            include: {
+                user: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+            },
+        });
+        return updatedFile;
+    }),
+    rename: protectedTeacherProcedure
+        .input(z.object({
+        fileId: z.string(),
+        newName: z.string(),
+        classId: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { fileId, newName, classId } = input;
+        // 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: "FORBIDDEN",
+                message: "You must be a teacher of this class to rename files",
+            });
+        }
+        // Get the file
+        const file = await prisma.file.findUnique({
+            where: { id: fileId },
+            include: {
+                folder: {
+                    include: {
+                        class: true,
+                    },
+                },
+            },
+        });
+        if (!file) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "File not found",
+            });
+        }
+        // Validate new name
+        if (!newName.trim()) {
+            throw new TRPCError({
+                code: "BAD_REQUEST",
+                message: "File name cannot be empty",
+            });
+        }
+        // Rename the file
+        const updatedFile = await prisma.file.update({
+            where: { id: fileId },
+            data: {
+                name: newName.trim(),
+            },
+            include: {
+                user: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+            },
+        });
+        return updatedFile;
+    }),
+    delete: protectedTeacherProcedure
+        .input(z.object({
+        fileId: z.string(),
+        classId: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { fileId, classId } = input;
+        // 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: "FORBIDDEN",
+                message: "You must be a teacher of this class to delete files",
+            });
+        }
+        // Get the file
+        const file = await prisma.file.findUnique({
+            where: { id: fileId },
+            include: {
+                folder: {
+                    include: {
+                        class: true,
+                    },
+                },
+                thumbnail: true,
+            },
+        });
+        if (!file) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "File not found",
+            });
+        }
+        // Verify the file belongs to this class
+        if (file.folder?.classId !== classId) {
+            throw new TRPCError({
+                code: "FORBIDDEN",
+                message: "File does not belong to this class",
+            });
+        }
+        // Delete files from storage
+        try {
+            // Delete the main file
+            await deleteFile(file.path);
+            // Delete thumbnail if it exists
+            if (file.thumbnail) {
+                await deleteFile(file.thumbnail.path);
+            }
+        }
+        catch (error) {
+            logger.warn(`Failed to delete file ${file.path}:`, error);
+        }
+        // Delete the file record from database
+        await prisma.file.delete({
+            where: { id: fileId },
+        });
+        return { success: true };
     }),
 });