changes to file routes

src/file/file.controller.ts

@@ -3,56 +3,114 @@ import { FastifyReply, FastifyRequest } from "fastify";
 import { generateId } from "../utils/id";
 import {
   completeMultiPartUpload,
-  deleteFileS3,
   getFileUrlS3,
   getUploadUrl,
   getUploadUrlMultiPart,
-  uploadFileS3,
 } from "../utils/s3";
-import { createFile, getFile } from "./file.service";
+import {
-import { UploadMultiPartCompleteRequest } from "./file.schema";
+  createFile,
+  deleteFile,
+  getChildren,
+  getFile,
+  updateFile,
+  uploadDone,
+} from "./file.service";
+import {
+  CreateFileInput,
+  UpdateFileInput,
+  UploadMultiPartCompleteRequest,
+} from "./file.schema";
 
-export async function fileUploadHandler(
+export async function createFileHandler(
   req: FastifyRequest,
   res: FastifyReply
 ) {
-  const file = await req.file();
+  const input = req.body as CreateFileInput;
-
-  if (!file) return res.code(400).send({ error: "file not found in the body" });
 
   try {
-    const chunks = [];
+    const file = await createFile(input, req.user);
-    for await (const chunk of file.file) {
+    const resObj = {
-      // @ts-ignore
+      file,
-      chunks.push(Buffer.from(chunk));
+    };
+
+    if (file.mimeType != "folder") {
+      const signedUrl = await getUploadUrl(file.pid);
+      resObj["signedUrl"] = signedUrl;
     }
-
+    return res.code(201).send(resObj);
-    const fileData = Buffer.concat(chunks);
-    const key = generateId();
-    await uploadFileS3(key, fileData);
-
-    const fileRec = await createFile(
-      key,
-      file.filename,
-      file.mimetype,
-      req.user.tenantId
-    );
-
-    return res.code(201).send(fileRec);
   } catch (err) {
     return err;
   }
 }
 
-export async function fileUploadS3UrlHandler(
+export async function uploadDoneHandler(
   req: FastifyRequest,
   res: FastifyReply
 ) {
-  try {
+  const { fileId } = req.params as { fileId: string };
-    const key = generateId();
-    const signedUrl = await getUploadUrl(key);
 
-    return res.code(200).send({ key, signedUrl });
+  try {
+    const file = await uploadDone(fileId, req.user.tenantId);
+    return res.code(200).send();
+  } catch (err) {
+    return err;
+  }
+}
+
+export async function getFileHandler(req: FastifyRequest, res: FastifyReply) {
+  const { fileId } = req.params as { fileId: string };
+
+  try {
+    const file = await getFile(fileId, req.user.tenantId);
+    if (!file) return res.code(404).send({ error: "resource not found" });
+
+    return res.code(200).send(file);
+  } catch (err) {
+    return err;
+  }
+}
+
+export async function getChildrenHandler(
+  req: FastifyRequest,
+  res: FastifyReply
+) {
+  const { fileId } = req.params as { fileId: string };
+
+  try {
+    const files = await getChildren(fileId, req.user.tenantId);
+    return res.code(200).send(files);
+  } catch (err) {
+    return err;
+  }
+}
+
+export async function updateFileHandler(
+  req: FastifyRequest,
+  res: FastifyReply
+) {
+  const { fileId } = req.params as { fileId: string };
+  const input = req.body as UpdateFileInput;
+
+  try {
+    const updatedFile = await updateFile(fileId, input, req.user.tenantId);
+    if (!updatedFile)
+      return res.code(404).send({ error: "resource not found" });
+
+    return res.code(200).send(updatedFile);
+  } catch (err) {
+    return err;
+  }
+}
+
+export async function deleteFileHandler(
+  req: FastifyRequest,
+  res: FastifyReply
+) {
+  const { fileId } = req.params as { fileId: string };
+
+  try {
+    await deleteFile(fileId, req.user.tenantId);
+    return res.code(204).send();
   } catch (err) {
     return err;
   }
@@ -95,46 +153,18 @@ export async function fileDownloadHandler(
   res: FastifyReply
 ) {
   const { fileId } = req.params as { fileId: string };
-  const { direct } = req.query as { direct: boolean };
 
   try {
-    let id: string;
-    let name: string | null;
-
-    if (!direct) {
     const file = await getFile(fileId, req.user.tenantId);
     if (file === null)
       return res.code(404).send({ error: "resource not found" });
 
-      id = file.id;
+    if (file.mimeType == "folder")
-      name = file.name;
+      return res.code(400).send({ error: "cannot download a folder" });
-    } else {
-      id = fileId;
-      name = null;
-    }
 
-    const signedUrl = await getFileUrlS3(id, name);
+    const signedUrl = await getFileUrlS3(file.pid, file.name);
     return res.code(200).send({ url: signedUrl });
   } catch (err) {
     return err;
   }
 }
-
-export async function deleteFileHandler(
-  req: FastifyRequest,
-  res: FastifyReply
-) {
-  const { fileId } = req.params as { fileId: string };
-
-  try {
-    const file = await getFile(fileId, req.user.tenantId);
-    if (file === null)
-      return res.code(404).send({ error: "resource not found" });
-
-    await deleteFileS3(file.pid);
-    await file.deleteOne();
-    return res.code(204).send();
-  } catch (err) {
-    return err;
-  }
-}

src/file/file.route.ts

@@ -1,27 +1,40 @@
 import { FastifyInstance } from "fastify";
 import {
+  createFileHandler,
   deleteFileHandler,
   fileDownloadHandler,
-  fileUploadHandler,
-  fileUploadS3UrlHandler,
   fileUploadS3UrlMultiPartHandler,
   finishMulitPartUploadHandler,
+  getChildrenHandler,
+  getFileHandler,
+  updateFileHandler,
+  uploadDoneHandler,
 } from "./file.controller";
 import { $file } from "./file.schema";
 
 export async function fileRoutes(fastify: FastifyInstance) {
   fastify.post(
-    "/upload",
+    "/",
     {
       schema: {
-        response: {
+        body: $file("createFileInput"),
-          201: $file("uploadFileResponse"),
-        },
       },
       config: { requiredClaims: ["file:upload"] },
       preHandler: [fastify.authorize],
     },
-    fileUploadHandler
+    createFileHandler
+  );
+
+  fastify.post(
+    "/:fileId/done",
+    {
+      schema: {
+        params: { type: "object", properties: { fileId: { type: "string" } } },
+      },
+      config: { requiredClaims: ["file:upload"] },
+      preHandler: [fastify.authorize],
+    },
+    uploadDoneHandler
   );
 
   fastify.get(
@@ -29,18 +42,35 @@ export async function fileRoutes(fastify: FastifyInstance) {
     {
       schema: {
         params: { type: "object", properties: { fileId: { type: "string" } } },
-        querystring: {
-          type: "object",
-          properties: { direct: { type: "boolean" } },
-        },
-        response: {
-          200: $file("downloadFileResponse"),
-        },
       },
       config: { requiredClaims: ["file:download"] },
       preHandler: [fastify.authorize],
     },
-    fileDownloadHandler
+    getFileHandler
+  );
+
+  fastify.get(
+    "/:fileId/children",
+    {
+      schema: {
+        params: { type: "object", properties: { fileId: { type: "string" } } },
+      },
+      config: { requiredClaims: ["file:download"] },
+      preHandler: [fastify.authorize],
+    },
+    getChildrenHandler
+  );
+
+  fastify.post(
+    "/:fileId",
+    {
+      schema: {
+        body: $file("updateFileInput"),
+      },
+      config: { requiredClaims: ["file:upload"] },
+      preHandler: [fastify.authorize],
+    },
+    updateFileHandler
   );
 
   fastify.delete(
@@ -56,12 +86,12 @@ export async function fileRoutes(fastify: FastifyInstance) {
   );
 
   fastify.get(
-    "/",
+    "/:fileId/download",
     {
-      config: { requiredClaims: ["file:upload"] },
+      config: { requiredClaims: ["file:download"] },
       preHandler: [fastify.authorize],
     },
-    fileUploadS3UrlHandler
+    fileDownloadHandler
   );
 
   fastify.get(

src/file/file.schema.ts

@@ -2,29 +2,48 @@ import { z } from "zod";
 import mongoose from "mongoose";
 import { buildJsonSchemas } from "fastify-zod";
 
-export const fileModel = mongoose.model(
+const fileSchema = new mongoose.Schema({
-  "file",
-  new mongoose.Schema({
   tenantId: String,
   pid: {
     type: String,
     unique: true,
     required: true,
   },
+  parentId: String,
   name: {
     type: String,
     required: true,
   },
-    mimeType: String,
+  size: Number,
+  mimeType: {
+    type: String,
+    required: true,
+  },
+  status: String,
   createdAt: Date,
-    createdBy: Date,
+  updatedAt: Date,
-  })
+  createdBy: {
-);
+    type: mongoose.Types.ObjectId,
+    ref: "user",
+  },
+  isDeleted: Boolean,
+});
 
-const uploadFileResponse = z.object({
+fileSchema.index({ pid: 1, parentId: 1, isDeleted: 1 });
-  pid: z.string(),
+
+export const fileModel = mongoose.model("file", fileSchema);
+
+const createFileInput = z.object({
+  parentId: z.string(),
   name: z.string(),
+  size: z.number().optional(),
   mimeType: z.string(),
+  root: z.boolean().optional(),
+});
+
+const updateFileInput = z.object({
+  parentId: z.string().optional(),
+  name: z.string().optional(),
 });
 
 const downloadFileResponse = z.object({
@@ -73,9 +92,13 @@ export type UploadMultiPartCompleteRequest = z.infer<
   typeof uploadMultipartCompleteRequest
 >;
 
+export type CreateFileInput = z.infer<typeof createFileInput>;
+export type UpdateFileInput = z.infer<typeof updateFileInput>;
+
 export const { schemas: fileSchemas, $ref: $file } = buildJsonSchemas(
   {
-    uploadFileResponse,
+    createFileInput,
+    updateFileInput,
     downloadFileResponse,
     uploadMultipartCompleteRequest,
   },

src/file/file.service.ts

@@ -1,22 +1,133 @@
-import { fileModel } from "./file.schema";
+import { AuthenticatedUser } from "../auth";
+import { generateId } from "../utils/id";
+import { deleteFileS3 } from "../utils/s3";
+import { CreateFileInput, fileModel, UpdateFileInput } from "./file.schema";
+
+export const ErrNotFound = "not_found";
+export const ParentNotFound = "parent_not_found";
+export const ParentNotFolder = "parent_is_not_folder";
 
 export async function createFile(
-  pid: string,
+  input: CreateFileInput,
-  name: string,
+  user: AuthenticatedUser
-  mimeType: string,
-  tenantId: string
 ) {
-  return await fileModel.create({
+  if (!input.root) {
-    tenantId: tenantId,
+    const parent = await fileModel.findOne({
-    pid: pid,
+      $and: [
-    name: name,
+        { tenantId: user.tenantId },
-    mimeType: mimeType,
+        { pid: input.parentId },
-    createdAt: new Date(),
+        { isDeleted: false },
+      ],
     });
+
+    if (!parent) throw ParentNotFound;
+    if (parent.mimeType != "folder") throw ParentNotFolder;
+  }
+
+  return await fileModel.create({
+    tenantId: user.tenantId,
+    pid: generateId(),
+    status: input.mimeType == "folder" ? "done" : "penidng",
+    createdAt: new Date(),
+    createdBy: user.userId,
+    isDeleted: false,
+    ...input,
+  });
+}
+
+export async function uploadDone(fileId: string, tenantId: string) {
+  return await fileModel.findOneAndUpdate(
+    {
+      $and: [{ tenantId: tenantId }, { pid: fileId }],
+    },
+    { status: "done" },
+    { new: true }
+  );
 }
 
 export async function getFile(fileId: string, tenantId: string) {
   return await fileModel.findOne({
-    $and: [{ tenantId: tenantId }, { pid: fileId }],
+    $and: [{ tenantId: tenantId }, { pid: fileId }, { isDeleted: false }],
   });
 }
+
+export async function getChildren(parentId: string, tenantId: string) {
+  return await fileModel.find({
+    $and: [
+      { tenantId: tenantId },
+      { parentId: parentId },
+      { isDeleted: false },
+      { status: "done" },
+    ],
+  });
+}
+
+export async function updateFile(
+  fileId: string,
+  input: UpdateFileInput,
+  tenantId: string
+) {
+  if (input.parentId) {
+    const parentInDb = await fileModel.findOne({
+      $and: [
+        { tenantId: tenantId },
+        { pid: input.parentId },
+        { isDeleted: false },
+      ],
+    });
+
+    if (!parentInDb) throw ParentNotFound;
+    if (parentInDb.mimeType != "folder") throw ParentNotFolder;
+  }
+
+  return await fileModel.findOneAndUpdate(
+    {
+      $and: [{ tenantId: tenantId }, { pid: fileId }, { isDeleted: false }],
+    },
+    {
+      ...input,
+      updatedAt: new Date(),
+    },
+    { new: true }
+  );
+}
+
+async function getAllDescendents(folderId: string, tenantId: string) {
+  const idArr: Array<string> = [];
+
+  async function traverseFolder(folderId: string) {
+    const children = await getChildren(folderId, tenantId);
+    for (const child of children) {
+      if (child.mimeType == "folder") {
+        await traverseFolder(child.pid);
+      }
+      idArr.push(child.pid);
+    }
+  }
+
+  await traverseFolder(folderId);
+
+  console.log(idArr);
+  return idArr;
+}
+
+export async function deleteFile(fileId: string, tenantId: string) {
+  const file = await fileModel.findOne({
+    $and: [{ tenantId: tenantId }, { pid: fileId }],
+  });
+
+  if (!file) throw ErrNotFound;
+
+  if (file.mimeType != "folder") {
+    await deleteFileS3(file.pid);
+    return await fileModel.deleteOne({
+      $and: [{ tenantId: tenantId }, { pid: fileId }],
+    });
+  } else {
+    const descendents = await getAllDescendents(file.pid, tenantId);
+    return await fileModel.updateMany(
+      { pid: { $in: descendents } },
+      { $set: { isDeleted: true } }
+    );
+  }
+}