baja-lite 1.8.8 → 1.8.9

package/const/types.js

@@ -0,0 +1,127 @@
+import { DEFAULT_MAX_DEAL, _daoConnection, _daoDB, _inTransaction } from '../const/symbols.js';
+// ===== 枚举 =====
+export var MapperIfUndefined;
+(function (MapperIfUndefined) {
+    MapperIfUndefined[MapperIfUndefined["Null"] = 0] = "Null";
+    MapperIfUndefined[MapperIfUndefined["Skip"] = 1] = "Skip";
+    MapperIfUndefined[MapperIfUndefined["Zero"] = 2] = "Zero";
+    MapperIfUndefined[MapperIfUndefined["EmptyString"] = 3] = "EmptyString";
+})(MapperIfUndefined || (MapperIfUndefined = {}));
+;
+export var SyncMode;
+(function (SyncMode) {
+    /** 同步执行 */
+    SyncMode[SyncMode["Sync"] = 0] = "Sync";
+    /** 异步执行 */
+    SyncMode[SyncMode["Async"] = 1] = "Async";
+})(SyncMode || (SyncMode = {}));
+export var InsertMode;
+(function (InsertMode) {
+    /**
+    # 默认使用
+    ** 支持单个、批量,语法 `INSERT INTO XX VALUES (第一条数据), (第二条数据);`
+    ** 批量执行有性能优势，但无法利用数据库的sql预编译功能
+    */
+    InsertMode[InsertMode["Insert"] = 0] = "Insert";
+    /**
+    # 利用临时表
+    ## 执行步骤
+    1. 建立临时表(从正式表复制)
+    2. 数据全部进入临时表
+    3. 临时表数据转移到正式表: `INSERT INTO 正式表 SELECT * FROM 临时表`
+    4. 删除临时表
+    ## 注意
+    1. 适用于：主键不会冲突、非自增
+    2. 临时表的结构复制正式表
+     */
+    InsertMode[InsertMode["InsertWithTempTable"] = 1] = "InsertWithTempTable";
+    /**
+     * 如果不存在则插入
+     * 来源是数据库，根据ID或者指定字段查询
+     */
+    InsertMode[InsertMode["InsertIfNotExists"] = 2] = "InsertIfNotExists";
+    /**
+    # 插入或者更新
+    1. 判断依据是主键,来源是从数据库查询
+     */
+    InsertMode[InsertMode["Replace"] = 3] = "Replace";
+})(InsertMode || (InsertMode = {}));
+export var DeleteMode;
+(function (DeleteMode) {
+    /**
+     ##常规删除 默认
+     ### 例一
+     `DELETE FROM WHERE (id = 1) OR (id = 2)`
+     ### 例二
+     `DELETE FROM WHERE (id = 1 AND idx = 11) OR (id = 2 AND idx = 22)`
+    */
+    DeleteMode[DeleteMode["Common"] = 0] = "Common";
+    /*
+    ## 借助临时表
+    ### 注意：必须保证where的字段都相同，否则会漏删数据
+    DELETE FROM 正式表 INNER JOIN 临时表 WHERE 字段1 = 字段1 AND 字段2 = 字段2
+     */
+    DeleteMode[DeleteMode["TempTable"] = 1] = "TempTable";
+})(DeleteMode || (DeleteMode = {}));
+export var SelectMode;
+(function (SelectMode) {
+    /**
+     ##常规 默认
+     ### 例一
+     `SELECT * FROM WHERE (id = 1) OR (id = 2)`
+     ### 例二
+     `SELECT * FROM WHERE (id = 1 AND idx = 11) OR (id = 2 AND idx = 22)`
+    */
+    SelectMode[SelectMode["Common"] = 0] = "Common";
+    /*
+    ## 借助临时表
+    ### 注意：必须保证where的字段都相同，否则会漏删数据
+    SELECT * FROM 正式表 INNER JOIN 临时表 WHERE 字段1 = 字段1 AND 字段2 = 字段2
+     */
+    SelectMode[SelectMode["TempTable"] = 1] = "TempTable";
+})(SelectMode || (SelectMode = {}));
+export var TemplateResult;
+(function (TemplateResult) {
+    /** 确定返回一条记录，如果不是一个，将报错，返回类型是T */
+    TemplateResult[TemplateResult["AssertOne"] = 0] = "AssertOne";
+    /** 可能返回一条记录，返回类型是T|null */
+    TemplateResult[TemplateResult["NotSureOne"] = 1] = "NotSureOne";
+    /** 返回多条记录 */
+    TemplateResult[TemplateResult["Many"] = 2] = "Many";
+    /** 仅查询记录数量 */
+    TemplateResult[TemplateResult["Count"] = 3] = "Count";
+})(TemplateResult || (TemplateResult = {}));
+export var SelectResult;
+(function (SelectResult) {
+    /** 一行一列 确定非空 */
+    SelectResult[SelectResult["R_C_Assert"] = 0] = "R_C_Assert";
+    /** 一行一列 可能空 */
+    SelectResult[SelectResult["R_C_NotSure"] = 1] = "R_C_NotSure";
+    /** 一行多列 确定非空 */
+    SelectResult[SelectResult["R_CS_Assert"] = 2] = "R_CS_Assert";
+    /** 一行多列 可能空 */
+    SelectResult[SelectResult["R_CS_NotSure"] = 3] = "R_CS_NotSure";
+    /** 多行一列 */
+    SelectResult[SelectResult["RS_C"] = 4] = "RS_C";
+    /** 多行多列 */
+    SelectResult[SelectResult["RS_CS"] = 5] = "RS_CS";
+})(SelectResult || (SelectResult = {}));
+export var ColumnMode;
+(function (ColumnMode) {
+    ColumnMode[ColumnMode["NONE"] = 0] = "NONE";
+    ColumnMode[ColumnMode["HUMP"] = 1] = "HUMP";
+})(ColumnMode || (ColumnMode = {}));
+// ===== 常量 =====
+export const SqliteMemory = ':memory:';
+export const _defOption = {
+    maxDeal: DEFAULT_MAX_DEAL,
+    skipUndefined: true,
+    skipNull: true,
+    skipEmptyString: true
+};
+/** 缓存存储后端。`redis` 走 ioredis 全局共享；`memory` 走进程内 LRU + Promise-based single-flight。 */
+export var StorageType;
+(function (StorageType) {
+    StorageType[StorageType["Redis"] = 0] = "Redis";
+    StorageType[StorageType["Memory"] = 1] = "Memory";
+})(StorageType || (StorageType = {}));

