mybase 1.1.1 → 1.1.3

package/mybase.js

@@ -7,7 +7,6 @@ const net = require('net')
 const chalk = require('chalk')
 const punycode = require('punycode');
 const _validURL = require('@7c/validurl')
-const { match } = require('assert');
 const validator = require('validator')
 const sha512 = require('js-sha512')
 const ip6addr = require('ip6addr')
@@ -116,7 +115,7 @@ function utcnow() { // ported
     return Math.floor(Date.now() / 1000)
 }
 
-function validIp(str) {
+function validIp(str) { // ported
     if (str && typeof str==='string') {
         let splitted
         if (splitted=str.match(/^([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)$/)) {
@@ -178,7 +177,7 @@ function validURL(host) {
     return _validURL(host)
 }
 
-function asJSON(str) {
+function asJSON(str) { // ported
     if (!str || typeof str!=='string') return false
     try { return JSON.parse(str)}catch(_) {}
     return false
@@ -263,7 +262,7 @@ function vaultRead(vault, key, cache_in_minutes = 10) {
 }
 
 
-function vaultFill(vault, obj, ignoreError = false, keepCache=true) {
+function vaultFill(vault, obj, ignoreError = false, keepCache=true) { // ported
     // v2.1
     // fills all strings with ^vault@/secret/... with proper vault values
     // if you call it again, it does reload the configuration
@@ -557,7 +556,7 @@ function sqlQuery(sqlHandle,query,values=[]) {
    })
 }
 
-function wait(seconds=1){
+function wait(seconds=1){ // ported
     return new Promise((resolve,reject)=>{
       setTimeout(resolve,seconds*1000)  
     })
@@ -574,7 +573,7 @@ function validUUID4(uuid) {
     return new RegExp(/^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i).test(uuid)
 }
 
-function promiseTimeout(ms, promise) {
+function promiseTimeout(ms, promise) { // ported
     // Create a promise that rejects in <ms> milliseconds
     let timeout = new Promise((resolve, reject) => {
         let id = setTimeout(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mybase",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "",
   "main": "mybase.js",
   "scripts": {
@@ -12,17 +12,19 @@
     "@7c/validurl": "0.0.3",
     "aes-js": "^3.1.2",
     "chalk": "^3.0.0",
-    "debug": "^4.3.1",
+    "debug": "^4.3.4",
     "ip-range-check": "^0.2.0",
     "ip6": "=0.2.7",
     "ip6addr": "^0.2.5",
     "js-sha512": "^0.8.0",
+    "node-vault": "^0.10.2",
     "psl": "^1.9.0",
     "punycode": "^2.1.1",
     "validator": "^13.7.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
+    "@types/debug": "^4.1.12",
     "@types/jest": "^29.5.11",
     "@types/node": "^20.11.5",
     "chai": "^4.2.0",

package/ts/funcs/asJSON.test.js

@@ -0,0 +1,72 @@
+const { asJSON } = require('./asJSON')
+
+describe('asJSON', () => {
+    // Returns parsed JSON object when valid JSON string is passed as input.
+    it('should return parsed JSON object when valid JSON string is passed as input', () => {
+        const inputString = '{"name": "John", "age": 30}';
+        const expectedOutput = { name: "John", age: 30 };
+        const result = asJSON(inputString);
+        expect(result).toEqual(expectedOutput);
+    });
+
+    // Returns false when empty string is passed as input.
+    it('should return false when empty string is passed as input', () => {
+        const inputString = "";
+        const expectedOutput = false;
+        const result = asJSON(inputString);
+        expect(result).toEqual(expectedOutput);
+    });
+
+    // Returns false when non-string input is passed.
+    it('should return false when non-string input is passed', () => {
+        const inputString = 123;
+        const expectedOutput = false;
+        const result = asJSON(inputString);
+        expect(result).toEqual(expectedOutput);
+    });
+
+    // Returns false when null is passed as input.
+    it('should return false when null is passed as input', () => {
+        const inputString = null;
+        const expectedOutput = false;
+        const result = asJSON(inputString);
+        expect(result).toEqual(expectedOutput);
+    });
+
+    // Returns false when undefined is passed as input.
+    it('should return false when undefined is passed as input', () => {
+        const inputString = undefined;
+        const expectedOutput = false;
+        const result = asJSON(inputString);
+        expect(result).toEqual(expectedOutput);
+    });
+
+    // Returns false when NaN is passed as input.
+    it('should return false when NaN is passed as input', () => {
+        const inputString = NaN;
+        const expectedOutput = false;
+        const result = asJSON(inputString);
+        expect(result).toEqual(expectedOutput);
+    });
+
+    // Returns false when invalid JSON string is passed as input.
+    it('should return false when invalid JSON string is passed as input', () => {
+      const inputString = 'invalid json';
+      const result = asJSON(inputString);
+      expect(result).toBe(false);
+    });
+
+    // Returns false when Infinity is passed as input.
+    it('should return false when Infinity is passed as input', () => {
+      const inputString = 'Infinity';
+      const result = asJSON(inputString);
+      expect(result).toBe(false);
+    });
+
+    // Returns false when input string contains a single quote.
+    it('should return false when input string contains a single quote', () => {
+      const inputString = "{'name': 'John'}";
+      const result = asJSON(inputString);
+      expect(result).toBe(false);
+    });
+});

package/ts/funcs/asJSON.ts

@@ -0,0 +1,6 @@
+
+export function asJSON(inputString: string): any | boolean {
+    if (!inputString || typeof inputString !== 'string') return false
+    try { return JSON.parse(inputString) } catch (_) { }
+    return false
+}

package/ts/funcs/fileCacheIsValid.js

@@ -0,0 +1,39 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileCacheIsValid = void 0;
+const fs = __importStar(require("fs"));
+function fileCacheIsValid(cacheFileName, cache_in_minutes = 60) {
+    if (fs.existsSync(cacheFileName)) {
+        const stat = fs.statSync(cacheFileName);
+        const mtime = new Date(stat.mtime).getTime();
+        if (Date.now() - mtime < cache_in_minutes * 60 * 1000) {
+            // cache is still valid
+            return true;
+        }
+    }
+    return false;
+}
+exports.fileCacheIsValid = fileCacheIsValid;

package/ts/funcs/fileCacheIsValid.ts

@@ -0,0 +1,13 @@
+import * as fs from 'fs'
+
+export function fileCacheIsValid(cacheFileName : string, cache_in_minutes = 60) : boolean {
+    if (fs.existsSync(cacheFileName)) {
+        const stat = fs.statSync(cacheFileName)
+        const mtime = new Date(stat.mtime).getTime()
+        if (Date.now() - mtime < cache_in_minutes * 60 * 1000) {
+            // cache is still valid
+            return true
+        }
+    }
+    return false
+}

package/ts/funcs/hash_sha512.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash_sha512 = void 0;
+const js_sha512_1 = require("js-sha512");
+function hash_sha512(plainString) {
+    if (typeof plainString === 'string')
+        return (0, js_sha512_1.sha512)(plainString);
+    return "";
+}
+exports.hash_sha512 = hash_sha512;

package/ts/funcs/hash_sha512.ts

@@ -0,0 +1,7 @@
+import { sha512 } from 'js-sha512'
+
+export function hash_sha512(plainString:string) : string {
+    if (typeof plainString==='string') 
+        return sha512(plainString)
+    return ""
+}

package/ts/funcs/promiseTimeout.test.js

@@ -0,0 +1,104 @@
+const { promiseTimeout } = require('./promiseTimeout');
+
+describe('promiseTimeout', () => {
+
+  // Returns a promise that resolves when inputPromise resolves before the timeout.
+  it('should resolve when inputPromise resolves before the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise((resolve) => {
+      setTimeout(() => {
+        resolve('Resolved');
+      }, 100);
+    });
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).resolves.toBe('Resolved');
+  });
+
+  // Returns a promise that rejects with onTimeout when inputPromise rejects after the timeout.
+  it('should reject with onTimeout when inputPromise rejects after the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise((resolve, reject) => {
+      setTimeout(() => {
+        reject('Rejected');
+      }, 200);
+    });
+
+    // Act
+    const resultPromise = promiseTimeout(100, inputPromise);
+
+    // Assert
+    return expect(resultPromise).rejects.toBe('TIMEDOUT');
+  });
+
+  // Returns a promise that rejects with onTimeout when inputPromise is pending after the timeout.
+  it('should reject with onTimeout when inputPromise is pending after the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise(() => { });
+
+    // Act
+    const resultPromise = promiseTimeout(100, inputPromise);
+
+    // Assert
+    return expect(resultPromise).rejects.toBe('TIMEDOUT');
+  });
+
+  // Returns a promise that resolves with inputPromise value when inputPromise resolves before the timeout.
+  it('should resolve with inputPromise value when inputPromise resolves before the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise((resolve) => {
+      setTimeout(() => {
+        resolve('Resolved');
+      }, 100);
+    });
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).resolves.toBe('Resolved');
+  });
+
+  // Returns a promise that rejects with inputPromise value when inputPromise rejects before the timeout.
+  it('should reject with inputPromise value when inputPromise rejects before the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise((resolve, reject) => {
+      setTimeout(() => {
+        reject('Rejected');
+      }, 100);
+    });
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).rejects.toBe('Rejected');
+  });
+
+  // Returns a promise that rejects with inputPromise value when inputPromise is pending before the timeout.
+  it('should reject with inputPromise value when inputPromise is pending before the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise(() => { });
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).rejects.toBe('TIMEDOUT');
+  });
+
+  // Returns a promise that resolves with undefined when inputPromise is undefined.
+  it('should resolve with undefined when inputPromise is undefined', () => {
+    // Arrange
+    const inputPromise = undefined;
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).resolves.toBe(undefined);
+  });
+});

