mybase 1.2.2 → 2.0.0

package/ts/models/Interfaces.ts

@@ -1,58 +0,0 @@
-import { networkInterfaces } from 'os';
-
-interface NetworkInterfaceInfo {
-    name: string;
-    ipv4: string[];
-    ipv6: string[];
-}
-
-
-export class Interfaces {
-
-    static findByName(name: string): NetworkInterfaceInfo | null {
-        const ifaces = this.getInterfaces()
-        const iface = ifaces.find(iface => iface.name === name)
-        return iface || null
-    }
-
-    static findByNamePrefix(prefix: string): NetworkInterfaceInfo[] {
-        const ifaces = this.getInterfaces()
-        return ifaces.filter(iface => iface.name.startsWith(prefix))
-    }
-
-    static findByIp(ip: string): NetworkInterfaceInfo | null {
-        const ifaces = this.getInterfaces()
-        const iface = ifaces.find(iface => iface.ipv4.includes(ip) || iface.ipv6.includes(ip))
-        return iface || null
-    }
-
-    static asApiServerConfig(ifaces:string[], port:number): {ip:string,port:number}[] {
-        const ret: {ip:string,port:number}[] = []
-        for (const iface of ifaces) {
-            const i = this.findByName(iface)
-            if (i) ret.push({ip:i.ipv4[0],port:port})
-        }
-        return ret
-    }
-
-    static getInterfaces(): NetworkInterfaceInfo[] {
-        const interfaces = networkInterfaces();
-        const result: NetworkInterfaceInfo[] = [];
-
-        for (const name of Object.keys(interfaces)) {
-            const networkInterface = interfaces[name];
-            if (networkInterface) {
-                const ipv4 = networkInterface.filter(info => info.family === 'IPv4').map(info => info.address);
-                const ipv6 = networkInterface.filter(info => info.family === 'IPv6').map(info => info.address);
-
-                result.push({
-                    name,
-                    ipv4,
-                    ipv6
-                });
-            }
-        }
-
-        return result;
-    }
-}

package/ts/models/OTPGenerator.test.ts

@@ -1,42 +0,0 @@
-import { OTPGenerator } from './OTPGenerator';
-import { wait } from './../funcs/wait';
-import { Timespan } from './Timespan';
-
-const passkey = 'hiowi3rmpewr34';
-describe('OTPGenerator', () => {
-    it('should generate OTP', () => {
-        const otpGenerator = new OTPGenerator(passkey, 5);
-        const otp = otpGenerator.generateOTP();
-        // length should be 5  + 13
-        expect(otp.length).toBe(18);
-        // console.log(otp);
-    })
-
-    it('should generate different OTPs in milliseconds', async () => {
-        const otpGenerator = new OTPGenerator(passkey, 5);
-        const otp1 = otpGenerator.generateOTP()
-        await wait(3/1000);
-        const otp2 = otpGenerator.generateOTP();
-        expect(otp1).not.toBe(otp2);
-    })
-
-    it('should generate different OTPs in milliseconds per password', async () => {
-        const otpGenerator1 = new OTPGenerator(passkey+'1', 5);
-        const otpGenerator2 = new OTPGenerator(passkey+'2', 5);
-        for(let i=0; i<10000; i++) {
-            const otp1 = otpGenerator1.generateOTP()
-            const otp2 = otpGenerator2.generateOTP();
-            expect(otp1).not.toBe(otp2);
-        }
-    })
-
-    it('age should be milliseconds since generation', async () => {
-        const otpGenerator = new OTPGenerator(passkey, 5);
-        const otp = otpGenerator.generateOTP();
-        await wait(1/1000);
-        const age = otpGenerator.age(otp);
-        expect(age).toBeInstanceOf(Timespan);
-        expect(age.miliseconds).toBeGreaterThan(0);
-        expect(age.miliseconds).toBeLessThan(100);
-    })
-});

package/ts/models/OTPGenerator.ts

