mybase 1.1.51 → 1.2.2

package/ts/models/DateIterator.ts

@@ -0,0 +1,80 @@
+import { Unixtime } from "./Unixtime"
+
+/**
+ * Iterates day-by-day backwards from `start` toward `end` (end-exclusive),
+ * emitting each date as a `yyyy{sep}mm{sep}dd` string.
+ *
+ * @example
+ *   const it = new DateIterator(Unixtime.now(), Unixtime.now().addDays(-5))
+ *   it.next()  // "20260417"
+ *   it.next()  // "20260416"
+ *   // ...
+ *   it.next()  // null
+ *
+ * @example separator
+ *   new DateIterator(start, end, "-").toArray()
+ *   // ["2026-04-17", "2026-04-16", ...]
+ *
+ * @example for..of
+ *   for (const d of new DateIterator(start, end, "/")) console.log(d)
+ */
+export class DateIterator implements Iterable<string> {
+    private readonly start: Unixtime
+    private readonly end: Unixtime
+    private readonly separator: string
+    private cursor: Unixtime | null
+
+    constructor(start: Unixtime, end: Unixtime, separator: string = "") {
+        if (start.lessThan(end)) {
+            throw new Error('DateIterator: `start` must be newer than or equal to `end`')
+        }
+        // Defensive clones: callers' instances must not be mutated, and
+        // Unixtime.addDays() mutates the underlying Date.
+        this.start = start.clone()
+        this.end = end.clone()
+        this.separator = separator
+        this.cursor = this.start.clone()
+    }
+
+    /** Returns the next formatted date going backwards, or `null` when exhausted. */
+    next(): string | null {
+        if (this.cursor === null) return null
+        if (!this.cursor.greaterThan(this.end)) {
+            this.cursor = null
+            return null
+        }
+        const value = this.cursor.yyyymmdd(this.separator)
+        this.cursor.addDays(-1)
+        return value
+    }
+
+    /** Reset the iterator so it can be consumed again from `start`. */
+    reset(): this {
+        this.cursor = this.start.clone()
+        return this
+    }
+
+    /** Collect all remaining dates into an array. */
+    toArray(): string[] {
+        const out: string[] = []
+        let d: string | null
+        while ((d = this.next()) !== null) out.push(d)
+        return out
+    }
+
+    [Symbol.iterator](): Iterator<string> {
+        let cursor: Unixtime | null = this.start.clone()
+        const end = this.end
+        const sep = this.separator
+        return {
+            next(): IteratorResult<string> {
+                if (cursor === null || !cursor.greaterThan(end)) {
+                    return { value: undefined as unknown as string, done: true }
+                }
+                const value = cursor.yyyymmdd(sep)
+                cursor.addDays(-1)
+                return { value, done: false }
+            }
+        }
+    }
+}

package/ts/models/IPAddress.d.ts

