@maiyunnet/kebab 4.1.0 → 5.0.1

package/lib/db/pool.js

@@ -0,0 +1,281 @@
+import * as mysql2 from 'mysql2/promise';
+import * as pg from 'pg';
+import * as lCore from '#kebab/lib/core.js';
+import * as lTime from '#kebab/lib/time.js';
+import * as lSql from '#kebab/lib/sql.js';
+import * as lDb from '#kebab/lib/db.js';
+import { Connection } from './conn.js';
+import { Transaction } from './tran.js';
+/** --- 连接列表池 --- */
+const connections = [];
+/**
+ * --- 获取当前连接池中所有连接的信息 ---
+ */
+export function getConnectionList() {
+    const list = [];
+    for (let i = 0; i < connections.length; ++i) {
+        const connection = connections[i];
+        const etc = connection.getEtc();
+        list.push({
+            'id': i,
+            'service': connection.getService(),
+            'last': connection.getLast(),
+            'host': etc.host,
+            'port': etc.port,
+            'name': etc.name,
+            'user': etc.user,
+            'lost': connection.isLost(),
+            'using': connection.isUsing(),
+            'transaction': connection.isTransaction()
+        });
+    }
+    return list;
+}
+/**
+ * --- 计划任务 10 秒一次，关闭超过 30 秒不活动的连接，回滚独占时间过长的连接 ---
+ */
+async function checkConnection() {
+    const now = lTime.stamp();
+    for (let i = 0; i < connections.length; ++i) {
+        const connection = connections[i];
+        if (connection.isLost()) {
+            // --- 连接已经丢失，移除 ---
+            await connection.end();
+            connections.splice(i, 1);
+            --i;
+            continue;
+        }
+        if (connection.isUsing()) {
+            // --- 连接正在被使用，看看是否空闲了超过 30 秒，超过则不是正常状态 ---
+            if (connection.getLast() <= now - 30) {
+                // --- 30 秒之前开始的 ---
+                const ls = connection.getLastSql();
+                const newarr = ls.map(item => {
+                    if (!item.values) {
+                        return item.sql;
+                    }
+                    return lSql.format(item.sql, item.values);
+                });
+                const msg = `[DB][checkConnection] There is a transactional connection[${i}] that is not closed, last sql: ${newarr.join(', ')}.`;
+                lCore.display(msg);
+                lCore.log({}, msg, '-error');
+                await connection.rollback();
+            }
+            continue;
+        }
+        if (connection.getLast() <= now - 30) {
+            // --- 超 30 秒未被使用，则关闭 ---
+            await connection.end();
+            connections.splice(i, 1);
+            --i;
+            continue;
+        }
+        // --- 30 秒内使用过，看看连接是否正常 ---
+        if (await connection.isAvailable(false)) {
+            // --- 正常 ---
+            continue;
+        }
+        // --- 连接有问题，直接关闭 ---
+        await connection.end();
+        connections.splice(i, 1);
+        --i;
+    }
+    setTimeout(function () {
+        checkConnection().catch(e => { lCore.display('[DB][checkConnection]', e); });
+    }, 10_000);
+}
+setTimeout(function () {
+    checkConnection().catch(e => { lCore.display('[DB][checkConnection]', e); });
+}, 10_000);
+/** --- 数据库连接池对象 --- */
+export class Pool {
+    constructor(etc, opt) {
+        /** --- SQL 执行次数 --- */
+        this._queries = 0;
+        this._etc = etc;
+        this._service = opt.service;
+    }
+    /** --- 获取当前连接的服务商 --- */
+    getService() {
+        return this._service;
+    }
+    /**
+     * --- 执行一条 SQL，无视顺序和相同连接，随用随取 ---
+     * @param sql 执行的 SQL 字符串
+     * @param values 要替换的 data 数据
+     * @returns error.errno = -500 表示系统错误
+     */
+    async query(sql, values) {
+        ++this._queries;
+        // --- 获取并自动 using  ---
+        const conn = await this._getConnection();
+        if (!conn) {
+            return {
+                'rows': null,
+                'fields': [],
+                'error': {
+                    'message': 'false',
+                    'errno': 0,
+                },
+                'result': -500,
+            };
+        }
+        // --- 执行一次后自动解除 using ---
+        return conn.query(sql, values);
+    }
+    /**
+     * --- 执行一条 SQL 并获得影响行数对象 packet，连接失败抛出错误 ---
+     * @param sql 执行的 SQL 字符串
+     * @param values 要替换的 data 数据
+     */
+    async execute(sql, values) {
+        ++this._queries;
+        const conn = await this._getConnection();
+        if (!conn) {
+            return {
+                'packet': null,
+                'fields': [],
+                'error': {
+                    'message': 'null',
+                    'errno': 0,
+                },
+                'result': -500,
+            };
+        }
+        return conn.execute(sql, values);
+    }
+    /**
+     * --- 开启事务，返回事务对象并锁定连接，别人任何人不可用，有 ctr 的话必传 this，独立执行时可传 null ---
+     */
+    async beginTransaction(ctr) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return null;
+        }
+        if (!await conn.beginTransaction()) {
+            return null;
+        }
+        return new Transaction(ctr, conn);
+    }
+    /**
+     * --- 获取一个连接，自动变为 using 状态，；连接失败会返回 null ---
+     */
+    async _getConnection() {
+        let conn = null;
+        for (const connection of connections) {
+            const etc = connection.getEtc();
+            const service = connection.getService();
+            if ((etc.host !== this._etc.host) ||
+                (etc.port !== this._etc.port) ||
+                (etc.name !== this._etc.name) ||
+                (etc.user !== this._etc.user) ||
+                (service !== this._service)) {
+                // --- 配置项连接项不匹配 ---
+                continue;
+            }
+            if (!connection.using()) {
+                // --- 正在被使用，或者已经 lost ---
+                continue;
+            }
+            // --- 匹配且可用 ---
+            conn = connection;
+            break;
+        }
+        if (!conn) {
+            // --- 没有找到合适的连接，创建一个 ---
+            loop: for (let i = 0; i < 3; ++i) {
+                try {
+                    switch (this._service) {
+                        case lDb.ESERVICE.MYSQL: {
+                            // --- MYSQL ---
+                            const link = await mysql2.createConnection({
+                                'host': this._etc.host,
+                                'port': this._etc.port,
+                                'charset': this._etc.charset,
+                                'database': this._etc.name,
+                                'user': this._etc.user,
+                                'password': this._etc.pwd,
+                                'connectTimeout': 3_000,
+                                typeCast: (field, next) => {
+                                    if (field.type !== 'GEOMETRY') {
+                                        return next();
+                                    }
+                                    const geo = field.geometry();
+                                    if (!geo) {
+                                        return null;
+                                    }
+                                    if (!Array.isArray(geo)) {
+                                        return geo;
+                                    }
+                                    if (geo[0].x && geo[0].y) {
+                                        return geo;
+                                    }
+                                    return geo[0];
+                                },
+                            });
+                            const c = new Connection(this._etc, link);
+                            c.using();
+                            link.on('error', function (err) {
+                                c.setLost();
+                                if (err.code !== 'PROTOCOL_CONNECTION_LOST') {
+                                    lCore.debug('[DB][_getConnection][MYSQL][error]', err);
+                                    lCore.log({}, '[DB][_getConnection][MYSQL][error] ' + err.message, '-error');
+                                }
+                            }).on('end', () => {
+                                // lCore.debug('[DB][_getConnection] connection end.');
+                                c.setLost();
+                            }).on('close', () => {
+                                c.setLost();
+                            });
+                            conn = c;
+                            connections.push(conn);
+                            break loop;
+                        }
+                        case lDb.ESERVICE.PGSQL: {
+                            // --- PGSQL ---
+                            const link = new pg.Client({
+                                'host': this._etc.host,
+                                'port': this._etc.port,
+                                'database': this._etc.name,
+                                'user': this._etc.user,
+                                'password': this._etc.pwd,
+                                'connectionTimeoutMillis': 3_000,
+                            });
+                            await link.connect();
+                            const c = new Connection(this._etc, link);
+                            c.using();
+                            link.on('error', err => {
+                                c.setLost();
+                                lCore.debug('[DB][_getConnection][PGSQL][error]', err);
+                                lCore.log({}, '[DB][_getConnection][PGSQL][error] ' + err.message, '-error');
+                            }).on('end', () => {
+                                c.setLost();
+                            });
+                            conn = c;
+                            connections.push(conn);
+                            break loop;
+                        }
+                    }
+                }
+                catch (err) {
+                    if (err.message.includes('ETIMEOUT') || err.message.includes('EHOSTUNREACH') || err.message.includes('ECONNREFUSED')) {
+                        // lCore.debug(`[DB][_getConnection][${lDb.ESERVICE[this._service]}]`, err);
+                        await lCore.sleep(300);
+                        continue;
+                    }
+                    const msg = `[DB][_getConnection][${lDb.ESERVICE[this._service]}] ${err.message}(${this._etc.host}:${this._etc.port})`;
+                    lCore.debug(msg);
+                    lCore.log({}, msg, '-error');
+                    break;
+                }
+            }
+        }
+        return conn;
+    }
+    /**
+     * --- 获取 SQL 执行次数 ---
+     */
+    getQueries() {
+        return this._queries;
+    }
+}

