mybase 1.2.2 → 2.0.0

package/ts/funcs/promiseTimeout.test.js

@@ -1,104 +0,0 @@
-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

@@ -1,19 +0,0 @@
-
-
-
-
-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/randomIP.test.ts

@@ -1,16 +0,0 @@
-import { randomIP } from './randomIP';
-
-describe('randomIP', () => {
-  it('should return a valid IP address', () => {
-    for(let i=0; i<1000; i++) {
-        const ipAddress = randomIP();
-        const ipParts = ipAddress.split('.');
-        expect(ipParts.length).toBe(4);
-        ipParts.forEach((part) => {
-          const partInt = parseInt(part);
-          expect(partInt).toBeGreaterThanOrEqual(0);
-          expect(partInt).toBeLessThanOrEqual(255);
-        });
-    }
-  });
-});

package/ts/funcs/randomIP.ts

@@ -1,10 +0,0 @@
-
-export function randomIP() : string {
-    function int2ip (ipInt: number) {
-        return ( (ipInt>>>24) +'.' + (ipInt>>16 & 255) +'.' + (ipInt>>8 & 255) +'.' + (ipInt & 255) );
-    }
-    return int2ip(Math.random()*Math.pow(2,32))
-}
-
-
-

package/ts/funcs/randomIP6.test.js

@@ -1,18 +0,0 @@
-const ip6 = require('ip6');
-const { randomIP6 } = require('./randomIP6');
-
-describe('randomIP6', () => {
-  it('should generate a random IPv6 address', () => {
-    const result = randomIP6();
-    expect(()=>ip6.normalize(result)).not.toThrow()
-    expect(()=>ip6.abbreviate(result)).not.toThrow()
-  });
-
-  it('generate 100 ipv6', () => {
-    for (let i = 0; i < 100; i++) {
-      const result = randomIP6();
-      expect(()=>ip6.normalize(result)).not.toThrow()
-      expect(()=>ip6.abbreviate(result)).not.toThrow()
-    }
-  })
-});

package/ts/funcs/randomIP6.ts

@@ -1,12 +0,0 @@
-import { randomBytes } from "crypto"
-// const ip6 = require('ip6')
-//@ts-ignore
-import ip6 from 'ip6'
-
-export function randomIP6() : string {
-    const bytes = randomBytes(16)
-    return ip6.abbreviate(ip6.normalize(bytes.toString('hex').match(/.{1,4}/g)?.join(':') || '0000:0000:0000:0000:0000:0000:0000:0000'))
-}
-
-
-

package/ts/funcs/randomString.test.ts

@@ -1,15 +0,0 @@
-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

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

package/ts/funcs/randomTCPPort.test.ts

@@ -1,62 +0,0 @@
-import { wait } from "./wait";
-import { randomTCPPort } from "./randomTCPPort";
-
-
-describe("randomTCPPort", () => {
-  let fromPort = 15000;
-  let untilPort = fromPort+1000;
-  let hostToBind="127.0.0.1"
-
-  beforeEach(() => {
-    untilPort = fromPort+1000;
-  })
-
-  test("should return a random port number within the given range", async () => {
-    const port = await randomTCPPort(1000, fromPort, untilPort, 1000, hostToBind);
-    expect(port).toBeGreaterThanOrEqual(fromPort);
-    expect(port).toBeLessThanOrEqual(untilPort);
-  });
-
-  test("should return false if no available port is found", async () => {
-    untilPort = fromPort+1;
-    // listen to the port 15000 and 15001 to simulate that these ports are in use
-    const server1 = require("net").createServer();
-    const server2 = require("net").createServer();
-    server1.listen(fromPort, hostToBind);
-    server2.listen(untilPort, hostToBind);
-    // try to find a port within the range
-    const port = await randomTCPPort(1000, fromPort, untilPort, 1000, hostToBind);
-    expect(port).toBe(false);
-    server1.close();
-    server2.close();
-    await wait(1/100)
-    const port2 = await randomTCPPort(1000, fromPort, untilPort, 1000, hostToBind);
-    expect(port2===fromPort || port2===untilPort).toBe(true);
-  });
-
-  test("should handle errors when trying to listen to a port", async () => {
-    const port = await randomTCPPort(1000, fromPort, untilPort, 1000, "invalid-host");
-    expect(port).toBe(false);
-  })
-
-  test("should return false if the given port range is invalid", async () => {
-    const port = await randomTCPPort(1000, untilPort, fromPort, 1000, hostToBind);
-    expect(port).toBe(false);
-  });
-
-  test("should return false if the given port range is invalid", async () => {
-    const port = await randomTCPPort(1000, -1, untilPort, 1000, hostToBind);
-    expect(port).toBe(false);
-  });
-
-  test("should return false if the given port range is invalid", async () => {
-    const port = await randomTCPPort(1000, fromPort, -1, 1000, hostToBind);
-    expect(port).toBe(false);
-  });
-
-  test("should return false if the given port range is invalid", async () => {
-    const port = await randomTCPPort(1000, fromPort, 65536, 1000, hostToBind);
-    expect(port).toBe(false);
-  });
-
-})