package/db/dao/format-dialects.d.ts

@@ -0,0 +1,6 @@
+export declare const formatDialects: {
+    0: import("sql-formatter").DialectOptions;
+    2: import("sql-formatter").DialectOptions;
+    4: import("sql-formatter").DialectOptions;
+    1: import("sql-formatter").DialectOptions;
+};

package/db/dao/format-dialects.js

@@ -0,0 +1,8 @@
+import { DBType } from 'baja-lite-field';
+import { mysql, postgresql, sqlite } from 'sql-formatter';
+export const formatDialects = {
+    [DBType.Mysql]: mysql,
+    [DBType.Sqlite]: sqlite,
+    [DBType.SqliteRemote]: sqlite,
+    [DBType.Postgresql]: postgresql,
+};

package/db/dao/mysql.d.ts

@@ -0,0 +1,44 @@
+import { _daoConnection, _daoDB, _inTransaction } from '../../const/symbols.js';
+import { Connection, Dao, SyncMode } from '../../const/types.js';
+export declare class MysqlConnection 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 Mysql implements Dao {
+    [_daoDB]: any;
+    private keepAliveTimer?;
+    private isClosing;
+    constructor(pool: any);
+    keepAlive(): Promise<void>;
+    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>;
+}

package/db/dao/mysql.js

