node-server-engine 1.2.9 → 1.3.0

package/src/middleware/multiPartFileUploader/multiPartFileUploader.ts

@@ -1,184 +1,249 @@
-import express from 'express';
+import { Request, Response, NextFunction } from 'express';
 import multer from 'multer';
 import fs from 'fs-extra';
 import path from 'path';
+import { Schema } from 'express-validator';
 import { reportDebug, reportError } from 'utils';
-
-const TEMP_DIR: string =
-  process.env.TEMP_CHUNK_FOLDER || './uploads/temp_chunks';
+import { WebError } from 'entities/WebError';
+import { validate } from './validate';
+import { MultiPartFileUploaderConfig } from './multiPartFileUploader.types';
 
 const namespace = 'engine:middleware:multiPartFileUploader';
 
+const TEMP_DIR: string = path.join(
+  process.env.FILE_STORAGE_FOLDER || './uploads',
+  'temp_chunks'
+);
+const FILE_DIR: string = path.join(
+  process.env.FILE_STORAGE_FOLDER || './uploads',
+  'completed_files'
+);
+
+fs.ensureDirSync(FILE_DIR);
 fs.ensureDirSync(TEMP_DIR);
 
 const storage = multer.memoryStorage();
 
-async function multiPartFileUploader(
-  req: express.Request,
-  res: express.Response,
-  next: express.NextFunction
-): Promise<void> {
-  try {
-    const uploadSingle = multer({ storage }).single('file');
-
-    uploadSingle(req, res, async (err) => {
-      if (err) {
-        reportError('Error uploading chunk');
-        return next(err);
-      }
-
-      const { filename, totalChunks, chunkIndex, uniqueID } = req.body;
-
-      if (
-        !filename ||
-        !totalChunks ||
-        chunkIndex === undefined ||
-        !uniqueID ||
-        !req.file
-      ) {
-        req.body.uploadDetails = {
-          status: 'failed',
-          message: 'Missing required fields',
-          details: {
-            filename,
-            totalChunks,
-            chunkIndex,
-            uniqueID,
-            receivedChunk: !!req.file
-          }
-        };
-        reportDebug({
-          namespace,
-          message: `Missing required fields`,
-          data: {
-            status: 'failed',
-            details: {
-              filename,
-              totalChunks,
-              chunkIndex,
-              uniqueID
-            }
-          }
-        });
-        return next();
-      }
-
-      const sessionFolder = path.join(TEMP_DIR, uniqueID);
-      fs.ensureDirSync(sessionFolder);
-
-      const chunkPath = path.join(
-        sessionFolder,
-        `${filename}.part${chunkIndex}`
-      );
-
-      try {
-        await fs.writeFile(chunkPath, req.file.buffer);
-      } catch (writeErr) {
-        reportError(
-          `Failed to write chunk ${chunkIndex}: ${(writeErr as Error).message}`
-        );
-        return next(writeErr);
-      }
+export function multiPartFileUploader(
+  filesOption: MultiPartFileUploaderConfig,
+  validator: Schema
+) {
+  return async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<void> => {
+    try {
+      reportDebug({ namespace, message: 'Starting file upload middleware' });
+
+      const uploadSingle = multer({ storage }).single('file');
+      uploadSingle(req, res, async (err) => {
+        if (err) {
+          reportError('Error uploading chunk');
+          return next(
+            new WebError({
+              statusCode: 500,
+              errorCode: 'upload-failed',
+              message: 'Error uploading file chunk',
+              data: { error: err.message }
+            })
+          );
+        }
 
-      const uploadedChunks = await fs.readdir(sessionFolder);
+        try {
+          reportDebug({ namespace, message: 'Validating request' });
+          await validate(req, validator);
+        } catch (error) {
+          reportDebug({
+            namespace,
+            message: 'Validation failed',
+            data: { error }
+          });
+          return next(
+            new WebError({
+              statusCode: 400,
+              errorCode: 'validation-failed',
+              message: 'Validation failed for file upload',
+              data: { error: (error as Error).message }
+            })
+          );
+        }
 
-      if (uploadedChunks.length === parseInt(totalChunks, 10)) {
+        const { filename, totalChunks, chunkIndex, uniqueID } = req.body;
         reportDebug({
           namespace,
-          message: `All chunks uploaded. Merging file...`
+          message: 'Received chunk data',
+          data: { filename, totalChunks, chunkIndex, uniqueID }
         });
 
-        try {
-          await mergeChunks(filename, totalChunks, sessionFolder);
-        } catch (mergeErr) {
-          reportError(`File merging failed: ${(mergeErr as Error).message}`);
-          return next(mergeErr);
+        if (
+          !filename ||
+          !totalChunks ||
+          chunkIndex === undefined ||
+          !uniqueID ||
+          !req.file
+        ) {
+          return next(
+            new WebError({
+              statusCode: 400,
+              errorCode: 'missing-field',
+              message: 'Missing required fields',
+              data: {
+                filename,
+                totalChunks,
+                chunkIndex,
+                uniqueID,
+                receivedChunk: !!req.file
+              }
+            })
+          );
+        }
+
+        if (
+          filesOption?.maxSize &&
+          req.file.size > parseInt(filesOption?.maxSize, 10)
+        ) {
+          return next(
+            new WebError({
+              statusCode: 400,
+              errorCode: 'chunk-too-large',
+              message: 'Uploaded chunk exceeds the maximum allowed size',
+              data: {
+                maxSize: filesOption.maxSize,
+                receivedSize: req.file.size
+              }
+            })
+          );
         }
 
-        const finalFilePath = path.join(sessionFolder, filename);
+        const sessionFolder = path.join(TEMP_DIR, uniqueID);
+        fs.ensureDirSync(sessionFolder);
+        const chunkPath = path.join(
+          sessionFolder,
+          `${filename}.part${chunkIndex}`
+        );
 
-        if (!fs.existsSync(finalFilePath)) {
-          reportError('File merging failed: File does not exist');
-          return next(new Error('File merging failed'));
+        try {
+          reportDebug({
+            namespace,
+            message: 'Writing chunk to disk',
+            data: { chunkPath }
+          });
+          await fs.writeFile(chunkPath, req.file.buffer);
+        } catch (writeErr) {
+          return next(
+            new WebError({
+              statusCode: 500,
+              errorCode: 'chunk-write-failed',
+              message: 'Failed to write chunk',
+              data: { chunkIndex, error: (writeErr as Error).message }
+            })
+          );
         }
 
-        req.body.uploadDetails = {
-          status: 'completed',
-          message: 'File uploaded and merged successfully',
-          details: { filename, uniqueID }
-        };
+        const uploadedChunks = await fs.readdir(sessionFolder);
         reportDebug({
           namespace,
-          message: `File merged successfully`,
-          data: {
-            status: 'completed',
-            details: { filename, uniqueID }
-          }
+          message: 'Uploaded chunk count',
+          data: { uploadedChunks: uploadedChunks.length, totalChunks }
         });
 
-        return next();
-      }
+        if (uploadedChunks.length === parseInt(totalChunks, 10)) {
+          try {
+            const finalFilePath = path.join(
+              FILE_DIR,
+              `${uniqueID}_${filename}`
+            );
+            await mergeChunks(
+              filename,
+              totalChunks,
+              sessionFolder,
+              finalFilePath
+            );
+            req.multipartFile = {
+              isPending: false,
+              originalname: filename,
+              uniqueID,
+              filePath: finalFilePath
+            };
+          } catch (mergeErr) {
+            return next(
+              new WebError({
+                statusCode: 500,
+                errorCode: 'file-merge-failed',
+                message: 'Error merging file chunks',
+                data: { error: (mergeErr as Error).message }
+              })
+            );
+          }
+          return next();
+        }
 
-      reportDebug({
-        namespace,
-        message: `Chunk uploaded successfully`,
-        data: {
-          filename,
+        req.multipartFile = {
+          isPending: true,
+          originalname: filename,
           uniqueID,
           chunkIndex,
           totalChunks
-        }
+        };
+        next();
       });
-
-      req.body.uploadDetails = {
-        status: 'pending',
-        message: 'Chunk uploaded successfully',
-        details: { filename, uniqueID, chunkIndex, totalChunks }
-      };
-
-      return next();
-    });
-  } catch (error) {
-    reportError(
-      `Failed to upload or process chunk: ${(error as Error).message}`
-    );
-    next(error);
-  }
+    } catch (error) {
+      next(
+        new WebError({
+          statusCode: 500,
+          errorCode: 'unexpected-error',
+          message: 'Unexpected error in file upload',
+          data: { error: (error as Error).message }
+        })
+      );
+    }
+  };
 }
 
 async function mergeChunks(
   filename: string,
   totalChunks: string | number,
-  sessionFolder: string
+  sessionFolder: string,
+  finalFilePath: string
 ): Promise<void> {
-  const finalFilePath = path.join(sessionFolder, filename);
   const writeStream = fs.createWriteStream(finalFilePath);
+  reportDebug({
+    namespace,
+    message: 'Merging file chunks',
+    data: { finalFilePath }
+  });
 
   for (let i = 0; i < parseInt(totalChunks as string, 10); i++) {
     const partPath = path.join(sessionFolder, `${filename}.part${i}`);
-
     try {
       const chunkData = await fs.readFile(partPath);
       writeStream.write(chunkData);
     } catch (error) {
-      reportError(`Error reading chunk ${i}: ${(error as Error).message}`);
-      throw error;
+      throw new WebError({
+        statusCode: 500,
+        errorCode: 'chunk-read-failed',
+        message: `Error reading chunk ${i}`,
+        data: { error: (error as Error).message }
+      });
     }
-
     fs.remove(partPath).catch((err: Error) =>
       reportError(`Error removing part ${partPath}: ${err.message}`)
     );
   }
 
   writeStream.end();
-
   return new Promise<void>((resolve, reject) => {
     writeStream.on('finish', () => resolve(undefined));
-    writeStream.on('error', (error) => {
-      reportError(`Error merging chunks: ${(error as Error).message}`);
-      reject(error);
-    });
+    writeStream.on('error', (error) =>
+      reject(
+        new WebError({
+          statusCode: 500,
+          errorCode: 'file-merge-error',
+          message: 'Error merging file chunks',
+          data: { error: (error as Error).message }
+        })
+      )
+    );
   });
 }
-
-export { multiPartFileUploader };

package/src/middleware/multiPartFileUploader/multiPartFileUploader.types.ts

@@ -0,0 +1,23 @@
+// Extend Express request object to include `files`
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace Express {
+    interface Request {
+      /** Uploaded files mapped by field name */
+      multipartFile?: {
+        isPending: boolean;
+        originalname: string;
+        uniqueID: string;
+        filePath?: string;
+        chunkIndex?: number;
+        totalChunks?: number;
+      };
+    }
+  }
+}
+
+/** Configuration for Multi part file upload */
+export interface MultiPartFileUploaderConfig {
+  required?: boolean;
+  maxSize?: string;
+}

package/src/middleware/multiPartFileUploader/validate/index.ts

@@ -0,0 +1 @@
+export * from './validate';

package/src/middleware/multiPartFileUploader/validate/validate.ts

@@ -0,0 +1,27 @@
+import { Request } from 'express';
+import { Schema } from 'express-validator';
+import { validate as validateMiddleware } from 'middleware/validate';
+
+/** Validate a schema against a request using our validation middleware */
+export async function validate(
+  request: Request,
+  schema: Schema
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    // Generate a validation chain using our middleware
+    const validationChain = validateMiddleware(schema).flat();
+    if (!validationChain.length) resolve();
+    // Recursively go through each middleware by imitating the next function from express
+    let position = -1;
+    const next = (error?: unknown): void => {
+      if (error) reject(error);
+      position++;
+      if (position === validationChain.length) {
+        resolve();
+        return;
+      }
+      validationChain[position](request, undefined, next);
+    };
+    next();
+  });
+}