@studious-lms/server 1.1.24 → 1.2.6

package/dist/routers/folder.js

@@ -1,25 +1,21 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="2a91768b-a0eb-5556-9154-f76d73b01c49")}catch(e){}}();
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure, protectedClassMemberProcedure, protectedTeacherProcedure } from "../trpc.js";
-import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma.js";
-import { createDirectUploadFiles } from "../lib/fileUpload.js";
-// DEPRECATED: This schema is no longer used - files are uploaded directly to GCS
-// Use directFileSchema instead
+import { createTRPCRouter, protectedProcedure, protectedClassMemberProcedure, protectedTeacherProcedure, } from "../trpc.js";
+import { createFolderRecord, getFolder, getChildFolders, getFolderChildren, getRootFolder, uploadFilesToFolder, deleteFolderRecord, moveFolder, updateFolderRecord, getFolderParents, getFolderUploadUrls, } from "../services/folder.js";
 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(directFileSchema), // Use direct file schema
+    files: z.array(directFileSchema),
 });
 const getRootFolderSchema = z.object({
     classId: z.string(),
@@ -28,488 +24,43 @@ export const folderRouter = createTRPCRouter({
     create: protectedTeacherProcedure
         .input(createFolderSchema)
         .mutation(async ({ ctx, input }) => {
-        const { classId, name, color } = input;
-        let parentFolderId = input.parentFolderId || null;
         if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You must be logged in to create a folder",
-            });
+            throw new Error("You must be logged in to create a folder");
         }
-        // Verify user is a teacher of the class
-        const classData = await prisma.class.findFirst({
-            where: {
-                id: classId,
-                teachers: {
-                    some: {
-                        id: ctx.user.id,
-                    },
-                },
-            },
+        return createFolderRecord(ctx.user.id, {
+            classId: input.classId,
+            name: input.name,
+            parentFolderId: input.parentFolderId,
+            color: input.color,
         });
-        if (!classData) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Class not found or you are not a teacher",
-            });
-        }
-        // If no parent folder specified, find or create the class parent folder
-        if (!parentFolderId) {
-            let classParentFolder = await prisma.folder.findFirst({
-                where: {
-                    classId: classId,
-                    parentFolderId: null,
-                },
-            });
-            if (!classParentFolder) {
-                // Create parent folder if it doesn't exist
-                classParentFolder = await prisma.folder.create({
-                    data: {
-                        name: "Class Files",
-                        class: {
-                            connect: { id: classId },
-                        },
-                        ...(color && {
-                            color: color,
-                        }),
-                    },
-                });
-            }
-            parentFolderId = classParentFolder.id;
-        }
-        else {
-            // Check if specified parent folder exists and belongs to the class
-            const parentFolder = await prisma.folder.findFirst({
-                where: {
-                    id: parentFolderId,
-                },
-            });
-            if (!parentFolder) {
-                throw new TRPCError({
-                    code: "NOT_FOUND",
-                    message: "Parent folder not found",
-                });
-            }
-        }
-        const folder = await prisma.folder.create({
-            data: {
-                name,
-                ...(parentFolderId && {
-                    parentFolder: {
-                        connect: { id: parentFolderId },
-                    },
-                }),
-                ...(color && {
-                    color: color,
-                }),
-            },
-            include: {
-                files: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                        size: true,
-                        uploadedAt: true,
-                        user: {
-                            select: {
-                                id: true,
-                                username: true,
-                            },
-                        },
-                    },
-                },
-                childFolders: {
-                    select: {
-                        id: true,
-                        name: true,
-                        _count: {
-                            select: {
-                                files: true,
-                                childFolders: true,
-                            },
-                        },
-                    },
-                },
-            },
-        });
-        return folder;
     }),
     get: protectedClassMemberProcedure
-        .input(z.object({
-        folderId: z.string(),
-        classId: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        const { classId, folderId } = input;
-        // Get specific folder
-        const folder = await prisma.folder.findFirst({
-            where: {
-                id: folderId,
-            },
-            include: {
-                files: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                        size: true,
-                        uploadedAt: true,
-                        user: {
-                            select: {
-                                id: true,
-                                username: true,
-                            },
-                        },
-                    },
-                    orderBy: {
-                        uploadedAt: 'desc',
-                    },
-                },
-                childFolders: {
-                    select: {
-                        id: true,
-                        name: true,
-                        color: true,
-                        _count: {
-                            select: {
-                                files: true,
-                                childFolders: true,
-                            },
-                        },
-                    },
-                    orderBy: {
-                        name: 'asc',
-                    },
-                },
-                parentFolder: {
-                    select: {
-                        id: true,
-                        name: true,
-                    },
-                },
-            },
-        });
-        if (!folder) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Folder not found",
-            });
-        }
-        return folder;
-    }),
+        .input(z.object({ folderId: z.string(), classId: z.string() }))
+        .query(({ input }) => getFolder(input.folderId)),
     getChildFolders: protectedClassMemberProcedure
