mybase 1.1.53 → 1.2.3

package/ts/funcs/initMysql2Pool.ts

@@ -1,11 +0,0 @@
-import * as mysql2 from "mysql2"
-import { Pool } from "mysql2"
-import debug from "debug"
-import { Mysql2ServerConfiguration } from "./getMysql2"
-const dbg = debug("initMysql2Pool")
-
-export function initMysql2Pool(sqlServer: Mysql2ServerConfiguration): Pool {
-    const connectionUri = `mysql://${sqlServer.login}:${sqlServer.password}@${sqlServer.host}`
-    dbg(`creating mysql pool to ${sqlServer.host}@${sqlServer.db} as connectionUri=${connectionUri}`)
-    return mysql2.createPool(connectionUri)
-}

package/ts/funcs/int2ip.test.js

@@ -1,33 +0,0 @@
-const { int2ip } =require('./int2ip')
-
-describe('int2ip', () => {
-  it('should convert integer to valid IPv4 address', () => {
-    const ipInt = 3232235521; // equivalent to 192.168.0.1
-    const result = int2ip(ipInt);
-    expect(result).toBe('192.168.0.1');
-  });
-
-  it('should throw an error for non-numeric input', () => {
-    const ipInt = '3232235521'; // string input instead of number
-    expect(() => int2ip(ipInt)).toThrow('require number as input');
-    expect(() => int2ip([])).toThrow('require number as input');
-    expect(() => int2ip(null)).toThrow('require number as input');
-    expect(() => int2ip({})).toThrow('require number as input');
-  });
-
-  it('overflowing is allowed', () => {
-    const ipInt = 4294967297;
-    let ip = int2ip(ipInt)
-    expect(ip).toBe('0.0.0.1')
-  });
-
-  it('should support 0', () => {
-    const ipInt = 0;
-    expect(int2ip(ipInt)).toBe('0.0.0.0')
-  });
-
-  it('negative numbers should throw', () => {
-    expect(() => int2ip(-1)).toThrow('require number as input');
-  })
-
-});

package/ts/funcs/int2ip.ts

@@ -1,9 +0,0 @@
-import net from 'net'
-
-//we only support ipv4
-export function int2ip (ipInt: number) : string {
-    if (typeof ipInt !== 'number' || ipInt<0) throw new Error(`require number as input`)
-    const ip4 = ( (ipInt>>>24) +'.' + (ipInt>>16 & 255) +'.' + (ipInt>>8 & 255) +'.' + (ipInt & 255) )
-    if (net.isIP(ip4) !== 4) throw new Error(`Invalid IP: ${ip4}`)
-    return ip4
-}

package/ts/funcs/ip2int.test.js

@@ -1,30 +0,0 @@
-const { ip2int } = require('./ip2int');
-const { randomIP } = require('./randomIP');
-
-describe('ip2int', () => {
-  it('should convert IP address to integer', () => {
-    const ipAddress = '192.168.0.1';
-    const result = ip2int(ipAddress);
-    expect(result).toBe(3232235521);
-  })
-
-  it('invalid inputs', () => {
-    expect(() => ip2int('')).toThrow()
-    expect(() => ip2int('192.168.0')).toThrow()
-    expect(() => ip2int(null)).toThrow()
-    expect(() => ip2int(undefined)).toThrow()
-  })
-
-  it('should not support ipv6', () => {
-    const ipAddress = '::';
-    expect(() => ip2int(ipAddress)).toThrow()
-  })
-
-  it('test 100 random ips', () => {
-    for (let i = 0; i < 100; i++) {
-      const ipAddress = randomIP();
-      const result = ip2int(ipAddress);
-      expect(result).toBe(ip2int(ipAddress));
-    }
-  })
-});

package/ts/funcs/ip2int.ts

@@ -1,10 +0,0 @@
-import net from 'net'
-// function int2ip (ipInt) {
-//     return ( (ipInt>>>24) +'.' + (ipInt>>16 & 255) +'.' + (ipInt>>8 & 255) +'.' + (ipInt & 255) );
-// }
-
-// only supports ipv4
-export function ip2int(ip:string) {
-    if (net.isIP(ip) !== 4) throw new Error(`Invalid IP: ${ip}`)
-    return ip.split('.').reduce(function(ipInt, octet) { return (ipInt<<8) + parseInt(octet, 10)}, 0) >>> 0;
-}

