midway-fatcms 0.0.1-beta.76 → 0.0.1-beta.77

package/dist/libs/crud-pro/models/TransactionMySQL.js

@@ -1,83 +1,48 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionMySQL = void 0;
-const CrudMonitor_1 = require("../../../libs/crud-pro/utils/CrudMonitor");
-class TransactionMySQL {
-    constructor() {
-        this.isBeginTransaction = false;
-        this.connectionMap = {};
-        this.connectionList = [];
-    }
-    /**
-     * 获取链接对象
-     * @param pool
-     */
-    async getTxConnection(pool) {
-        // 尽量复用同一个连接
-        let connection = this.connectionMap[pool.poolName];
-        if (!connection) {
-            const poolInstance = pool.poolInstance;
-            connection = await poolInstance.getConnection();
-            this.connectionMap[pool.poolName] = connection;
-            this.connectionList.push(connection);
-            CrudMonitor_1.CrudMonitor.mysqlGetConnectionCount++;
-            // 开启了事务
-            if (this.isBeginTransaction) {
-                await connection.beginTransaction();
-            }
-        }
-        return connection;
-    }
-    /**
-     * 开始事务
-     */
-    beginTx() {
-        this.isBeginTransaction = true;
-    }
-    /**
-     * 提交事务
-     */
-    async commitTx() {
-        if (!this.isBeginTransaction) {
-            return;
-        }
-        const connections = this.connectionList;
-        for (let i = 0; i < connections.length; i++) {
-            const connection = connections[i];
-            await connection.commit();
-        }
-    }
-    /**
-     * 事务回滚
-     */
-    async rollbackTx() {
-        if (!this.isBeginTransaction) {
-            return;
-        }
-        const connections = this.connectionList;
-        for (let i = 0; i < connections.length; i++) {
-            const connection = connections[i];
-            await connection.rollback();
-        }
-    }
-    /**
-     * 释放连接
-     */
-    async releaseTx() {
-        // 不管有没有开启事务，都要释放连接。
-        const connections = this.connectionList;
-        for (let i = 0; i < connections.length; i++) {
-            const connection = connections[i];
-            try {
-                CrudMonitor_1.CrudMonitor.mysqlReleaseConnectionCount++;
-                await connection.release();
-            }
-            catch (e) {
-                console.error(e);
-            }
-        }
-        this.connectionList = [];
-        this.connectionMap = {};
-    }
-}
-exports.TransactionMySQL = TransactionMySQL;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionMySQL = void 0;
+const CrudMonitor_1 = require("../../../libs/crud-pro/utils/CrudMonitor");
+class MySqlConnectionClient {
+    constructor(originConnection) {
+        this.originConnection = originConnection;
+        CrudMonitor_1.CrudMonitor.mysqlGetConnectionCount++;
+    }
+    async query(sql, values) {
+        const res = await this.originConnection.query(sql, values);
+        const rows = res[0];
+        return {
+            rows,
+            originRes: res
+        };
+    }
+    async beginTransaction() {
+        await this.originConnection.beginTransaction();
+    }
+    async commit() {
+        await this.originConnection.commit();
+    }
+    async rollback() {
+        await this.originConnection.commit();
+    }
+    async release() {
+        try {
+            CrudMonitor_1.CrudMonitor.mysqlReleaseConnectionCount++;
+            await this.originConnection.release();
+        }
+        catch (e) {
+            console.log('[crud-pro] MySqlConnectionClient release ', e);
+        }
+    }
+}
+class TransactionMySQL {
+    /**
+     * 获取链接对象
+     * @param pool
+     */
+    async getTxConnection(pool) {
+        const poolInstance = pool.poolInstance;
+        const originConnection = await poolInstance.getConnection();
+        return new MySqlConnectionClient(originConnection);
+    }
+}
+exports.TransactionMySQL = TransactionMySQL;

package/dist/libs/crud-pro/models/TransactionPostgres.d.ts

