@reldens/server-utils 0.25.0 → 0.26.0

package/lib/uploader-factory.js

@@ -25,10 +25,17 @@ class UploaderFactory
         this.maxFilenameLength = props.maxFilenameLength || 255;
     }
 
+    setError(message, additionalData = {})
+    {
+        if(!this.error.message){
+            this.error = {message, ...additionalData};
+        }
+    }
+
     createUploader(fields, buckets, allowedFileTypes)
     {
         if(!this.validateInputs(fields, buckets, allowedFileTypes)){
-            this.error = {message: 'Invalid uploader configuration: ' + this.error.message};
+            this.setError('Invalid uploader configuration: ' + this.error.message);
             return false;
         }
         let storage = multer.diskStorage({
@@ -36,17 +43,23 @@ class UploaderFactory
                 try{
                     let dest = buckets[file.fieldname];
                     if(!FileHandler.isValidPath(dest)){
+                        this.setError('Invalid destination path', {dest, fieldname: file.fieldname});
                         return cb(new Error('Invalid destination path'));
                     }
-                    FileHandler.createFolder(dest);
+                    let folderCreated = FileHandler.createFolder(dest);
+                    if(!folderCreated){
+                        this.setError('Cannot create destination folder', {dest, fileHandlerError: FileHandler.error});
+                        return cb(new Error('Cannot create destination folder'));
+                    }
                     cb(null, dest);
                 } catch(error){
-                    this.error = {message: 'Cannot prepare destination.', error: error};
+                    this.setError('Cannot prepare destination.', {error: error});
                     cb(error);
                 }
             },
             filename: (req, file, cb) => {
                 if(!this.validateFilenameSecurity(file.originalname)){
+                    this.setError('Invalid filename', {originalname: file.originalname});
                     return cb(new Error('Invalid filename'));
                 }
                 if(!this.applySecureFileNames) {
@@ -80,6 +93,7 @@ class UploaderFactory
                     if(multerError instanceof multer.MulterError){
                         if('LIMIT_FILE_SIZE' === multerError.code){
                             let messageFile = 'File too large.';
+                            this.setError(messageFile, {multerError});
                             if('function' === typeof this.processErrorResponse){
                                 return this.processErrorResponse(413, messageFile, req, res);
                             }
@@ -87,18 +101,21 @@ class UploaderFactory
                         }
                         if('LIMIT_FILE_COUNT' === multerError.code){
                             let messageTooMany = 'Too many files.';
+                            this.setError(messageTooMany, {multerError});
                             if('function' === typeof this.processErrorResponse){
                                 return this.processErrorResponse(413, messageTooMany, req, res);
                             }
                             return res.status(413).send(messageTooMany);
                         }
                         let messageUpload = 'File upload error.';
+                        this.setError(messageUpload, {multerError});
                         if('function' === typeof this.processErrorResponse){
                             return this.processErrorResponse(400, messageUpload, multerError, req, res);
                         }
                         return res.status(400).send(messageUpload);
                     }
-                    let messageServer = this.error && this.error.message ? this.error.message : 'Server error during file upload.';
+                    let messageServer = this.error?.message ? this.error.message : 'Server error during file upload.';
+                    this.setError(messageServer, {multerError});
                     if('function' === typeof this.processErrorResponse){
                         return this.processErrorResponse(415, messageServer, req, res);
                     }
@@ -109,8 +126,9 @@ class UploaderFactory
                 }
                 let validationResult = await this.validateAllUploadedFiles(req, allowedFileTypes);
                 if(!validationResult){
-                    FileHandler.removeMultiple(Object.values(req.files).flat().map(file => file.path));
-                    let messageContents = this.error && this.error.message ? this.error.message : 'File validation failed.';
+                    let filePaths = Object.values(req.files).flat().map(file => file.path);
+                    FileHandler.removeMultiple(filePaths);
+                    let messageContents = this.error?.message ? this.error.message : 'File validation failed.';
                     if('function' === typeof this.processErrorResponse){
                         return this.processErrorResponse(415, messageContents, req, res);
                     }
@@ -126,7 +144,8 @@ class UploaderFactory
         try {
             for(let fieldName in req.files){
                 for(let file of req.files[fieldName]){
-                    if(!await this.validateFileContents(file, allowedFileTypes[fieldName])){
+                    let validationResult = await this.validateFileContents(file, allowedFileTypes[fieldName]);
+                    if(!validationResult){
                         FileHandler.remove(file.path);
                         return false;
                     }
@@ -134,7 +153,7 @@ class UploaderFactory
             }
             return true;
         } catch(error){
-            this.error = {message: 'Error processing uploaded files.', error};
+            this.setError('Error processing uploaded files.', {error});
             return false;
         }
     }
@@ -163,28 +182,28 @@ class UploaderFactory
     validateInputs(fields, buckets, allowedFileTypes)
     {
         if(!Array.isArray(fields)){
-            this.error = {message: 'Fields must be an array'};
+            this.setError('Fields must be an array');
             return false;
         }
         if(!buckets || 'object' !== typeof buckets){
-            this.error = {message: 'Buckets must be an object'};
+            this.setError('Buckets must be an object');
             return false;
         }
         if(!allowedFileTypes || 'object' !== typeof allowedFileTypes){
-            this.error = {message: 'AllowedFileTypes must be an object'};
+            this.setError('AllowedFileTypes must be an object');
             return false;
         }
         for(let field of fields){
             if(!field.name || 'string' !== typeof field.name){
-                this.error = {message: 'Field name is invalid'};
+                this.setError('Field name is invalid');
                 return false;
             }
             if(!buckets[field.name]){
-                this.error = {message: 'Missing bucket for field: ' + field.name};
+                this.setError('Missing bucket for field: ' + field.name);
                 return false;
             }
             if(!allowedFileTypes[field.name]){
-                this.error = {message: 'Missing allowedFileType for field: ' + field.name};
+                this.setError('Missing allowedFileType for field: ' + field.name);
                 return false;
             }
         }
@@ -197,23 +216,33 @@ class UploaderFactory
             return cb(null, true);
         }
         if(!this.validateFilenameSecurity(file.originalname)){
-            this.error = {message: 'Insecure filename: '+file.originalname};
+            this.setError('Insecure filename: '+file.originalname, {originalname: file.originalname});
             return cb(new Error('Insecure filename: '+file.originalname));
         }
         let fileExtension = FileHandler.extension(file.originalname).toLowerCase();
         let allowedExtensions = this.allowedExtensions && this.allowedExtensions[allowedFileType];
         if(allowedExtensions && !allowedExtensions.includes(fileExtension)){
-            this.error = {message: 'Invalid file extension: '+fileExtension};
+            this.setError('Invalid file extension: '+fileExtension, {
+                extension: fileExtension,
+                allowedExtensions,
+                allowedFileType,
+                filename: file.originalname
+            });
             return cb(new Error('Invalid file extension: '+fileExtension));
         }
         let allowedFileTypeRegex = this.convertToRegex(allowedFileType);
         if(!allowedFileTypeRegex){
-            this.error = {message: 'File type could not be converted to regex.', allowedFileType};
+            this.setError('File type could not be converted to regex.', {allowedFileType});
             return cb(new Error('File type could not be converted to regex'));
         }
         let mimeTypeValid = allowedFileTypeRegex.test(file.mimetype);
         if(!mimeTypeValid){
-            this.error = {message: 'Invalid MIME type: '+file.mimetype};
+            this.setError('Invalid MIME type: '+file.mimetype, {
+                mimetype: file.mimetype,
+                allowedFileType,
+                filename: file.originalname,
+                regex: allowedFileTypeRegex
+            });
             return cb(new Error('Invalid MIME type: '+file.mimetype));
         }
         return cb(null, true);
@@ -222,21 +251,39 @@ class UploaderFactory
     async validateFileContents(file, allowedFileType)
     {
         if(!FileHandler.isFile(file.path)){
-            this.error = {message: 'File path must be provided.', file};
+            this.setError('File path must be provided.', {file});
             return false;
         }
         let detectedType = FileHandler.detectFileType(file.path);
         if(detectedType && 'application/octet-stream' !== detectedType){
             let expectedMimeTypes = this.mimeTypes[allowedFileType] || [];
             if(0 < expectedMimeTypes.length && -1 === expectedMimeTypes.indexOf(detectedType)){
-                this.error = {
-                    message: 'File content type mismatch.',
-                    detected: detectedType, expected: expectedMimeTypes
-                };
+                this.setError('File content type mismatch.', {
+                    detected: detectedType,
+                    expected: expectedMimeTypes,
+                    filename: file.filename,
+                    path: file.path,
+                    allowedFileType
+                });
                 return false;
             }
         }
-        return FileHandler.validateFileType(file.path, allowedFileType, this.allowedExtensions, this.maxFileSize);
+        let typeValidationResult = FileHandler.validateFileType(
+            file.path,
+            allowedFileType,
+            this.allowedExtensions,
+            this.maxFileSize
+        );
+        if(!typeValidationResult){
+            this.setError('File type validation failed.', {
+                fileHandlerError: FileHandler.error,
+                filename: file.filename,
+                path: file.path,
+                allowedFileType
+            });
+            return false;
+        }
+        return true;
     }
 
     convertToRegex(key)

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/server-utils",
     "scope": "@reldens",
-    "version": "0.25.0",
+    "version": "0.26.0",
     "description": "Reldens - Server Utils",
     "author": "Damian A. Pastorini",
     "license": "MIT",