@@ -0,0 +1,303 @@
+var _a;
+import { _daoConnection, _daoDB, _GlobalSqlOption, _inTransaction, _LoggerService, _MysqlKeepAliveTime, DEFAULT_KEEPALIVE_INTERVAL } from '../../const/symbols.js';
+import { SyncMode } from '../../const/types.js';
+export class MysqlConnection {
+    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('MYSQL 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 [_result] = await this[_daoConnection].execute(sql, params);
+                const result = _result;
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    globalThis[_LoggerService].verbose?.(result);
+                }
+                return { affectedRows: result.affectedRows, insertId: result.insertId };
+            }
+            catch (error) {
+                globalThis[_LoggerService].error(error.message, { cause: error });
+                throw error;
+            }
+        })();
+    }
+    pluck(sync, sql, params) {
+        globalThis[_LoggerService].debug?.(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].warn('MYSQL not supported sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            globalThis[_LoggerService].verbose?.(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return (async () => {
+            try {
+                const [result] = await this[_daoConnection].query(sql, params);
+                if (result && result[0]) {
+                    const r = Object.values(result[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('MYSQL not supported sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            globalThis[_LoggerService].verbose?.(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return (async () => {
+            try {
+                const [result] = await this[_daoConnection].query(sql, params);
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    globalThis[_LoggerService].verbose?.(result);
+                }
+                if (result && result[0]) {
+                    return result[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('MYSQL not supported sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            globalThis[_LoggerService].verbose?.(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return (async () => {
+            try {
+                const [result] = await this[_daoConnection].query(sql, params);
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    globalThis[_LoggerService].verbose?.(result);
+                }
+                // 修复 fall-through：原代码 `if (result) resolve(...); resolve([])` 第二行
+                // 是 no-op，但写法埋雷。
+                if (result) {
+                    return result.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('MYSQL not supported sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            globalThis[_LoggerService].verbose?.(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return (async () => {
+            try {
+                const [result] = await this[_daoConnection].query(sql, params);
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    globalThis[_LoggerService].verbose?.(result);
+                }
+                return result;
+            }
+            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 Mysql {
+    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('MYSQL not supported sync mode');
+            return null;
+        }
+        ;
+        return (async () => {
+            try {
+                const connection = await this[_daoDB].getConnection();
+                globalThis[_LoggerService].debug?.('create new connection!');
+                return new MysqlConnection(connection);
+            }
+            catch (error) {
+                globalThis[_LoggerService].error(error.message, { cause: error });
+                throw error;
+            }
+        })();
+    }
+    transaction(sync, fn, conn) {
+        if (sync === SyncMode.Sync) {
+            globalThis[_LoggerService].warn('MYSQL 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].beginTransaction();
+                globalThis[_LoggerService].debug?.('beginTransaction end!');
+            }
+            conn[_inTransaction] = true;
+            try {
+                const result = await fn(conn);
+                if (needCommit) {
+                    globalThis[_LoggerService].debug?.('commit begin!');
+                    await conn[_daoConnection].commit();
+                    globalThis[_LoggerService].debug?.('commit end!');
+                }
+                return result;
+            }
+            catch (error) {
+                if (needCommit) {
+                    globalThis[_LoggerService].debug?.('rollback begin!');
+                    await conn[_daoConnection].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);
+        }
+        return this[_daoDB]?.destroy();
+    }
+    backup(sync, name) {
+    }
+    remove(sync) {
+    }
+    restore(sync, name) {
+    }
+}

package/db/dao/postgresql.d.ts

@@ -0,0 +1,44 @@
+import { _daoConnection, _daoDB, _inTransaction } from '../../const/symbols.js';
+import { Connection, Dao, SyncMode } from '../../const/types.js';
+export declare class PostgresqlConnection 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 Postgresql implements Dao {
+    [_daoDB]: any;
+    private keepAliveTimer?;
+    private isClosing;
+    constructor(pool: any);
+    keepAlive(): Promise<void>;
+    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>;
+}