@@ -1,29 +1,19 @@
-import { PoolClient } from 'pg';
-import { IConnectionPool } from '../interfaces';
-declare class TransactionPostgres {
-    private isBeginTransaction;
-    private connectionMap;
-    private connectionList;
-    /**
-     * 获取链接对象
-     * @param pool
-     */
-    getTxConnection(pool: IConnectionPool): Promise<PoolClient>;
-    /**
-     * 开始事务
-     */
-    beginTx(): void;
-    /**
-     * 提交事务
-     */
-    commitTx(): Promise<void>;
-    /**
-     * 事务回滚
-     */
-    rollbackTx(): Promise<void>;
-    /**
-     * 释放连接
-     */
-    releaseTx(): Promise<void>;
-}
-export { TransactionPostgres };
+import { PoolClient } from 'pg';
+import { IConnectionPool, IPoolConnectionClient, IPoolConnectionQueryResult } from '../interfaces';
+declare class PostgresConnectionClient implements IPoolConnectionClient {
+    originConnection: PoolClient;
+    constructor(originConnection: PoolClient);
+    query(sql: string, values: any[]): Promise<IPoolConnectionQueryResult>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    release(): Promise<void>;
+}
+declare class TransactionPostgres {
+    /**
+     * 获取链接对象
+     * @param pool
+     */
+    getTxConnection(pool: IConnectionPool): Promise<PostgresConnectionClient>;
+}
+export { TransactionPostgres };

package/dist/libs/crud-pro/models/TransactionPostgres.js

@@ -1,91 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionPostgres = void 0;
-const CrudMonitor_1 = require("../../../libs/crud-pro/utils/CrudMonitor");
-async function beginTransaction(connection) {
-    return await connection.query('BEGIN');
-}
-async function commit(connection) {
-    return await connection.query('COMMIT');
-}
-async function rollback(connection) {
-    return await connection.query('ROLLBACK');
-}
-class TransactionPostgres {
-    constructor() {
-        this.isBeginTransaction = false;
-        this.connectionMap = {};
-        this.connectionList = [];
-    }
-    /**
-     * 获取链接对象
-     * @param pool
-     */
-    async getTxConnection(pool) {
-        let connection = this.connectionMap[pool.poolName];
-        if (!connection) {
-            const poolInstance = pool.poolInstance;
-            connection = await poolInstance.connect();
-            this.connectionMap[pool.poolName] = connection;
-            this.connectionList.push(connection);
-            CrudMonitor_1.CrudMonitor.postgresGetConnectionCount++;
-            // 开启了事务
-            if (this.isBeginTransaction) {
-                await beginTransaction(connection);
-            }
-        }
-        return connection;
-    }
-    /**
-     * 开始事务
-     */
-    beginTx() {
-        this.isBeginTransaction = true;
-    }
-    /**
-     * 提交事务
-     */
-    async commitTx() {
-        if (!this.isBeginTransaction) {
-            return;
-        }
-        const connections = this.connectionList;
-        for (let i = 0; i < connections.length; i++) {
-            const connection = connections[i];
-            await commit(connection);
-        }
-    }
-    /**
-     * 事务回滚
-     */
-    async rollbackTx() {
-        if (!this.isBeginTransaction) {
-            return;
-        }
-        const connections = this.connectionList;
-        for (let i = 0; i < connections.length; i++) {
-            const connection = connections[i];
-            await rollback(connection);
-        }
-    }
-    /**
-     * 释放连接
-     */
-    async releaseTx() {
-        // 不管有没有开启事务，都要释放连接。
-        const connections = this.connectionList;
-        for (let i = 0; i < connections.length; i++) {
-            const connection = connections[i];
-            try {
-                CrudMonitor_1.CrudMonitor.postgresReleaseConnectionCount++;
-                await connection.release();
-            }
-            catch (e) {
-                console.error(e);
-            }
-        }
-        this.connectionList = [];
-        this.connectionMap = {};
-    }
-}
-exports.TransactionPostgres = TransactionPostgres;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionPostgres = void 0;
+const CrudMonitor_1 = require("../../../libs/crud-pro/utils/CrudMonitor");
+async function beginTransaction(connection) {
+    return await connection.query('BEGIN');
+}
+async function commit(connection) {
+    return await connection.query('COMMIT');
+}
+async function rollback(connection) {
+    return await connection.query('ROLLBACK');
+}
+class PostgresConnectionClient {
+    constructor(originConnection) {
+        this.originConnection = originConnection;
+        CrudMonitor_1.CrudMonitor.postgresGetConnectionCount++;
+    }
+    async query(sql, values) {
+        const pgClient = this.originConnection;
+        const result = await pgClient.query({
+            text: sql,
+            values: values || [],
+        });
+        let rows = [];
+        if (result && Array.isArray(result.rows)) {
+            rows = result.rows;
+        }
+        return {
+            rows,
+            originRes: result
+        };
+    }
+    async beginTransaction() {
+        await beginTransaction(this.originConnection);
+    }
+    async commit() {
+        await commit(this.originConnection);
+    }
+    async rollback() {
+        await rollback(this.originConnection);
+    }
+    async release() {
+        try {
+            CrudMonitor_1.CrudMonitor.postgresReleaseConnectionCount++;
+            await this.originConnection.release();
+        }
+        catch (e) {
+            console.log('[crud-pro] PostgresConnectionClient release ', e);
+        }
+    }
+}
+class TransactionPostgres {
+    /**
+     * 获取链接对象
+     * @param pool
+     */
+    async getTxConnection(pool) {
+        const poolInstance = pool.poolInstance;
+        const originConnection = await poolInstance.connect();
+        return new PostgresConnectionClient(originConnection);
+    }
+}
+exports.TransactionPostgres = TransactionPostgres;