package/ts/funcs/randomTCPPort.ts

@@ -1,58 +0,0 @@
-import * as net from 'net'
-
-/**
- * This function returns a random port number that is not in use and we should validate this port number by trying to listen to it and releasing
- * this port number immediately
- * This function should be used for testing purposes only
- * This function is not suitable for production use
- * @param timeout the timeout for each port check
- * @param fromPort the first port number to check defaults to 1025
- * @param untilPort the last port number to check defaults to 65534
- * @param tries the number of tries to find a port number
- * @param host the host to bind to
- */
-export async function randomTCPPort(timeout: number = 1000, fromPort: number = 1025, untilPort: number = 65534, tries = 1000, host = '127.0.0.1'): Promise<number | false> {
-    return new Promise(async function (resolve, reject) {
-        // check if the given port range is valid
-        if (fromPort > untilPort) return resolve(false)
-        // check if the given port range is valid
-        if (fromPort < 0 || untilPort < 0) return resolve(false)
-        // check if the given port range is valid
-        if (fromPort > 65535 || untilPort > 65535) return resolve(false)
-
-        // this function shall return a random port number that is not in use and we should validate this port number by trying to listen to it and releasing
-        // this port number immediately
-        // this function should be used for testing purposes only
-        // this function is not suitable for production use
-        while(true && tries > 0) {
-            tries--
-            let port = Math.floor(Math.random() * (untilPort - fromPort + 1) + fromPort)
-            let server = net.createServer()
-            let checkPort = new Promise((resolveInner, reject) => {
-                server.on('error', (err) => {
-                    // any error should raise problem
-                    resolveInner(false)
-                })
-                server.on('listening', () => {
-                    resolveInner(true)
-                })
-            })
-            server.listen(port, host)
-            let result = await checkPort
-            if (result) {
-                let to = setTimeout(() => {
-                    return resolve(port)
-                },1000)
-                server.on('close', () => {
-                    clearTimeout(to)
-                    return resolve(port)
-                })
-                server.close()
-                return
-            } else server.close()
-        }
-        if (tries===0) 
-            return resolve(false)
-    })
-
-}

package/ts/funcs/randomUTFString.test.ts

@@ -1,44 +0,0 @@
-import { randomUTFString } from './randomUTFString';
-
-describe('randomUTFString', () => {
-    const asciiCharacters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-    let extendedCharset =
-        'àáâãäåæçèéêëìíîïðñòóôõöøùúûüýÿ' + // Accented Latin characters
-        'ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩαβγδεζηθικλμνξοπρσςτυφχψω' + // Greek
-        'אבגדהוזחטיךכלםמןנסעפצקרשת' + // Hebrew
-        //Arabic
-        'ا ب ت ث ج ح خ د ذ ر ز س ش ص ض ط ظ ع غ ف ق ك ل م ن ه و ي' +
-        // Persian
-        'آ ا ب پ ت ث ج چ ح خ د ذ ر ز ژ س ش ص ض ط ظ ع غ ف ق ک گ ل م ن و ه ی' +
-        // Turkish
-        'a b c ç d e f g ğ h ı i j k l m n o ö p r s ş t u ü v y z' +
-        'A B C Ç D E F G Ğ H I İ J K L M N O Ö P R S Ş T U Ü V Y Z' +
-        // More Emojis
-        '🙂🤔😍😂👍🚀❤️🎉' +
-        'абвгдежзийклмнопрстуфхцчшщъыьэюя' + // Cyrillic (Russian, etc.)
-        '日本語中文한국어' + // Japanese, Chinese, Korean characters
-        '🙂🤔😍😂👍🚀❤️🎉' // Emojis
-    it('should generate a random string within the specified length range', () => {
-        const minLength = 5;
-        const maxLength = 10;
-        const result = randomUTFString(minLength, maxLength);
-        expect(result.length).toBeGreaterThanOrEqual(minLength);
-        expect(result.length).toBeLessThanOrEqual(maxLength+1); // utf8 characters can be 1-4 bytes long
-    });
-
-    it('should include ASCII characters by default', () => {
-        const result = randomUTFString(500, 400);
-        
-        expect(result).toMatch(new RegExp(`[${asciiCharacters}]`));
-    });
-
-    it('should exclude ASCII characters when includeAscii is set to false', () => {
-        const result = randomUTFString(500, 1000, false);
-        expect(result).not.toMatch(new RegExp(`[${asciiCharacters}]`));
-    });
-
-    it('should include extended characters when includeAscii is set to true', () => {
-        const result = randomUTFString(500, 1000, true);
-        expect(result).toMatch(new RegExp(`[${extendedCharset}]`));
-    });
-});