package/lib/db/tran.d.ts

@@ -0,0 +1,33 @@
+import * as sCtr from '#kebab/sys/ctr.js';
+import * as lDb from '#kebab/lib/db.js';
+import * as kebab from '#kebab/index.js';
+import * as conn from './conn.js';
+/** --- 事务连接对象，commit 和 rollback 后将无法使用 --- */
+export declare class Transaction {
+    /** --- SQL 执行次数 --- */
+    private _queries;
+    /** --- 连接对象 --- */
+    private _conn;
+    private readonly _ctr;
+    private readonly _timer;
+    constructor(ctr: sCtr.Ctr | null, conn: conn.Connection, opts?: {
+        'warning'?: number;
+        'danger'?: number;
+    });
+    /** --- 获取当前连接的服务商 --- */
+    getService(): lDb.ESERVICE | null;
+    /**
+     * --- 在事务连接中执行一条 SQL ---
+     * @param sql 执行的 SQL 字符串
+     * @param values 要替换的 data 数据
+     */
+    query(sql: string, values?: kebab.DbValue[]): Promise<lDb.IData>;
+    /**
+     * --- 执行一条 SQL 并获得影响行数对象 packet，连接失败抛出错误 ---
+     * @param sql 执行的 SQL 字符串
+     * @param values 要替换的 data 数据
+     */
+    execute(sql: string, values?: kebab.DbValue[]): Promise<lDb.IPacket>;
+    commit(): Promise<boolean>;
+    rollback(): Promise<boolean>;
+}