package/dist/libs/crud-pro/models/TransactionSqlServer.d.ts

@@ -1,35 +1,9 @@
-import { ConnectionPool } from 'mssql';
-import { IConnectionPool, IPoolConnectionClient } from '../interfaces';
-interface ISqlServerConnection extends IPoolConnectionClient {
-    originConnection: ConnectionPool;
-}
-declare class TransactionSqlServer {
-    private isBeginTransaction;
-    private connectionMap;
-    private connectionList;
-    private transactionList;
-    /**
-     * 获取链接对象
-     * @param pool
-     */
-    getTxConnection(pool: IConnectionPool): Promise<ISqlServerConnection>;
-    private connectAndCreateConnection;
-    /**
-     * 开始事务
-     */
-    beginTx(): void;
-    /**
-     * 提交事务
-     */
-    commitTx(): Promise<void>;
-    /**
-     * 事务回滚
-     */
-    rollbackTx(): Promise<void>;
-    /**
-     * 释放连接
-     */
-    releaseTx(): Promise<void>;
-    private beginTransaction;
-}
-export { TransactionSqlServer };
+import { IConnectionPool, IPoolConnectionClient } from '../interfaces';
+declare class TransactionSqlServer {
+    /**
+     * 获取链接对象
+     * @param pool
+     */
+    getTxConnection(pool: IConnectionPool): Promise<IPoolConnectionClient>;
+}
+export { TransactionSqlServer };

package/dist/libs/crud-pro/models/TransactionSqlServer.js