package/ts/funcs/promiseTimeout.ts

@@ -0,0 +1,19 @@
+
+
+
+
+export function promiseTimeout(miliseconds:number, inputPromise:Promise<any>, onTimeout:any='TIMEDOUT') { // ported
+    // Create a promise that rejects in <miliseconds> milliseconds
+    let timeout = new Promise((resolve, reject) => {
+        let stID = setTimeout(() => {
+            clearTimeout(stID);
+            reject(onTimeout)
+        }, miliseconds)
+    })
+
+    // Returns a race between our timeout and the passed in promise
+    return Promise.race([
+        inputPromise,
+        timeout
+    ])
+}

package/ts/funcs/vaultFill.js

@@ -0,0 +1,96 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultFill = void 0;
+const debug_1 = require("debug");
+const vaultRead_1 = require("./vaultRead");
+const dbg = (0, debug_1.debug)('vaultFill');
+function vaultFill(vaultInstance, inputObject, ignoreError = false, keepCache = true) {
+    // v2.1
+    // fills all strings with ^vault@/secret/... with proper vault values
+    // if you call it again, it does reload the configuration
+    // v2.2 
+    // supports keepCache - if vault fails, we will keep previous values instead of filling with false
+    return new Promise(function (resolve, reject) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let vaultKeys = Array();
+            let vaultResults = {};
+            findVaultKeyMappings(inputObject, vaultKeys);
+            // read these keys from vault
+            for (let idx in vaultKeys) {
+                const val = vaultKeys[idx];
+                if (typeof val !== "string")
+                    continue;
+                try {
+                    let got = yield (0, vaultRead_1.vaultRead)(vaultInstance, vaultKeys[idx]);
+                    got['__vaultkey'] = val;
+                    got['__vaultfilled'] = Date.now();
+                    vaultResults[val] = got;
+                }
+                catch (err) {
+                    dbg(`Could not read vaultKey '${val}'`, err);
+                    if (!ignoreError)
+                        vaultResults[val] = false;
+                }
+            }
+            fillVaultKeyMappings(inputObject, vaultResults, keepCache);
+            resolve(true);
+        });
+    });
+}
+exports.vaultFill = vaultFill;
+function findVaultKeyMappings(config, keys = Array()) {
+    for (var i in config) {
+        if (config[i] !== null) {
+            if (typeof config[i] === 'object' && (config[i].constructor.name === 'Array' || config[i].constructor.name === 'Object'))
+                findVaultKeyMappings(config[i], keys);
+            // detect previously read vaultKey
+            if (i === '__vaultkey') {
+                if (!keys.includes(vaultKey))
+                    keys.push(config[i]);
+                continue;
+            }
+            // --
+            if (typeof config[i] === 'string' && config[i].search(/^vault@/) == 0) {
+                var splitted = config[i].split(/vault@/);
+                if (splitted.length == 2) {
+                    var vaultKey = splitted[1];
+                    if (!keys.includes(vaultKey))
+                        keys.push(vaultKey);
+                }
+            }
+        }
+    }
+}
+function fillVaultKeyMappings(config, vaultResults, keepCache = true) {
+    for (var i in config) {
+        if (config[i] !== null) {
+            if (config[i] && config[i].constructor.name === 'Object' && config[i].hasOwnProperty('__vaultkey')) {
+                if (keepCache) {
+                    if (vaultResults[config[i]['__vaultkey']])
+                        config[i] = vaultResults[config[i]['__vaultkey']];
+                }
+                else
+                    config[i] = vaultResults[config[i]['__vaultkey']];
+                continue;
+            }
+            if (typeof config[i] === 'object' && (config[i].constructor.name === 'Array' || config[i].constructor.name === 'Object'))
+                fillVaultKeyMappings(config[i], vaultResults);
+            if (typeof config[i] === 'string' && config[i].search(/^vault@/) == 0) {
+                var splitted = config[i].split(/vault@/);
+                if (splitted.length == 2) {
+                    var vaultKey = splitted[1];
+                    config[i] = vaultResults[vaultKey];
+                }
+            }
+        }
+    }
+}

