mybase 1.2.2 → 1.2.3

package/ts/funcs/ensureFolder.test.ts

@@ -1,79 +0,0 @@
-import { ensureFolder } from './ensureFolder'
-import * as fs from 'fs'
-import { wait } from '../index'
-
-describe('ensureFolder', () => {
-    let folderPath: string
-    let filePath: string
-    
-    beforeEach(async () => {
-        folderPath = `/tmp/ensureFolder.test.${Date.now()}`
-        filePath = `/tmp/ensureFolder.test.${Date.now()}.file`
-        await wait(1/1000)
-    })
-
-    it('should create a folder if it does not exist and return the folder path', () => {
-        const folder = ensureFolder(folderPath)
-        expect(folder).toBe(folderPath)
-        expect(fs.existsSync(folderPath)).toBe(true)
-    })
-
-    it('should throw an error if the folder path exists and is not a folder', () => {
-        fs.writeFileSync(filePath, 'test')
-        expect(() => ensureFolder(filePath)).toThrow('exists and is not a folder')
-    })
-
-    it('creating same folder twice should return the same folder path', () => {
-        expect(ensureFolder(folderPath)).toBe(folderPath)
-        expect(fs.existsSync(folderPath)).toBe(true)
-        expect(ensureFolder(folderPath)).toBe(folderPath)
-    })
-
-    it('we should be able to create recursively a folders and default to recursive mode', () => {
-        let sfolder= ensureFolder(`${folderPath}/subfolder/subsubfolder`)
-        expect(sfolder).toBe(`${folderPath}/subfolder/subsubfolder`) 
-        if (sfolder) expect(fs.existsSync(sfolder)).toBe(true)
-        // test creating 10 recursive folders
-        for(let i=0;i<10;i++) {
-            sfolder= `${sfolder}/subsubsubfolder${i}`
-            expect(ensureFolder(sfolder)).toBe(sfolder) 
-            if (sfolder) expect(fs.existsSync(sfolder)).toBe(true)
-        }
-    })
-
-    it('we should not be able to disable recursive mode', () => {
-        expect(ensureFolder(`${folderPath}/subfolder/subsubfolder`, { recursive: false })).toBe(`${folderPath}/subfolder/subsubfolder`)
-    })
-
-    it('we should be able to create a folder with a custom mode', () => {
-        let sfolder= ensureFolder(`${folderPath}/subfolder/subsubfolder`, { mode: 0o700 })
-        expect(sfolder).toBe(`${folderPath}/subfolder/subsubfolder`) 
-        if (sfolder) expect(fs.existsSync(sfolder)).toBe(true)
-        expect(fs.statSync(sfolder).mode & 0o777).toBe(0o700);
-    })
-
-    it('try to create a file where we do not have write permissions should throw an error', () => {
-        expect(() => ensureFolder('/dev/ensureFolder.test.file')).toThrow()
-    })
-
-    it('should throw an error if folder path is empty', () => {
-        expect(() => ensureFolder('')).toThrow();
-    });
-
-    it('should throw an error if folder path is null or undefined or array or object', () => {
-        expect(() => ensureFolder(null as unknown as string)).toThrow();
-        expect(() => ensureFolder(undefined as unknown as string)).toThrow();
-        expect(() => ensureFolder([] as unknown as string)).toThrow();
-        expect(() => ensureFolder({} as unknown as string)).toThrow();
-    });
-
-    it('should not change the permissions of an existing folder', () => {
-        fs.mkdirSync(folderPath, { mode: 0o755 });
-        ensureFolder(folderPath, { mode: 0o700 });
-        expect(fs.statSync(folderPath).mode & 0o777).toBe(0o755);
-    });
-
-    it('should throw error for invalid mode value', () => {
-        
-    });
-})

package/ts/funcs/ensureFolder.ts

