@maiyunnet/kebab 4.1.0 → 5.0.1

package/index.d.ts

@@ -5,7 +5,7 @@
  * --- 本文件用来定义每个目录实体地址的常量 ---
  */
 /** --- 当前系统版本号 --- */
-export declare const VER = "4.1.0";
+export declare const VER = "5.0.1";
 /** --- 框架根目录，以 / 结尾  --- */
 export declare const ROOT_PATH: string;
 export declare const LIB_PATH: string;
@@ -37,7 +37,12 @@ export interface IConfig {
         [key: string]: Json;
     };
     'const': IConfigConst;
-    'db': IConfigDb;
+    'db': Record<string, {
+        'default': IConfigDb;
+        'read': IConfigDb;
+    }> & {
+        'default': 'MYSQL' | 'PGSQL';
+    };
     'jwt': IConfigJwt;
     'kv': IConfigKv;
     'route': Record<string, string>;

package/index.js

@@ -6,7 +6,7 @@
  * --- 本文件用来定义每个目录实体地址的常量 ---
  */
 /** --- 当前系统版本号 --- */
-export const VER = '4.1.0';
+export const VER = '5.0.1';
 // --- 服务端用的路径 ---
 const imu = decodeURIComponent(import.meta.url).replace('file://', '').replace(/^\/(\w:)/, '$1');
 /** --- /xxx/xxx --- */

package/lib/db/conn.d.ts

@@ -0,0 +1,91 @@
+import * as mysql2 from 'mysql2/promise';
+import * as pg from 'pg';
+import * as lDb from '#kebab/lib/db.js';
+import * as kebab from '#kebab/index.js';
+/** --- 数据库连接对象 --- */
+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 | pg.Client);
+    /**
+     * --- 获取连接 etc 信息 ---
+     */
+    getEtc(): kebab.IConfigDb;
+    /** --- 获取数据库服务类型 --- */
+    getService(): lDb.ESERVICE;
+    /**
+     * --- 获取最后一次获取连接的时间 ---
+     */
+    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<lDb.IData>;
+    /**
+     * --- 执行一条 SQL 并获得影响行数对象 packet ---
+     * @param sql 执行的 SQL 字符串
+     * @param values 要替换的 data 数据
+     */
+    execute(sql: string, values?: kebab.DbValue[]): Promise<lDb.IPacket>;
+    /**
+     * --- 关闭连接，一般情况下不使用 ---
+     */
+    end(): Promise<boolean>;
+    beginTransaction(): Promise<boolean>;
+    commit(): Promise<boolean>;
+    rollback(): Promise<boolean>;
+}

package/lib/db/conn.js