package/ts/funcs/vaultFill.ts

@@ -0,0 +1,89 @@
+import { debug } from "debug"
+import nodeVault from "node-vault";
+import { vaultRead } from "./vaultRead";
+const dbg = debug('vaultFill')
+
+export function vaultFill(vaultInstance: nodeVault.client, inputObject: any, ignoreError = false, keepCache = true) {
+    // v2.1
+    // fills all strings with ^vault@/secret/... with proper vault values
+    // if you call it again, it does reload the configuration
+    // v2.2 
+    // supports keepCache - if vault fails, we will keep previous values instead of filling with false
+    return new Promise(async function (resolve, reject) {
+        let vaultKeys = Array<string>()
+        let vaultResults: any = {}
+        findVaultKeyMappings(inputObject, vaultKeys)
+
+        // read these keys from vault
+        for (let idx in vaultKeys) {
+            const val = vaultKeys[idx]
+            if (typeof val !== "string") continue
+
+            try {
+                let got = await vaultRead(vaultInstance, vaultKeys[idx])
+                got['__vaultkey'] = val
+                got['__vaultfilled'] = Date.now()
+                vaultResults[val]=got
+            }
+            catch (err) {
+
+                dbg(`Could not read vaultKey '${val}'`, err)
+                if (!ignoreError) vaultResults[val]=false
+            }
+        }
+
+        fillVaultKeyMappings(inputObject, vaultResults, keepCache)
+
+        resolve(true)
+    })
+}
+
+
+function findVaultKeyMappings(config: any, keys = Array<string>()) {
+    for (var i in config) {
+        if (config[i] !== null) {
+            if (typeof config[i] === 'object' && (config[i].constructor.name === 'Array' || config[i].constructor.name === 'Object'))
+                findVaultKeyMappings(config[i], keys)
+
+            // detect previously read vaultKey
+            if (i === '__vaultkey') {
+                if (!keys.includes(vaultKey)) keys.push(config[i])
+                continue
+            }
+            // --
+            if (typeof config[i] === 'string' && config[i].search(/^vault@/) == 0) {
+                var splitted = config[i].split(/vault@/)
+                if (splitted.length == 2) {
+                    var vaultKey = splitted[1]
+                    if (!keys.includes(vaultKey)) keys.push(vaultKey)
+                }
+            }
+        }
+    }
+}
+
+function fillVaultKeyMappings(config: any, vaultResults:any, keepCache = true) {
+    for (var i in config) {
+        if (config[i] !== null) {
+
+            if (config[i] && config[i].constructor.name === 'Object' && config[i].hasOwnProperty('__vaultkey')) {
+                if (keepCache) {
+                    if (vaultResults[config[i]['__vaultkey']]) config[i] = vaultResults[config[i]['__vaultkey']]
+                }
+
+                else
+                    config[i] = vaultResults[config[i]['__vaultkey']]
+                continue
+            }
+            if (typeof config[i] === 'object' && (config[i].constructor.name === 'Array' || config[i].constructor.name === 'Object'))
+                fillVaultKeyMappings(config[i], vaultResults)
+            if (typeof config[i] === 'string' && config[i].search(/^vault@/) == 0) {
+                var splitted = config[i].split(/vault@/)
+                if (splitted.length == 2) {
+                    var vaultKey = splitted[1]
+                    config[i] = vaultResults[vaultKey]
+                }
+            }
+        }
+    }
+}

