mybase 1.0.51 → 1.1.2

package/README.md

@@ -1,5 +1,12 @@
-# mybase
+# Typescript support is being added
+adding them slowly to the project
+```
+import { utcnow } from 'mybase/ts'
+// types 
+import { UnixtimeShort } from 'mybase/ts/types'
+```
 
+# mybase
 ```
 var { isLocal } = require('mybase')
 ```

package/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

package/mybase.js

@@ -112,11 +112,11 @@ function arrayRandomItem(arry,defaultValue=false) {
     return defaultValue
 }
 
-function utcnow() {
+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]+)$/)) {
@@ -130,7 +130,7 @@ function validIp(str) {
     return false
 }
 
-function Geoip2Paths() {
+function Geoip2Paths() { // ported
     function firstExisting(paths) {
         if (Array.isArray(paths))
             for(let fpath of paths)
@@ -263,7 +263,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
@@ -363,7 +363,7 @@ function maxmindOpen(geoipFile) {
     })
 }
 
-function isLocal() {
+function isLocal() { // ported
     return (os.type() === 'Darwin')
 }
 
@@ -440,7 +440,7 @@ function object_shuffle(object) {
 
 
 
-function randomString(length = 10, charSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") {
+function randomString(length = 10, charSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") { // ported
     var text = "";
     for (var i = 0; i < length; i++)
         text += charSet.charAt(Math.floor(Math.random() * charSet.length));
@@ -557,7 +557,7 @@ function sqlQuery(sqlHandle,query,values=[]) {
    })
 }
 
-function wait(seconds=1){
+function wait(seconds=1){ // ported
     return new Promise((resolve,reject)=>{
       setTimeout(resolve,seconds*1000)  
     })

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "mybase",
-  "version": "1.0.51",
+  "version": "1.1.2",
   "description": "",
   "main": "mybase.js",
   "scripts": {
-    "test": "node_modules/mocha/bin/mocha tests/*.js --exit"
+    "test": "jest"
   },
   "author": "",
   "license": "ISC",
@@ -12,19 +12,25 @@
     "@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",
     "jest": "^29.7.0",
     "mocha": "^8.2.1",
-    "should": "^13.2.3"
+    "should": "^13.2.3",
+    "ts-jest": "^29.1.1"
   }
 }

package/ts/funcs/Geoip2Paths.d.ts

@@ -0,0 +1,7 @@
+export type Geoip2Paths = {
+    country: string | false;
+    city: string | false;
+    isp: string | false;
+    ct: string | false;
+};
+export declare function Geoip2Paths(): Geoip2Paths;

package/ts/funcs/Geoip2Paths.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Geoip2Paths = void 0;
+const fs = require("fs");
+const path = require("path");
+function Geoip2Paths() {
+    var _a, _b, _c, _d;
+    function firstExisting(paths) {
+        if (Array.isArray(paths))
+            for (let fpath of paths)
+                if (fs.existsSync(fpath))
+                    return fpath;
+        return false;
+    }
+    return {
+        country: firstExisting(['/opt/geoip2/GeoIP2-Country.mmdb', '/usr/local/var/GeoIP/GeoIP2-Country.mmdb', '/var/lib/GeoIP/GeoIP2-Country.mmdb', '/usr/share/GeoIP/GeoIP2-Country.mmdb', path.join(__dirname, 'assets/GeoIP2-Country.mmdb'), path.join(((_a = require === null || require === void 0 ? void 0 : require.main) === null || _a === void 0 ? void 0 : _a.path) || __dirname, 'assets/GeoIP2-Country.mmdb')]),
+        city: firstExisting(['/opt/geoip2/GeoIP2-City.mmdb', '/usr/local/var/GeoIP/GeoIP2-City.mmdb', '/var/lib/GeoIP/GeoIP2-City.mmdb', '/usr/share/GeoIP/GeoIP2-City.mmdb', path.join(__dirname, 'assets/GeoIP2-City.mmdb'), path.join(((_b = require === null || require === void 0 ? void 0 : require.main) === null || _b === void 0 ? void 0 : _b.path) || __dirname, 'assets/GeoIP2-City.mmdb')]),
+        isp: firstExisting(['/opt/geoip2/GeoIP2-ISP.mmdb', '/usr/local/var/GeoIP/GeoIP2-ISP.mmdb', '/var/lib/GeoIP/GeoIP2-ISP.mmdb', '/usr/share/GeoIP/GeoIP2-ISP.mmdb', path.join(__dirname, 'assets/GeoIP2-ISP.mmdb'), path.join(((_c = require === null || require === void 0 ? void 0 : require.main) === null || _c === void 0 ? void 0 : _c.path) || __dirname, 'assets/GeoIP2-ISP.mmdb')]),
+        ct: firstExisting(['/opt/geoip2/GeoIP2-Connection-Type.mmdb', '/usr/local/var/GeoIP/GeoIP2-Connection-Type.mmdb', '/var/lib/GeoIP/GeoIP2-Connection-Type.mmdb', '/usr/share/GeoIP/GeoIP2-Connection-Type.mmdb', path.join(__dirname, 'assets/GeoIP2-Connection-Type.mmdb'), path.join(((_d = require === null || require === void 0 ? void 0 : require.main) === null || _d === void 0 ? void 0 : _d.path) || __dirname, 'assets/GeoIP2-Connection-Type.mmdb')]),
+    };
+}
+exports.Geoip2Paths = Geoip2Paths;

package/ts/funcs/Geoip2Paths.test.ts

@@ -0,0 +1,11 @@
+import { Geoip2Paths } from './Geoip2Paths'
+import * as fs from 'fs'
+
+describe('Geoip2Paths', () => {
+  it('should return a valid path', () => {
+    const paths = Geoip2Paths()
+    expect(paths).toHaveProperty('country')
+    expect(typeof paths.country).toBe('string')
+    expect(fs.existsSync(paths.country as string)).toBe(true)
+  })
+})

package/ts/funcs/Geoip2Paths.ts

@@ -0,0 +1,26 @@
+import fs = require('fs')
+import path = require('path')
+
+export type Geoip2Paths = {
+    country:string|false,
+    city:string|false,
+    isp:string|false,
+    ct:string|false,
+}
+
+
+export function Geoip2Paths() :Geoip2Paths {
+    function firstExisting(paths:Array<string>) : string|false {
+        if (Array.isArray(paths))
+            for(let fpath of paths)
+                if (fs.existsSync(fpath)) return fpath
+        return false
+    }
+
+    return {
+        country:firstExisting(['/opt/geoip2/GeoIP2-Country.mmdb','/usr/local/var/GeoIP/GeoIP2-Country.mmdb','/var/lib/GeoIP/GeoIP2-Country.mmdb','/usr/share/GeoIP/GeoIP2-Country.mmdb',path.join(__dirname, 'assets/GeoIP2-Country.mmdb'),path.join(require?.main?.path || __dirname, 'assets/GeoIP2-Country.mmdb')]),
+        city:firstExisting(['/opt/geoip2/GeoIP2-City.mmdb','/usr/local/var/GeoIP/GeoIP2-City.mmdb','/var/lib/GeoIP/GeoIP2-City.mmdb','/usr/share/GeoIP/GeoIP2-City.mmdb',path.join(__dirname, 'assets/GeoIP2-City.mmdb'),path.join(require?.main?.path || __dirname, 'assets/GeoIP2-City.mmdb')]),
+        isp:firstExisting(['/opt/geoip2/GeoIP2-ISP.mmdb','/usr/local/var/GeoIP/GeoIP2-ISP.mmdb','/var/lib/GeoIP/GeoIP2-ISP.mmdb','/usr/share/GeoIP/GeoIP2-ISP.mmdb',path.join(__dirname, 'assets/GeoIP2-ISP.mmdb'),path.join(require?.main?.path || __dirname, 'assets/GeoIP2-ISP.mmdb')]),
+        ct:firstExisting(['/opt/geoip2/GeoIP2-Connection-Type.mmdb','/usr/local/var/GeoIP/GeoIP2-Connection-Type.mmdb','/var/lib/GeoIP/GeoIP2-Connection-Type.mmdb','/usr/share/GeoIP/GeoIP2-Connection-Type.mmdb',path.join(__dirname, 'assets/GeoIP2-Connection-Type.mmdb'),path.join(require?.main?.path || __dirname, 'assets/GeoIP2-Connection-Type.mmdb')]),
+    }
+}

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/isLocal.d.ts

@@ -0,0 +1 @@
+export declare function isLocal(): boolean;

package/ts/funcs/isLocal.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocal = void 0;
+const os_1 = __importDefault(require("os"));
+function isLocal() {
+    return (os_1.default.type() === 'Darwin');
+}
+exports.isLocal = isLocal;

package/ts/funcs/isLocal.test.ts

@@ -0,0 +1,16 @@
+import { isLocal } from './isLocal';
+import os from 'os';
+
+describe('isLocal', () => {
+  it('should return true on Darwin OS', () => {
+    jest.spyOn(os, 'type').mockReturnValue('Darwin');
+    const result = isLocal();
+    expect(result).toBe(true);
+  });
+
+  it('should return false on non-Darwin OS', () => {
+    jest.spyOn(os, 'type').mockReturnValue('Linux');
+    const result = isLocal();
+    expect(result).toBe(false);
+  });
+});

package/ts/funcs/isLocal.ts

@@ -0,0 +1,5 @@
+import os from  'os'
+
+export function isLocal() : boolean {
+    return (os.type() === 'Darwin')
+}

package/ts/funcs/randomString.d.ts

@@ -0,0 +1 @@
+export declare function randomString(length?: number, charSet?: string): string;

package/ts/funcs/randomString.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomString = void 0;
+function randomString(length = 10, charSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") {
+    return Array.from({ length }, () => charSet.charAt(Math.floor(Math.random() * charSet.length))).join('');
+}
+exports.randomString = randomString;

package/ts/funcs/randomString.test.ts

@@ -0,0 +1,15 @@
+import { randomString } from "./randomString";
+
+test('randomString', () => {
+    // Test default length and character set
+    expect(randomString()).toHaveLength(10);
+    expect(randomString()).toMatch(/^[A-Za-z0-9]{10}$/);
+
+    // Test custom length and character set
+    expect(randomString(5, "abc")).toHaveLength(5);
+    expect(randomString(5, "abc")).toMatch(/^[abc]{5}$/);
+
+    // Test empty character set
+    expect(randomString(10, "")).toHaveLength(0);
+    expect(randomString(10, "")).toMatch(/^$/);
+});

package/ts/funcs/randomString.ts

@@ -0,0 +1,5 @@
+
+
+export function randomString(length = 10, charSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"): string {
+    return Array.from({ length }, () => charSet.charAt(Math.floor(Math.random() * charSet.length))).join('');
+}

package/ts/funcs/utcnow.d.ts

@@ -0,0 +1,2 @@
+import { UnixtimeShort } from '../types';
+export declare function utcnow(): UnixtimeShort;

package/ts/funcs/utcnow.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utcnow = void 0;
+function utcnow() {
+    return Math.floor(Date.now() / 1000);
+}
+exports.utcnow = utcnow;

package/ts/funcs/utcnow.ts

@@ -0,0 +1,5 @@
+import { UnixtimeShort } from '../types'
+
+export function utcnow() : UnixtimeShort  {
+    return Math.floor(Date.now() / 1000)
+}

package/ts/funcs/validIp.d.ts

@@ -0,0 +1 @@
+export declare function validIp(IPAddress: string): number;

package/ts/funcs/validIp.js

@@ -0,0 +1,31 @@
+"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.validIp = void 0;
+const net = __importStar(require("net"));
+function validIp(IPAddress) {
+    return net.isIP(IPAddress);
+}
+exports.validIp = validIp;

package/ts/funcs/validIp.test.ts

@@ -0,0 +1,33 @@
+import { validIp } from './validIp';
+
+describe('validIp', () => {
+  it('should return true for a valid IP address', () => {
+    const ipAddress = '192.168.0.1';
+    const result = validIp(ipAddress);
+    expect(result).toBe(4);
+  });
+
+  it('should return false for an invalid IP address', () => {
+    const ipAddress = '256.0.0.1';
+    const result = validIp(ipAddress);
+    expect(result).toBe(0);
+  });
+
+  it('should support IPv6', () => {
+    const ipAddress = '2001:0db8:85a3:0000:0000:8a2e:0370:7334';
+    const result = validIp(ipAddress);
+    expect(result).toBe(6);
+  })
+
+  it('invalid IPv6', () => {
+    const ipAddress = '2001:0db8:85a3:0000:0000:8a2e:0370:7334:0000';
+    const result = validIp(ipAddress);
+    expect(result).toBe(0);
+  })
+
+  it('should support IPv6 shorthand', () => {
+    const ipAddress = '2001:db8:85a3::8a2e:370:7334';
+    const result = validIp(ipAddress);
+    expect(result).toBe(6);
+  })
+})

package/ts/funcs/validIp.ts

@@ -0,0 +1,5 @@
+import * as net from 'net'
+
+export function validIp(IPAddress: string): number {
+    return net.isIP(IPAddress)
+}

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

@@ -0,0 +1,6 @@
+export * from "./funcs/Geoip2Paths";
+export * from "./funcs/isLocal";
+export * from "./funcs/randomString";
+export * from "./funcs/utcnow";
+export * from "./funcs/validIp";
+export * from "./funcs/wait";

package/ts/index.js

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./funcs/Geoip2Paths"), exports);
+__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

@@ -0,0 +1,7 @@
+import * as IMPORTS from "./index";
+
+test('exports', () => {
+    for(let key in IMPORTS) {
+        expect(typeof IMPORTS[key]).toBe('function')
+    }
+})

package/ts/index.ts

@@ -0,0 +1,10 @@
+export * from "./funcs/Geoip2Paths";
+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"

package/ts/types.d.ts

@@ -0,0 +1 @@
+export type UnixtimeShort = number;

package/ts/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/ts/types.ts

@@ -0,0 +1 @@
+export type UnixtimeShort = number

package/tsconfig.json

@@ -0,0 +1,113 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+    
+  },
+  "exclude": [
+    "**/*.test.ts",
+  ]
+}