package/ts/funcs/isLANIp.test.ts

@@ -1,59 +0,0 @@
-import { isLANIp } from './isLANIp';
-
-describe('isLANIp', () => {
-  it('should return true for LAN IP addresses', () => {
-    expect(isLANIp('192.168.0.1')).toBe(true);
-    expect(isLANIp('10.0.0.1')).toBe(true);
-    expect(isLANIp('172.16.0.1')).toBe(true);
-    
-    // Add more test cases for LAN IP addresses
-  });
-
-  it('should return false for non-LAN IP addresses', () => {
-    expect(isLANIp('8.8.8.8')).toBe(false);
-    expect(isLANIp('2001:0db8:85a3:0000:0000:8a2e:0370:7334')).toBe(false);
-    // Add more test cases for non-LAN IP addresses
-  });
-
-  it('should return false for invalid IP addresses', () => {
-    expect(isLANIp('')).toBe(false);
-    expect(isLANIp('192.168.0.')).toBe(false);
-    expect(isLANIp('256.0.0.1')).toBe(false);
-    // Add more test cases for invalid IP addresses
-  });
-
-  test('should return true for private IPv4', () => {
-    const ip = '192.168.1.1';
-    expect(isLANIp(ip)).toBe(true);
-});
-
-test('should return true for private IPv6', () => {
-    const ip = 'fd00::';
-    expect(isLANIp(ip)).toBe(true);
-});
-
-test('should return null for public IPv4', () => {
-    const ip = '8.8.8.8';
-    expect(isLANIp(ip)).toBe(false);
-});
-
-test('should return false for public IPv6', () => {
-    const ip = '2001:4860:4860::8888';
-    expect(isLANIp(ip)).toBe(false);
-});
-
-test('should return false for invalid IP', () => {
-    const ip = 'invalid';
-    expect(isLANIp(ip)).toBe(false);
-});
-
-test('should return false for invalid IP', () => {
-    const ip = '1.2.3';
-    expect(isLANIp(ip)).toBe(false);
-});
-
-test('should return null for non private IPv6', () => {
-    const ip = '::2';
-    expect(isLANIp(ip)).toBe(false);
-});
-});

package/ts/funcs/isLANIp.ts

@@ -1,37 +0,0 @@
-import ip6addr from '@7c/node-ip6addr'
-import net from 'net'
-
-export const private_network_cidrs = [
-    ip6addr.createCIDR('10.0.0.0/8'),
-    ip6addr.createCIDR('172.16.0.0/12'),
-    ip6addr.createCIDR('192.168.0.0/16'),
-    ip6addr.createCIDR('fd00::/8'), // Reserved by IETF for future use, but not currently in active use.
-    ip6addr.createCIDR('fc00::/8'), // The range currently in use for local communications within a site or organization.
-]
-
-export function isLANIp(ip:string) : boolean { 
-    ip=normalizeIp(ip)
-    if (net.isIP(ip)===0) return false
-    try {
-        // speed optimized
-        let ipVersion = net.isIPv4(ip) ? 'ipv4' : 'ipv6'
-        for (let cidr of private_network_cidrs) {
-            if (!cidr) continue
-            
-            let first = cidr.first()
-            if (first.kind() !== ipVersion) continue
-            if (cidr.contains(ip))
-                return true
-        }
-    } catch (err) {
-        console.log(err)
-    }
-    return false
-}
-
-function normalizeIp(ip:string):string {
-    // also support ipv6
-    if (net.isIP(ip) === 0) return ''
-    if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
-    return ip
-}

package/ts/funcs/isLocal.test.ts

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

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

package/ts/funcs/isLoopbackIP.test.ts