@@ -1,43 +0,0 @@
-import * as crypto from 'crypto';
-import { Timespan } from './Timespan';
-
-
-export class OTPGenerator {
-    constructor(private passkey: string, private length: number = 4) {}
-
-    // Generate OTP with the current timestamp as nonce
-    public generateOTP(): string {
-        return this.generateOTPWithNonce(Date.now());
-    }
-
-    // Validate if the OTP matches by extracting the nonce and regenerating OTP
-    public validateOTP(otp: string): boolean {
-        if (!this.isValid(otp)) return false; // Validate plausibility of OTP
-        const nonce = this.extractNonce(otp);
-        return otp === this.generateOTPWithNonce(nonce);
-    }
-
-    // Get the age of the OTP compared to now
-    public age(otp: string): Timespan {
-        if (!this.isValid(otp)) throw new Error('Invalid OTP');
-        const nonce = this.extractNonce(otp);
-        return new Timespan(Date.now() - nonce)
-    }
-
-    public generateOTPWithNonce(nonce: number): string { // lets keep it public for testing
-        const hash = crypto.createHmac('sha256', this.passkey).update(nonce.toString()).digest('hex');
-        const otp = [...hash.slice(0, this.length)].map(char => String.fromCharCode((parseInt(char, 16) % 26) + 97)).join('');
-        return `${otp}${nonce.toString(16).padStart(13, '0')}`;
-    }
-
-    // Private helper to validate plausibility of OTP
-    private isValid(otp: string): boolean {
-        return otp.length === this.length + 13;
-    }
-
-    // Private helper to extract the nonce from the OTP
-    private extractNonce(otp: string): number {
-        const nonceHex = otp.slice(-13);
-        return parseInt(nonceHex, 16);
-    }
-}

package/ts/models/Timespan.ts

@@ -1,80 +0,0 @@
-export class Timespan {
-    constructor(private readonly ms: number){
-    }
-
-    get miliseconds() : number {
-        return this.ms
-    }
-
-    get seconds() : number {
-        return this.ms / 1000
-    }
-
-    get minutes() : number {
-        return this.ms / 1000 / 60
-    }
-
-    get hours() : number {
-        return this.ms / 1000 / 60 / 60
-    }
-
-    get days() : number {
-        return this.ms / 1000 / 60 / 60 / 24
-    }
-
-    get weeks() : number {
-        return this.ms / 1000 / 60 / 60 / 24 / 7
-    }
-
-    get months() : number {
-        return this.ms / 1000 / 60 / 60 / 24 / 30
-    }
-
-    static miliseconds(amount: number): Timespan {
-        return new Timespan(amount)
-    }
-
-    static seconds(amount: number): Timespan {
-        return new Timespan(amount * 1000)
-    }
-
-    static minutes(mins: number): Timespan {
-        return new Timespan(mins * 60 * 1000)
-    }
-
-    static hours(hours: number): Timespan {
-        return new Timespan(hours * 60 * 60 * 1000)
-    }
-
-    static days(days: number): Timespan {
-        return new Timespan(days * 24 * 60 * 60 * 1000)
-    }
-
-    static weeks(weeks: number): Timespan {
-        return new Timespan(weeks * 7 * 24 * 60 * 60 * 1000)
-    }
-
-    static months(months: number): Timespan {
-        return new Timespan(months * 30 * 24 * 60 * 60 * 1000)
-    }
-
-    static years(years: number): Timespan {
-        return new Timespan(years * 365 * 24 * 60 * 60 * 1000)
-    }
-
-    add(timespan: Timespan): Timespan {
-        return new Timespan(this.ms + timespan.ms)
-    }
-
-    subtract(timespan: Timespan): Timespan {
-        return new Timespan(this.ms - timespan.ms)
-    }
-
-
-    toJSON() {
-        return {
-            __type:'Timespan',
-            value:this.ms
-        }
-    }
-}

package/ts/models/Unixtime.test.ts

