mybase 1.1.25 → 1.1.26

package/package.json

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

package/ts/funcs/ensureFolder.js

@@ -0,0 +1,47 @@
+"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) {
+    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}`);
+    return fs.mkdirSync(folderPath, { recursive: true }) ? folderPath : undefined;
+}
+exports.ensureFolder = ensureFolder;
+//# sourceMappingURL=ensureFolder.js.map

package/ts/funcs/ensureFolder.test.ts

@@ -0,0 +1,41 @@
+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', () => {
+        const sfolder= ensureFolder(`${folderPath}/subfolder/subsubfolder`)
+        expect(sfolder).toBe(`${folderPath}/subfolder/subsubfolder`) 
+        if (sfolder) expect(fs.existsSync(sfolder)).toBe(true)
+    })
+
+    it('try to create a file where we do not have write permissions should throw an error', () => {
+        expect(() => ensureFolder('/dev/ensureFolder.test.file')).toThrow()
+    })
+})

package/ts/funcs/ensureFolder.ts

@@ -0,0 +1,17 @@
+import debug from 'debug'
+import * as fs from 'fs';
+const dbg = debug('_mybase:ensureFolder')
+
+export function ensureFolder(folderPath: string) : string | undefined {
+    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}`)
+    return fs.mkdirSync(folderPath, { recursive: true }) ? folderPath : undefined
+}

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";
+