mybase 1.1.25 → 1.1.27

package/package.json

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

package/ts/funcs/ensureFolder.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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, options) {
+    options = options || {};
+    options.recursive = true;
+    dbg('ensureFolder()', folderPath);
+    if (fs.existsSync(folderPath)) {
+        if (!fs.lstatSync(folderPath).isDirectory()) {
+            dbg(`${folderPath} exists and is not a folder`);
+            throw new Error(`${folderPath} exists and is not a folder`);
+        }
+        dbg(`${folderPath} exists and is a folder`);
+        return folderPath;
+    }
+    dbg(`creating ${folderPath}`, options);
+    fs.mkdirSync(folderPath, options);
+    return folderPath;
+}
+exports.ensureFolder = ensureFolder;
+//# sourceMappingURL=ensureFolder.js.map

package/ts/funcs/ensureFolder.test.ts

@@ -0,0 +1,79 @@
+import { ensureFolder } from './ensureFolder'
+import * as fs from 'fs'
+import { wait } from '../index'
+
+describe('ensureFolder', () => {
+    let folderPath: string
+    let filePath: string
+    
+    beforeEach(async () => {
+        folderPath = `/tmp/ensureFolder.test.${Date.now()}`
+        filePath = `/tmp/ensureFolder.test.${Date.now()}.file`
+        await wait(1/1000)
+    })
+
+    it('should create a folder if it does not exist and return the folder path', () => {
+        const folder = ensureFolder(folderPath)
+        expect(folder).toBe(folderPath)
+        expect(fs.existsSync(folderPath)).toBe(true)
+    })
+
+    it('should throw an error if the folder path exists and is not a folder', () => {
+        fs.writeFileSync(filePath, 'test')
+        expect(() => ensureFolder(filePath)).toThrow('exists and is not a folder')
+    })
+
+    it('creating same folder twice should return the same folder path', () => {
+        expect(ensureFolder(folderPath)).toBe(folderPath)
+        expect(fs.existsSync(folderPath)).toBe(true)
+        expect(ensureFolder(folderPath)).toBe(folderPath)
+    })
+
+    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

@@ -0,0 +1,21 @@
+import debug from 'debug'
+import * as fs from 'fs';
+import { MakeDirectoryOptions } from 'fs';
+const dbg = debug('_mybase:ensureFolder')
+
+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()) {
+            dbg(`${folderPath} exists and is not a folder`)
+            throw new Error(`${folderPath} exists and is not a folder`);
+        }
+        dbg(`${folderPath} exists and is a folder`)
+        return folderPath
+    } 
+    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.d.ts

@@ -23,3 +23,5 @@ export * from "./funcs/getMysql2";
 export * from "./funcs/initMysql2Pool";
 export * from "./funcs/randomUTFString";
 export * from "./funcs/MaxRuntimeHours";
+export * from "./funcs/ensureFolder";
+

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 {