@@ -1,168 +0,0 @@
-import { Timespan } from './Timespan';
-import { Unixtime } from './Unixtime';
-
-describe('Unixtime', () => {
-  it('should create Unixtime object from Date', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    expect(unixtime.toDate()).toEqual(date);
-  });
-
-  it('create invalid date should throw error', () => {
-    expect(() => new Unixtime('invalid date')).toThrow();
-  })
-
-  it('should create Unixtime object from string', () => {
-    const dateString = '2022-01-01T00:00:00Z';
-    const date = new Date(dateString);
-    const unixtime = new Unixtime(dateString);
-    expect(unixtime.toDate()).toEqual(date);
-  });
-
-  it('should create Unixtime object from number (short form)', () => {
-    const timestamp = 1640995200; // January 1, 2022 00:00:00 UTC
-    const date = new Date(timestamp * 1000);
-    const unixtime = new Unixtime(timestamp);
-    expect(unixtime.toDate()).toEqual(date);
-  });
-
-  it('should create Unixtime object from number (long form)', () => {
-    const timestamp = 1640995200000; // January 1, 2022 00:00:00 UTC
-    const date = new Date(timestamp);
-    const unixtime = new Unixtime(timestamp);
-    expect(unixtime.toDate()).toEqual(date);
-  });
-
-  it('should convert Unixtime to short Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const shortUnixtime = Math.round(date.getTime() / 1000);
-    expect(unixtime.toShortUnixtime()).toEqual(shortUnixtime);
-  });
-
-  it('should convert Unixtime to long Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    expect(unixtime.toLongUnixtime()).toEqual(date.getTime());
-  });
-
-  it('should convert Unixtime to ISO string', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    expect(unixtime.toISOString()).toEqual(date.toISOString());
-  });
-
-  it('should add miliseconds to Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const addedUnixtime = unixtime.addMiliseconds(1000);
-    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 1000));
-  });
-
-  it('should add seconds to Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const addedUnixtime = unixtime.addSeconds(1);
-    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 1000));
-  });
-
-  it('should add minutes to Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const addedUnixtime = unixtime.addMinutes(1);
-    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 60000));
-  });
-
-  it('should add hours to Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const addedUnixtime = unixtime.addHours(1);
-    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 3600000));
-  });
-
-  it('should add days to Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const addedUnixtime = unixtime.addDays(1);
-    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 86400000));
-  });
-
-  it('should add months to Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const addedUnixtime = unixtime.addMonths(1);
-    expect(addedUnixtime.toDate()).toEqual(new Date(date.setMonth(date.getMonth() + 1)));
-  });
-
-  it('should add years to Unixtime', () => {
-    const date = new Date();
-    const unixtime = new Unixtime(date);
-    const addedUnixtime = unixtime.addYears(1);
-    expect(addedUnixtime.toDate()).toEqual(new Date(date.setFullYear(date.getFullYear() + 1)));
-  });
-
-  it('clone should create brand new object', () => {
-    const unixtime0 = new Unixtime(new Date())
-    const unixtime1 = unixtime0.clone();
-    expect(unixtime1).not.toBe(unixtime0);
-    expect(unixtime0.toDate()).toEqual(unixtime1.toDate());
-  });
-
-
-  it('day,month,year should return correct values', () => {
-    const unixtime = new Unixtime("2024-10-11T12:13:14Z");
-    expect(unixtime.day).toEqual(11);
-    expect(unixtime.month).toEqual(10);
-    expect(unixtime.year).toEqual(2024);
-    expect(unixtime.minutes).toEqual(13);
-    expect(unixtime.seconds).toEqual(14);
-    expect(unixtime.hours).toEqual(12);
-  })
-
-  it('fromYYYYMMDD should create Unixtime object from string', () => {
-    const unixtime = Unixtime.fromYYYYMMDD('20241011');
-    expect(unixtime.toISOString()).toEqual('2024-10-11T00:00:00.000Z');
-  })
-
-  it('yyyymmddhh should return correct values',() => {
-    const unixtime = new Unixtime("2024-10-11T12:13:14Z");
-    expect(unixtime.yyyymmdd()).toEqual('20241011');
-    expect(unixtime.yyyymmddhh()).toEqual('2024101112');
-    // should also work with optional seperators
-    expect(unixtime.yyyymmddhh('-')).toEqual('2024-10-11-12');
-  })
-
-  it('randomPast should return random time in the past', () => {
-    const end = Unixtime.now()
-    const begin = end.clone().addYears(-1)
-    for(let i=0;i<100000;i++) {
-      const rand = Unixtime.randomPast(Timespan.years(1))
-      expect(rand.toLongUnixtime()).toBeGreaterThan(begin.toLongUnixtime());
-      expect(rand.toLongUnixtime()).toBeLessThan(end.toLongUnixtime());
-    }
-  })
-
-  it('randomFuture should return random time in the future within given timespan of 1 year', () => {
-    const begin = Unixtime.now()
-    const end = begin.clone().addYears(1)
-    for(let i=0;i<100000;i++) {
-      const rand = Unixtime.randomFuture(Timespan.years(1))
-      expect(rand.toLongUnixtime()).toBeGreaterThan(begin.toLongUnixtime());
-      expect(rand.toLongUnixtime()).toBeLessThan(end.toLongUnixtime());
-    }
-  })
-
-  it('yyyymmdd should work as designed',() => {
-    const unixtime = new Unixtime("2024-10-11T12:13:14Z");
-    expect(unixtime.yyyymmdd()).toEqual('20241011');
-    expect(unixtime.yyyymmdd('-')).toEqual('2024-10-11');
-  })
-
-  it('fromYYYYMMDD should throw error when invalid date', () => {
-    expect(() => Unixtime.fromYYYYMMDD('20243131')).toThrow('Invalid month');
-    expect(() => Unixtime.fromYYYYMMDD('20241233')).toThrow('Invalid day');
-    expect(() => Unixtime.fromYYYYMMDD('xx')).toThrow('Invalid yyyymmdd value');
-    //@ts-ignore
-    expect(() => Unixtime.fromYYYYMMDD([])).toThrow('Invalid yyyymmdd value');
-  })
-});

