@reldens/server-utils 0.23.0 → 0.25.0

package/README.md

@@ -40,7 +40,7 @@ A Node.js server toolkit providing secure application server creation, file hand
 - Password hashing using PBKDF2 with configurable iterations
 - Password validation against stored hashes
 - AES-256-GCM data encryption and decryption
-- Secure token generation with customizable length
+- Secure token generation with a customizable length
 - TOTP (Time-based One-Time Password) generation
 - Data hashing with multiple algorithms (SHA-256, SHA-512, MD5)
 - HMAC generation and verification
@@ -245,8 +245,9 @@ let serverResult = appServerFactory.createAppServer({
 ### FileHandler Methods
 
 - `exists(path)` - Checks if file or folder exists
-- `createFolder(path)` - Creates folder with recursive option
+- `createFolder(path)` - Creates folder with a recursive option
 - `remove(path)` - Removes file or folder recursively
+- `removeMultiple(filePaths)` - Removes multiple files from an array of paths
 - `copyFile(source, destination)` - Copies file to destination
 - `copyFolderSync(source, destination)` - Copies folder recursively
 - `readFile(path)` - Reads file contents as string
@@ -254,14 +255,14 @@ let serverResult = appServerFactory.createAppServer({
 - `fetchFileJson(path)` - Reads and parses JSON file
 - `fetchFileContents(path)` - Reads file with validation
 - `updateFileContents(path, content)` - Updates existing file
-- `isFile(path)` - Checks if path is file
-- `isFolder(path)` - Checks if path is folder
+- `isFile(path)` - Checks if a path is a file
+- `isFolder(path)` - Checks if a path is folder
 - `getFilesInFolder(path, extensions)` - Lists files with optional filtering
 - `validateFileType(path, type, allowedTypes, maxSize)` - Validates file type and size
 - `detectFileType(path)` - Detects MIME type from file signature
 - `generateSecureFilename(originalName)` - Generates cryptographically secure filename
 - `quarantineFile(path, reason)` - Moves file to quarantine folder
-- `createTempFile(prefix, extension)` - Creates temporary file path
+- `createTempFile(prefix, extension)` - Creates a temporary file path
 
 ### Encryptor Methods
 
@@ -281,9 +282,8 @@ let serverResult = appServerFactory.createAppServer({
 
 - `createUploader(fields, buckets, allowedTypes)` - Creates multer upload middleware
 - `validateFilenameSecurity(filename)` - Validates filename for security
-- `validateFile(file, allowedType, callback)` - Validates file during upload
+- `validateFile(file, allowedType, callback)` - Validates a file during upload
 - `validateFileContents(file, allowedType)` - Validates file content after upload
-- `cleanupFiles(files)` - Removes uploaded files on error
 
 ## Security Features
 
@@ -291,7 +291,7 @@ let serverResult = appServerFactory.createAppServer({
 All file operations include comprehensive path validation to prevent directory traversal attacks and access to system files.
 
 ### Secure File Upload
-File uploads are validated at multiple levels including filename, MIME type, file extension, file size, and content validation using magic number detection.
+File uploads are validated at multiple levels including filename, MIME type, file extension, file size, and content validation using magic number detection. Failed uploads are automatically cleaned up using efficient file removal.
 
 ### Rate Limiting
 Configurable rate limiting with development mode detection for appropriate thresholds in different environments.

package/lib/file-handler.js

@@ -22,6 +22,8 @@ class FileHandler
             'C:\\Windows\\', 'C:\\System32\\',
             '%2e%2e%2f', '%2e%2e%5c'
         ];
+        this.nativeHandler = fs;
+        this.nativePaths = path;
     }
 
     joinPaths(...args)
@@ -29,6 +31,24 @@ class FileHandler
         return path.join(...args);
     }
 
+    getFileName(filePath)
+    {
+        if(!this.isValidPath(filePath)){
+            this.error = {message: 'Invalid file path.', filePath};
+            return false;
+        }
+        return path.basename(filePath);
+    }
+
+    getFolderName(filePath)
+    {
+        if(!this.isValidPath(filePath)){
+            this.error = {message: 'Invalid file path.', filePath};
+            return false;
+        }
+        return path.dirname(filePath);
+    }
+
     exists(fullPath)
     {
         if(!this.isValidPath(fullPath)){
@@ -121,6 +141,20 @@ class FileHandler
         }
     }
 
+    removeMultiple(filePaths)
+    {
+        if(!Array.isArray(filePaths)){
+            this.error = {message: 'File paths must be an array'};
+            return false;
+        }
+        for(let filePath of filePaths){
+            if(!this.remove(filePath)){
+                return false;
+            }
+        }
+        return true;
+    }
+
     createFolder(folderPath)
     {
         if(!this.isValidPath(folderPath)){
@@ -507,6 +541,230 @@ class FileHandler
         return this.joinPaths(tempDir, fileName);
     }
 
+    moveFile(from, to)
+    {
+        if(!this.isValidPath(from) || !this.isValidPath(to)){
+            this.error = {message: 'Invalid path for file move.', from, to};
+            return false;
+        }
+        if(!this.exists(from)){
+            this.error = {message: 'Source file does not exist.', from};
+            return false;
+        }
+        try {
+            fs.renameSync(from, to);
+            return true;
+        } catch (error) {
+            this.error = {message: 'Failed to move file.', error, from, to};
+            return false;
+        }
+    }
+
+    getFileSize(filePath)
+    {
+        if(!this.isValidPath(filePath)){
+            this.error = {message: 'Invalid file path.', filePath};
+            return false;
+        }
+        if(!this.exists(filePath)){
+            this.error = {message: 'File does not exist.', filePath};
+            return false;
+        }
+        try {
+            return fs.statSync(filePath).size;
+        } catch (error) {
+            this.error = {message: 'Failed to get file size.', error, filePath};
+            return false;
+        }
+    }
+
+    compareFiles(file1, file2)
+    {
+        if(!this.isValidPath(file1) || !this.isValidPath(file2)){
+            this.error = {message: 'Invalid file paths for comparison.', file1, file2};
+            return false;
+        }
+        if(!this.exists(file1) || !this.exists(file2)){
+            this.error = {message: 'One or both files do not exist.', file1, file2};
+            return false;
+        }
+        try {
+            let content1 = this.readFile(file1);
+            let content2 = this.readFile(file2);
+            if(!content1 || !content2){
+                return false;
+            }
+            return content1 === content2;
+        } catch (error) {
+            this.error = {message: 'Failed to compare files.', error, file1, file2};
+            return false;
+        }
+    }
+
+    getRelativePath(from, to)
+    {
+        if(!this.isValidPath(from) || !this.isValidPath(to)){
+            this.error = {message: 'Invalid paths for relative calculation.', from, to};
+            return false;
+        }
+        try {
+            return path.relative(from, to);
+        } catch (error) {
+            this.error = {message: 'Failed to calculate relative path.', error, from, to};
+            return false;
+        }
+    }
+
+    isAbsolutePath(filePath)
+    {
+        if(!this.isValidPath(filePath)){
+            this.error = {message: 'Invalid file path.', filePath};
+            return false;
+        }
+        return path.isAbsolute(filePath);
+    }
+
+    normalizePath(filePath)
+    {
+        if(!filePath){
+            this.error = {message: 'Path cannot be empty.', filePath};
+            return false;
+        }
+        try {
+            return path.normalize(filePath);
+        } catch (error) {
+            this.error = {message: 'Failed to normalize path.', error, filePath};
+            return false;
+        }
+    }
+
+    walkDirectory(dirPath, callback)
+    {
+        if(!this.isValidPath(dirPath)){
+            this.error = {message: 'Invalid directory path.', dirPath};
+            return false;
+        }
+        if(!this.isFolder(dirPath)){
+            this.error = {message: 'Path is not a directory.', dirPath};
+            return false;
+        }
+        if('function' !== typeof callback){
+            this.error = {message: 'Callback must be a function.', dirPath};
+            return false;
+        }
+        try {
+            let items = this.readFolder(dirPath);
+            for(let item of items){
+                let itemPath = this.joinPaths(dirPath, item);
+                callback(itemPath);
+                if(this.isFolder(itemPath)){
+                    this.walkDirectory(itemPath, callback);
+                }
+            }
+            return true;
+        } catch (error) {
+            this.error = {message: 'Failed to walk directory.', error, dirPath};
+            return false;
+        }
+    }
+
+    getDirectorySize(dirPath)
+    {
+        if(!this.isValidPath(dirPath)){
+            this.error = {message: 'Invalid directory path.', dirPath};
+            return false;
+        }
+        if(!this.isFolder(dirPath)){
+            this.error = {message: 'Path is not a directory.', dirPath};
+            return false;
+        }
+        let totalSize = 0;
+        let calculateSize = (itemPath) => {
+            if(this.isFile(itemPath)){
+                let size = this.getFileSize(itemPath);
+                if(false !== size){
+                    totalSize += size;
+                }
+            }
+        };
+        let walkResult = this.walkDirectory(dirPath, calculateSize);
+        if(!walkResult){
+            return false;
+        }
+        return totalSize;
+    }
+
+    emptyDirectory(dirPath)
+    {
+        if(!this.isValidPath(dirPath)){
+            this.error = {message: 'Invalid directory path.', dirPath};
+            return false;
+        }
+        if(!this.isFolder(dirPath)){
+            this.error = {message: 'Path is not a directory.', dirPath};
+            return false;
+        }
+        try {
+            let items = this.readFolder(dirPath);
+            for(let item of items){
+                let itemPath = this.joinPaths(dirPath, item);
+                this.remove(itemPath);
+            }
+            return true;
+        } catch (error) {
+            this.error = {message: 'Failed to empty directory.', error, dirPath};
+            return false;
+        }
+    }
+
+    appendToFile(filePath, content)
+    {
+        if(!this.isValidPath(filePath)){
+            this.error = {message: 'Invalid file path.', filePath};
+            return false;
+        }
+        try {
+            fs.appendFileSync(filePath, content, this.encoding);
+            return true;
+        } catch (error) {
+            this.error = {message: 'Failed to append to file.', error, filePath};
+            return false;
+        }
+    }
+
+    prependToFile(filePath, content)
+    {
+        if(!this.isValidPath(filePath)){
+            this.error = {message: 'Invalid file path.', filePath};
+            return false;
+        }
+        if(!this.exists(filePath)){
+            return this.writeFile(filePath, content);
+        }
+        let existingContent = this.readFile(filePath);
+        if(!existingContent){
+            return false;
+        }
+        return this.writeFile(filePath, content + existingContent);
+    }
+
+    replaceInFile(filePath, searchValue, replaceValue)
+    {
+        if(!this.isValidPath(filePath)){
+            this.error = {message: 'Invalid file path.', filePath};
+            return false;
+        }
+        if(!this.exists(filePath)){
+            this.error = {message: 'File does not exist.', filePath};
+            return false;
+        }
+        let content = this.readFile(filePath);
+        if(!content){
+            return false;
+        }
+        return this.writeFile(filePath, content.replace(searchValue, replaceValue));
+    }
+
 }
 
 module.exports.FileHandler = new FileHandler();

package/lib/uploader-factory.js

@@ -31,32 +31,36 @@ class UploaderFactory
             this.error = {message: 'Invalid uploader configuration: ' + this.error.message};
             return false;
         }
-        let diskStorageConfiguration = {
+        let storage = multer.diskStorage({
             destination: (req, file, cb) => {
-                let dest = buckets[file.fieldname];
-                if(!FileHandler.isValidPath(dest)){
-                    return cb(new Error('Invalid destination path'));
+                try{
+                    let dest = buckets[file.fieldname];
+                    if(!FileHandler.isValidPath(dest)){
+                        return cb(new Error('Invalid destination path'));
+                    }
+                    FileHandler.createFolder(dest);
+                    cb(null, dest);
+                } catch(error){
+                    this.error = {message: 'Cannot prepare destination.', error: error};
+                    cb(error);
                 }
-                FileHandler.createFolder(dest);
-                cb(null, dest);
-            }
-        };
-        diskStorageConfiguration.filename = (req, file, cb) => {
-            if(!this.validateFilenameSecurity(file.originalname)){
-                return cb(new Error('Invalid filename'));
-            }
-            if(!this.applySecureFileNames) {
-                cb(null, file.originalname);
-                return;
-            }
-            let secureFilename = FileHandler.generateSecureFilename(file.originalname);
-            if(!req.fileNameMapping){
-                req.fileNameMapping = {};
+            },
+            filename: (req, file, cb) => {
+                if(!this.validateFilenameSecurity(file.originalname)){
+                    return cb(new Error('Invalid filename'));
+                }
+                if(!this.applySecureFileNames) {
+                    cb(null, file.originalname);
+                    return;
+                }
+                let secureFilename = FileHandler.generateSecureFilename(file.originalname);
+                if(!req.fileNameMapping){
+                    req.fileNameMapping = {};
+                }
+                req.fileNameMapping[secureFilename] = file.originalname;
+                cb(null, secureFilename);
             }
-            req.fileNameMapping[secureFilename] = file.originalname;
-            cb(null, secureFilename);
-        };
-        let storage = multer.diskStorage(diskStorageConfiguration);
+        });
         let limits = {
             fileSize: this.maxFileSize
         };
@@ -74,14 +78,14 @@ class UploaderFactory
             upload.fields(fields)(req, res, async (multerError) => {
                 if(multerError){
                     if(multerError instanceof multer.MulterError){
-                        if(multerError.code === 'LIMIT_FILE_SIZE'){
+                        if('LIMIT_FILE_SIZE' === multerError.code){
                             let messageFile = 'File too large.';
                             if('function' === typeof this.processErrorResponse){
                                 return this.processErrorResponse(413, messageFile, req, res);
                             }
                             return res.status(413).send(messageFile);
                         }
-                        if(multerError.code === 'LIMIT_FILE_COUNT'){
+                        if('LIMIT_FILE_COUNT' === multerError.code){
                             let messageTooMany = 'Too many files.';
                             if('function' === typeof this.processErrorResponse){
                                 return this.processErrorResponse(413, messageTooMany, req, res);
@@ -94,19 +98,19 @@ class UploaderFactory
                         }
                         return res.status(400).send(messageUpload);
                     }
-                    let messageServer = 'Server error during file upload.';
+                    let messageServer = this.error && this.error.message ? this.error.message : 'Server error during file upload.';
                     if('function' === typeof this.processErrorResponse){
-                        return this.processErrorResponse(500, messageServer, req, res);
+                        return this.processErrorResponse(415, messageServer, req, res);
                     }
-                    return res.status(500).send(messageServer);
+                    return res.status(415).send(messageServer);
                 }
                 if(!req.files){
                     return next();
                 }
                 let validationResult = await this.validateAllUploadedFiles(req, allowedFileTypes);
                 if(!validationResult){
-                    this.cleanupFiles(req.files);
-                    let messageContents = 'File validation failed.';
+                    FileHandler.removeMultiple(Object.values(req.files).flat().map(file => file.path));
+                    let messageContents = this.error && this.error.message ? this.error.message : 'File validation failed.';
                     if('function' === typeof this.processErrorResponse){
                         return this.processErrorResponse(415, messageContents, req, res);
                     }
@@ -190,17 +194,17 @@ class UploaderFactory
     validateFile(file, allowedFileType, cb)
     {
         if(!allowedFileType){
-            return cb();
+            return cb(null, true);
         }
         if(!this.validateFilenameSecurity(file.originalname)){
-            this.error = {message: 'Insecure filename: ' + file.originalname};
-            return cb(new Error('Insecure filename: ' + file.originalname));
+            this.error = {message: 'Insecure filename: '+file.originalname};
+            return cb(new Error('Insecure filename: '+file.originalname));
         }
         let fileExtension = FileHandler.extension(file.originalname).toLowerCase();
-        let allowedExtensions = this.allowedExtensions[allowedFileType];
+        let allowedExtensions = this.allowedExtensions && this.allowedExtensions[allowedFileType];
         if(allowedExtensions && !allowedExtensions.includes(fileExtension)){
-            this.error = {message: 'Invalid file extension: ' + fileExtension};
-            return cb(new Error('Invalid file extension: ' + fileExtension));
+            this.error = {message: 'Invalid file extension: '+fileExtension};
+            return cb(new Error('Invalid file extension: '+fileExtension));
         }
         let allowedFileTypeRegex = this.convertToRegex(allowedFileType);
         if(!allowedFileTypeRegex){
@@ -209,10 +213,10 @@ class UploaderFactory
         }
         let mimeTypeValid = allowedFileTypeRegex.test(file.mimetype);
         if(!mimeTypeValid){
-            this.error = {message: 'Invalid MIME type: ' + file.mimetype};
-            return cb(new Error('Invalid MIME type: ' + file.mimetype));
+            this.error = {message: 'Invalid MIME type: '+file.mimetype};
+            return cb(new Error('Invalid MIME type: '+file.mimetype));
         }
-        return cb();
+        return cb(null, true);
     }
 
     async validateFileContents(file, allowedFileType)
@@ -246,17 +250,6 @@ class UploaderFactory
         return new RegExp(types.join('|'));
     }
 
-    cleanupFiles(files)
-    {
-        if(!files){
-            return;
-        }
-        for(let fieldName in files){
-            for(let file of files[fieldName]){
-                FileHandler.remove(file.path);
-            }
-        }
-    }
 }
 
 module.exports.UploaderFactory = UploaderFactory;

package/package.json

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