@@ -1,21 +0,0 @@
-import debug from 'debug'
-import * as fs from 'fs';
-import { MakeDirectoryOptions } from 'fs';
-const dbg = debug('_mybase:ensureFolder')
-
-export function ensureFolder(folderPath: string, options?: MakeDirectoryOptions | null) : string {
-    options = options || {}
-    options.recursive = true
-    dbg('ensureFolder()', folderPath)
-    if (fs.existsSync(folderPath)) {
-        if (!fs.lstatSync(folderPath).isDirectory()) {
-            dbg(`${folderPath} exists and is not a folder`)
-            throw new Error(`${folderPath} exists and is not a folder`);
-        }
-        dbg(`${folderPath} exists and is a folder`)
-        return folderPath
-    } 
-    dbg(`creating ${folderPath}`,options)
-    fs.mkdirSync(folderPath, options)
-    return folderPath
-}

package/ts/funcs/fileCacheIsValid.ts

@@ -1,13 +0,0 @@
-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/getMysql1.ts

@@ -1,41 +0,0 @@
-import * as mysql1 from "mysql"
-import { MysqlError } from "mysql"
-import debug from "debug"
-const dbg = debug("getMysql1")
-
-export type Mysql1ServerConfiguration = {
-    host: string,
-    port: number,
-    login: string,
-    password: string,
-    db: string
-}
-
-export async function getMysql1(config: Mysql1ServerConfiguration, pingInterval: number = 0) {
-    return new Promise((resolve, reject) => {
-        const mysql_client = mysql1.createConnection({
-            host: config.host,
-            port: config.port ? config.port : 3306,
-            user: config.login,
-            password: config.password,
-            database: config.db
-        })
-
-        mysql_client.connect((err:MysqlError, res) => {
-            if (err) {
-                dbg(`mysql connection has failed to ${config.host}@${config.db}`, err)
-                return reject(err)
-            }
-            dbg(`mysql connection has been established to ${config.host}@${config.db}`)
-            // install a pinger every 30 seconds to keep the connection alive
-            if (pingInterval > 0)
-                setInterval(() => {
-                    mysql_client.ping(function (err:MysqlError) {
-                        if (err) return console.log(`could not ping mysql ${config.host}@${config.db}`, err.code)
-                        dbg(`mysql ${config.host}@${config.db} is pinging properly`)
-                    })
-                }, pingInterval)
-            resolve(mysql_client)
-        })
-    })
-}

package/ts/funcs/getMysql2.ts

@@ -1,42 +0,0 @@
-import * as mysql2 from "mysql2"
-import { QueryError,Connection } from "mysql2"
-import debug from "debug"
-const dbg = debug("getMysql2")
-
-export type Mysql2ServerConfiguration = {
-    host: string,
-    port: number,
-    login: string,
-    password: string,
-    db: string
-}
-
-export async function getMysql2(config: Mysql2ServerConfiguration, pingInterval: number = 0):Promise<Connection> {
-    return new Promise((resolve, reject) => {
-        const mysql_client = mysql2.createConnection({
-            host: config.host,
-            port: config.port ? config.port : 3306,
-            user: config.login,
-            password: config.password,
-            database: config.db
-        })
-
-        mysql_client.connect((err: QueryError | null) => {
-            if (err) {
-                dbg(`mysql connection has failed to ${config.host}@${config.db}`, err)
-                return reject(err)
-            }
-            dbg(`mysql connection has been established to ${config.host}@${config.db}`)
-            // install a pinger every 30 seconds to keep the connection alive
-            if (pingInterval > 0)
-                setInterval(() => {
-                    mysql_client.ping(function (err:QueryError | null) {
-                        if (err) 
-                            return console.log(`could not ping mysql ${config.host}@${config.db}`, err.code)
-                        dbg(`mysql ${config.host}@${config.db} is pinging properly`)
-                    })
-                }, pingInterval)
-            resolve(mysql_client)
-        })
-    })
-}

package/ts/funcs/getWeekNumber.test.ts

@@ -1,9 +0,0 @@
-import { getWeekNumber } from './getWeekNumber'
-
-
-describe('getWeekNumber', () => {
-    it('should return the correct week number', () => {
-        expect(getWeekNumber(new Date('2012-01-01'))).toBe(52)
-        expect(getWeekNumber(new Date('2014-12-30'))).toBe(1)
-    })  
-})

package/ts/funcs/getWeekNumber.ts