@@ -1,72 +0,0 @@
-import { randomIP } from './randomIP';
-import { isLoopbackIP } from './isLoopbackIP';
-
-describe('isLoopbackIP', () => {
-    test('should return true for loopback IPv4 address', () => {
-        expect(isLoopbackIP('127.0.0.1')).toBe(true);
-    });
-
-    test('should return true for loopback IPv6 address', () => {
-        expect(isLoopbackIP('::1')).toBe(true);
-    });
-
-    test('should return false for non-loopback IPv4 address', () => {
-        expect(isLoopbackIP('192.168.0.1')).toBe(false);
-    });
-
-    test('should return false for non-loopback IPv6 address', () => {
-        expect(isLoopbackIP('2001:0db8:85a3:0000:0000:8a2e:0370:7334')).toBe(false);
-    });
-
-    test('should return false for invalid IP address', () => {
-        expect(isLoopbackIP('invalid')).toBe(false);
-    });
-
-    test('should return true for local IPv4', () => {
-        const ip = '127.0.0.1'
-        expect(isLoopbackIP(ip)).toBe(true)
-    })
-
-    test('should return true for local IPv4', () => {
-        const ip = '127.2.0.1'
-        expect(isLoopbackIP(ip)).toBe(true)
-    })
-
-    test('should return true for local IPv4', () => {
-        const ip = '127.255.0.1'
-        expect(isLoopbackIP(ip)).toBe(true)
-    })
-
-    test('should return true for local IPv4', () => {
-        const ip = '127.127.127.127'
-        expect(isLoopbackIP(ip)).toBe(true)
-    })
-
-    test('should return true for local IPv6', () => {
-        const ip = '::1'
-        expect(isLoopbackIP(ip)).toBe(true)
-    })
-
-    test('should return null for non-local IPv4', () => {
-        const ip = '8.8.8.8'
-        expect(isLoopbackIP(ip)).toBe(false)
-    })
-
-    test('should return null for non-local IPv6', () => {
-        const ip = '2001:4860:4860::8888'
-        expect(isLoopbackIP(ip)).toBe(false)
-    })
-
-    test('should return false for invalid IP', () => {
-        const ip = 'invalid'
-        expect(isLoopbackIP(ip)).toBe(false)
-    })
-
-    test('random ips should not be Loopback', () => {
-        for(let i=0;i<10;i++){
-            let ip = randomIP()
-            expect(isLoopbackIP(ip)).toBe(false)
-        }
-            
-    })
-});

package/ts/funcs/isLoopbackIP.ts

@@ -1,32 +0,0 @@
-import ip6addr from '@7c/node-ip6addr'
-import net from 'net'
-
-export const local_network_cidrs = [
-    ip6addr.createCIDR('127.0.0.0/8'),
-    ip6addr.createCIDR('::1/128')
-]
-
-export function isLoopbackIP(ip:string) : boolean {
-    ip=normalizeIp(ip)
-    if (net.isIP(ip)===0) return false
-    try {
-        // speed optimized
-        let ipVersion = net.isIPv4(ip) ? 'ipv4' : 'ipv6'
-        for (let cidr of local_network_cidrs) {
-            let first = cidr.first()
-            if (first.kind() !== ipVersion) continue
-            if (cidr.contains(ip))
-                return true
-        }
-    } catch (err) {
-        console.log(err)
-    }
-    return false
-}
-
-function normalizeIp(ip:string):string {
-    // also support ipv6
-    if (net.isIP(ip) === 0) return ''
-    if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
-    return ip
-}

package/ts/funcs/knexConnection.ts

@@ -1,42 +0,0 @@
-import debug from "debug"
-import knex from "knex"
-const dbg = debug('_knexConnection')
-
-export function knexConnection(connection:{
-    host: string,
-    port: number,
-    password: string,
-    db: string,
-    login: string
-}, poolConfiguration:knex.Knex.PoolConfig= {
-    min: 1,
-    max: 10
-}, acquireConnectionTimeout:number=10000, debug: boolean = false) {
-    return knex({
-        client: 'mysql2',
-        debug,
-        connection:{ 
-            host: connection.host,
-            port: connection.port,
-            password: connection.password,
-            database: connection.db, 
-            user: connection.login
-        },
-        pool: poolConfiguration,
-        acquireConnectionTimeout,
-        log: {
-            warn(message: string) {
-                dbg('knex warn', message)
-            },
-            error(message: string) {
-                dbg('knex error', message)
-            },
-            deprecate(message: string) {
-                dbg('knex deprecate', message)
-            },
-            debug(message: string) {
-                if (debug) console.log('knex debug', message)
-            },
-          }
-    } as knex.Knex.Config)
-}

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);
-  });
-
-})