-        .input(z.object({
-        classId: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        const { classId } = input;
-        // Get the parent folder for the class (or create it if it doesn't exist)
-        let parentFolder = await prisma.folder.findFirst({
-            where: {
-                classId: classId,
-                parentFolderId: null,
-            },
-        });
-        if (!parentFolder) {
-            // Create parent folder if it doesn't exist
-            parentFolder = await prisma.folder.create({
-                data: {
-                    name: "Class Files",
-                    class: {
-                        connect: { id: classId },
-                    },
-                },
-            });
-        }
-        // Get all child folders of the parent
-        const childFolders = await prisma.folder.findMany({
-            where: {
-                parentFolderId: parentFolder.id,
-            },
-            include: {
-                files: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                        size: true,
-                        uploadedAt: true,
-                        user: {
-                            select: {
-                                id: true,
-                                username: true,
-                            },
-                        },
-                    },
-                    orderBy: {
-                        uploadedAt: 'desc',
-                    },
-                },
-                childFolders: {
-                    select: {
-                        id: true,
-                        name: true,
-                        _count: {
-                            select: {
-                                files: true,
-                                childFolders: true,
-                            },
-                        },
-                    },
-                    orderBy: {
-                        name: 'asc',
-                    },
-                },
-            },
-            orderBy: {
-                name: 'asc',
-            },
-        });
-        return childFolders;
-    }),
+        .input(z.object({ classId: z.string() }))
+        .query(({ input }) => getChildFolders(input.classId)),
     getFolderChildren: protectedClassMemberProcedure
-        .input(z.object({
-        folderId: z.string(),
-        classId: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        const { folderId, classId } = input;
-        // Get direct children of the specified folder
-        const children = await prisma.folder.findMany({
-            where: {
-                parentFolderId: folderId,
-                classId: classId,
-            },
-            include: {
-                files: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                        size: true,
-                        uploadedAt: true,
-                        user: {
-                            select: {
-                                id: true,
-                                username: true,
-                            },
-                        },
-                    },
-                    orderBy: {
-                        uploadedAt: 'desc',
-                    },
-                },
-                childFolders: {
-                    select: {
-                        id: true,
-                        name: true,
-                        color: true,
-                        _count: {
-                            select: {
-                                files: true,
-                                childFolders: true,
-                            },
-                        },
-                    },
-                    orderBy: {
-                        name: 'asc',
-                    },
-                },
-            },
-            orderBy: {
-                name: 'asc',
-            },
-        });
-        return children;
-    }),
+        .input(z.object({ folderId: z.string(), classId: z.string() }))
+        .query(({ input }) => getFolderChildren(input.folderId, input.classId)),
     getRootFolder: protectedClassMemberProcedure
         .input(getRootFolderSchema)
-        .query(async ({ ctx, input }) => {
-        const { classId } = input;
-        // Get or create the parent folder for the class
-        let parentFolder = await prisma.folder.findFirst({
-            where: {
-                classId: classId,
-                parentFolderId: null,
-            },
-        });
-        if (!parentFolder) {
-            // Create parent folder if it doesn't exist
-            parentFolder = await prisma.folder.create({
-                data: {
-                    name: "Class Files",
-                    class: {
-                        connect: { id: classId },
-                    },
-                },
-            });
-        }
-        // Get the parent folder with its files and child folders
-        const rootFolder = await prisma.folder.findFirst({
-            where: {
-                id: parentFolder.id,
-                classId: classId,
-            },
-            include: {
-                files: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                        size: true,
-                        uploadedAt: true,
-                        user: {
-                            select: {
-                                id: true,
-                                username: true,
-                            },
-                        },
-                    },
-                    orderBy: {
-                        uploadedAt: 'desc',
-                    },
-                },
-                childFolders: {
-                    select: {
-                        id: true,
-                        name: true,
-                        color: true,
-                        files: {
-                            select: {
-                                id: true,
-                            },
-                        },
-                        childFolders: {
-                            select: {
-                                id: true,
-                            },
-                        },
-                    },
-                    orderBy: {
-                        name: 'asc',
-                    },
-                },
-            },
-        });
-        return rootFolder;
-    }),
+        .query(({ input }) => getRootFolder(input.classId)),
     uploadFiles: protectedTeacherProcedure
         .input(uploadFilesToFolderSchema)
         .mutation(async ({ ctx, input }) => {
-        const { classId, folderId, 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 folder exists and belongs to the class
-        const folder = await prisma.folder.findFirst({
-            where: {
-                id: folderId,
-            },
-        });
-        if (!folder) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Folder not found",
-            });
+            throw new Error("You must be logged in to upload files");
         }
