midway-fatcms 0.0.1-beta.1

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestModel = void 0;
+const _ = require("lodash");
+const MixinUtils_1 = require("../utils/MixinUtils");
+const exceptions_1 = require("../exceptions");
+const defaultConfigs_1 = require("../defaultConfigs");
+class RequestModel {
+    constructor(req, visitor) {
+        Object.assign(this, req);
+        this.visitor = visitor;
+        this.columns = MixinUtils_1.MixinUtils.parseColumns(req.columns);
+        this.orderBys = this.parseOrderBys(req.orderBy);
+        const limitOffset = this.parseOffsetList(req);
+        this.limit = limitOffset.limit;
+        this.offset = limitOffset.offset;
+    }
+    parseOrderBys(orderByStr) {
+        if (MixinUtils_1.MixinUtils.isEmpty(orderByStr)) {
+            return [];
+        }
+        if (Array.isArray(orderByStr)) {
+            return orderByStr
+                .map(obj => {
+                if (typeof obj === 'string') {
+                    return { fieldName: obj, orderType: 'asc' };
+                }
+                const { fieldName, orderType = 'asc' } = obj;
+                if (fieldName) {
+                    return { fieldName, orderType };
+                }
+                return null;
+            })
+                .filter(o => {
+                return !!o;
+            });
+        }
+        const orderByResult = [];
+        const orderByArray = orderByStr
+            .split(',')
+            .map(s => {
+            return s.trim();
+        })
+            .filter(s => !!s);
+        if (MixinUtils_1.MixinUtils.isEmpty(orderByArray)) {
+            return orderByResult;
+        }
+        for (let i = 0; i < orderByArray.length; i++) {
+            const orderByItem = orderByArray[i];
+            let orderType = 'asc'; //默认升序
+            let fieldName = orderByItem;
+            if (orderByItem.endsWith('+')) {
+                // 升序
+                fieldName = orderByItem.substring(0, orderByItem.length - 1);
+                orderType = 'asc'; //升序
+            }
+            else if (orderByItem.endsWith('-')) {
+                //降序
+                fieldName = orderByItem.substring(0, orderByItem.length - 1);
+                orderType = 'desc'; //降序
+            }
+            fieldName = fieldName.trim();
+            if (MixinUtils_1.MixinUtils.isEmpty(fieldName) || !MixinUtils_1.MixinUtils.isValidFieldName(fieldName)) {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.REQUEST_MODEL_PARSE_ORDER_BY_FAILED, orderByItem);
+            }
+            orderByResult.push({ fieldName, orderType });
+        }
+        return orderByResult;
+    }
+    parseOffsetList(req) {
+        const { limit, offset, pageSize, pageNo } = req;
+        const limitOffset = {
+            limit: defaultConfigs_1.DEFAULT_LIMIT,
+            offset: 0,
+        };
+        if (typeof limit === 'number') {
+            limitOffset.limit = limit;
+        }
+        if (typeof offset === 'number') {
+            limitOffset.offset = offset;
+        }
+        if (typeof pageNo === 'number' && typeof pageSize === 'number' && pageNo > 0 && pageSize > 0) {
+            limitOffset.limit = pageSize;
+            limitOffset.offset = (pageNo - 1) * pageSize;
+        }
+        return limitOffset;
+    }
+    /**
+     * 获取对象数据类型
+     * @param attrName
+     */
+    getCondOrDataJsonObject(attrName) {
+        if (attrName.startsWith('data') || attrName.startsWith('condition')) {
+            const jsonObject = _.get(this, attrName);
+            if (!jsonObject) {
+                return null;
+            }
+            if (typeof jsonObject !== 'object' && !Array.isArray(jsonObject)) {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.RUN_GET_COND_OR_DATA_JSONOBJECT, attrName);
+            }
+            return jsonObject;
+        }
+        throw new exceptions_1.CommonException(exceptions_1.Exceptions.RUN_GET_COND_OR_DATA_JSONOBJECT, attrName);
+    }
+    /**
+     * 获取基本数据类型
+     * @param attrName
+     */
+    getJsonObjectValue(attrName) {
+        return _.get(this, attrName);
+    }
+}
+exports.RequestModel = RequestModel;

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

