@studious-lms/server 1.0.4 → 1.0.7

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";
+import { TRPCError } from "@trpc/server";
+import { getSignedUrl, deleteFile } from "../lib/googleCloudStorage";
+import { prisma } from "../lib/prisma";
+import { logger } from "../utils/logger";
+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,279 @@ 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",
+            });
+        }
+        // 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",
+            });
+        }
+        // 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 };
     }),
 });

package/dist/routers/folder.d.ts

@@ -0,0 +1,296 @@
+import { z } from "zod";
+export declare const folderRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("../trpc").Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.typeToFlattenedError<any, string> | null;
+            prismaError: import("../utils/prismaErrorHandler").PrismaErrorInfo | null;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    create: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            name: string;
+            parentFolderId?: string | undefined;
+        };
+        output: {
+            files: {
+                type: string;
+                user: {
+                    id: string;
+                    username: string;
+                } | null;
+                id: string;
+                name: string;
+                size: number | null;
+                uploadedAt: Date | null;
+            }[];
+            childFolders: {
+                id: string;
+                _count: {
+                    files: number;
+                    childFolders: number;
+                };
+                name: string;
+            }[];
+        } & {
+            id: string;
+            name: string;
+            classId: string | null;
+            parentFolderId: string | null;
+        };
+        meta: object;
+    }>;
+    get: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            folderId: string;
+        };
+        output: {
+            files: {
+                type: string;
+                user: {
+                    id: string;
+                    username: string;
+                } | null;
+                id: string;
+                name: string;
+                size: number | null;
+                uploadedAt: Date | null;
+            }[];
+            childFolders: {
+                id: string;
+                _count: {
+                    files: number;
+                    childFolders: number;
+                };
+                name: string;
+            }[];
+            parentFolder: {
+                id: string;
+                name: string;
+            } | null;
+        } & {
+            id: string;
+            name: string;
+            classId: string | null;
+            parentFolderId: string | null;
+        };
+        meta: object;
+    }>;
+    getChildFolders: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+        };
+        output: ({
+            files: {
+                type: string;
+                user: {
+                    id: string;
+                    username: string;
+                } | null;
+                id: string;
+                name: string;
+                size: number | null;
+                uploadedAt: Date | null;
+            }[];
+            childFolders: {
+                id: string;
+                _count: {
+                    files: number;
+                    childFolders: number;
+                };
+                name: string;
+            }[];
+        } & {
+            id: string;
+            name: string;
+            classId: string | null;
+            parentFolderId: string | null;
+        })[];
+        meta: object;
+    }>;
+    getFolderChildren: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            folderId: string;
+        };
+        output: ({
+            files: {
+                type: string;
+                user: {
+                    id: string;
+                    username: string;
+                } | null;
+                id: string;
+                name: string;
+                size: number | null;
+                uploadedAt: Date | null;
+            }[];
+            childFolders: {
+                id: string;
+                _count: {
+                    files: number;
+                    childFolders: number;
+                };
+                name: string;
+            }[];
+        } & {
+            id: string;
+            name: string;
+            classId: string | null;
+            parentFolderId: string | null;
+        })[];
+        meta: object;
+    }>;
+    getRootFolder: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+        };
+        output: ({
+            files: {
+                type: string;
+                user: {
+                    id: string;
+                    username: string;
+                } | null;
+                id: string;
+                name: string;
+                size: number | null;
+                uploadedAt: Date | null;
+            }[];
+            childFolders: {
+                id: string;
+                files: {
+                    id: string;
+                }[];
+                name: string;
+                childFolders: {
+                    id: string;
+                }[];
+            }[];
+        } & {
+            id: string;
+            name: string;
+            classId: string | null;
+            parentFolderId: string | null;
+        }) | null;
+        meta: object;
+    }>;
+    uploadFiles: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            files: {
+                type: string;
+                name: string;
+                size: number;
+                data: string;
+            }[];
+            folderId: string;
+        };
+        output: {
+            success: boolean;
+            uploadedCount: number;
+        };
+        meta: object;
+    }>;
+    delete: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            folderId: string;
+        };
+        output: {
+            success: boolean;
+            deletedFiles: number;
+            deletedFolders: number;
+        };
+        meta: object;
+    }>;
+    move: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            folderId: string;
+            targetParentFolderId?: string | undefined;
+        };
+        output: {
+            files: {
+                type: string;
+                user: {
+                    id: string;
+                    username: string;
+                } | null;
+                id: string;
+                name: string;
+                size: number | null;
+                uploadedAt: Date | null;
+            }[];
+            childFolders: {
+                id: string;
+                _count: {
+                    files: number;
+                    childFolders: number;
+                };
+                name: string;
+            }[];
+        } & {
+            id: string;
+            name: string;
+            classId: string | null;
+            parentFolderId: string | null;
+        };
+        meta: object;
+    }>;
+    rename: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            folderId: string;
+            newName: string;
+        };
+        output: {
+            files: {
+                type: string;
+                user: {
+                    id: string;
+                    username: string;
+                } | null;
+                id: string;
+                name: string;
+                size: number | null;
+                uploadedAt: Date | null;
+            }[];
+            childFolders: {
+                id: string;
+                _count: {
+                    files: number;
+                    childFolders: number;
+                };
+                name: string;
+            }[];
+        } & {
+            id: string;
+            name: string;
+            classId: string | null;
+            parentFolderId: string | null;
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=folder.d.ts.map

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

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