midway-fatcms 0.0.1-beta.7 → 0.0.1-beta.70

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

@@ -1,79 +1,79 @@
-import { PoolConnection, Pool } from 'mysql2/promise';
-import { IConnectionPool } from '../interfaces';
-
-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();
-      }
-    }
-    return connection;
-  }
-
-  /**
-   * 开始事务
-   */
-  public beginTx() {
-    this.isBeginTransaction = true;
-  }
-
-  /**
-   * 提交事务
-   */
-  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();
-    }
-  }
-
-  /**
-   * 事务回滚
-   */
-  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();
-    }
-  }
-
-  /**
-   * 释放连接
-   */
-  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 = {};
-  }
-}
-
-export { TransactionMySQL };
+import { PoolConnection, Pool } from 'mysql2/promise';
+import { IConnectionPool } from '../interfaces';
+
+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();
+      }
+    }
+    return connection;
+  }
+
+  /**
+   * 开始事务
+   */
+  public beginTx() {
+    this.isBeginTransaction = true;
+  }
+
+  /**
+   * 提交事务
+   */
+  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();
+    }
+  }
+
+  /**
+   * 事务回滚
+   */
+  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();
+    }
+  }
+
+  /**
+   * 释放连接
+   */
+  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 = {};
+  }
+}
+
+export { TransactionMySQL };

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

@@ -1,91 +1,91 @@
-import { PoolClient, Pool } from 'pg';
-import { IConnectionPool } from '../interfaces';
-
-async function beginTransaction(connection: PoolClient) {
-  return await connection.query('BEGIN');
-}
-
-async function commit(connection: PoolClient) {
-  return await connection.query('COMMIT');
-}
-
-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);
-      }
-    }
-    return connection;
-  }
-
-  /**
-   * 开始事务
-   */
-  public beginTx() {
-    this.isBeginTransaction = true;
-  }
-
-  /**
-   * 提交事务
-   */
-  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);
-    }
-  }
-
-  /**
-   * 事务回滚
-   */
-  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);
-    }
-  }
-
-  /**
-   * 释放连接
-   */
-  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 = {};
-  }
-}
-
-export { TransactionPostgres };
+import { PoolClient, Pool } from 'pg';
+import { IConnectionPool } from '../interfaces';
+
+async function beginTransaction(connection: PoolClient) {
+  return await connection.query('BEGIN');
+}
+
+async function commit(connection: PoolClient) {
+  return await connection.query('COMMIT');
+}
+
+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);
+      }
+    }
+    return connection;
+  }
+
+  /**
+   * 开始事务
+   */
+  public beginTx() {
+    this.isBeginTransaction = true;
+  }
+
+  /**
+   * 提交事务
+   */
+  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);
+    }
+  }
+
+  /**
+   * 事务回滚
+   */
+  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);
+    }
+  }
+
+  /**
+   * 释放连接
+   */
+  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 = {};
+  }
+}
+
+export { TransactionPostgres };

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

@@ -1,107 +1,102 @@
-import { ConnectionPool, Request, Transaction } from 'mssql';
-import { IConnectionPool, IPoolConnectionClient } from '../interfaces';
-
-
-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);
-      }
-    }
-    return connection;
-  }
-
-  private async connectAndCreateConnection(pool: IConnectionPool) : Promise<ISqlServerConnection> {
-    const poolInstance: ConnectionPool = pool.poolInstance as any;
-    const originConnection = await poolInstance.connect();
-    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);
-      }
-    }
-  }
-
-  /**
-   * 开始事务
-   */
-  public beginTx() {
-    this.isBeginTransaction = true;
-  }
-
-  /**
-   * 提交事务
-   */
-  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();
-    }
-  }
-
-  /**
-   * 事务回滚
-   */
-  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();
-    }
-  }
-
-  /**
-   * 释放连接
-   */
-  public async releaseTx() {
-    this.connectionMap = {};
-    this.transactionMap = {};
-  }
-
-
-  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 };
+import { ConnectionPool, Request, Transaction } from 'mssql';
+import { IConnectionPool, IPoolConnectionClient } from '../interfaces';
+
+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);
+      }
+    }
+    return connection;
+  }
+
+  private async connectAndCreateConnection(pool: IConnectionPool): Promise<ISqlServerConnection> {
+    const poolInstance: ConnectionPool = pool.poolInstance as any;
+    const originConnection = await poolInstance.connect();
+    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);
+      },
+    };
+  }
+
+  /**
+   * 开始事务
+   */
+  public beginTx() {
+    this.isBeginTransaction = true;
+  }
+
+  /**
+   * 提交事务
+   */
+  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();
+    }
+  }
+
+  /**
+   * 事务回滚
+   */
+  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();
+    }
+  }
+
+  /**
+   * 释放连接
+   */
+  public async releaseTx() {
+    this.connectionMap = {};
+    this.transactionMap = {};
+  }
+
+  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 };