@@ -0,0 +1,328 @@
+import * as pg from 'pg';
+import * as lCore from '#kebab/lib/core.js';
+import * as lTime from '#kebab/lib/time.js';
+import * as lDb from '#kebab/lib/db.js';
+// --- 注册解析器 ---
+pg.types.setTypeParser(pg.types.builtins.POLYGON, val => {
+    if (val === null) {
+        return null;
+    }
+    // --- val 如 ((1,1),(2,2),(3,3),(1,1)) ---
+    // --- 去除两端括号，然后按分隔解析坐标 ---
+    const matches = val
+        .replace(/^\(\(/, '')
+        .replace(/\)\)$/, '')
+        .split('),(');
+    const points = matches.map(pair => {
+        const [xStr, yStr] = pair.split(',');
+        return { 'x': parseFloat(xStr), 'y': parseFloat(yStr) };
+    });
+    // --- 返回 [{x: 1, y: 1}, {x :2, y: 2}, ... ] ---
+    return points;
+});
+/** --- 数据库连接对象 --- */
+export class Connection {
+    constructor(etc, link) {
+        /** --- 本连接最后一次使用时间 --- */
+        this._last = 0;
+        /** --- 最后两次执行的 sql 完整串 --- */
+        this._lastSql = [];
+        /** --- 当前连接是否正在被独占使用 --- */
+        this._using = false;
+        /** --- 当发生断开，则需从连接池移除连接 --- */
+        this._lost = false;
+        /** --- 当前正在处理事务 --- */
+        this._transaction = false;
+        this._etc = etc;
+        this._link = link;
+        this.refreshLast();
+    }
+    /**
+     * --- 获取连接 etc 信息 ---
+     */
+    getEtc() {
+        return this._etc;
+    }
+    /** --- 获取数据库服务类型 --- */
+    getService() {
+        return this._link instanceof pg.Client ? lDb.ESERVICE.PGSQL : lDb.ESERVICE.MYSQL;
+    }
+    /**
+     * --- 获取最后一次获取连接的时间 ---
+     */
+    getLast() {
+        return this._last;
+    }
+    /**
+     * --- 获取最后两次执行的 sql 字符串 ---
+     */
+    getLastSql() {
+        return this._lastSql;
+    }
+    /**
+     * --- 将本条连接设置为不可用 ---
+     */
+    setLost() {
+        this._lost = true;
+    }
+    /**
+     * --- 是否已经丢失 ---
+     */
+    isLost() {
+        return this._lost;
+    }
+    /**
+     * --- 是否是开启事务状态 ---
+     */
+    isTransaction() {
+        return this._transaction;
+    }
+    /**
+     * --- 获取当前状态是否正在被使用中 ---
+     */
+    isUsing() {
+        return this._using;
+    }
+    /**
+     * --- 判断是否可用（丢失的也算不可用），返回 true 代表获取成功并自动刷新最后时间 ---
+     */
+    using() {
+        if (this._lost || this._using) {
+            return false;
+        }
+        else {
+            this.refreshLast();
+            this._using = true;
+            return true;
+        }
+    }
+    /**
+     * --- 取消占用 ---
+     */
+    used() {
+        this._using = false;
+    }
+    /**
+     * --- 设定最后使用时间 ---
+     */
+    refreshLast() {
+        this._last = lTime.stamp();
+    }
+    /**
+     * --- 通过执行一条语句判断当前连接是否可用 ---
+     * @param last 是否刷新最后使用时间（默认刷新）
+     */
+    async isAvailable(last = true) {
+        if (last) {
+            this.refreshLast();
+        }
+        try {
+            if (this._link instanceof pg.Client) {
+                await this._link.query('SELECT 1');
+            }
+            else {
+                await this._link.query('SELECT 1');
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * --- 执行一条 SQL 并获得返回数据 ---
+     * @param sql 执行的 SQL 字符串
+     * @param values 要替换的 data 数据
+     */
+    async query(sql, values) {
+        const rtn = {
+            'rows': null,
+            'fields': [],
+            'error': null,
+            'result': 1,
+        };
+        try {
+            this.refreshLast();
+            if (this._lastSql.length === 2) {
+                this._lastSql.splice(0, 1);
+            }
+            this._lastSql.push({
+                'sql': sql,
+                'values': values
+            });
+            const time = Date.now();
+            if (this._link instanceof pg.Client) {
+                const res = await this._link.query(sql, values);
+                rtn.rows = res.rows;
+                rtn.fields = res.fields.map(item => ({
+                    'name': item.name,
+                    'length': item.dataTypeSize,
+                }));
+            }
+            else {
+                const res = await this._link.execute(sql, values);
+                rtn.rows = res[0];
+                rtn.fields = res[1].map(item => ({
+                    'name': item.orgName || item.name,
+                    'length': item.length ?? -1,
+                }));
+            }
+            if (Date.now() - time > 200) {
+                lCore.log({}, '[WARNING][DB][Connection][query] slow sql 200ms: ' + sql, '-warning');
+            }
+        }
+        catch (e) {
+            rtn.error = {
+                'message': e.message,
+                'errno': e.errno ?? Number(e.code),
+            };
+            rtn.result = -500;
+        }
+        if (!this._transaction) {
+            this._using = false;
+        }
+        // --- 返回数据 ---
+        return rtn;
+    }
+    /**
+     * --- 执行一条 SQL 并获得影响行数对象 packet ---
+     * @param sql 执行的 SQL 字符串
+     * @param values 要替换的 data 数据
+     */
+    async execute(sql, values) {
+        const rtn = {
+            'packet': null,
+            'fields': [],
+            'error': null,
+            'result': 1,
+        };
+        try {
+            this.refreshLast();
+            if (this._lastSql.length === 2) {
+                this._lastSql.splice(0, 1);
+            }
+            this._lastSql.push({
+                'sql': sql,
+                'values': values,
+            });
+            const time = Date.now();
+            if (this._link instanceof pg.Client) {
+                if (sql.startsWith('INSERT ') && !sql.includes('RETURNING ')) {
+                    if (sql.endsWith(';')) {
+                        sql = sql.slice(0, -1);
+                    }
+                    sql += ' RETURNING "id"';
+                }
+                const res = await this._link.query(sql, values);
+                rtn.packet = {
+                    'affected': res.rowCount ?? 0,
+                    'insert': res.rows[0]?.id ?? 0,
+                };
+                rtn.fields = res.fields.map(item => ({
+                    'name': item.name,
+                    'length': item.dataTypeSize,
+                }));
+            }
+            else {
+                const res = await this._link.execute(sql, values);
+                rtn.packet = {
+                    'affected': res[0].affectedRows,
+                    'insert': res[0].insertId,
+                };
+                if (res[1]) {
+                    rtn.fields = res[1].map(item => ({
+                        'name': item.orgName,
+                        'length': item.length ?? -1,
+                    }));
+                }
+            }
+            if (Date.now() - time > 200) {
+                lCore.log({}, '[WARNING][DB][Connection][execute] slow sql 200ms: ' + sql, '-warning');
+            }
+        }
+        catch (e) {
+            let errno = e.errno ?? Number(e.code.replace(/[a-z][A-Z]/g, ''));
+            if (errno === 23505) {
+                errno = 1062;
+            }
+            // --- e.errno 可能为 1062 ---
+            rtn.error = {
+                'message': e.message,
+                'errno': errno,
+            };
+            rtn.result = -500;
+        }
+        if (!this._transaction) {
+            this._using = false;
+        }
+        // --- 返回数据 ---
+        return rtn;
+    }
+    /**
+     * --- 关闭连接，一般情况下不使用 ---
+     */
+    async end() {
+        try {
+            await this._link.end();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // --- 事务，只能在独占连接中使用，pool 创建事务返回独占连接，commit 或 rollback 释放连接回池 ---
+    async beginTransaction() {
+        if (this._using) {
+            try {
+                this._transaction = true;
+                if (this._link instanceof pg.Client) {
+                    await this._link.query('BEGIN');
+                }
+                else {
+                    await this._link.beginTransaction();
+                }
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    async commit() {
+        try {
+            if (this._link instanceof pg.Client) {
+                await this._link.query('COMMIT');
+            }
+            else {
+                await this._link.commit();
+            }
+            this.refreshLast();
+            this._transaction = false;
+            this._using = false;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async rollback() {
+        try {
+            if (this._link instanceof pg.Client) {
+                await this._link.query('ROLLBACK');
+            }
+            else {
+                await this._link.rollback();
+            }
+            this.refreshLast();
+            this._transaction = false;
+            this._using = false;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/lib/db/pool.d.ts

@@ -0,0 +1,61 @@
+import * as kebab from '#kebab/index.js';
+import * as lDb from '#kebab/lib/db.js';
+import * as sCtr from '#kebab/sys/ctr.js';
+import { Transaction } from './tran.js';
+/** --- 连接信息 --- */
+export interface IConnectionInfo {
+    'id': number;
+    'service': lDb.ESERVICE;
+    'last': number;
+    'host': string;
+    'port': number;
+    'name': string;
+    'user': string;
+    'lost': boolean;
+    'using': boolean;
+    'transaction': boolean;
+}
+/**
+ * --- 获取当前连接池中所有连接的信息 ---
+ */
+export declare function getConnectionList(): IConnectionInfo[];
+/** --- 数据库连接池对象 --- */
+export declare class Pool {
+    /** --- SQL 执行次数 --- */
+    private _queries;
+    /** --- 当前服务商 --- */
+    private readonly _service;
+    /** --- 当前 Pool 对象的数据库连接信息 --- */
+    private readonly _etc;
+    constructor(etc: kebab.IConfigDb, opt: {
+        /** --- 服务商 --- */
+        'service': lDb.ESERVICE;
+    });
+    /** --- 获取当前连接的服务商 --- */
+    getService(): lDb.ESERVICE;
+    /**
+     * --- 执行一条 SQL，无视顺序和相同连接，随用随取 ---
+     * @param sql 执行的 SQL 字符串
+     * @param values 要替换的 data 数据
+     * @returns error.errno = -500 表示系统错误
+     */
+    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>;
+    /**
+     * --- 开启事务，返回事务对象并锁定连接，别人任何人不可用，有 ctr 的话必传 this，独立执行时可传 null ---
+     */
+    beginTransaction(ctr: sCtr.Ctr | null): Promise<Transaction | null>;
+    /**
+     * --- 获取一个连接，自动变为 using 状态，；连接失败会返回 null ---
+     */
+    private _getConnection;
+    /**
+     * --- 获取 SQL 执行次数 ---
+     */
+    getQueries(): number;
+}