@@ -1,15 +1,15 @@
-import ip6addr, { ToStringOpts } from '@7c/node-ip6addr';
+import { CIDR, ToStringOpts } from '@7c/node-ip6addr';
 export declare class IPAddress {
     private _ip;
-    static loopback_cidrs4: ip6addr.CIDR[];
-    static loopback_cidrs6: ip6addr.CIDR[];
-    static loopback_cidrs: ip6addr.CIDR[];
-    static lan_cidrs4: ip6addr.CIDR[];
-    static lan_cidrs6: ip6addr.CIDR[];
-    static lan_cidrs: ip6addr.CIDR[];
-    static local_cidrs: ip6addr.CIDR[];
-    static local_cidrs4: ip6addr.CIDR[];
-    static local_cidrs6: ip6addr.CIDR[];
+    static loopback_cidrs4: CIDR[];
+    static loopback_cidrs6: CIDR[];
+    static loopback_cidrs: CIDR[];
+    static lan_cidrs4: CIDR[];
+    static lan_cidrs6: CIDR[];
+    static lan_cidrs: CIDR[];
+    static local_cidrs: CIDR[];
+    static local_cidrs4: CIDR[];
+    static local_cidrs6: CIDR[];
     constructor(ip: string);
     abbreviated(): string;
     toString(opts?: ToStringOpts): string;
@@ -20,13 +20,13 @@ export declare class IPAddress {
     isLoopbackIP(): boolean;
     isLANIP(): boolean;
     isLocalIP(): boolean;
-    partOfCIDR(cidr_networks: ip6addr.CIDR[]): boolean;
-    static partOfCIDR(_ip: string, cidr_networks: ip6addr.CIDR[]): boolean;
+    partOfCIDR(cidr_networks: CIDR[]): boolean;
+    static partOfCIDR(_ip: string, cidr_networks: CIDR[]): boolean;
     isPublicIP(): boolean;
     static unserialize(serializedIpString: string): IPAddress;
     static randomIP4(): IPAddress;
     static randomIP6(): IPAddress;
-    static randomCIDRIp(cidr: ip6addr.CIDR[] | 'loopback' | 'lan' | 'local' | 'loopback4' | 'loopback6' | 'lan4' | 'lan6' | 'local4' | 'local6'): IPAddress;
+    static randomCIDRIp(cidr: CIDR[] | 'loopback' | 'lan' | 'local' | 'loopback4' | 'loopback6' | 'lan4' | 'lan6' | 'local4' | 'local6'): IPAddress;
     serialize(): string;
     kind(): number;
     equals(secondIp: IPAddress): boolean;

package/ts/models/IPAddress.ts

@@ -1,7 +1,7 @@
 /// <reference path="./../../ip6addr.d.ts" />
 import debug from 'debug'
 import { randomIP, randomIP6, } from "./../"
-import ip6addr, { Addr, ToStringOpts } from '@7c/node-ip6addr'
+import ip6addr, { Addr, CIDR, ToStringOpts } from '@7c/node-ip6addr'
 import net from 'net'
 const ip6 = require('ip6') // "url": "https://github.com/elgs/ip6"
 const dbg = debug('_IPAddress')
@@ -103,7 +103,7 @@ export class IPAddress {
         return this.partOfCIDR(IPAddress.local_cidrs)
     }
 
-    partOfCIDR(cidr_networks: ip6addr.CIDR[]): boolean {
+    partOfCIDR(cidr_networks: CIDR[]): boolean {
         const ipNormalized = this.toString()
         let ipVersion = net.isIPv4(ipNormalized) ? 'ipv4' : 'ipv6'
         for (let cidr of cidr_networks) {
@@ -116,7 +116,7 @@ export class IPAddress {
         return false
     }
 
-    static partOfCIDR(_ip: string, cidr_networks: ip6addr.CIDR[]): boolean {
+    static partOfCIDR(_ip: string, cidr_networks: CIDR[]): boolean {
         const ip = IPAddress.try(_ip)
         if (ip === undefined) return false
         return ip.partOfCIDR(cidr_networks)
@@ -151,7 +151,7 @@ export class IPAddress {
     }
 
 
-    public static randomCIDRIp(cidr: ip6addr.CIDR[] | 'loopback' | 'lan' | 'local' | 'loopback4' | 'loopback6' | 'lan4' | 'lan6' | 'local4' | 'local6'): IPAddress {
+    public static randomCIDRIp(cidr: CIDR[] | 'loopback' | 'lan' | 'local' | 'loopback4' | 'loopback6' | 'lan4' | 'lan6' | 'local4' | 'local6'): IPAddress {
         if (cidr === 'loopback') cidr = IPAddress.loopback_cidrs
         if (cidr === 'loopback4') cidr = IPAddress.loopback_cidrs4
         if (cidr === 'loopback6') cidr = IPAddress.loopback_cidrs6

package/ts/models/OTPGenerator.test.ts

@@ -15,7 +15,7 @@ describe('OTPGenerator', () => {
     it('should generate different OTPs in milliseconds', async () => {
         const otpGenerator = new OTPGenerator(passkey, 5);
         const otp1 = otpGenerator.generateOTP()
-        await wait(1/1000);
+        await wait(3/1000);
         const otp2 = otpGenerator.generateOTP();
         expect(otp1).not.toBe(otp2);
     })

package/ts/types.d.ts

@@ -1 +1,36 @@
 export type UnixtimeShort = number;
+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;
+};

package/ts/types.js

@@ -1,3 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+//#endregion
 //# sourceMappingURL=types.js.map

package/ts/types.ts

@@ -1 +1,42 @@
-export type UnixtimeShort = number
+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

@@ -0,0 +1,11 @@
+{
+  "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,5 +1,6 @@
 {
-  "compilerOptions": {        
+  "compilerOptions": {
+    // "ignoreDeprecations": "6.0",
     "target": "es2017",          
     "experimentalDecorators": true,                   
     "emitDecoratorMetadata": true,                    

package/types/third-party.d.ts

@@ -0,0 +1,21 @@
+declare module '@7c/validurl' {
+  function validURL(host: unknown): boolean
+  export = validURL
+}
+
+declare module 'ip6' {
+  export function normalize(a: string): string
+  export function abbreviate(a: string): string
+}
+
+declare module 'aes-js' {
+  const aesjs: {
+    utils: {
+      utf8: { toBytes(s: string): Uint8Array; fromBytes(b: Uint8Array): string }
+      hex: { fromBytes(b: Uint8Array): string; toBytes(s: string): Uint8Array }
+    }
+    padding: { pkcs7: { pad(b: Uint8Array, n: number): Uint8Array; strip(b: Uint8Array): Uint8Array } }
+    ModeOfOperation: { cbc: new (key: Uint8Array) => { encrypt(b: Uint8Array): Uint8Array; decrypt(b: Uint8Array): Uint8Array } }
+  }
+  export = aesjs
+}