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

package/src/libs/crud-pro/models/Transaction.ts

@@ -1,24 +1,91 @@
-import { IConnectionPool, IPoolConnectionClient } from '../interfaces';
+import {IConnectionPool, IPoolConnectionClient, IPoolConnectionQueryResult} from '../interfaces';
 import { SqlDbType } from './keys';
 import { TransactionMySQL } from './TransactionMySQL';
 import { TransactionPostgres } from './TransactionPostgres';
 import { TransactionSqlServer } from './TransactionSqlServer';
 
+class TransactionConnection implements IPoolConnectionClient {
+  originConnection: IPoolConnectionClient;
+  private isFinished: boolean = false;
+  private isTxBegan: boolean = false;
+  private isTxCommitted: boolean = false;
+  private isTxRollback: boolean = false;
+  private isReleased: boolean = false;
+
+  constructor(originConnection: IPoolConnectionClient) {
+    this.originConnection = originConnection;
+  }
+
+  async query(sql: string, values: any[]): Promise<IPoolConnectionQueryResult> {
+    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 {
   private transactionMySQL: TransactionMySQL = new TransactionMySQL();
   private transactionPostgres: TransactionPostgres = new TransactionPostgres();
   private transactionSqlServer: TransactionSqlServer = new TransactionSqlServer();
+
+  private isBeginTransaction = false;
+  private connectionMap: Record<string, TransactionConnection> = {};
+  private connectionList: TransactionConnection[] = [];
+
+
   private isReleased = false;
 
   private getTxObj(pool: IConnectionPool): TransactionMySQL | TransactionPostgres | TransactionSqlServer {
     if (pool.dbType === SqlDbType.postgres) {
       return this.transactionPostgres;
     }
-
     if (pool.dbType === SqlDbType.sqlserver) {
       return this.transactionSqlServer;
     }
-
     if (!pool.dbType || pool.dbType === SqlDbType.mysql) {
       return this.transactionMySQL;
     }
@@ -29,53 +96,108 @@ class Transaction {
    * 获取链接对象
    * @param pool
    */
-  public async getTxConnection(pool: IConnectionPool): Promise<IPoolConnectionClient> {
+  public async getTxConnection(pool: IConnectionPool): Promise<TransactionConnection> {
     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;
+
   }
 
   /**
    * 开始事务
    */
   public beginTx() {
-    this.transactionMySQL.beginTx();
-    this.transactionPostgres.beginTx();
-    this.transactionSqlServer.beginTx();
+    this.isBeginTransaction = true;
   }
 
   /**
    * 提交事务
    */
   public 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();
+    }
   }
 
   /**
    * 事务回滚
    */
   public 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();
+    }
   }
 
   /**
    * 释放连接
    */
   public 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);
+      }
+    }
   }
+
+  public 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);
+      }
+    }
+  }
+
 }
 
 export { Transaction };

package/src/libs/crud-pro/models/TransactionMySQL.ts

@@ -1,78 +1,57 @@
 import { PoolConnection, Pool } from 'mysql2/promise';
-import { IConnectionPool } from '../interfaces';
+import {IConnectionPool, IPoolConnectionClient, IPoolConnectionQueryResult} from '../interfaces';
+import { CrudMonitor } from "@/libs/crud-pro/utils/CrudMonitor";
 
