@reldens/server-utils 0.23.0 → 0.24.0

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)){
@@ -507,6 +527,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/package.json

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