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

package/dist/controller/base/BaseApiController.js

@@ -151,18 +151,22 @@ let BaseApiController = class BaseApiController extends BaseService_1.BaseServic
     async decodeBodyBySession(body) {
         var _a;
         if (!((_a = this.ctx.userSession) === null || _a === void 0 ? void 0 : _a.isLogin())) {
-            throw new Error('[decodeBodyBySessionId] 用户必须登录');
+            throw new Error('身份安全校验不通过, 用户必须先登录');
         }
         const sessionInfo = this.getUserSessionInfo();
         const secretBody0 = body;
         if (!secretBody0.payload1 || !secretBody0.payload2 || !secretBody0.payload3 || !secretBody0.payload4) {
             return body;
         }
+        const { privateKey, publicKey, accountId } = sessionInfo;
+        const serverPayload1 = md5(publicKey + accountId);
+        if (serverPayload1 !== secretBody0.payload1) {
+            throw new Error('身份安全校验不通过，请重新登录');
+        }
         const secretBody = {
             secretPayload: secretBody0.payload2,
             secretKey: secretBody0.payload4,
         };
-        const { privateKey, publicKey } = sessionInfo;
         const secretPayload = secretBody.secretPayload;
         const secretKey = secretBody.secretKey; // 使用RSA加密的AES密钥
         const aesKey = await AsymmetricCrypto_1.AsymmetricCrypto.decrypt(privateKey, secretKey); // 解密AES密钥

package/dist/controller/manage/SystemInfoManageApi.js

@@ -16,6 +16,7 @@ const BaseApiController_1 = require("../base/BaseApiController");
 const permission_middleware_1 = require("../../middleware/permission.middleware");
 const SystemPerm_1 = require("../../models/SystemPerm");
 const common_dto_1 = require("../../libs/utils/common-dto");
+const CrudMonitor_1 = require("../../libs/crud-pro/utils/CrudMonitor");
 let SystemInfoManageApi = class SystemInfoManageApi extends BaseApiController_1.BaseApiController {
     /**
      * 预设系统内置功能点数据
@@ -49,6 +50,7 @@ let SystemInfoManageApi = class SystemInfoManageApi extends BaseApiController_1.
             timeInfo,
             envInfo,
             networkInfo,
+            crudMonitorInfo: CrudMonitor_1.CrudMonitor
         });
     }
 };

package/dist/libs/crud-pro/CrudPro.js

@@ -100,6 +100,9 @@ class CrudPro {
         await this.executeSQLList();
         // 执行SQL执行之后的的处理
         await this.afterExecuteSQLList();
+        // 再次尝试释放一下资源。避免因为不正确的使用方式导致，连接未释放。
+        const txObj = this.executeContext.getTransaction();
+        await txObj.releaseTxOnlyReleased();
         return exeCtx;
     }
     async getCachedCfgByMethod(method, isEnableCache) {

package/dist/libs/crud-pro/interfaces.d.ts

@@ -17,8 +17,17 @@ export interface IConnectionPool {
     poolName: string;
     poolInstance: any;
 }
+export interface IPoolConnectionQueryResult {
+    rows: any[];
+    originRes: any;
+}
 export interface IPoolConnectionClient {
-    query: (sql: string, values: any[]) => Promise<any[]>;
+    query: (sql: string, values: any[]) => Promise<IPoolConnectionQueryResult>;
+    release: () => Promise<any>;
+    commit: () => Promise<any>;
+    rollback: () => Promise<any>;
+    beginTransaction: () => Promise<any>;
+    originConnection: any;
 }
 /**
  * 用户请求

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

@@ -1,15 +1,33 @@
-import { IConnectionPool, IPoolConnectionClient } from '../interfaces';
+import { IConnectionPool, IPoolConnectionClient, IPoolConnectionQueryResult } from '../interfaces';
+declare class TransactionConnection implements IPoolConnectionClient {
+    originConnection: IPoolConnectionClient;
+    private isFinished;
+    private isTxBegan;
+    private isTxCommitted;
+    private isTxRollback;
+    private isReleased;
+    constructor(originConnection: IPoolConnectionClient);
+    query(sql: string, values: any[]): Promise<IPoolConnectionQueryResult>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    release(): Promise<void>;
+    releaseOnlyFinished(): Promise<void>;
+}
 declare class Transaction {
     private transactionMySQL;
     private transactionPostgres;
     private transactionSqlServer;
+    private isBeginTransaction;
+    private connectionMap;
+    private connectionList;
     private isReleased;
     private getTxObj;
     /**
      * 获取链接对象
      * @param pool
      */
-    getTxConnection(pool: IConnectionPool): Promise<IPoolConnectionClient>;
+    getTxConnection(pool: IConnectionPool): Promise<TransactionConnection>;
     /**
      * 开始事务
      */
@@ -26,5 +44,6 @@ declare class Transaction {
      * 释放连接
      */
     releaseTx(): Promise<void>;
+    releaseTxOnlyReleased(): Promise<void>;
 }
 export { Transaction };

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

@@ -5,11 +5,68 @@ const keys_1 = require("./keys");
 const TransactionMySQL_1 = require("./TransactionMySQL");
 const TransactionPostgres_1 = require("./TransactionPostgres");
 const TransactionSqlServer_1 = require("./TransactionSqlServer");
+class TransactionConnection {
+    constructor(originConnection) {
+        this.isFinished = false;
+        this.isTxBegan = false;
+        this.isTxCommitted = false;
+        this.isTxRollback = false;
+        this.isReleased = false;
+        this.originConnection = originConnection;
+    }
+    async query(sql, values) {
+        try {
+            return await this.originConnection.query(sql, values);
+        }
+        catch (error) {
+            console.error('[crud-pro]TransactionConnection', error);
+            throw error;
+        }
+        finally {
+            this.isFinished = true;
+        }
+    }
+    async beginTransaction() {
+        this.isTxBegan = true;
+        await this.originConnection.beginTransaction();
+    }
+    async commit() {
+        this.isTxCommitted = true;
+        await this.originConnection.commit();
+    }
+    async rollback() {
+        this.isTxRollback = true;
+        await this.originConnection.commit();
+    }
+    async release() {
+        if (this.isReleased) {
+            return;
+        }
+        this.isReleased = true;
+        try {
+            if (this.isTxBegan && !this.isTxRollback && !this.isTxCommitted) {
+                await this.commit();
+            }
+            await this.originConnection.release();
+        }
+        catch (e) {
+            console.log('[crud-pro] MySqlConnectionClient release ', e);
+        }
+    }
+    async releaseOnlyFinished() {
+        if (this.isFinished) {
+            await this.release();
+        }
+    }
+}
 class Transaction {
     constructor() {
         this.transactionMySQL = new TransactionMySQL_1.TransactionMySQL();
         this.transactionPostgres = new TransactionPostgres_1.TransactionPostgres();
         this.transactionSqlServer = new TransactionSqlServer_1.TransactionSqlServer();
+        this.isBeginTransaction = false;
+        this.connectionMap = {};
+        this.connectionList = [];
         this.isReleased = false;
     }
     getTxObj(pool) {
@@ -30,45 +87,91 @@ class Transaction {
      */
     async getTxConnection(pool) {
         if (this.isReleased) {
-            const msg = '[Transaction] getTxConnection error, the txObject is isReleased, please check your code . DB request must be await';
+            const msg = '[crud-pro][Transaction] getTxConnection error, the txObject is isReleased, please check your code . DB request must be await';
             console.error(msg);
             throw new Error(msg);
         }
-        const txObj = this.getTxObj(pool);
-        return txObj.getTxConnection(pool);
+        // 尽量复用同一个连接。但是如果并行请求，也允许使用多个链接。
+        // 复用一个链接：可以使用事务。
+        // 使用多个链接：不能使用事务。
+        let connection = this.connectionMap[pool.poolName];
+        if (!connection) {
+            const txObj = this.getTxObj(pool);
+            const connection0 = await txObj.getTxConnection(pool);
+            connection = new TransactionConnection(connection0);
+            this.connectionMap[pool.poolName] = connection;
+            this.connectionList.push(connection);
+            // 开启了事务
+            if (this.isBeginTransaction) {
+                await connection.beginTransaction();
+            }
+        }
+        return connection;
     }
     /**
      * 开始事务
      */
     beginTx() {
-        this.transactionMySQL.beginTx();
-        this.transactionPostgres.beginTx();
-        this.transactionSqlServer.beginTx();
+        this.isBeginTransaction = true;
     }
     /**
      * 提交事务
      */
     async commitTx() {
-        await this.transactionMySQL.commitTx();
-        await this.transactionPostgres.commitTx();
-        await this.transactionSqlServer.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() {
-        await this.transactionMySQL.rollbackTx();
-        await this.transactionPostgres.rollbackTx();
-        await this.transactionSqlServer.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() {
-        await this.transactionMySQL.releaseTx();
-        await this.transactionPostgres.releaseTx();
-        await this.transactionSqlServer.releaseTx();
         this.isReleased = true;
+        // 不管有没有开启事务，都要释放连接。
+        const connections = this.connectionList;
+        for (let i = 0; i < connections.length; i++) {
+            const connection = connections[i];
+            try {
+                await connection.releaseOnlyFinished();
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+    }
+    async releaseTxOnlyReleased() {
+        if (!this.isReleased) {
+            return;
+        }
+        // 不管有没有开启事务，都要释放连接。
+        const connections = this.connectionList;
+        for (let i = 0; i < connections.length; i++) {
+            const connection = connections[i];
+            try {
+                await connection.releaseOnlyFinished();
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
     }
 }
 exports.Transaction = Transaction;

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

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

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

@@ -1,76 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionMySQL = void 0;
-class TransactionMySQL {
-    constructor() {
-        this.isBeginTransaction = false;
-        this.connectionMap = {};
+const CrudMonitor_1 = require("../../../libs/crud-pro/utils/CrudMonitor");
+class MySqlConnectionClient {
+    constructor(originConnection) {
+        this.originConnection = originConnection;
+        CrudMonitor_1.CrudMonitor.mysqlGetConnectionCount++;
     }
-    /**
-     * 获取链接对象
-     * @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;
-            // 开启了事务
-            if (this.isBeginTransaction) {
-                await connection.beginTransaction();
-            }
-        }
-        return connection;
+    async query(sql, values) {
+        const res = await this.originConnection.query(sql, values);
+        const rows = res[0];
+        return {
+            rows,
+            originRes: res
+        };
     }
-    /**
-     * 开始事务
-     */
-    beginTx() {
-        this.isBeginTransaction = true;
+    async beginTransaction() {
+        await this.originConnection.beginTransaction();
     }
-    /**
-     * 提交事务
-     */
-    async commitTx() {
-        if (!this.isBeginTransaction) {
-            return;
-        }
-        const connections = Object.values(this.connectionMap);
-        for (let i = 0; i < connections.length; i++) {
-            const connection = connections[i];
-            await connection.commit();
-        }
+    async commit() {
+        await this.originConnection.commit();
     }
-    /**
-     * 事务回滚
-     */
-    async rollbackTx() {
-        if (!this.isBeginTransaction) {
-            return;
+    async rollback() {
+        await this.originConnection.commit();
+    }
+    async release() {
+        try {
+            CrudMonitor_1.CrudMonitor.mysqlReleaseConnectionCount++;
+            await this.originConnection.release();
         }
-        const connections = Object.values(this.connectionMap);
-        for (let i = 0; i < connections.length; i++) {
-            const connection = connections[i];
-            await connection.rollback();
+        catch (e) {
+            console.log('[crud-pro] MySqlConnectionClient release ', e);
         }
     }
+}
+class TransactionMySQL {
     /**
-     * 释放连接
+     * 获取链接对象
+     * @param pool
      */
-    async releaseTx() {
-        // 不管有没有开启事务，都要释放连接。
-        const connections = Object.values(this.connectionMap);
-        for (let i = 0; i < connections.length; i++) {
-            const connection = connections[i];
-            try {
-                await connection.release();
-            }
-            catch (e) {
-                console.error(e);
-            }
-        }
-        this.connectionMap = {};
+    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,28 +1,19 @@
 import { PoolClient } from 'pg';
-import { IConnectionPool } from '../interfaces';
+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 {
-    private isBeginTransaction;
-    private connectionMap;
     /**
      * 获取链接对象
      * @param pool
      */
-    getTxConnection(pool: IConnectionPool): Promise<PoolClient>;
-    /**
-     * 开始事务
-     */
-    beginTx(): void;
-    /**
-     * 提交事务
-     */
-    commitTx(): Promise<void>;
-    /**
-     * 事务回滚
-     */
-    rollbackTx(): Promise<void>;
-    /**
-     * 释放连接
-     */
-    releaseTx(): Promise<void>;
+    getTxConnection(pool: IConnectionPool): Promise<PostgresConnectionClient>;
 }
 export { TransactionPostgres };

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

@@ -1,6 +1,7 @@
 "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');
 }
@@ -10,76 +11,54 @@ async function commit(connection) {
 async function rollback(connection) {
     return await connection.query('ROLLBACK');
 }
-class TransactionPostgres {
-    constructor() {
-        this.isBeginTransaction = false;
-        this.connectionMap = {};
+class PostgresConnectionClient {
+    constructor(originConnection) {
+        this.originConnection = originConnection;
+        CrudMonitor_1.CrudMonitor.postgresGetConnectionCount++;
     }
-    /**
-     * 获取链接对象
-     * @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;
-            // 开启了事务
-            if (this.isBeginTransaction) {
-                await beginTransaction(connection);
-            }
+    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 connection;
+        return {
+            rows,
+            originRes: result
+        };
     }
-    /**
-     * 开始事务
-     */
-    beginTx() {
-        this.isBeginTransaction = true;
+    async beginTransaction() {
+        await beginTransaction(this.originConnection);
     }
-    /**
-     * 提交事务
-     */
-    async commitTx() {
-        if (!this.isBeginTransaction) {
-            return;
-        }
-        const connections = Object.values(this.connectionMap);
-        for (let i = 0; i < connections.length; i++) {
-            const connection = connections[i];
-            await commit(connection);
-        }
+    async commit() {
+        await commit(this.originConnection);
     }
-    /**
-     * 事务回滚
-     */
-    async rollbackTx() {
-        if (!this.isBeginTransaction) {
-            return;
+    async rollback() {
+        await rollback(this.originConnection);
+    }
+    async release() {
+        try {
+            CrudMonitor_1.CrudMonitor.postgresReleaseConnectionCount++;
+            await this.originConnection.release();
         }
-        const connections = Object.values(this.connectionMap);
-        for (let i = 0; i < connections.length; i++) {
-            const connection = connections[i];
-            await rollback(connection);
+        catch (e) {
+            console.log('[crud-pro] PostgresConnectionClient release ', e);
         }
     }
+}
+class TransactionPostgres {
     /**
-     * 释放连接
+     * 获取链接对象
+     * @param pool
      */
-    async releaseTx() {
-        // 不管有没有开启事务，都要释放连接。
-        const connections = Object.values(this.connectionMap);
-        for (let i = 0; i < connections.length; i++) {
-            const connection = connections[i];
-            try {
-                await connection.release();
-            }
-            catch (e) {
-                console.error(e);
-            }
-        }
-        this.connectionMap = {};
+    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,34 +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 transactionMap;
     /**
      * 获取链接对象
      * @param pool
      */
-    getTxConnection(pool: IConnectionPool): Promise<ISqlServerConnection>;
-    private connectAndCreateConnection;
-    /**
-     * 开始事务
-     */
-    beginTx(): void;
-    /**
-     * 提交事务
-     */
-    commitTx(): Promise<void>;
-    /**
-     * 事务回滚
-     */
-    rollbackTx(): Promise<void>;
-    /**
-     * 释放连接
-     */
-    releaseTx(): Promise<void>;
-    private beginTransaction;
+    getTxConnection(pool: IConnectionPool): Promise<IPoolConnectionClient>;
 }
 export { TransactionSqlServer };