package/ts/funcs/randomUTFString.ts

@@ -1,33 +0,0 @@
-
-
-
-export function randomUTFString(minLength: number, maxLength: number, includeAscii:boolean=true): string {
-    // Extended characters set including various languages and symbols
-    let characters = 
-        'àáâãäåæçèéêëìíîïðñòóôõöøùúûüýÿ' + // Accented Latin characters
-        'ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩαβγδεζηθικλμνξοπρσςτυφχψω' + // Greek
-        'אבגדהוזחטיךכלםמןנסעפצקרשת' + // Hebrew
-        //Arabic
-        'ا ب ت ث ج ح خ د ذ ر ز س ش ص ض ط ظ ع غ ف ق ك ل م ن ه و ي' +
-        // Persian
-        'آ ا ب پ ت ث ج چ ح خ د ذ ر ز ژ س ش ص ض ط ظ ع غ ف ق ک گ ل م ن و ه ی' +
-        // Turkish
-        'ğıöşü' +
-        'ĞİÖŞÜ ' +
-        // More Emojis
-        '🙂🤔😍😂👍🚀❤️🎉' +
-        'бвгдежзийклмнопрстуфхцчшщъыьэюя' + // Cyrillic (Russian, etc.)
-        '日本語中文한국어' + // Japanese, Chinese, Korean characters
-        '🙂🤔😍😂👍🚀❤️🎉' // Emojis
-
-    if (includeAscii) characters += 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
-
-    const charactersLength = Array.from(characters).length
-    const length = Math.floor(Math.random() * (maxLength - minLength + 1)) + minLength
-    let result = ''
-
-    for (let i = 0; i < length; i++) 
-        result += Array.from(characters)[Math.floor(Math.random() * charactersLength)]
-    
-    return result
-}

package/ts/funcs/utcnow.ts

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

package/ts/funcs/validEmail.test.js

@@ -1,31 +0,0 @@
-const { validEmail } = require('./validEmail')
-
-// since we use validator, we do not need to test it further
-// detailed tests with millions of emails are in tests/ folder which is .gitignored
-
-describe('validEmail', () => {
-    test('should return true for a valid email', () => {
-        const email = 'test@example.com'
-        expect(validEmail(email)).toBe(true)
-    })
-
-    test('should return false for an invalid email', () => {
-        const email = 'invalidemail'
-        expect(validEmail(email)).toBe(false)
-    })
-
-    test('should return false for an empty email', () => {
-        const email = ''
-        expect(validEmail(email)).toBe(false)
-    })
-
-    test('should return false for a null email', () => {
-        const email = null
-        expect(validEmail(email)).toBe(false)
-    })
-
-    test('should return false for a non-string email', () => {
-        const email = 12345
-        expect(validEmail(email)).toBe(false)
-    })
-})

package/ts/funcs/validEmail.ts

@@ -1,11 +0,0 @@
-import validator from 'validator'
-
-export function validEmail(email: unknown): boolean {
-    if (typeof email==='string')
-        return validator.isEmail(email) // validator needs a string
-    return false
-    // giving up old style, was not reliable
-    // taken from https://www.w3resource.com/javascript/form/email-validation.php
-    // strange looking emails might be indeed valid
-    // check https://www.w3resource.com/javascript/form/example-javascript-form-validation-email-REC-2822.html
-}

package/ts/funcs/validIp.test.ts

@@ -1,33 +0,0 @@
-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

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

package/ts/funcs/vaultFill.ts

@@ -1,89 +0,0 @@
-import { debug } from "debug"
-import nodeVault from "node-vault";
-import { vaultRead } from "./vaultRead";
-const dbg = debug('mybase')
-
-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.ts

@@ -1,50 +0,0 @@
-import { debug } from "debug"
-import chalk from "chalk"
-import nodeVault from "node-vault";
-import path from "path";
-import fs from "fs";
-import { readFileSync } from 'fs';
-import { fileCacheIsValid } from "./fileCacheIsValid";
-import { vault_cache_folder } from "../global";
-import { hash_sha512 } from "./hash_sha512";
-const dbg = debug('mybase')
-
-// 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) => {
-        const cacheKeyMaterial = `${vaultInstance.endpoint}/${vaultKey}`
-        const cacheHash = hash_sha512(cacheKeyMaterial)
-        if (cacheHash === false) return reject(new Error('vault cache key hash failed'))
-        let cache_file = path.join(vault_cache_folder, cacheHash)
-
-        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 => {
-            console.log(e)
-            dbg(`exception inside vaultRead`, e)
-            // we will still return latest information from cache
-            try {
-                console.log(chalk.bgRed(`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.ts

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

package/ts/global.ts

@@ -1,10 +0,0 @@
-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)
-}