package/lib/db/tran.js

@@ -0,0 +1,122 @@
+import * as lCore from '#kebab/lib/core.js';
+/** --- 事务连接对象，commit 和 rollback 后将无法使用 --- */
+export class Transaction {
+    constructor(ctr, conn, opts = {}) {
+        /** --- SQL 执行次数 --- */
+        this._queries = 0;
+        // --- 事务时长监听 timer ---
+        this._timer = {
+            'warning': undefined,
+            'danger': undefined
+        };
+        // --- 进来的连接对象直接是事务独占模式 ---
+        this._ctr = ctr;
+        if (ctr) {
+            ++ctr.getPrototype('_waitInfo').transaction;
+        }
+        this._conn = conn;
+        // --- 事务时长监听 ---
+        const warning = opts.warning ?? 1_500;
+        this._timer.warning = setTimeout(() => {
+            this._timer.warning = undefined;
+            lCore.display('[WARNING][DB][Transaction] time too long, ms: ' + warning + ' ' + (this._ctr?.getPrototype('_config').const.path ?? 'no ctr'));
+        }, warning);
+        const danger = opts.danger ?? 5_000;
+        this._timer.danger = setTimeout(() => {
+            this._timer.danger = undefined;
+            lCore.display('[DANGER][DB][Transaction] time too long, ms:', danger, this._ctr?.getPrototype('_config').const.path ?? 'no ctr');
+        }, danger);
+    }
+    /** --- 获取当前连接的服务商 --- */
+    getService() {
+        return this._conn?.getService() ?? null;
+    }
+    /**
+     * --- 在事务连接中执行一条 SQL ---
+     * @param sql 执行的 SQL 字符串
+     * @param values 要替换的 data 数据
+     */
+    async query(sql, values) {
+        if (!this._conn) {
+            // --- 当前连接已不可用 ---
+            lCore.display('[DB][Transaction][query] has been closed ' + (this._ctr?.getPrototype('_config').const.path ?? 'no ctr') + ': ' + sql);
+            lCore.log({}, '[DB][Transaction][query] has been closed ' + (this._ctr?.getPrototype('_config').const.path ?? 'no ctr') + ': ' + sql, '-error');
+            return {
+                'rows': null,
+                'fields': [],
+                'error': {
+                    'message': 'false',
+                    'errno': 0,
+                },
+                'result': -500,
+            };
+        }
+        ++this._queries;
+        return this._conn.query(sql, values);
+    }
+    /**
+     * --- 执行一条 SQL 并获得影响行数对象 packet，连接失败抛出错误 ---
+     * @param sql 执行的 SQL 字符串
+     * @param values 要替换的 data 数据
+     */
+    async execute(sql, values) {
+        if (!this._conn) {
+            // --- 当前连接已不可用 ---
+            lCore.display('[DB][Transaction][execute] has been closed ' + (this._ctr?.getPrototype('_config').const.path ?? 'no ctr') + ': ' + sql);
+            lCore.log({}, '(db.Transaction.execute) has been closed ' + (this._ctr?.getPrototype('_config').const.path ?? 'no ctr') + ': ' + sql, '-error');
+            return {
+                'packet': null,
+                'fields': [],
+                'error': {
+                    'message': 'null',
+                    'errno': 0,
+                },
+                'result': -500,
+            };
+        }
+        ++this._queries;
+        return this._conn.execute(sql, values);
+    }
+    async commit() {
+        if (!this._conn) {
+            // --- 当前连接已不可用 ---
+            lCore.display('[DB][Transaction][commit] has been closed ' + (this._ctr?.getPrototype('_config').const.path ?? 'no ctr'));
+            lCore.log({}, '[DB][Transaction][commit] has been closed ' + (this._ctr?.getPrototype('_config').const.path ?? 'no ctr'), '-error');
+            return false;
+        }
+        const r = await this._conn.commit();
+        if (!r) {
+            return false;
+        }
+        this._conn = null;
+        if (this._ctr) {
+            --this._ctr.getPrototype('_waitInfo').transaction;
+        }
+        clearTimeout(this._timer.warning);
+        this._timer.warning = undefined;
+        clearTimeout(this._timer.danger);
+        this._timer.danger = undefined;
+        return true;
+    }
+    async rollback() {
+        if (!this._conn) {
+            // --- 当前连接已不可用 ---
+            lCore.display('[DB][Transaction][rollback] has been closed: ' + (this._ctr?.getPrototype('_config').const.path ?? 'no ctr'));
+            lCore.log({}, '[DB][Transaction][rollback] has been closed: ' + (this._ctr?.getPrototype('_config').const.path ?? 'no ctr'), '-error');
+            return false;
+        }
+        const r = await this._conn.rollback();
+        if (!r) {
+            return false;
+        }
+        this._conn = null;
+        if (this._ctr) {
+            --this._ctr.getPrototype('_waitInfo').transaction;
+        }
+        clearTimeout(this._timer.warning);
+        this._timer.warning = undefined;
+        clearTimeout(this._timer.danger);
+        this._timer.danger = undefined;
+        return true;
+    }
+}