package/ts/models/Unixtime.ts

@@ -1,208 +0,0 @@
-import { Timespan } from "./Timespan"
-
-// this will be a class to work with short and long version of unixtime format
-export class Unixtime {
-    private value: Date
-
-
-    static EMPTY = new Unixtime(new Date(0))
-
-    static NOW() {
-        return new Unixtime(Date.now())
-    }
-
-    static now() {
-        return new Unixtime(Date.now())
-    }
-
-    greaterThan(other: Unixtime) {
-        return this.toLongUnixtime() > other.toLongUnixtime()
-    }
-
-    isEmpty() {
-        return this.toLongUnixtime() == 0
-    }
-
-    lessThan(other: Unixtime) {
-        return this.toLongUnixtime() < other.toLongUnixtime()
-    }
-
-    get elapsed():Timespan {
-        return new Timespan(Date.now() - this.toLongUnixtime())
-    }
-
-    toJSON() {
-        return {
-            __type:'Unixtime',
-            value:this.toLongUnixtime()
-        }
-    }
-
-
-    constructor(value: Date | string | number) {
-        if (typeof value === 'string') {
-            this.value = new Date(value)
-        } else if (typeof value === 'number') {
-            // the number might be short or long form(from nodejs Date.now()
-            if (value < 10000000000) value *= 1000
-            else
-                value = Math.round(value)
-            // set the value
-            this.value = new Date(value)
-        }
-        else if (value instanceof Date) {
-            this.value = value
-        } 
-        else {
-            throw new Error('Invalid value')
-        }
-
-        if (isNaN(this.value.getTime())) {
-            throw new Error('Invalid date')
-        }
-    }
-
-    public addTimespan(timespan: Timespan): Unixtime {
-        this.value = new Date(this.value.getTime() + timespan.miliseconds)
-        return this
-    }
-
-    public subtractTimespan(timespan: Timespan): Unixtime {
-        this.value = new Date(this.value.getTime() - timespan.miliseconds)
-        return this
-    }
-
-    public addMiliseconds(miliseconds: number = 1): Unixtime {
-        this.value = new Date(this.value.getTime() + miliseconds)
-        return this
-    }
-
-    public addSeconds(seconds: number = 1): Unixtime {
-        this.value = new Date(this.value.getTime() + seconds * 1000)
-        return this
-    }
-
-    public addMinutes(minutes: number = 1): Unixtime {
-        this.value = new Date(this.value.getTime() + minutes * 60000)
-        return this
-    }
-
-    public addHours(hours: number = 1): Unixtime {
-        this.value = new Date(this.value.getTime() + hours * 3600000)
-        return this
-    }
-
-    public addDays(days: number = 1): Unixtime {
-        this.value = new Date(this.value.getTime() + days * 86400000)
-        return this
-    }
-
-    public addMonths(months: number = 1): Unixtime {
-        this.value.setUTCMonth(this.value.getMonth() + months)
-        return this
-    }
-
-    public addYears(years: number = 1): Unixtime {
-        this.value.setUTCFullYear(this.year + years)
-        return this
-    }
-
-    public yyyymmdd(seperator: string=""): string {
-        let mm = this.month
-        let dd = this.day
-        return [this.value.getFullYear(),
-        (mm > 9 ? '' : '0') + mm,
-        (dd > 9 ? '' : '0') + dd,
-        ].join(seperator)
-    }
-
-    public yyyymmddhh(seperator: string=""): string {
-        let mm = this.month
-        let dd = this.day
-        let hh = this.hours
-        return [this.year,
-        (mm > 9 ? '' : '0') + mm,
-        (dd > 9 ? '' : '0') + dd,
-        (hh > 9 ? '' : '0') + hh,
-        ].join(seperator)
-    }
-
-    /**
-    @deprecated use 'day' instead
-    */
-    public getDay() : number {return this.value.getUTCDay()}
-
-    get day(): number {  return this.value.getUTCDate() }
-    get month(): number { return this.value.getUTCMonth() + 1 }
-    get year(): number { return this.value.getUTCFullYear() }
-    get hours(): number { return this.value.getUTCHours() }
-    get minutes(): number { return this.value.getUTCMinutes() }
-    get seconds(): number { return this.value.getUTCSeconds() }
-
-    static from(value: Date | string | number) {
-        return new Unixtime(value)
-    }
-
-    public toShortUnixtime(): number {
-        return Math.round(this.toLongUnixtime() / 1000)
-    }
-
-    public toLongUnixtime(): number {
-        return this.value.getTime()
-    }
-
-    public toDate(): Date {
-        return this.value
-    }
-
-    public toISOString(): string {
-        return this.value.toISOString()
-    }
-
-    public elapsedSeconds(): number {
-        return Math.round((Date.now() - this.toLongUnixtime()) / 1000)
-    }
-
-    public elapsedMinutes(): number {
-        return Math.round(this.elapsedSeconds() / 60)
-    }
-
-    clone():Unixtime {
-        return new Unixtime(this.toLongUnixtime())
-    }
-
-    /**
-     * @param max maximum timespan to subtract
-     * @returns returns random time in the past within given timespan 
-     */
-    static randomPast(max: Timespan=Timespan.years(1), base: Unixtime=Unixtime.now()): Unixtime {
-        return base.addSeconds(Math.random()*max.seconds*-1)
-    }
-
-    /**
-     * @param max maximum timespan to add
-     * @returns returns random time in the future within given timespan
-     */
-    static randomFuture(max: Timespan=Timespan.years(1), base: Unixtime=Unixtime.now()): Unixtime {
-        return base.addSeconds(Math.random()*max.seconds)
-    }
-
-    static fromYYYYMMDD(value: string): Unixtime {
-        if (value.length != 8) throw new Error('Invalid yyyymmdd value')
-        let year = parseInt(value.substring(0, 4))
-        let month = parseInt(value.substring(4, 6)) - 1
-        let day = parseInt(value.substring(6, 8))
-        if (isNaN(year) || isNaN(month) || isNaN(day)) throw new Error('Invalid yyyymmdd value')
-        if (month < 0 || month > 11) throw new Error('Invalid month')
-        if (day < 1 || day > 31) throw new Error('Invalid day')
-        return new Unixtime(new Date(Date.UTC(year, month, day)))
-    }
-
-    static try(value: Date | string | number): Unixtime | null {
-        try {
-            return new Unixtime(value)
-        } catch (e) {
-            return null
-        }
-    }
-}