-class TransactionMySQL {
-  private isBeginTransaction = false;
-  private connectionMap: Record<string, PoolConnection> = {};
 
-  /**
-   * 获取链接对象
-   * @param pool
-   */
-  public async getTxConnection(pool: IConnectionPool): Promise<PoolConnection> {
-    let connection = this.connectionMap[pool.poolName];
-    if (!connection) {
-      const poolInstance: Pool = pool.poolInstance as any;
-      connection = await poolInstance.getConnection();
-      this.connectionMap[pool.poolName] = connection;
-      // 开启了事务
-      if (this.isBeginTransaction) {
-        await connection.beginTransaction();
-      }
+class MySqlConnectionClient implements IPoolConnectionClient {
+  originConnection: PoolConnection;
+  constructor(originConnection: PoolConnection) {
+    this.originConnection = originConnection;
+    CrudMonitor.mysqlGetConnectionCount++;
+  }
+  async query(sql: string, values: any[]): Promise<IPoolConnectionQueryResult> {
+    const res = await this.originConnection.query(sql, values);
+    const rows =  res[0] as any;
+    return {
+      rows,
+      originRes: res
     }
-    return connection;
   }
 
-  /**
-   * 开始事务
-   */
-  public beginTx() {
-    this.isBeginTransaction = true;
+  async beginTransaction() {
+    await this.originConnection.beginTransaction();
   }
 
-  /**
-   * 提交事务
-   */
-  public 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();
   }
 
-  /**
-   * 事务回滚
-   */
-  public async rollbackTx() {
-    if (!this.isBeginTransaction) {
-      return;
-    }
-    const connections = Object.values(this.connectionMap);
-    for (let i = 0; i < connections.length; i++) {
-      const connection = connections[i];
-      await connection.rollback();
+  async rollback() {
+      await this.originConnection.commit();
+  }
+
+  async release() {
+    try {
+      CrudMonitor.mysqlReleaseConnectionCount++;
+      await this.originConnection.release();
+    } catch (e) {
+      console.log('[crud-pro] MySqlConnectionClient release ', e);
     }
   }
 
+
+}
+
+
+class TransactionMySQL {
   /**
-   * 释放连接
+   * 获取链接对象
+   * @param pool
    */
-  public 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 = {};
+  public async getTxConnection(pool: IConnectionPool): Promise<MySqlConnectionClient> {
+      const poolInstance: Pool = pool.poolInstance as any;
+      const originConnection = await poolInstance.getConnection();
+      return new MySqlConnectionClient(originConnection);
   }
 }
 

package/src/libs/crud-pro/models/TransactionPostgres.ts

@@ -1,5 +1,6 @@
-import { PoolClient, Pool } from 'pg';
-import { IConnectionPool } from '../interfaces';
+import {Pool, PoolClient} from 'pg';
+import {IConnectionPool, IPoolConnectionClient, IPoolConnectionQueryResult} from '../interfaces';
+import { CrudMonitor } from "@/libs/crud-pro/utils/CrudMonitor";
 
 async function beginTransaction(connection: PoolClient) {
   return await connection.query('BEGIN');
@@ -13,78 +14,65 @@ async function rollback(connection: PoolClient) {
   return await connection.query('ROLLBACK');
 }
 
-class TransactionPostgres {
-  private isBeginTransaction = false;
-  private connectionMap: Record<string, PoolClient> = {};
 
-  /**
-   * 获取链接对象
-   * @param pool
-   */
-  public async getTxConnection(pool: IConnectionPool): Promise<PoolClient> {
-    let connection = this.connectionMap[pool.poolName];
-    if (!connection) {
-      const poolInstance: Pool = pool.poolInstance as any;
-      connection = await poolInstance.connect();
-      this.connectionMap[pool.poolName] = connection;
-      // 开启了事务
-      if (this.isBeginTransaction) {
-        await beginTransaction(connection);
-      }
+class PostgresConnectionClient implements IPoolConnectionClient {
+  originConnection: PoolClient;
+  constructor(originConnection: PoolClient) {
+    this.originConnection = originConnection;
+    CrudMonitor.postgresGetConnectionCount++;
+  }
+  async query(sql: string, values: any[]): Promise<IPoolConnectionQueryResult> {
+    const pgClient = this.originConnection;
+    const result = await pgClient.query({
+      text: sql,
+      values: values || [],
+    });
+    let rows: any[] = [];
+    if (result && Array.isArray(result.rows)) {
+      rows = result.rows;
+    }
+
+    return {
+      rows,
+      originRes: result
     }
-    return connection;
   }
 
-  /**
-   * 开始事务
-   */
-  public beginTx() {
-    this.isBeginTransaction = true;
+  async beginTransaction() {
+    await beginTransaction(this.originConnection);
   }
 
-  /**
-   * 提交事务
-   */
-  public 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);
   }
 
-  /**
-   * 事务回滚
-   */
-  public async rollbackTx() {
-    if (!this.isBeginTransaction) {
-      return;
-    }
-    const connections = Object.values(this.connectionMap);
-    for (let i = 0; i < connections.length; i++) {
-      const connection = connections[i];
-      await rollback(connection);
+  async rollback() {
+    await rollback(this.originConnection);
+  }
+
+
+  async release() {
+    try {
+      CrudMonitor.postgresReleaseConnectionCount++;
+      await this.originConnection.release();
+    } catch (e) {
+      console.log('[crud-pro] PostgresConnectionClient release ', e);
     }
   }
 
+}
+
+
+
+class TransactionPostgres {
   /**
-   * 释放连接
+   * 获取链接对象
+   * @param pool
    */
-  public 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 = {};
+  public async getTxConnection(pool: IConnectionPool): Promise<PostgresConnectionClient> {
+      const poolInstance: Pool = pool.poolInstance as any;
+      const originConnection = await poolInstance.connect();
+    return new PostgresConnectionClient(originConnection);
   }
 }
 

package/src/libs/crud-pro/models/TransactionSqlServer.ts

@@ -1,102 +1,77 @@
 import { ConnectionPool, Request, Transaction } from 'mssql';
-import { IConnectionPool, IPoolConnectionClient } from '../interfaces';
+import {IConnectionPool, IPoolConnectionClient, IPoolConnectionQueryResult} from '../interfaces';
+import { CrudMonitor } from "@/libs/crud-pro/utils/CrudMonitor";
+import * as _ from 'lodash';
 
-interface ISqlServerConnection extends IPoolConnectionClient {
-  originConnection: ConnectionPool;
-}
 
-class TransactionSqlServer {
-  private isBeginTransaction = false;
-  private connectionMap: Record<string, ISqlServerConnection> = {};
-  private transactionMap: Record<string, Transaction> = {};
 
-  /**
-   * 获取链接对象
-   * @param pool
-   */
-  public async getTxConnection(pool: IConnectionPool): Promise<ISqlServerConnection> {
-    let connection = this.connectionMap[pool.poolName];
-    if (!connection) {
-      connection = await this.connectAndCreateConnection(pool);
-      this.connectionMap[pool.poolName] = connection;
-
-      // 开启了事务
-      if (this.isBeginTransaction) {
-        await this.beginTransaction(pool.poolName);
+class SqlServerConnectionClient implements IPoolConnectionClient {
+  originConnection: ConnectionPool;
+  private sqlServerTransaction: Transaction;
+  constructor(originConnection: ConnectionPool) {
+    this.originConnection = originConnection;
+  }
+  async query(sql: string, values: any[]): Promise<IPoolConnectionQueryResult> {
+    const request = new 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);
       }
     }
-    return connection;
-  }
 
-  private async connectAndCreateConnection(pool: IConnectionPool): Promise<ISqlServerConnection> {
-    const poolInstance: ConnectionPool = pool.poolInstance as any;
-    const originConnection = await poolInstance.connect();
+    const res = await request.query(sql);
+    const rows = _.get(res, 'recordsets[0]') || [];
     return {
-      originConnection,
-      query: (sql: string, values: any): Promise<any> => {
-        const request = new 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);
-      },
+      rows,
+      originRes: res
     };
   }
 
-  /**
-   * 开始事务
-   */
-  public beginTx() {
-    this.isBeginTransaction = true;
+
+
+  async beginTransaction() {
+    const originConnection: ConnectionPool = this.originConnection;
+    const tmpTx = new Transaction(originConnection);
+    this.sqlServerTransaction = tmpTx;
+    return await tmpTx.begin();
   }
 
-  /**
-   * 提交事务
-   */
-  public async commitTx() {
-    if (!this.isBeginTransaction) {
-      return;
-    }
-    const transactions = Object.values(this.transactionMap);
-    for (let i = 0; i < transactions.length; i++) {
-      const tmpTx = transactions[i];
-      await tmpTx.commit();
-    }
+  async commit() {
+    const tmpTx = this.sqlServerTransaction;
+    await tmpTx.commit();
   }
 
-  /**
-   * 事务回滚
-   */
-  public async rollbackTx() {
-    if (!this.isBeginTransaction) {
-      return;
-    }
-    const transactions = Object.values(this.transactionMap);
-    for (let i = 0; i < transactions.length; i++) {
-      const tmpTx = transactions[i];
-      await tmpTx.rollback();
+  async rollback() {
+    const tmpTx = this.sqlServerTransaction;
+     await tmpTx.rollback();
+  }
+
+
+  async release() {
+    try {
+      CrudMonitor.postgresReleaseConnectionCount++;
+    } catch (e) {
+      console.log('[crud-pro] SqlServerConnectionClient release ', e);
     }
   }
 
+}
+
+class TransactionSqlServer {
+
   /**
-   * 释放连接
+   * 获取链接对象
+   * @param pool
    */
-  public async releaseTx() {
-    this.connectionMap = {};
-    this.transactionMap = {};
+  public async getTxConnection(pool: IConnectionPool): Promise<IPoolConnectionClient> {
+    const poolInstance: ConnectionPool = pool.poolInstance as any;
+    const originConnection = await poolInstance.connect();
+    return new SqlServerConnectionClient(originConnection);
   }
 
-  private async beginTransaction(poolName: string) {
-    const connection = this.connectionMap[poolName];
-    const originConnection: ConnectionPool = connection.originConnection;
-    const tmpTx = new Transaction(originConnection);
-    this.transactionMap[poolName] = tmpTx;
-    return await tmpTx.begin();
-  }
 }
 
 export { TransactionSqlServer };

package/src/libs/crud-pro/services/CrudProCachedCfgService.ts

@@ -3,7 +3,7 @@ import { CrudProServiceBase } from './CrudProServiceBase';
 import { IRequestCfgModel } from '../interfaces';
 import { MixinUtils } from '../utils/MixinUtils';
 import { ICurdProServiceHub } from '../models/ServiceHub';
-import { pickAndConvertRowsByMix } from '../utils/sqlConvert/convertMix';
+// import { pickAndConvertRowsByMix } from '../utils/sqlConvert/convertMix';
 import MemoryRefreshCache from '../utils/MemoryRefreshCache';
 
 const methodCache = new MemoryRefreshCache();
@@ -57,7 +57,7 @@ class CrudProCachedCfgService extends CrudProServiceBase {
     };
 
     const queryRes = await this.executeUnsafeQuery(baseInfo, sql, [method]);
-    const rows2: any[] = pickAndConvertRowsByMix(queryRes, sysDatabaseDbType);
+    const rows2: any[] = queryRes.rows || [];
     if (rows2.length > 0) {
       return parseMethodInfo(rows2[0]);
     }
@@ -73,7 +73,7 @@ class CrudProCachedCfgService extends CrudProServiceBase {
       sqlDbType: sysDatabaseDbType,
     };
     const queryRes = await this.executeUnsafeQuery(baseInfo, sql);
-    const rows2: any[] = pickAndConvertRowsByMix(queryRes, sysDatabaseDbType);
+    const rows2: any[] = queryRes.rows || [];
     return rows2.map(row => {
       return parseMethodInfo(row);
     });