package/ts/funcs/vaultRead.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultRead = void 0;
+const debug_1 = require("debug");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const node_fs_1 = require("node:fs");
+const fileCacheIsValid_1 = require("./fileCacheIsValid");
+const global_1 = require("../global");
+const hash_sha512_1 = require("./hash_sha512");
+const dbg = (0, debug_1.debug)('vaultRead');
+// need to implement it better
+function vaultRead(vaultInstance, vaultKey, cache_in_minutes = 10) {
+    // v2 - supports caching
+    return new Promise((resolve, reject) => {
+        let cache_file = path_1.default.join(global_1.vault_cache_folder, (0, hash_sha512_1.hash_sha512)(`${vaultInstance.endpoint}/${vaultKey}`));
+        if (cache_in_minutes > 0 && (0, fileCacheIsValid_1.fileCacheIsValid)(cache_file, cache_in_minutes))
+            return resolve(JSON.parse((0, node_fs_1.readFileSync)(cache_file).toString()));
+        vaultInstance.read(vaultKey).then((r) => {
+            if (r.data) {
+                dbg(`vault ${vaultKey} - success`);
+                if (cache_in_minutes > 0)
+                    try {
+                        fs_1.default.writeFileSync(cache_file, JSON.stringify(r.data));
+                        fs_1.default.chmodSync(cache_file, 0o600);
+                    }
+                    catch (_) { }
+                return resolve(r.data);
+            }
+            dbg(`vault ${vaultKey} - failed`);
+            reject(r);
+        }).catch(e => {
+            dbg(`exception inside vaultRead`, e);
+            // we will still return latest information from cache
+            try {
+                dbg(`returning vault@${vaultKey} from cache due to error`);
+                if (fs_1.default.existsSync(cache_file))
+                    return resolve(JSON.parse(fs_1.default.readFileSync(cache_file).toString()));
+            }
+            catch (e2) {
+                // content of the file is invalid
+                console.log(e2);
+            }
+            reject(e);
+        });
+    });
+}
+exports.vaultRead = vaultRead;