package/ts/types.ts

@@ -1,42 +0,0 @@
-export type UnixtimeShort = number
-
-//#region mybase
-export type MysqlConfig = {
-  host: string
-  port?: number
-  login: string
-  password: string
-  db: string
-}
-
-export type MysqlConnection = {
-  connect: (callback: (err: NodeJS.ErrnoException | null) => void) => void
-  ping: (callback: (err?: NodeJS.ErrnoException | Error | null) => void) => void
-}
-
-export type MysqlConnector = {
-  createConnection: (opts: {
-    host: string
-    port: number
-    user: string
-    password: string
-    database: string
-  }) => MysqlConnection
-}
-
-export type VaultClient = {
-  endpoint?: string
-  read: (key: string) => Promise<{ data?: unknown }>
-}
-
-export type SqlQueryable = {
-  query: (q: string, values: unknown[], callback: (err: Error | null, res?: unknown) => void) => void
-}
-
-export type Geoip2PathMap = {
-  country: string | false
-  city: string | false
-  isp: string | false
-  ct: string | false
-}
-//#endregion

package/tsconfig.jest.json

@@ -1,11 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "allowJs": true,
-    "types": ["jest", "node"],
-    "noImplicitAny": false
-  },
-  "include": ["**/*.test.ts", "mybase.ts", "ts/**/*.ts"],
-  "exclude": ["node_modules"]
-}

