@studious-lms/server 1.2.53 → 1.4.0

package/src/routers/folder.ts

@@ -1,12 +1,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 { createDirectUploadFiles, type DirectUploadFile, type UploadedFile } from "../lib/fileUpload.js";
-import { type Folder } from "@prisma/client";
-
-// 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(),
@@ -14,17 +25,15 @@ const createFolderSchema = z.object({
   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({
@@ -35,871 +44,133 @@ 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",
-        });
-      }
-
-      // 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,
-      };
+        throw new Error("You must be logged in to upload files");
+      }
+      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({
-      folderId: z.string(),
-      targetParentFolderId: z.string(),
-      classId: z.string(),
-    }))
+    .input(
+      z.object({
+        folderId: z.string(),
+        targetParentFolderId: z.string(),
+        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: any = 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",
-          });
-        }
-      }
-
-      // 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;
+      if (!ctx.user) {
+        throw new Error("You must be logged in to move folders");
+      }
+      return moveFolder(
+        ctx.user.id,
+        input.folderId,
+        input.targetParentFolderId,
+        input.classId
+      );
     }),
 
   update: protectedTeacherProcedure
-    .input(z.object({
-      folderId: z.string(),
-      name: z.string(),
-      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;
-    }),
-    getParents: protectedProcedure
-    .input(z.object({
-      folderId: z.string(),
-    }))
-    .query(async ({ ctx, input }) => {
-      const { folderId } = input;
-
-      let currentParent: string | null = folderId;
-      const parents: Folder[] = [];
-      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(),
+        name: z.string(),
+        color: z.string().optional(),
+        classId: z.string(),
+      })
+    )
+    .mutation(({ input }) =>
+      updateFolderRecord(
+        input.folderId,
+        input.name,
+        input.color,
+        input.classId
+      )
+    ),
+
+  getParents: protectedProcedure
+    .input(z.object({ folderId: z.string() }))
+    .query(({ input }) => getFolderParents(input.folderId)),
 
   getFolderUploadUrls: protectedTeacherProcedure
-    .input(z.object({
-      classId: z.string(),
-      folderId: z.string(),
-      files: z.array(directFileSchema),
-    }))
+    .input(
+      z.object({
+        classId: z.string(),
+        folderId: z.string(),
+        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: typeof folder | null = 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",
-        });
-      }
-
-      // Create direct upload files
-      const uploadFiles = await createDirectUploadFiles(files, ctx.user.id, folder.id);
-      
-      return uploadFiles;
+        throw new Error("You must be logged in to upload files");
+      }
+      return getFolderUploadUrls(
+        ctx.user.id,
+        input.classId,
+        input.folderId,
+        input.files
+      );
     }),
 
   confirmFolderUpload: protectedTeacherProcedure
-    .input(z.object({
-      fileId: z.string(),
-      uploadSuccess: z.boolean(),
-    }))
+    .input(
+      z.object({
+        fileId: z.string(),
+        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 };
     }),
-}); 
+});