midway-fatcms 0.0.1-beta.20 → 0.0.1-beta.24

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

@@ -1,6 +1,6 @@
-declare class SqlSegArg {
-    sql: string;
-    args: any[];
-    constructor(sql: string, args?: any[]);
-}
-export { SqlSegArg };
+declare class SqlSegArg {
+    sql: string;
+    args: any[];
+    constructor(sql: string, args?: any[]);
+}
+export { SqlSegArg };

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

@@ -1,12 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqlSegArg = void 0;
-class SqlSegArg {
-    constructor(sql, args) {
-        this.sql = sql;
-        if (args) {
-            this.args = args;
-        }
-    }
-}
-exports.SqlSegArg = SqlSegArg;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlSegArg = void 0;
+class SqlSegArg {
+    constructor(sql, args) {
+        this.sql = sql;
+        if (args) {
+            this.args = args;
+        }
+    }
+}
+exports.SqlSegArg = SqlSegArg;

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

@@ -1,29 +1,29 @@
-import { IConnectionPool, IPoolConnectionClient } from '../interfaces';
-declare class Transaction {
-    private transactionMySQL;
-    private transactionPostgres;
-    private transactionSqlServer;
-    private getTxObj;
-    /**
-     * 获取链接对象
-     * @param pool
-     */
-    getTxConnection(pool: IConnectionPool): Promise<IPoolConnectionClient>;
-    /**
-     * 开始事务
-     */
-    beginTx(): void;
-    /**
-     * 提交事务
-     */
-    commitTx(): Promise<void>;
-    /**
-     * 事务回滚
-     */
-    rollbackTx(): Promise<void>;
-    /**
-     * 释放连接
-     */
-    releaseTx(): Promise<void>;
-}
-export { Transaction };
+import { IConnectionPool, IPoolConnectionClient } from '../interfaces';
+declare class Transaction {
+    private transactionMySQL;
+    private transactionPostgres;
+    private transactionSqlServer;
+    private getTxObj;
+    /**
+     * 获取链接对象
+     * @param pool
+     */
+    getTxConnection(pool: IConnectionPool): Promise<IPoolConnectionClient>;
+    /**
+     * 开始事务
+     */
+    beginTx(): void;
+    /**
+     * 提交事务
+     */
+    commitTx(): Promise<void>;
+    /**
+     * 事务回滚
+     */
+    rollbackTx(): Promise<void>;
+    /**
+     * 释放连接
+     */
+    releaseTx(): Promise<void>;
+}
+export { Transaction };

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

@@ -1,67 +1,67 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transaction = void 0;
-const keys_1 = require("./keys");
-const TransactionMySQL_1 = require("./TransactionMySQL");
-const TransactionPostgres_1 = require("./TransactionPostgres");
-const TransactionSqlServer_1 = require("./TransactionSqlServer");
-class Transaction {
-    constructor() {
-        this.transactionMySQL = new TransactionMySQL_1.TransactionMySQL();
-        this.transactionPostgres = new TransactionPostgres_1.TransactionPostgres();
-        this.transactionSqlServer = new TransactionSqlServer_1.TransactionSqlServer();
-    }
-    getTxObj(pool) {
-        if (pool.dbType === keys_1.SqlDbType.postgres) {
-            return this.transactionPostgres;
-        }
-        if (pool.dbType === keys_1.SqlDbType.sqlserver) {
-            return this.transactionSqlServer;
-        }
-        if (!pool.dbType || pool.dbType === keys_1.SqlDbType.mysql) {
-            return this.transactionMySQL;
-        }
-        return null;
-    }
-    /**
-     * 获取链接对象
-     * @param pool
-     */
-    async getTxConnection(pool) {
-        const txObj = this.getTxObj(pool);
-        return txObj.getTxConnection(pool);
-    }
-    /**
-     * 开始事务
-     */
-    beginTx() {
-        this.transactionMySQL.beginTx();
-        this.transactionPostgres.beginTx();
-        this.transactionSqlServer.beginTx();
-    }
-    /**
-     * 提交事务
-     */
-    async commitTx() {
-        await this.transactionMySQL.commitTx();
-        await this.transactionPostgres.commitTx();
-        await this.transactionSqlServer.commitTx();
-    }
-    /**
-     * 事务回滚
-     */
-    async rollbackTx() {
-        await this.transactionMySQL.rollbackTx();
-        await this.transactionPostgres.rollbackTx();
-        await this.transactionSqlServer.rollbackTx();
-    }
-    /**
-     * 释放连接
-     */
-    async releaseTx() {
-        await this.transactionMySQL.releaseTx();
-        await this.transactionPostgres.releaseTx();
-        await this.transactionSqlServer.releaseTx();
-    }
-}
-exports.Transaction = Transaction;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+const keys_1 = require("./keys");
+const TransactionMySQL_1 = require("./TransactionMySQL");
+const TransactionPostgres_1 = require("./TransactionPostgres");
+const TransactionSqlServer_1 = require("./TransactionSqlServer");
+class Transaction {
+    constructor() {
+        this.transactionMySQL = new TransactionMySQL_1.TransactionMySQL();
+        this.transactionPostgres = new TransactionPostgres_1.TransactionPostgres();
+        this.transactionSqlServer = new TransactionSqlServer_1.TransactionSqlServer();
+    }
+    getTxObj(pool) {
+        if (pool.dbType === keys_1.SqlDbType.postgres) {
+            return this.transactionPostgres;
+        }
+        if (pool.dbType === keys_1.SqlDbType.sqlserver) {
+            return this.transactionSqlServer;
+        }
+        if (!pool.dbType || pool.dbType === keys_1.SqlDbType.mysql) {
+            return this.transactionMySQL;
+        }
+        return null;
+    }
+    /**
+     * 获取链接对象
+     * @param pool
+     */
+    async getTxConnection(pool) {
+        const txObj = this.getTxObj(pool);
+        return txObj.getTxConnection(pool);
+    }
+    /**
+     * 开始事务
+     */
+    beginTx() {
+        this.transactionMySQL.beginTx();
+        this.transactionPostgres.beginTx();
+        this.transactionSqlServer.beginTx();
+    }
+    /**
+     * 提交事务
+     */
+    async commitTx() {
+        await this.transactionMySQL.commitTx();
+        await this.transactionPostgres.commitTx();
+        await this.transactionSqlServer.commitTx();
+    }
+    /**
+     * 事务回滚
+     */
+    async rollbackTx() {
+        await this.transactionMySQL.rollbackTx();
+        await this.transactionPostgres.rollbackTx();
+        await this.transactionSqlServer.rollbackTx();
+    }
+    /**
+     * 释放连接
+     */
+    async releaseTx() {
+        await this.transactionMySQL.releaseTx();
+        await this.transactionPostgres.releaseTx();
+        await this.transactionSqlServer.releaseTx();
+    }
+}
+exports.Transaction = Transaction;

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