package/tsconfig.json

@@ -1,37 +0,0 @@
-{
-  "compilerOptions": {
-    // "ignoreDeprecations": "6.0",
-    "target": "es2017",          
-    "experimentalDecorators": true,                   
-    "emitDecoratorMetadata": true,                    
-    "module": "commonjs",        
-    "moduleResolution" : "Node",
-    "esModuleInterop": true,                  
-    "forceConsistentCasingInFileNames": true,            
-    "strict": true,
-    "declaration": true, // Generates corresponding .d.ts file
-    "noImplicitReturns": true, // Report error when not all code paths in function return a value
-    "noUnusedLocals": true, // Report errors on unused locals
-    // "noUnusedParameters": true, // Report errors on unused parameters
-    "noFallthroughCasesInSwitch": true, // Report errors for fallthrough cases in switch statement
-    // "noUncheckedIndexedAccess": true, // Include 'undefined' in index signature results
-    "noImplicitAny": true, // Raise error on expressions and declarations with an implied 'any' type
-    "strictNullChecks": true, // Enable strict null checking
-    "strictFunctionTypes": true, // Ensure function parameter types match
-    "strictBindCallApply": true, // Ensure 'bind', 'call', and 'apply' methods match function types
-    "strictPropertyInitialization": true, // Ensure non-undefined class properties are initialized in the constructor
-    "alwaysStrict": true, // Parse in strict mode and emit "use strict" for each source file
-    "sourceMap": true,
-    "skipLibCheck": true,      
-    "baseUrl": ".",
-    "paths": {
-      "@root/*": ["./*"],
-      "@models/*": ["./models/*"],
-      "@inc/*": ["./inc/ts/*"]
-    },
-    "typeRoots": ["./node_modules/@types", "./types/"]
-  },
-  "exclude": [
-    "**/*.test.ts"
-  ]
-}