package/ts/funcs/vaultRead.ts

@@ -0,0 +1,45 @@
+import { debug } from "debug"
+import nodeVault from "node-vault";
+import path from "path";
+import fs from "fs";
+import { readFileSync } from 'node:fs';
+import { fileCacheIsValid } from "./fileCacheIsValid";
+import { vault_cache_folder } from "../global";
+import { hash_sha512 } from "./hash_sha512";
+const dbg = debug('vaultRead')
+
+// need to implement it better
+
+export function vaultRead(vaultInstance: nodeVault.client, vaultKey: string, cache_in_minutes = 10) : Promise<any> {
+    // v2 - supports caching
+    return new Promise((resolve, reject) => {
+        let cache_file = path.join(vault_cache_folder, hash_sha512(`${vaultInstance.endpoint}/${vaultKey}`))
+
+        if (cache_in_minutes > 0 && fileCacheIsValid(cache_file, cache_in_minutes))
+            return resolve(JSON.parse(readFileSync(cache_file as string).toString()))
+
+        vaultInstance.read(vaultKey).then((r) => {
+            if (r.data) {
+                dbg(`vault ${vaultKey} - success`)
+                if (cache_in_minutes > 0)
+                    try { fs.writeFileSync(cache_file, JSON.stringify(r.data)); fs.chmodSync(cache_file, 0o600); } catch (_) { }
+                return resolve(r.data);
+            }
+            dbg(`vault ${vaultKey} - failed`)
+            reject(r);
+        }).catch(e => {
+            dbg(`exception inside vaultRead`, e)
+            // we will still return latest information from cache
+            try {
+                dbg(`returning vault@${vaultKey} from cache due to error`)
+                if (fs.existsSync(cache_file))
+                    return resolve(JSON.parse(fs.readFileSync(cache_file as string).toString()))
+            } catch (e2) {
+                // content of the file is invalid
+                console.log(e2)
+            }
+
+            reject(e);
+        })
+    })
+}

