mybase 1.1.26 → 1.1.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mybase",
-  "version": "1.1.26",
+  "version": "1.1.28",
   "description": "",
   "main": "mybase.js",
   "scripts": {

package/ts/funcs/ensureFolder.js

@@ -30,7 +30,9 @@ exports.ensureFolder = void 0;
 const debug_1 = __importDefault(require("debug"));
 const fs = __importStar(require("fs"));
 const dbg = (0, debug_1.default)('_mybase:ensureFolder');
-function ensureFolder(folderPath) {
+function ensureFolder(folderPath, options) {
+    options = options || {};
+    options.recursive = true;
     dbg('ensureFolder()', folderPath);
     if (fs.existsSync(folderPath)) {
         if (!fs.lstatSync(folderPath).isDirectory()) {
@@ -40,8 +42,9 @@ function ensureFolder(folderPath) {
         dbg(`${folderPath} exists and is a folder`);
         return folderPath;
     }
-    dbg(`creating ${folderPath}`);
-    return fs.mkdirSync(folderPath, { recursive: true }) ? folderPath : undefined;
+    dbg(`creating ${folderPath}`, options);
+    fs.mkdirSync(folderPath, options);
+    return folderPath;
 }
 exports.ensureFolder = ensureFolder;
 //# sourceMappingURL=ensureFolder.js.map

package/ts/funcs/ensureFolder.test.ts

@@ -29,13 +29,51 @@ describe('ensureFolder', () => {
         expect(ensureFolder(folderPath)).toBe(folderPath)
     })
 
-    it('we should be able to create recursively a folders', () => {
-        const sfolder= ensureFolder(`${folderPath}/subfolder/subsubfolder`)
+    it('we should be able to create recursively a folders and default to recursive mode', () => {
+        let sfolder= ensureFolder(`${folderPath}/subfolder/subsubfolder`)
         expect(sfolder).toBe(`${folderPath}/subfolder/subsubfolder`) 
         if (sfolder) expect(fs.existsSync(sfolder)).toBe(true)
+        // test creating 10 recursive folders
+        for(let i=0;i<10;i++) {
+            sfolder= `${sfolder}/subsubsubfolder${i}`
+            expect(ensureFolder(sfolder)).toBe(sfolder) 
+            if (sfolder) expect(fs.existsSync(sfolder)).toBe(true)
+        }
+    })
+
+    it('we should not be able to disable recursive mode', () => {
+        expect(ensureFolder(`${folderPath}/subfolder/subsubfolder`, { recursive: false })).toBe(`${folderPath}/subfolder/subsubfolder`)
+    })
+
+    it('we should be able to create a folder with a custom mode', () => {
+        let sfolder= ensureFolder(`${folderPath}/subfolder/subsubfolder`, { mode: 0o700 })
+        expect(sfolder).toBe(`${folderPath}/subfolder/subsubfolder`) 
+        if (sfolder) expect(fs.existsSync(sfolder)).toBe(true)
+        expect(fs.statSync(sfolder).mode & 0o777).toBe(0o700);
     })
 
     it('try to create a file where we do not have write permissions should throw an error', () => {
         expect(() => ensureFolder('/dev/ensureFolder.test.file')).toThrow()
     })
+
+    it('should throw an error if folder path is empty', () => {
+        expect(() => ensureFolder('')).toThrow();
+    });
+
+    it('should throw an error if folder path is null or undefined or array or object', () => {
+        expect(() => ensureFolder(null as unknown as string)).toThrow();
+        expect(() => ensureFolder(undefined as unknown as string)).toThrow();
+        expect(() => ensureFolder([] as unknown as string)).toThrow();
+        expect(() => ensureFolder({} as unknown as string)).toThrow();
+    });
+
+    it('should not change the permissions of an existing folder', () => {
+        fs.mkdirSync(folderPath, { mode: 0o755 });
+        ensureFolder(folderPath, { mode: 0o700 });
+        expect(fs.statSync(folderPath).mode & 0o777).toBe(0o755);
+    });
+
+    it('should throw error for invalid mode value', () => {
+        
+    });
 })

package/ts/funcs/ensureFolder.ts

@@ -1,8 +1,11 @@
 import debug from 'debug'
 import * as fs from 'fs';
+import { MakeDirectoryOptions } from 'fs';
 const dbg = debug('_mybase:ensureFolder')
 
-export function ensureFolder(folderPath: string) : string | undefined {
+export function ensureFolder(folderPath: string, options?: MakeDirectoryOptions | null) : string {
+    options = options || {}
+    options.recursive = true
     dbg('ensureFolder()', folderPath)
     if (fs.existsSync(folderPath)) {
         if (!fs.lstatSync(folderPath).isDirectory()) {
@@ -12,6 +15,7 @@ export function ensureFolder(folderPath: string) : string | undefined {
         dbg(`${folderPath} exists and is a folder`)
         return folderPath
     } 
-    dbg(`creating ${folderPath}`)
-    return fs.mkdirSync(folderPath, { recursive: true }) ? folderPath : undefined
+    dbg(`creating ${folderPath}`,options)
+    fs.mkdirSync(folderPath, options)
+    return folderPath
 }

package/ts/funcs/isLoopbackIP.test.ts

@@ -65,7 +65,6 @@ describe('isLoopbackIP', () => {
     test('random ips should not be Loopback', () => {
         for(let i=0;i<10;i++){
             let ip = randomIP()
-            console.log(ip)
             expect(isLoopbackIP(ip)).toBe(false)
         }
             

package/ts/index.js

@@ -40,6 +40,7 @@ __exportStar(require("./funcs/getMysql2"), exports);
 __exportStar(require("./funcs/initMysql2Pool"), exports);
 __exportStar(require("./funcs/randomUTFString"), exports);
 __exportStar(require("./funcs/MaxRuntimeHours"), exports);
+__exportStar(require("./funcs/ensureFolder"), exports);
 // models
 __exportStar(require("./models/Unixtime"), exports);
 __exportStar(require("./models/Timespan"), exports);

package/ts/index.ts

@@ -24,7 +24,7 @@ export * from "./funcs/getMysql2"
 export * from "./funcs/initMysql2Pool"
 export * from "./funcs/randomUTFString"
 export * from "./funcs/MaxRuntimeHours"
-
+export * from "./funcs/ensureFolder"
 
 
 // models

package/ts/models/IPAddress.js

@@ -64,7 +64,7 @@ class IPAddress {
         return (0, __1.isLANIp)(this._ip.toString());
     }
     isPublicIP() {
-        return !this.isLoopbackIP() && !this.isLANIP() && this.toString() !== '0.0.0.0';
+        return this.toString() !== '0.0.0.0' && !this.isLoopbackIP() && !this.isLANIP();
     }
     static unserialize(serializedIpString) {
         var _a, _b;

package/ts/models/IPAddress.ts

@@ -59,7 +59,7 @@ export class IPAddress {
     }
 
     public isPublicIP(): boolean {
-        return !this.isLoopbackIP() && !this.isLANIP() && this.toString() !== '0.0.0.0'
+        return this.toString() !== '0.0.0.0' && !this.isLoopbackIP() && !this.isLANIP()
     }
 
     public static unserialize(serializedIpString: string): IPAddress {