package/lib/db.d.ts

@@ -1,196 +1,62 @@
 /**
  * Project: Kebab, User: JianSuoQiYue
  * Date: 2019-4-15 13:40
- * Last: 2020-4-13 15:34:45, 2022-09-12 13:10:34, 2023-5-24 18:29:38, 2024-7-11 14:37:54, 2024-8-25 00:32:53, 2024-9-22 17:30:47, 2025-8-3 20:24:03
+ * Last: 2020-4-13 15:34:45, 2022-09-12 13:10:34, 2023-5-24 18:29:38, 2024-7-11 14:37:54, 2024-8-25 00:32:53, 2024-9-22 17:30:47, 2025-8-3 20:24:03, 2025-11-8 19:13:03
  */
-import * as mysql2 from 'mysql2/promise';
 import * as kebab from '#kebab/index.js';
 import * as sCtr from '#kebab/sys/ctr.js';
+import { Connection } from './db/conn.js';
+import { Pool } from './db/pool.js';
+import { Transaction } from './db/tran.js';
+/** --- 服务商定义 --- */
+export declare enum ESERVICE {
+    'MYSQL' = 0,
+    'PGSQL' = 1
+}
 /** --- query 返回的数据 --- */
 export interface IData {
-    'rows': any[] | null;
-    'fields': mysql2.FieldPacket[];
+    'rows': Array<Record<string, any>> | null;
+    'fields': Array<{
+        /** --- 字段名 --- */
+        'name': string;
+        /** --- 字段格式长度 --- */
+        'length': number;
+    }>;
     'error': {
         'message': string;
         'errno': number;
-        [key: string]: any;
     } | null;
     /** --- 1-正常,-500-服务器错误 --- */
     'result': number;
 }
 /** --- exec 返回对象 --- */
 export interface IPacket {
-    'packet': mysql2.ResultSetHeader | null;
-    'fields': mysql2.FieldPacket[];
+    'packet': {
+        /** --- 受影响的行数 --- */
+        'affected': number;
+        /** --- 插入的 id --- */
+        'insert': number;
+    } | null;
+    'fields': Array<{
+        /** --- 字段名 --- */
+        'name': string;
+        /** --- 字段格式长度 --- */
+        'length': number;
+    }>;
     'error': {
         'message': string;
         'errno': number;
         [key: string]: any;
     } | null;
-}
-/** --- 连接信息 --- */
-export interface IConnectionInfo {
-    'id': number;
-    'last': number;
-    'host': string;
-    'port': number;
-    'name': string;
-    'user': string;
-    'lost': boolean;
-    'using': boolean;
-    'transaction': boolean;
-}
-/** --- 数据库连接池对象 --- */
-export declare class Pool {
-    /** --- SQL 执行次数 --- */
-    private _queries;
-    /** --- 当前 Pool 对象的数据库连接信息 --- */
-    private readonly _etc;
-    constructor(etc: kebab.IConfigDb);
-    /**
-     * --- 执行一条 SQL，无视顺序和相同连接，随用随取 ---
-     * @param sql 执行的 SQL 字符串
-     * @param values 要替换的 data 数据
-     * @returns error.errno = -500 表示系统错误
-     */
-    query(sql: string, values?: kebab.DbValue[]): Promise<IData>;
-    /**
-     * --- 执行一条 SQL 并获得影响行数对象 packet，连接失败抛出错误 ---
-     * @param sql 执行的 SQL 字符串
-     * @param values 要替换的 data 数据
-     */
-    execute(sql: string, values?: kebab.DbValue[]): Promise<IPacket>;
-    /**
-     * --- 开启事务，返回事务对象并锁定连接，别人任何人不可用，有 ctr 的话必传 this，独立执行时可传 null ---
-     */
-    beginTransaction(ctr: sCtr.Ctr | null): Promise<Transaction | null>;
-    /**
-     * --- 获取一个连接，自动变为 using 状态，；连接失败会返回 null ---
-     */
-    private _getConnection;
-    /**
-     * --- 获取 SQL 执行次数 ---
-     */
-    getQueries(): number;
-}
-/** --- 事务连接对象，commit 和 rollback 后将无法使用 --- */
-export declare class Transaction {
-    /** --- SQL 执行次数 --- */
-    private _queries;
-    /** --- 连接对象 --- */
-    private _conn;
-    private readonly _ctr;
-    private readonly _timer;
-    constructor(ctr: sCtr.Ctr | null, conn: Connection, opts?: {
-        'warning'?: number;
-        'danger'?: number;
-    });
-    /**
-     * --- 在事务连接中执行一条 SQL ---
-     * @param sql 执行的 SQL 字符串
-     * @param values 要替换的 data 数据
-     */
-    query(sql: string, values?: kebab.DbValue[]): Promise<IData>;
-    /**
-     * --- 执行一条 SQL 并获得影响行数对象 packet，连接失败抛出错误 ---
-     * @param sql 执行的 SQL 字符串
-     * @param values 要替换的 data 数据
-     */
-    execute(sql: string, values?: kebab.DbValue[]): Promise<IPacket>;
-    commit(): Promise<boolean>;
-    rollback(): Promise<boolean>;
-}
-/** --- 数据库连接对象 --- */
-export declare class Connection {
-    /** --- 本连接最后一次使用时间 --- */
-    private _last;
-    /** --- 最后两次执行的 sql 完整串 --- */
-    private readonly _lastSql;
-    /** --- 数据库连接对象 --- */
-    private readonly _link;
-    /** --- 当前连接是否正在被独占使用 --- */
-    private _using;
-    /** --- 当发生断开，则需从连接池移除连接 --- */
-    private _lost;
-    /** --- 当前正在处理事务 --- */
-    private _transaction;
-    /** --- 当前的连接配置信息 --- */
-    private readonly _etc;
-    constructor(etc: kebab.IConfigDb, link: mysql2.Connection);
-    /**
-     * --- 获取连接 etc 信息 ---
-     */
-    getEtc(): kebab.IConfigDb;
-    /**
-     * --- 获取最后一次获取连接的时间 ---
-     */
-    getLast(): number;
-    /**
-     * --- 获取最后两次执行的 sql 字符串 ---
-     */
-    getLastSql(): Array<{
-        'sql': string;
-        'values'?: kebab.DbValue[];
-    }>;
-    /**
-     * --- 将本条连接设置为不可用 ---
-     */
-    setLost(): void;
-    /**
-     * --- 是否已经丢失 ---
-     */
-    isLost(): boolean;
-    /**
-     * --- 是否是开启事务状态 ---
-     */
-    isTransaction(): boolean;
-    /**
-     * --- 获取当前状态是否正在被使用中 ---
-     */
-    isUsing(): boolean;
-    /**
-     * --- 判断是否可用（丢失的也算不可用），返回 true 代表获取成功并自动刷新最后时间 ---
-     */
-    using(): boolean;
-    /**
-     * --- 取消占用 ---
-     */
-    used(): void;
-    /**
-     * --- 设定最后使用时间 ---
-     */
-    refreshLast(): void;
-    /**
-     * --- 通过执行一条语句判断当前连接是否可用 ---
-     * @param last 是否刷新最后使用时间（默认刷新）
-     */
-    isAvailable(last?: boolean): Promise<boolean>;
-    /**
-     * --- 执行一条 SQL 并获得返回数据 ---
-     * @param sql 执行的 SQL 字符串
-     * @param values 要替换的 data 数据
-     */
-    query(sql: string, values?: kebab.DbValue[]): Promise<IData>;
-    /**
-     * --- 执行一条 SQL 并获得影响行数对象 packet ---
-     * @param sql 执行的 SQL 字符串
-     * @param values 要替换的 data 数据
-     */
-    execute(sql: string, values?: kebab.DbValue[]): Promise<IPacket>;
-    /**
-     * --- 关闭连接，一般情况下不使用 ---
-     */
-    end(): Promise<boolean>;
-    beginTransaction(): Promise<boolean>;
-    commit(): Promise<boolean>;
-    rollback(): Promise<boolean>;
+    /** --- 1-正常,-500-服务器错误 --- */
+    'result': number;
 }
 /**
  * --- 获取 Db Pool 对象 ---
  * @param etc 配置信息可留空
  */
-export declare function get(ctrEtc: sCtr.Ctr | kebab.IConfigDb): Pool;
-/**
- * --- 获取当前连接池中所有连接的信息 ---
- */
-export declare function getConnectionList(): IConnectionInfo[];
+export declare function get(ctrEtc: sCtr.Ctr | kebab.IConfigDb, opt?: {
+    /** --- 服务商，默认 PGSQL --- */
+    'service'?: ESERVICE;
+}): Pool;
+export { Connection, Pool, Transaction };