@@ -0,0 +1,20 @@
+import { RequestCfgModel } from './RequestCfgModel';
+import { RequestModel } from './RequestModel';
+import { SqlCfgModel } from './SqlCfgModel';
+import { ExecuteContext } from './ExecuteContext';
+import { IFuncCfgModel, IRequestCfgModel, ITableMeta } from '../interfaces';
+import { FuncContext } from './FuncContext';
+export interface ICurdProServiceHub {
+    getExecuteContext(): ExecuteContext;
+    validateByAllow(cfgModel: RequestCfgModel, reqModel: RequestModel): any;
+    validateByReject(cfgModel: RequestCfgModel, reqModel: RequestModel): any;
+    validateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): any;
+    validateByAuthCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
+    updateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): any;
+    getCachedCfgByMethod(method: string, isEnableCache: boolean): Promise<IRequestCfgModel>;
+    generateSQLList(exeCtx: ExecuteContext): Promise<void>;
+    executeSqlCfgModels(exeCtx: ExecuteContext): Promise<void>;
+    convertOriginToExecuteSql(sqlCfgModel: SqlCfgModel): Promise<void>;
+    executeFuncCfg(tmpFunCfg: IFuncCfgModel, exeFunCtx: FuncContext): string;
+    getTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta>;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,22 @@
+import { ColumnRelation, IFuncCfgModel, ISqlCfgModel } from '../interfaces';
+import { KeyOfCrudTypes, KeysOfSqlResPicker, SqlDbType } from './keys';
+declare class SqlCfgModel {
+    columns: string[];
+    columnsRelation?: ColumnRelation[];
+    sqlTable: string;
+    sqlSchema?: string;
+    sqlDatabase?: string;
+    sqlDdType?: SqlDbType;
+    maxLimit: number;
+    resName: string;
+    resPicker: KeysOfSqlResPicker;
+    originSql: string;
+    validate: IFuncCfgModel;
+    executeWhen: IFuncCfgModel;
+    executeSql: string;
+    executeSqlArgs: any[];
+    crudType: KeyOfCrudTypes;
+    constructor(json: Partial<ISqlCfgModel>);
+    getCrudType(): KeyOfCrudTypes;
+}
+export { SqlCfgModel };

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlCfgModel = void 0;
+const MixinUtils_1 = require("../utils/MixinUtils");
+const keys_1 = require("./keys");
+const functions_1 = require("../../utils/functions");
+const { isEmpty } = MixinUtils_1.MixinUtils;
+class SqlCfgModel {
+    constructor(json) {
+        this.crudType = null;
+        Object.assign(this, json);
+        this.columns = MixinUtils_1.MixinUtils.parseColumns(json.columns);
+        this.executeWhen = (0, functions_1.parseJsonObject)(json.executeWhen);
+    }
+    getCrudType() {
+        if (!this.crudType) {
+            const sql = this.executeSql.trim().toUpperCase();
+            if (isEmpty(sql)) {
+                this.crudType = keys_1.KeyOfCrudTypes.EMPTY_SQL;
+            }
+            else if (sql.startsWith(keys_1.KeyOfCrudTypes.SELECT)) {
+                this.crudType = keys_1.KeyOfCrudTypes.SELECT;
+            }
+            else if (sql.startsWith(keys_1.KeyOfCrudTypes.UPDATE)) {
+                this.crudType = keys_1.KeyOfCrudTypes.UPDATE;
+            }
+            else if (sql.startsWith(keys_1.KeyOfCrudTypes.DELETE)) {
+                this.crudType = keys_1.KeyOfCrudTypes.DELETE;
+            }
+            else if (sql.startsWith(keys_1.KeyOfCrudTypes.INSERT)) {
+                this.crudType = keys_1.KeyOfCrudTypes.INSERT;
+            }
+            else {
+                this.crudType = keys_1.KeyOfCrudTypes.NOT_CRUD;
+            }
+        }
+        return this.crudType;
+    }
+}
+exports.SqlCfgModel = SqlCfgModel;

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

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

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

@@ -0,0 +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;

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

@@ -0,0 +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 };

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

@@ -0,0 +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;

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

@@ -0,0 +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 };

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

@@ -0,0 +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;

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

@@ -0,0 +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 };

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

@@ -0,0 +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;

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

@@ -0,0 +1,34 @@
+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;
+}
+export { TransactionSqlServer };

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionSqlServer = void 0;
+const mssql_1 = require("mssql");
+class TransactionSqlServer {
+    constructor() {
+        this.isBeginTransaction = false;
+        this.connectionMap = {};
+        this.transactionMap = {};
+    }
+    /**
+     * 获取链接对象
+     * @param pool
+     */
+    async getTxConnection(pool) {
+        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;
+    }
+    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 = Object.values(this.transactionMap);
+        for (let i = 0; i < transactions.length; i++) {
+            const tmpTx = transactions[i];
+            await tmpTx.commit();
+        }
+    }
+    /**
+     * 事务回滚
+     */
+    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 releaseTx() {
+        this.connectionMap = {};
+        this.transactionMap = {};
+    }
+    async beginTransaction(poolName) {
+        const connection = this.connectionMap[poolName];
+        const originConnection = connection.originConnection;
+        const tmpTx = new mssql_1.Transaction(originConnection);
+        this.transactionMap[poolName] = tmpTx;
+        return await tmpTx.begin();
+    }
+}
+exports.TransactionSqlServer = TransactionSqlServer;