baja-lite 1.8.8 → 1.8.9

package/db/dao/postgresql.js

@@ -0,0 +1,322 @@
+var _a;
+import { _daoConnection, _daoDB, _GlobalSqlOption, _inTransaction, _LoggerService, _MysqlKeepAliveTime, DEFAULT_KEEPALIVE_INTERVAL } from '../../const/symbols.js';
+import { SyncMode } from '../../const/types.js';
+import { replacePlaceholders } from '../../string.js';
+export class PostgresqlConnection {
+    constructor(conn) {
+        this[_a] = false;
+        this[_daoConnection] = conn;
+    }
+    execute(sync, sql, params) {
+        globalThis[_LoggerService].debug?.(sql, params ?? '');
+        if (!sql) {
+            return { affectedRows: 0, insertId: 0n };
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].warn('Postgresql not supported sync mode');
+            return { affectedRows: 0, insertId: 0n };
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            globalThis[_LoggerService].verbose?.(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return (async () => {
+            try {
+                const { rowCount } = await this[_daoConnection].query({
+                    text: replacePlaceholders(sql),
+                    values: params
+                });
+                const result = rowCount;
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    globalThis[_LoggerService].verbose?.(result);
+                }
+                return { affectedRows: rowCount || 0, insertId: 0n };
+            }
+            catch (error) {
+                globalThis[_LoggerService].error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        })();
+    }
+    pluck(sync, sql, params) {
+        globalThis[_LoggerService].debug?.(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].warn('Postgresql not supported sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            globalThis[_LoggerService].verbose?.(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return (async () => {
+            try {
+                const { rows } = await this[_daoConnection].query({
+                    text: replacePlaceholders(sql),
+                    values: params
+                });
+                // 修复 fall-through：原代码 if 分支 resolve 后没 return，导致 resolve(null)
+                // 紧跟其后（虽然第二次 resolve 是 no-op，但写法有歧义）。
+                if (rows && rows[0]) {
+                    const r = Object.values(rows[0])[0];
+                    return r === null ? null : r;
+                }
+                return null;
+            }
+            catch (error) {
+                globalThis[_LoggerService].error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        })();
+    }
+    get(sync, sql, params) {
+        globalThis[_LoggerService].debug?.(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].warn('Postgresql not supported sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            globalThis[_LoggerService].verbose?.(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return (async () => {
+            try {
+                const { rows } = await this[_daoConnection].query({
+                    text: replacePlaceholders(sql),
+                    values: params
+                });
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    globalThis[_LoggerService].verbose?.(rows);
+                }
+                if (rows && rows[0]) {
+                    return rows[0];
+                }
+                return null;
+            }
+            catch (error) {
+                globalThis[_LoggerService].error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        })();
+    }
+    raw(sync, sql, params) {
+        globalThis[_LoggerService].debug?.(sql, params ?? '');
+        if (!sql) {
+            return [];
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].warn('Postgresql not supported sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            globalThis[_LoggerService].verbose?.(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return (async () => {
+            try {
+                const { rows } = await this[_daoConnection].query({
+                    text: replacePlaceholders(sql),
+                    values: params
+                });
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    globalThis[_LoggerService].verbose?.(rows);
+                }
+                if (rows) {
+                    return rows.map((i) => Object.values(i)[0]);
+                }
+                return [];
+            }
+            catch (error) {
+                globalThis[_LoggerService].error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        })();
+    }
+    query(sync, sql, params) {
+        globalThis[_LoggerService].debug?.(sql, params ?? '');
+        if (!sql) {
+            return [];
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].warn('Postgresql not supported sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            globalThis[_LoggerService].verbose?.(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return (async () => {
+            try {
+                const { rows } = await this[_daoConnection].query({
+                    text: replacePlaceholders(sql),
+                    values: params
+                });
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    globalThis[_LoggerService].verbose?.(rows);
+                }
+                return rows;
+            }
+            catch (error) {
+                globalThis[_LoggerService].error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        })();
+    }
+    release(sync) {
+        try {
+            this[_daoConnection]?.release();
+        }
+        catch (error) {
+        }
+        if (sync === SyncMode.Async) {
+            return Promise.resolve();
+        }
+    }
+}
+_a = _inTransaction;
+export class Postgresql {
+    constructor(pool) {
+        this.isClosing = false;
+        this[_daoDB] = pool;
+        this.keepAlive();
+    }
+    async keepAlive() {
+        if (this.isClosing)
+            return;
+        let connection = null;
+        try {
+            connection = await this.createConnection(SyncMode.Async);
+            if (connection) {
+                await connection.query(SyncMode.Async, 'SELECT 1 FROM DUAL');
+                // (globalThis[_LoggerService]! as LoggerService).debug?.('keepAlive->', data?.[0]?.[1]);
+            }
+        }
+        catch (error) {
+            globalThis[_LoggerService].error('keepAlive error', error);
+        }
+        finally {
+            if (connection) {
+                await connection.release(SyncMode.Async);
+            }
+            if (!this.isClosing) {
+                this.keepAliveTimer = setTimeout(() => this.keepAlive(), globalThis[_MysqlKeepAliveTime] ?? DEFAULT_KEEPALIVE_INTERVAL);
+            }
+        }
+    }
+    createConnection(sync) {
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].error('Postgresql not supported sync mode');
+            return null;
+        }
+        ;
+        return (async () => {
+            try {
+                const connection = await this[_daoDB].connect();
+                globalThis[_LoggerService].debug?.('create new connection!');
+                return new PostgresqlConnection(connection);
+            }
+            catch (error) {
+                throw error;
+            }
+        })();
+    }
+    transaction(sync, fn, conn) {
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].warn('Postgresql not supported sync mode');
+            return null;
+        }
+        ;
+        return (async () => {
+            let needCommit = false;
+            let newConn = false;
+            if (!conn) {
+                conn = await this.createConnection(SyncMode.Async) ?? undefined;
+                newConn = true;
+            }
+            if (conn?.[_inTransaction] !== true) {
+                needCommit = true;
+                globalThis[_LoggerService].debug?.('beginTransaction begin!');
+                await conn[_daoConnection].query('BEGIN');
+                globalThis[_LoggerService].debug?.('beginTransaction end!');
+            }
+            conn[_inTransaction] = true;
+            try {
+                const result = await fn(conn);
+                if (needCommit) {
+                    globalThis[_LoggerService].debug?.('commit begin!');
+                    await conn[_daoConnection].query('COMMIT');
+                    globalThis[_LoggerService].debug?.('commit end!');
+                }
+                return result;
+            }
+            catch (error) {
+                if (needCommit) {
+                    globalThis[_LoggerService].debug?.('rollback begin!');
+                    await conn[_daoConnection].query('ROLLBACK');
+                    globalThis[_LoggerService].debug?.('rollback end!');
+                }
+                globalThis[_LoggerService].error(error.message, { cause: error });
+                throw error;
+            }
+            finally {
+                try {
+                    if (needCommit) {
+                        conn[_inTransaction] = false;
+                    }
+                    if (newConn) {
+                        globalThis[_LoggerService].debug?.('release begin!');
+                        conn[_daoConnection].release();
+                        globalThis[_LoggerService].debug?.('release end!');
+                    }
+                }
+                catch (error) {
+                    // 释放连接失败通常不影响业务逻辑，记录日志即可
+                    globalThis[_LoggerService].warn?.('Failed to release connection in finally block', error);
+                }
+            }
+        })();
+    }
+    close(sync) {
+        this.isClosing = true;
+        if (this.keepAliveTimer) {
+            clearTimeout(this.keepAliveTimer);
+        }
+        this[_daoDB]?.end();
+    }
+    backup(sync, name) {
+    }
+    remove(sync) {
+    }
+    restore(sync, name) {
+    }
+}

