mybase 1.1.34 → 1.1.35

package/jest/isLANIp.test.js

@@ -0,0 +1,36 @@
+const { isLANIp } = require('./../mybase');
+
+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(null);
+});
+
+test('should return null for public IPv6', () => {
+    const ip = '2001:4860:4860::8888';
+    expect(isLANIp(ip)).toBe(null);
+});
+
+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(null);
+});

package/jest/isLoopbackIP.test.js

@@ -0,0 +1,31 @@
+const { isLoopbackIP } = require('./../mybase') // adjust the path to mybase.js
+
+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.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(null)
+})
+
+test('should return null for non-local IPv6', () => {
+    const ip = '2001:4860:4860::8888'
+    expect(isLoopbackIP(ip)).toBe(null)
+})
+
+test('should return false for invalid IP', () => {
+    const ip = 'invalid'
+    expect(isLoopbackIP(ip)).toBe(false)
+})

package/jest.config.js

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

package/package.json

@@ -1,12 +1,9 @@
 {
   "name": "mybase",
-  "version": "1.1.34",
+  "version": "1.1.35",
   "description": "",
   "main": "mybase.js",
-  "files": [
-    "mybase.js",
-    "ip6addr.d.ts"
-  ],
+  "types": "./ip6addr.d.ts",
   "scripts": {
     "test": "jest --forceExit --verbose"
   },

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,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Geoip2Paths = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function Geoip2Paths() {
+    var _a, _b, _c, _d;
+    function firstExisting(paths) {
+        if (Array.isArray(paths))
+            for (let fpath of paths)
+                if (fs_1.default.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_1.default.join(__dirname, 'assets/GeoIP2-Country.mmdb'), path_1.default.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_1.default.join(__dirname, 'assets/GeoIP2-City.mmdb'), path_1.default.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_1.default.join(__dirname, 'assets/GeoIP2-ISP.mmdb'), path_1.default.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_1.default.join(__dirname, 'assets/GeoIP2-Connection-Type.mmdb'), path_1.default.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;
+//# sourceMappingURL=Geoip2Paths.js.map

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 from 'fs'
+import path from '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/MaxRuntimeHours.d.ts

@@ -0,0 +1 @@
+export declare function MaxRuntimeHours(hours?: number): void;

package/ts/funcs/MaxRuntimeHours.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxRuntimeHours = void 0;
+function MaxRuntimeHours(hours = 24) {
+    setTimeout(() => {
+        console.log(`Max runtime of ${hours} hours reached, exiting`);
+        process.exit(0);
+    }, hours * 60 * 60 * 1000);
+}
+exports.MaxRuntimeHours = MaxRuntimeHours;
+//# sourceMappingURL=MaxRuntimeHours.js.map

package/ts/funcs/MaxRuntimeHours.ts

@@ -0,0 +1,7 @@
+
+export function MaxRuntimeHours(hours:number=24) {
+    setTimeout(() => {
+        console.log(`Max runtime of ${hours} hours reached, exiting`)
+        process.exit(0)
+    }, hours * 60 * 60 * 1000)
+}

package/ts/funcs/asJSON.d.ts

@@ -0,0 +1 @@
+export declare function asJSON(inputString: string): any | boolean;

package/ts/funcs/asJSON.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asJSON = void 0;
+function asJSON(inputString) {
+    if (!inputString || typeof inputString !== 'string')
+        return false;
+    try {
+        return JSON.parse(inputString);
+    }
+    catch (_) { }
+    return false;
+}
+exports.asJSON = asJSON;
+//# sourceMappingURL=asJSON.js.map

package/ts/funcs/asJSON.test.js

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

package/ts/funcs/asJSON.ts

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

package/ts/funcs/ensureFolder.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { MakeDirectoryOptions } from 'fs';
+export declare function ensureFolder(folderPath: string, options?: MakeDirectoryOptions | null): string;

package/ts/funcs/ensureFolder.js

@@ -0,0 +1,50 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureFolder = void 0;
+const debug_1 = __importDefault(require("debug"));
+const fs = __importStar(require("fs"));
+const dbg = (0, debug_1.default)('_mybase:ensureFolder');
+function ensureFolder(folderPath, options) {
+    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;
+}
+exports.ensureFolder = ensureFolder;
+//# sourceMappingURL=ensureFolder.js.map

package/ts/funcs/ensureFolder.test.ts

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

@@ -0,0 +1,21 @@
+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.d.ts

@@ -0,0 +1 @@
+export declare function fileCacheIsValid(cacheFileName: string, cache_in_minutes?: number): boolean;

package/ts/funcs/fileCacheIsValid.js

@@ -0,0 +1,40 @@
+"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;
+//# sourceMappingURL=fileCacheIsValid.js.map

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

@@ -0,0 +1,8 @@
+export type Mysql1ServerConfiguration = {
+    host: string;
+    port: number;
+    login: string;
+    password: string;
+    db: string;
+};
+export declare function getMysql1(config: Mysql1ServerConfiguration, pingInterval?: number): Promise<unknown>;

package/ts/funcs/getMysql1.js

@@ -0,0 +1,62 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMysql1 = void 0;
+const mysql1 = __importStar(require("mysql"));
+const debug_1 = __importDefault(require("debug"));
+const dbg = (0, debug_1.default)("getMysql1");
+async function getMysql1(config, pingInterval = 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, 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) {
+                        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);
+        });
+    });
+}
+exports.getMysql1 = getMysql1;
+//# sourceMappingURL=getMysql1.js.map

package/ts/funcs/getMysql1.ts

@@ -0,0 +1,41 @@
+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.d.ts

@@ -0,0 +1,9 @@
+import { Connection } from "mysql2";
+export type Mysql2ServerConfiguration = {
+    host: string;
+    port: number;
+    login: string;
+    password: string;
+    db: string;
+};
+export declare function getMysql2(config: Mysql2ServerConfiguration, pingInterval?: number): Promise<Connection>;