@@ -1,100 +1,61 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionSqlServer = void 0;
-const mssql_1 = require("mssql");
-const CrudMonitor_1 = require("../../../libs/crud-pro/utils/CrudMonitor");
-class TransactionSqlServer {
-    constructor() {
-        this.isBeginTransaction = false;
-        this.connectionMap = {};
-        this.connectionList = [];
-        this.transactionList = [];
-    }
-    /**
-     * 获取链接对象
-     * @param pool
-     */
-    async getTxConnection(pool) {
-        let connection = this.connectionMap[pool.poolName];
-        if (!connection) {
-            connection = await this.connectAndCreateConnection(pool);
-            this.connectionMap[pool.poolName] = connection;
-            this.connectionList.push(connection);
-            CrudMonitor_1.CrudMonitor.mssqlGetConnectionCount++;
-            // 开启了事务
-            if (this.isBeginTransaction) {
-                await this.beginTransaction(connection);
-            }
-        }
-        return connection;
-    }
-    async connectAndCreateConnection(pool) {
-        const poolInstance = pool.poolInstance;
-        const originConnection = await poolInstance.connect();
-        return {
-            originConnection,
-            query: (sql, values) => {
-                const request = new mssql_1.Request(originConnection);
-                if (Array.isArray(values)) {
-                    for (let i = 0; i < values.length; i++) {
-                        const index = i + 1;
-                        const value = values[i];
-                        request.input(`fatcms_ms${index}`, value);
-                    }
-                }
-                return request.query(sql);
-            },
-        };
-    }
-    /**
-     * 开始事务
-     */
-    beginTx() {
-        this.isBeginTransaction = true;
-    }
-    /**
-     * 提交事务
-     */
-    async commitTx() {
-        if (!this.isBeginTransaction) {
-            return;
-        }
-        const transactions = this.transactionList;
-        for (let i = 0; i < transactions.length; i++) {
-            const tmpTx = transactions[i];
-            await tmpTx.commit();
-        }
-    }
-    /**
-     * 事务回滚
-     */
-    async rollbackTx() {
-        if (!this.isBeginTransaction) {
-            return;
-        }
-        const transactions = this.transactionList;
-        for (let i = 0; i < transactions.length; i++) {
-            const tmpTx = transactions[i];
-            await tmpTx.rollback();
-        }
-    }
-    /**
-     * 释放连接
-     */
-    async releaseTx() {
-        const connections = this.connectionList || [];
-        for (let i = 0; i < connections.length; i++) {
-            CrudMonitor_1.CrudMonitor.mssqlReleaseConnectionCount--;
-        }
-        this.connectionMap = {};
-        this.connectionList = [];
-        this.transactionList = [];
-    }
-    async beginTransaction(connection) {
-        const originConnection = connection.originConnection;
-        const tmpTx = new mssql_1.Transaction(originConnection);
-        this.transactionList.push(tmpTx);
-        return await tmpTx.begin();
-    }
-}
-exports.TransactionSqlServer = TransactionSqlServer;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionSqlServer = void 0;
+const mssql_1 = require("mssql");
+const CrudMonitor_1 = require("../../../libs/crud-pro/utils/CrudMonitor");
+const _ = require("lodash");
+class SqlServerConnectionClient {
+    constructor(originConnection) {
+        this.originConnection = originConnection;
+    }
+    async query(sql, values) {
+        const request = new mssql_1.Request(this.originConnection);
+        if (Array.isArray(values)) {
+            for (let i = 0; i < values.length; i++) {
+                const index = i + 1;
+                const value = values[i];
+                request.input(`fatcms_ms${index}`, value);
+            }
+        }
+        const res = await request.query(sql);
+        const rows = _.get(res, 'recordsets[0]') || [];
+        return {
+            rows,
+            originRes: res
+        };
+    }
+    async beginTransaction() {
+        const originConnection = this.originConnection;
+        const tmpTx = new mssql_1.Transaction(originConnection);
+        this.sqlServerTransaction = tmpTx;
+        return await tmpTx.begin();
+    }
+    async commit() {
+        const tmpTx = this.sqlServerTransaction;
+        await tmpTx.commit();
+    }
+    async rollback() {
+        const tmpTx = this.sqlServerTransaction;
+        await tmpTx.rollback();
+    }
+    async release() {
+        try {
+            CrudMonitor_1.CrudMonitor.postgresReleaseConnectionCount++;
+        }
+        catch (e) {
+            console.log('[crud-pro] SqlServerConnectionClient release ', e);
+        }
+    }
+}
+class TransactionSqlServer {
+    /**
+     * 获取链接对象
+     * @param pool
+     */
+    async getTxConnection(pool) {
+        const poolInstance = pool.poolInstance;
+        const originConnection = await poolInstance.connect();
+        return new SqlServerConnectionClient(originConnection);
+    }
+}
+exports.TransactionSqlServer = TransactionSqlServer;