@@ -1,28 +1,28 @@
-import { PoolConnection } from 'mysql2/promise';
-import { IConnectionPool } from '../interfaces';
-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>;
-}
-export { TransactionMySQL };
+import { PoolConnection } from 'mysql2/promise';
+import { IConnectionPool } from '../interfaces';
+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>;
+}
+export { TransactionMySQL };

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

@@ -1,76 +1,76 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionMySQL = void 0;
-class TransactionMySQL {
-    constructor() {
-        this.isBeginTransaction = false;
-        this.connectionMap = {};
-    }
-    /**
-     * 获取链接对象
-     * @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;
-    }
-    /**
-     * 开始事务
-     */
-    beginTx() {
-        this.isBeginTransaction = true;
-    }
-    /**
-     * 提交事务
-     */
-    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 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 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 = {};
-    }
-}
-exports.TransactionMySQL = TransactionMySQL;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionMySQL = void 0;
+class TransactionMySQL {
+    constructor() {
+        this.isBeginTransaction = false;
+        this.connectionMap = {};
+    }
+    /**
+     * 获取链接对象
+     * @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;
+    }
+    /**
+     * 开始事务
+     */
+    beginTx() {
+        this.isBeginTransaction = true;
+    }
+    /**
+     * 提交事务
+     */
+    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 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 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 = {};
+    }
+}
+exports.TransactionMySQL = TransactionMySQL;

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

@@ -1,28 +1,28 @@
-import { PoolClient } from 'pg';
-import { IConnectionPool } from '../interfaces';
-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>;
-}
-export { TransactionPostgres };
+import { PoolClient } from 'pg';
+import { IConnectionPool } from '../interfaces';
+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>;
+}
+export { TransactionPostgres };

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

@@ -1,85 +1,85 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionPostgres = void 0;
-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 = {};
-    }
-    /**
-     * 获取链接对象
-     * @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);
-            }
-        }
-        return connection;
-    }
-    /**
-     * 开始事务
-     */
-    beginTx() {
-        this.isBeginTransaction = true;
-    }
-    /**
-     * 提交事务
-     */
-    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 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 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 = {};
-    }
-}
-exports.TransactionPostgres = TransactionPostgres;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionPostgres = void 0;
+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 = {};
+    }
+    /**
+     * 获取链接对象
+     * @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);
+            }
+        }
+        return connection;
+    }
+    /**
+     * 开始事务
+     */
+    beginTx() {
+        this.isBeginTransaction = true;
+    }
+    /**
+     * 提交事务
+     */
+    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 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 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 = {};
+    }
+}
+exports.TransactionPostgres = TransactionPostgres;