package/ts/funcs/wait.d.ts

@@ -0,0 +1 @@
+export declare function wait(seconds?: number): Promise<void>;

package/ts/funcs/wait.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wait = void 0;
+function wait(seconds = 1) {
+    return new Promise((resolve, reject) => {
+        setTimeout(resolve, seconds * 1000);
+    });
+}
+exports.wait = wait;

package/ts/funcs/wait.ts

@@ -0,0 +1,7 @@
+
+
+export function wait(seconds=1) : Promise<void> {
+    return new Promise((resolve,reject)=>{
+      setTimeout(resolve,seconds*1000)
+    })
+}

package/ts/global.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vault_cache_folder = void 0;
+const fs_1 = __importDefault(require("fs"));
+exports.vault_cache_folder = '/var/tmp/vault-cache';
+try {
+    if (!fs_1.default.existsSync(exports.vault_cache_folder))
+        fs_1.default.mkdirSync(exports.vault_cache_folder);
+}
+catch (e) {
+    console.log(e);
+}

package/ts/global.ts

@@ -0,0 +1,10 @@
+import fs from 'fs'
+
+export let vault_cache_folder = '/var/tmp/vault-cache'
+
+try {
+    if (!fs.existsSync(vault_cache_folder)) 
+    fs.mkdirSync(vault_cache_folder)
+} catch(e) {
+    console.log(e)
+}

package/ts/index.d.ts

@@ -3,3 +3,4 @@ export * from "./funcs/isLocal";
 export * from "./funcs/randomString";
 export * from "./funcs/utcnow";
 export * from "./funcs/validIp";
+export * from "./funcs/wait";

package/ts/index.js

@@ -19,3 +19,8 @@ __exportStar(require("./funcs/isLocal"), exports);
 __exportStar(require("./funcs/randomString"), exports);
 __exportStar(require("./funcs/utcnow"), exports);
 __exportStar(require("./funcs/validIp"), exports);
+__exportStar(require("./funcs/wait"), exports);
+__exportStar(require("./funcs/fileCacheIsValid"), exports);
+__exportStar(require("./funcs/hash_sha512"), exports);
+__exportStar(require("./funcs/vaultRead"), exports);
+__exportStar(require("./funcs/vaultFill"), exports);

package/ts/index.test.ts

@@ -1,9 +1,7 @@
 import * as IMPORTS from "./index";
 
 test('exports', () => {
-    expect(typeof IMPORTS.Geoip2Paths).toBe('function')
-    expect(typeof IMPORTS.isLocal).toBe('function')
-    expect(typeof IMPORTS.randomString).toBe('function')
-    expect(typeof IMPORTS.utcnow).toBe('function')
-    expect(typeof IMPORTS.validIp).toBe('function')
+    for(let fn of Object.values(IMPORTS)) {
+        expect(typeof fn).toBe('function')
+    }
 })

package/ts/index.ts

@@ -3,4 +3,10 @@ export * from "./funcs/isLocal"
 export * from "./funcs/randomString"
 export * from "./funcs/utcnow"
 export * from "./funcs/validIp"
-
+export * from "./funcs/wait"
+export * from "./funcs/fileCacheIsValid"
+export * from "./funcs/hash_sha512"
+export * from "./funcs/vaultRead"
+export * from "./funcs/vaultFill"
+export * from "./funcs/asJSON"
+export * from "./funcs/promiseTimeout"