package/db/dao/sqlite-remote.d.ts

@@ -0,0 +1,46 @@
+import { ExtensionCodec } from "@msgpack/msgpack";
+import { _daoConnection, _daoDB, _inTransaction, _sqliteRemoteName } from '../../const/symbols.js';
+import { Connection, Dao, SqliteRemoteInterface, SyncMode } from '../../const/types.js';
+export declare const extensionCodec: ExtensionCodec<undefined>;
+export declare class SqliteRemoteConnection implements Connection {
+    [_daoConnection]: SqliteRemoteInterface;
+    [_sqliteRemoteName]: string;
+    [_inTransaction]: boolean;
+    constructor(conn: SqliteRemoteInterface, name: string);
+    execute(sync: SyncMode.Sync, sql?: string, params?: any): {
+        affectedRows: number;
+        insertId: bigint;
+    };
+    execute(sync: SyncMode.Async, sql?: string, params?: any): Promise<{
+        affectedRows: number;
+        insertId: bigint;
+    }>;
+    pluck<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T | null;
+    pluck<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T | null>;
+    get<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T | null;
+    get<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T | null>;
+    raw<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T[];
+    raw<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T[]>;
+    query<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T[];
+    query<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T[]>;
+    release(sync: SyncMode.Sync): void;
+    release(sync: SyncMode.Async): Promise<void>;
+}
+export declare class SqliteRemote implements Dao {
+    [_sqliteRemoteName]: string;
+    [_daoDB]: SqliteRemoteInterface;
+    private connection?;
+    constructor(db: SqliteRemoteInterface, name: string);
+    createConnection(sync: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    close(sync: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    backup(sync: SyncMode.Sync, exportPath: string): void;
+    backup(sync: SyncMode.Async, exportPath: string): Promise<void>;
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    restore(sync: SyncMode.Sync, importPath: string): void;
+    restore(sync: SyncMode.Async, importPath: string): Promise<void>;
+}

package/db/dao/sqlite-remote.js

@@ -0,0 +1,226 @@
+var _a;
+import { decode, DecodeError, encode, ExtensionCodec } from "@msgpack/msgpack";
+import { _daoConnection, _daoDB, _GlobalSqlOption, _inTransaction, _LoggerService, _sqliteRemoteName } from '../../const/symbols.js';
+import { SyncMode } from '../../const/types.js';
+const BIGINT_EXT_TYPE = 0;
+export const extensionCodec = new ExtensionCodec();
+extensionCodec.register({
+    type: BIGINT_EXT_TYPE,
+    encode(input) {
+        if (typeof input === "bigint") {
+            if (input <= Number.MAX_SAFE_INTEGER && input >= Number.MIN_SAFE_INTEGER) {
+                return encode(Number(input));
+            }
+            else {
+                return encode(String(input));
+            }
+        }
+        else {
+            return null;
+        }
+    },
+    decode(data) {
+        const val = decode(data);
+        if (!(typeof val === "string" || typeof val === "number")) {
+            throw new DecodeError(`unexpected BigInt source: ${val} (${typeof val})`);
+        }
+        return BigInt(val);
+    },
+});
+export class SqliteRemoteConnection {
+    constructor(conn, name) {
+        this[_a] = false;
+        this[_daoConnection] = conn;
+        this[_sqliteRemoteName] = name;
+    }
+    execute(sync, sql, params) {
+        globalThis[_LoggerService].debug?.(sql, params ?? '');
+        if (!sql) {
+            return { affectedRows: 0, insertId: 0n };
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].warn('SqliteRemote not supported sync mode');
+            return { affectedRows: 0, insertId: 0n };
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            globalThis[_LoggerService].verbose?.(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return (async () => {
+            try {
+                const data = await this[_daoConnection].execute(encode([this[_sqliteRemoteName], sql, params], { extensionCodec }));
+                const { affectedRows, insertId } = decode(data, { extensionCodec });
+                return { affectedRows, insertId: insertId ? BigInt(insertId) : 0n };
+            }
+            catch (error) {
+                globalThis[_LoggerService].error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        })();
+    }
+    pluck(sync, sql, params) {
+        globalThis[_LoggerService].debug?.(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].warn('SqliteRemote not supported sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            globalThis[_LoggerService].verbose?.(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return (async () => {
+            try {
+                const data = await this[_daoConnection].pluck(encode([this[_sqliteRemoteName], sql, params], { extensionCodec }));
+                return decode(data, { extensionCodec });
+            }
+            catch (error) {
+                globalThis[_LoggerService].error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        })();
+    }
+    get(sync, sql, params) {
+        globalThis[_LoggerService].debug?.(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].warn('SqliteRemote not supported sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            globalThis[_LoggerService].verbose?.(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return (async () => {
+            try {
+                const data = await this[_daoConnection].get(encode([this[_sqliteRemoteName], sql, params], { extensionCodec }));
+                return decode(data, { extensionCodec });
+            }
+            catch (error) {
+                globalThis[_LoggerService].error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        })();
+    }
+    raw(sync, sql, params) {
+        globalThis[_LoggerService].debug?.(sql, params ?? '');
+        if (!sql) {
+            return [];
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].warn('SqliteRemote not supported sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            globalThis[_LoggerService].verbose?.(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return (async () => {
+            try {
+                const data = await this[_daoConnection].raw(encode([this[_sqliteRemoteName], sql, params], { extensionCodec }));
+                return decode(data, { extensionCodec });
+            }
+            catch (error) {
+                globalThis[_LoggerService].error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        })();
+    }
+    query(sync, sql, params) {
+        globalThis[_LoggerService].debug?.(sql, params ?? '');
+        if (!sql) {
+            return [];
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].warn('SqliteRemote not supported sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            globalThis[_LoggerService].verbose?.(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return (async () => {
+            try {
+                const data = await this[_daoConnection].query(encode([this[_sqliteRemoteName], sql, params], { extensionCodec }));
+                return decode(data, { extensionCodec });
+            }
+            catch (error) {
+                globalThis[_LoggerService].error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        })();
+    }
+    release(sync) {
+    }
+}
+_a = _inTransaction;
+export class SqliteRemote {
+    constructor(db, name) {
+        this[_daoDB] = db;
+        this[_sqliteRemoteName] = name;
+    }
+    createConnection(sync) {
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].error('SQLITEREMOTE not supported sync mode');
+            return null;
+        }
+        ;
+        if (!this.connection) {
+            this.connection = new SqliteRemoteConnection(this[_daoDB], this[_sqliteRemoteName]);
+        }
+        return Promise.resolve(this.connection);
+    }
+    transaction(sync, fn, conn) {
+        globalThis[_LoggerService].warn(`SQLITEREMOTE not supported transaction`);
+        return null;
+    }
+    close(sync) {
+        if (sync === SyncMode.Async) {
+            return this[_daoDB]?.close(this[_sqliteRemoteName]);
+        }
+        ;
+    }
+    backup(sync, exportPath) {
+        if (sync === SyncMode.Async) {
+            return this[_daoDB]?.export(this[_sqliteRemoteName], exportPath);
+        }
+        ;
+    }
+    remove(sync) {
+    }
+    restore(sync, importPath) {
+        if (sync === SyncMode.Async) {
+            return this[_daoDB]?.restore(this[_sqliteRemoteName], importPath);
+        }
+        ;
+    }
+}

package/db/dao/sqlite.d.ts

@@ -0,0 +1,41 @@
+import { _daoConnection, _daoDB, _inTransaction } from '../../const/symbols.js';
+import { Connection, Dao, SyncMode } from '../../const/types.js';
+export declare class SqliteConnection implements Connection {
+    [_daoConnection]: any;
+    [_inTransaction]: boolean;
+    constructor(conn: any);
+    execute(sync: SyncMode.Sync, sql?: string, params?: any): {
+        affectedRows: number;
+        insertId: bigint;
+    };
+    execute(sync: SyncMode.Async, sql?: string, params?: any): Promise<{
+        affectedRows: number;
+        insertId: bigint;
+    }>;
+    pluck<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T | null;
+    pluck<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T | null>;
+    get<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T | null;
+    get<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T | null>;
+    raw<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T[];
+    raw<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T[]>;
+    query<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T[];
+    query<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T[]>;
+    release(sync: SyncMode.Sync): void;
+    release(sync: SyncMode.Async): Promise<void>;
+}
+export declare class Sqlite implements Dao {
+    [_daoDB]: any;
+    constructor(db: any);
+    createConnection(sync: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    close(sync: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    backup(sync: SyncMode.Sync, name: string): void;
+    backup(sync: SyncMode.Async, name: string): Promise<void>;
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    restore(sync: SyncMode.Sync, name: string): void;
+    restore(sync: SyncMode.Async, name: string): Promise<void>;
+}