@maiyunnet/kebab 2.0.0

package/lib/db.js

@@ -0,0 +1,521 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connection = exports.Transaction = exports.Pool = void 0;
+exports.get = get;
+exports.getConnectionList = getConnectionList;
+const mysql2 = __importStar(require("mysql2/promise"));
+const time = __importStar(require("~/lib/time"));
+const lSql = __importStar(require("~/lib/sql"));
+const core = __importStar(require("~/lib/core"));
+const text = __importStar(require("~/lib/text"));
+const ctr = __importStar(require("~/sys/ctr"));
+const connections = [];
+async function checkConnection() {
+    const now = time.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()) {
+            if (connection.getLast() <= now - 60) {
+                const ls = connection.getLastSql();
+                const sql = ls[1] ?? ls[0];
+                console.log(`[child] [db] [error] There is a transactional connection[${i}] that is not closed, last sql: ${sql?.sql ?? 'undefined'}.`);
+                const newarr = ls.map(item => {
+                    if (!item.values) {
+                        return item.sql;
+                    }
+                    return lSql.format(item.sql, item.values);
+                });
+                await core.log({
+                    'path': '',
+                    'urlFull': '',
+                    'hostname': '',
+                    'req': null,
+                    'get': {},
+                    'cookie': {},
+                    'headers': {}
+                }, `(db.checkConnection)There is a transactional connection[${i}] that is not closed, last sql: ${newarr.join(', ')}.`, '-error');
+                await connection.rollback();
+            }
+            continue;
+        }
+        if (connection.getLast() > now - 180) {
+            continue;
+        }
+        await connection.end();
+        connections.splice(i, 1);
+        --i;
+    }
+    setTimeout(function () {
+        checkConnection().catch(e => { console.log('[DB]', e); });
+    }, 30000);
+}
+setTimeout(function () {
+    checkConnection().catch(e => { console.log('[DB]', e); });
+}, 30000);
+class Pool {
+    constructor(etc) {
+        this._queries = 0;
+        this._etc = etc;
+    }
+    async query(sql, values) {
+        ++this._queries;
+        const conn = await this._getConnection();
+        if (!conn) {
+            return {
+                'rows': null,
+                'fields': [],
+                'error': {
+                    'message': 'null',
+                    'errno': 0
+                }
+            };
+        }
+        return conn.query(sql, values);
+    }
+    async execute(sql, values) {
+        ++this._queries;
+        const conn = await this._getConnection();
+        if (!conn) {
+            return {
+                'packet': null,
+                'fields': [],
+                'error': {
+                    'message': 'null',
+                    'errno': 0
+                }
+            };
+        }
+        return conn.execute(sql, values);
+    }
+    async beginTransaction(ctr) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return null;
+        }
+        if (!await conn.beginTransaction()) {
+            return null;
+        }
+        return new Transaction(ctr, conn);
+    }
+    async _getConnection() {
+        let conn = null;
+        for (const connection of connections) {
+            const etc = connection.getEtc();
+            if ((etc.host !== this._etc.host) ||
+                (etc.port !== this._etc.port) ||
+                (etc.name !== this._etc.name) ||
+                (etc.user !== this._etc.user)) {
+                continue;
+            }
+            if (!connection.using()) {
+                continue;
+            }
+            conn = connection;
+            break;
+        }
+        if (!conn) {
+            try {
+                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': 3000
+                });
+                const c = new Connection(this._etc, link);
+                c.using();
+                link.on('error', function (err) {
+                    if (err.code !== 'PROTOCOL_CONNECTION_LOST') {
+                        console.log(err);
+                    }
+                    c.setLost();
+                }).on('end', function () {
+                    c.setLost();
+                });
+                conn = c;
+                connections.push(conn);
+            }
+            catch (e) {
+                await core.log({
+                    'path': '',
+                    'urlFull': '',
+                    'hostname': '',
+                    'req': null,
+                    'get': {},
+                    'cookie': {},
+                    'headers': {}
+                }, '(db._getConnection)' + text.stringifyJson(e.stack).slice(1, -1), '-error');
+            }
+        }
+        return conn;
+    }
+    getQueries() {
+        return this._queries;
+    }
+}
+exports.Pool = Pool;
+class Transaction {
+    constructor(ctr, conn, opts = {}) {
+        this._queries = 0;
+        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;
+            console.log('[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;
+            console.log('[DANGER][DB][Transaction] time too long, ms:', danger, this._ctr?.getPrototype('_config').const.path ?? 'no ctr');
+        }, danger);
+    }
+    async query(sql, values) {
+        if (!this._conn) {
+            console.log('[ERROR][DB][Transaction.query] has been closed.', this._ctr?.getPrototype('_config').const.path ?? 'no ctr', sql);
+            await core.log({
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '(db.Transaction.query) has been closed, ' + (this._ctr?.getPrototype('_config').const.path ?? 'no ctr') + ': ' + sql, '-error');
+            return {
+                'rows': null,
+                'fields': [],
+                'error': {
+                    'message': 'null',
+                    'errno': 0
+                }
+            };
+        }
+        ++this._queries;
+        return this._conn.query(sql, values);
+    }
+    async execute(sql, values) {
+        if (!this._conn) {
+            console.log('[ERROR][DB][Transaction.execute] has been closed.', this._ctr?.getPrototype('_config').const.path ?? 'no ctr', sql);
+            await core.log({
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '(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
+                }
+            };
+        }
+        ++this._queries;
+        return this._conn.execute(sql, values);
+    }
+    async commit() {
+        if (!this._conn) {
+            console.log('[ERROR][DB][Transaction.commit] has been closed.', this._ctr?.getPrototype('_config').const.path ?? 'no ctr');
+            await core.log({
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '(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) {
+            console.log('[ERROR][DB][Transaction.rollback] has been closed.', this._ctr?.getPrototype('_config').const.path ?? 'no ctr');
+            await core.log({
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '(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;
+    }
+}
+exports.Transaction = Transaction;
+class Connection {
+    constructor(etc, link) {
+        this._last = 0;
+        this._lastSql = [];
+        this._using = false;
+        this._lost = false;
+        this._transaction = false;
+        this._etc = etc;
+        this._link = link;
+        this.refreshLast();
+    }
+    getEtc() {
+        return this._etc;
+    }
+    getLast() {
+        return this._last;
+    }
+    getLastSql() {
+        return this._lastSql;
+    }
+    setLost() {
+        this._lost = true;
+    }
+    isLost() {
+        return this._lost;
+    }
+    isTransaction() {
+        return this._transaction;
+    }
+    isUsing() {
+        return this._using;
+    }
+    using() {
+        if (this._lost || this._using) {
+            return false;
+        }
+        else {
+            this.refreshLast();
+            this._using = true;
+            return true;
+        }
+    }
+    used() {
+        this._using = false;
+    }
+    refreshLast() {
+        this._last = time.stamp();
+    }
+    async isAvailable() {
+        this.refreshLast();
+        try {
+            await this._link.query('SELECT 1');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async query(sql, values) {
+        let res;
+        try {
+            this.refreshLast();
+            if (this._lastSql.length === 2) {
+                this._lastSql.splice(0, 1);
+            }
+            this._lastSql.push({
+                'sql': sql,
+                'values': values
+            });
+            res = await this._link.query(sql, values);
+        }
+        catch (e) {
+            if (!this._transaction) {
+                this._using = false;
+            }
+            return {
+                'rows': null,
+                'fields': [],
+                'error': e
+            };
+        }
+        if (!this._transaction) {
+            this._using = false;
+        }
+        return {
+            'rows': res[0],
+            'fields': res[1],
+            'error': null
+        };
+    }
+    async execute(sql, values) {
+        let res;
+        try {
+            this.refreshLast();
+            if (this._lastSql.length === 2) {
+                this._lastSql.splice(0, 1);
+            }
+            this._lastSql.push({
+                'sql': sql,
+                'values': values
+            });
+            res = await this._link.execute(sql, values);
+        }
+        catch (e) {
+            if (!this._transaction) {
+                this._using = false;
+            }
+            return {
+                'packet': null,
+                'fields': [],
+                'error': e
+            };
+        }
+        if (!this._transaction) {
+            this._using = false;
+        }
+        return {
+            'packet': res[0],
+            'fields': res[1],
+            'error': null
+        };
+    }
+    async end() {
+        try {
+            await this._link.end();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async beginTransaction() {
+        if (this._using) {
+            try {
+                this._transaction = true;
+                await this._link.beginTransaction();
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    async commit() {
+        try {
+            await this._link.commit();
+            this.refreshLast();
+            this._transaction = false;
+            this._using = false;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async rollback() {
+        try {
+            await this._link.rollback();
+            this.refreshLast();
+            this._transaction = false;
+            this._using = false;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.Connection = Connection;
+function get(ctrEtc) {
+    const etc = ctrEtc instanceof ctr.Ctr ? ctrEtc.getPrototype('_config').db : ctrEtc;
+    return new Pool(etc);
+}
+function getConnectionList() {
+    const list = [];
+    for (let i = 0; i < connections.length; ++i) {
+        const connection = connections[i];
+        const etc = connection.getEtc();
+        list.push({
+            'id': i,
+            '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;
+}