@@ -1,31 +0,0 @@
-// credit: https://stackoverflow.com/questions/6117814/get-week-of-year-in-javascript-like-in-php
-/* For a given date, get the ISO week number
- 
-  Based on information at:
- 
-     THIS PAGE (DOMAIN EVEN) DOESN'T EXIST ANYMORE UNFORTUNATELY
-     http://www.merlyn.demon.co.uk/weekcalc.htm#WNR
- 
-  Algorithm is to find nearest thursday, it's year
-  is the year of the week number. Then get weeks
-  between that date and the first day of that year.
- 
-  Note that dates in one year can be weeks of previous
-  or next year, overlap is up to 3 days.
- 
-  e.g. 2014/12/29 is Monday in week  1 of 2015
-       2012/1/1   is Sunday in week 52 of 2011
-*/
-export function getWeekNumber(d: Date = new Date()): number {
-    // Copy date so don't modify original
-    const date = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
-    // Set to nearest Thursday: current date + 4 - current day number
-    // Make Sunday's day number 7
-    date.setUTCDate(date.getUTCDate() + 4 - (date.getUTCDay() || 7));
-    // Get first day of year
-    const yearStart = new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
-    // Calculate full weeks to nearest Thursday
-    const weekNo = Math.ceil(((date.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
-    // Return the week number
-    return weekNo;
-}

package/ts/funcs/hash_sha512.ts

@@ -1,6 +0,0 @@
-import { sha512 } from 'js-sha512'
-
-export function hash_sha512(plain: unknown): string | false {
-  if (typeof plain === 'string') return sha512(plain)
-  return false
-}

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,58 +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 null for non-LAN IP addresses', () => {
-    expect(isLANIp('8.8.8.8')).toBeNull();
-    expect(isLANIp('2001:0db8:85a3:0000:0000:8a2e:0370:7334')).toBeNull();
-  });
-
-  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)).toBeNull();
-});
-
-test('should return null for public IPv6', () => {
-    const ip = '2001:4860:4860::8888';
-    expect(isLANIp(ip)).toBeNull();
-});
-
-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)).toBeNull();
-});
-});

package/ts/funcs/isLANIp.ts

@@ -1,34 +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.
-]
-
-function normalizeIp(ip: string): string | false {
-  if (net.isIP(ip) === 0) return false
-  if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
-  return ip
-}
-
-export function isLANIp(ip: string): boolean | null {
-  const n = normalizeIp(ip)
-  if (n === false || net.isIP(n) === 0) return false
-  try {
-    const ipVersion = net.isIPv4(n) ? 'ipv4' : 'ipv6'
-    for (const cidr of private_network_cidrs) {
-      if (!cidr) continue
-      const first = cidr.first()
-      if (first.kind() !== ipVersion) continue
-      if (cidr.contains(n)) return true
-    }
-    return null
-  } catch (err) {
-    console.log(err)
-  }
-  return false
-}

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 null for non-loopback IPv4 address', () => {
-        expect(isLoopbackIP('192.168.0.1')).toBeNull();
-    });
-
-    test('should return null for non-loopback IPv6 address', () => {
-        expect(isLoopbackIP('2001:0db8:85a3:0000:0000:8a2e:0370:7334')).toBeNull();
-    });
-
-    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)).toBeNull()
-    })
-
-    test('should return null for non-local IPv6', () => {
-        const ip = '2001:4860:4860::8888'
-        expect(isLoopbackIP(ip)).toBeNull()
-    })
-
-    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)).toBeNull()
-        }
-            
-    })
-});

package/ts/funcs/isLoopbackIP.ts

@@ -1,30 +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'),
-]
-
-function normalizeIp(ip: string): string | false {
-  if (net.isIP(ip) === 0) return false
-  if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
-  return ip
-}
-
-export function isLoopbackIP(ip: string): boolean | null {
-  const n = normalizeIp(ip)
-  if (n === false || net.isIP(n) === 0) return false
-  try {
-    const ipVersion = net.isIPv4(n) ? 'ipv4' : 'ipv6'
-    for (const cidr of local_network_cidrs) {
-      const first = cidr.first()
-      if (first.kind() !== ipVersion) continue
-      if (cidr.contains(n)) return true
-    }
-    return null
-  } catch (err) {
-    console.log(err)
-  }
-  return false
-}

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