-        // Upload files
-        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 => ({
-        //       name: file.name,
-        //       type: file.type,
-        //       size: file.size,
-        //       path: file.path,
-        //       userId: ctx.user!.id,
-        //       folderId: folderId,
-        //       ...(file.thumbnailId && {
-        //         thumbnailId: file.thumbnailId,
-        //       }),
-        //     })),
-        //   });
-        return {
-            success: true,
-            uploadedCount: uploadedFiles.length,
-        };
+        return uploadFilesToFolder(ctx.user.id, input.classId, input.folderId, input.files);
     }),
     delete: protectedTeacherProcedure
-        .input(z.object({
-        classId: z.string(),
-        folderId: z.string(),
-    }))
+        .input(z.object({ classId: z.string(), folderId: z.string() }))
         .mutation(async ({ ctx, input }) => {
-        const { classId, folderId } = 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: "Class not found or you are not a teacher",
-            });
-        }
-        // Verify folder exists and belongs to the class
-        const folder = await prisma.folder.findFirst({
-            where: {
-                id: folderId,
-                classId: classId,
-            },
-            include: {
-                _count: {
-                    select: {
-                        files: true,
-                        childFolders: true,
-                    },
-                },
-            },
-        });
-        if (!folder) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Folder not found",
-            });
+        if (!ctx.user) {
+            throw new Error("You must be logged in to delete folders");
         }
-        // Delete folder and all its contents (cascade)
-        await prisma.folder.delete({
-            where: {
-                id: folderId,
-            },
-        });
-        return {
-            success: true,
-            deletedFiles: folder._count.files,
-            deletedFolders: folder._count.childFolders + 1, // +1 for the folder itself
-        };
+        return deleteFolderRecord(ctx.user.id, input.classId, input.folderId);
     }),
     move: protectedTeacherProcedure
         .input(z.object({
@@ -518,125 +69,10 @@ export const folderRouter = createTRPCRouter({
         classId: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
-        const { folderId, targetParentFolderId, 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 move folders",
-            });
-        }
-        // Get the folder to move
-        const folder = await prisma.folder.findFirst({
-            where: {
-                id: folderId,
-            },
-        });
-        if (!folder) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Folder not found",
-            });
-        }
-        // Prevent moving the root folder
-        if (!folder.parentFolderId) {
-            throw new TRPCError({
-                code: "BAD_REQUEST",
-                message: "Cannot move the root folder",
-            });
-        }
-        // If target parent folder is specified, verify it exists and belongs to the class
-        if (targetParentFolderId) {
-            const targetParentFolder = await prisma.folder.findFirst({
-                where: {
-                    id: targetParentFolderId,
-                },
-            });
-            if (!targetParentFolder) {
-                throw new TRPCError({
-                    code: "NOT_FOUND",
-                    message: "Target parent folder not found",
-                });
-            }
-            // Prevent moving a folder into itself or its descendants
-            if (targetParentFolderId === folderId) {
-                throw new TRPCError({
-                    code: "BAD_REQUEST",
-                    message: "Cannot move a folder into itself",
-                });
-            }
-            // Check if target is a descendant of the folder being moved
-            let currentParent = targetParentFolder;
-            while (currentParent?.parentFolderId) {
-                if (currentParent.parentFolderId === folderId) {
-                    throw new TRPCError({
-                        code: "BAD_REQUEST",
-                        message: "Cannot move a folder into its descendant",
-                    });
-                }
-                currentParent = await prisma.folder.findUnique({
-                    where: { id: currentParent.parentFolderId },
-                });
-                if (!currentParent)
-                    break;
-            }
-        }
-        else {
-            // Moving to root - verify the folder isn't already at root
-            if (!folder.parentFolderId) {
-                throw new TRPCError({
-                    code: "BAD_REQUEST",
-                    message: "Folder is already at root level",
-                });
-            }
+        if (!ctx.user) {
+            throw new Error("You must be logged in to move folders");
         }
-        // Move the folder
-        const updatedFolder = await prisma.folder.update({
-            where: { id: folderId },
-            data: {
-                parentFolderId: targetParentFolderId,
-            },
-            include: {
-                files: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                        size: true,
-                        uploadedAt: true,
-                        user: {
-                            select: {
-                                id: true,
-                                username: true,
-                            },
-                        },
-                    },
-                },
-                childFolders: {
-                    select: {
-                        id: true,
-                        name: true,
-                        _count: {
-                            select: {
-                                files: true,
-                                childFolders: true,
-                            },
-                        },
-                    },
-                },
-            },
-        });
-        return updatedFolder;
+        return moveFolder(ctx.user.id, input.folderId, input.targetParentFolderId, input.classId);
     }),
     update: protectedTeacherProcedure
         .input(z.object({
@@ -645,87 +81,10 @@ export const folderRouter = createTRPCRouter({
         color: z.string().optional(),
         classId: z.string(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        const { folderId, name, color, classId } = input;
-        // Get the folder
-        const folder = await prisma.folder.findFirst({
-            where: {
-                id: folderId,
-            },
-        });
-        if (!folder) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Folder not found",
-            });
-        }
-        // Validate new name
-        if (!name.trim()) {
-            throw new TRPCError({
-                code: "BAD_REQUEST",
-                message: "Folder name cannot be empty",
-            });
-        }
-        // Rename the folder
-        const updatedFolder = await prisma.folder.update({
-            where: { id: folderId },
-            data: {
-                name: name.trim(),
-                ...(color && {
-                    color: color,
-                }),
-            },
-            include: {
-                files: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                        size: true,
-                        uploadedAt: true,
-                        user: {
-                            select: {
-                                id: true,
-                                username: true,
-                            },
-                        },
-                    },
-                },
-                childFolders: {
-                    select: {
-                        id: true,
-                        name: true,
-                        _count: {
-                            select: {
-                                files: true,
-                                childFolders: true,
-                            },
-                        },
-                    },
-                },
-            },
-        });
-        return updatedFolder;
-    }),
+        .mutation(({ input }) => updateFolderRecord(input.folderId, input.name, input.color, input.classId)),
     getParents: protectedProcedure
