permit-api/src/file/file.controller.ts

import { FastifyReply, FastifyRequest } from "fastify";

import { generateId } from "../utils/id";
import {
  completeMultiPartUpload,
  getFileUrlS3,
  getUploadUrl,
  getUploadUrlMultiPart,
} from "../utils/s3";
import {
  createFile,
  deleteFile,
  getChildren,
  getFile,
  updateFile,
  uploadDone,
  uploadDoneBatch,
} from "./file.service";
import {
  CreateFileInput,
  CreateFilesBatch,
  UpdateFileInput,
  UploadDoneBatchInput,
  UploadMultiPartCompleteRequest,
} from "./file.schema";

export async function createFileHandler(
  req: FastifyRequest,
  res: FastifyReply
) {
  const input = req.body as CreateFileInput;

  try {
    const file = await createFile(input, req.user);
    const resObj = {
      file,
    };

    if (file.mimeType != "folder") {
      const signedUrl = await getUploadUrl(file.pid);
      resObj["signedUrl"] = signedUrl;
    }
    return res.code(201).send(resObj);
  } catch (err) {
    return err;
  }
}

export async function createFileBatchHandler(
  req: FastifyRequest,
  res: FastifyReply
) {
  const input = req.body as CreateFilesBatch;
  const resObj = [];

  try {
    for (const file of input.files) {
      const newFile = (await createFile(file, req.user)).toObject();

      if (newFile.mimeType != "folder") {
        const signedUrl = await getUploadUrl(newFile.pid);
        newFile["signedUrl"] = signedUrl;
      }

      resObj.push({ ...newFile });
    }

    return res.code(201).send(resObj);
  } catch (err) {
    return err;
  }
}

export async function uploadDoneHandler(
  req: FastifyRequest,
  res: FastifyReply
) {
  const { fileId } = req.params as { fileId: string };

  try {
    const file = await uploadDone(fileId, req.user.tenantId);
    return res.code(200).send();
  } catch (err) {
    return err;
  }
}

export async function uploadDoneBatchHandler(
  req: FastifyRequest,
  res: FastifyReply
) {
  const input = req.body as UploadDoneBatchInput;

  try {
    const updateRes = await uploadDoneBatch(input, req.user);
    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;
  }
}

export async function fileUploadS3UrlMultiPartHandler(
  req: FastifyRequest,
  res: FastifyReply
) {
  try {
    const { fileSize } = req.query as { fileSize: number };
    if (!fileSize || fileSize == 0)
      return res.code(400).send({ error: "invalid fileSize" });

    const key = generateId();
    const multiPartRes = await getUploadUrlMultiPart(key, fileSize);

    return res.code(200).send({ key, ...multiPartRes });
  } catch (err) {
    return err;
  }
}

export async function finishMulitPartUploadHandler(
  req: FastifyRequest,
  res: FastifyReply
) {
  const input = req.body as UploadMultiPartCompleteRequest;

  try {
    await completeMultiPartUpload(input.key, input.uploadId, input.parts);
    return res.code(200).send();
  } catch (err) {
    return err;
  }
}

export async function fileDownloadHandler(
  req: FastifyRequest,
  res: FastifyReply
) {
  const { fileId } = req.params as { fileId: string };
  const { contentDisposition } = req.query as { contentDisposition: boolean };

  try {
    const file = await getFile(fileId, req.user.tenantId);
    if (file === null)
      return res.code(404).send({ error: "resource not found" });

    if (file.mimeType == "folder")
      return res.code(400).send({ error: "cannot download a folder" });

    const signedUrl = await getFileUrlS3(
      file.pid,
      file.name,
      contentDisposition
    );
    return res.code(200).send({ url: signedUrl });
  } catch (err) {
    return err;
  }
}