-        .input(z.object({
-        folderId: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        const { folderId } = input;
-        let currentParent = folderId;
-        const parents = [];
-        while (currentParent) {
-            const parent = await prisma.folder.findFirst({
-                where: {
-                    id: currentParent,
-                },
-            });
-            currentParent = parent?.parentFolderId;
-            parents.push(parent);
-        }
-        return parents;
-    }),
+        .input(z.object({ folderId: z.string() }))
+        .query(({ input }) => getFolderParents(input.folderId)),
     getFolderUploadUrls: protectedTeacherProcedure
         .input(z.object({
         classId: z.string(),
@@ -733,72 +92,10 @@ export const folderRouter = createTRPCRouter({
         files: z.array(directFileSchema),
     }))
         .mutation(async ({ ctx, input }) => {
-        const { classId, folderId, 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 folder exists
-        const folder = await prisma.folder.findUnique({
-            where: {
-                id: folderId,
-            },
-        });
-        if (!folder) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Folder not found",
-            });
-        }
-        // Verify folder belongs to the class by traversing parent hierarchy
-        // Only root folders have classId, child folders use parentFolderId
-        let currentFolder = folder;
-        let belongsToClass = false;
-        while (currentFolder) {
-            // Check if we've reached a root folder with the matching classId
-            if (currentFolder.classId === classId) {
-                belongsToClass = true;
-                break;
-            }
-            // If this folder has a parent, traverse up
-            if (currentFolder.parentFolderId) {
-                currentFolder = await prisma.folder.findUnique({
-                    where: { id: currentFolder.parentFolderId },
-                });
-            }
-            else {
-                // Reached a root folder without matching classId
-                break;
-            }
-        }
-        if (!belongsToClass) {
-            throw new TRPCError({
-                code: "FORBIDDEN",
-                message: "Folder does not belong to this class",
-            });
+            throw new Error("You must be logged in to upload files");
         }
-        // Create direct upload files
-        const uploadFiles = await createDirectUploadFiles(files, ctx.user.id, folder.id);
-        return uploadFiles;
+        return getFolderUploadUrls(ctx.user.id, input.classId, input.folderId, input.files);
     }),
     confirmFolderUpload: protectedTeacherProcedure
         .input(z.object({
@@ -806,17 +103,13 @@ export const folderRouter = createTRPCRouter({
         uploadSuccess: z.boolean(),
     }))
         .mutation(async ({ ctx, input }) => {
-        const { fileId, uploadSuccess } = input;
         if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You must be logged in to confirm uploads",
-            });
+            throw new Error("You must be logged in to confirm uploads");
         }
-        // Import the confirmDirectUpload function
         const { confirmDirectUpload } = await import("../lib/fileUpload.js");
-        // Confirm the upload
-        await confirmDirectUpload(fileId, uploadSuccess);
+        await confirmDirectUpload(input.fileId, input.uploadSuccess);
         return { success: true };
     }),
 });
+//# sourceMappingURL=folder.js.map
+//# debugId=2a91768b-a0eb-5556-9154-f76d73b01c49