midway-fatcms 0.0.1-beta.30 → 0.0.1-beta.31

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestCfgModel = void 0;
+const SqlCfgModel_1 = require("./SqlCfgModel");
+const MixinUtils_1 = require("../utils/MixinUtils");
+const defaultConfigs_1 = require("../defaultConfigs");
+//
+// const columnsRelation = [
+//   {
+//     relatedType: 'dict',
+//     relatedCode: 'SexEnum',
+//     sourceColumns: ['sex'],
+//     targetColumns: [{ from: 'label', to: 'sexLabel' }],
+//   },
+//   {
+//     relatedType: 'userBasic',
+//     // relatedCode: 'SexEnum',
+//     sourceColumns: ['created_by'],
+//     targetColumns: [{ from: 'userNick', to: 'created_by_user_nick' }],
+//   },
+//   {
+//     relatedType: 'sysConfig',
+//     relatedCode: 'SexEnum',
+//     sourceColumns: ['sex'],
+//     targetColumns: [{ from: 'userNick', to: 'created_by_user_nick' }],
+//   },
+// ];
+/**
+ *  sqlSimpleName/sqlCfgList 二选一
+ *  sqlCfgList 优先级高于 sqlSimpleName
+ *  如果设置了sqlCfgList，则sqlSimpleName不再生效。
+ */
+class RequestCfgModel {
+    constructor(json) {
+        this.maxLimit = defaultConfigs_1.DEFAULT_MAX_LIMIT; // 最大一次性返回的数量
+        Object.assign(this, json);
+        this.columns = MixinUtils_1.MixinUtils.parseColumns(json.columns);
+        this.authConfig = this.parseAuthConfig(json.authConfig);
+        this.sqlCfgList = [];
+        this.addSqlCfgModelList(json.sqlCfgList);
+    }
+    parseAuthConfig(cfg) {
+        if (!cfg) {
+            return null;
+        }
+        if (Array.isArray(cfg)) {
+            return cfg;
+        }
+        if (typeof cfg === 'string') {
+            return [cfg];
+        }
+        return null;
+    }
+    addSqlCfgModel(resName, originSql, resPicker, executeWhenFunCfg) {
+        const model = new SqlCfgModel_1.SqlCfgModel({ resName, originSql });
+        if (resPicker) {
+            model.resPicker = resPicker;
+        }
+        if (executeWhenFunCfg) {
+            model.executeWhen = executeWhenFunCfg;
+        }
+        this.addSqlCfgModelIf(model);
+    }
+    addSqlCfgModelList(list) {
+        if (!list || !Array.isArray(list)) {
+            return;
+        }
+        for (let i = 0; i < list.length; i++) {
+            const listElement = list[i];
+            const model = new SqlCfgModel_1.SqlCfgModel(listElement);
+            this.addSqlCfgModelIf(model);
+        }
+    }
+    addSqlCfgModelIf(model) {
+        if (!this.sqlCfgList) {
+            this.sqlCfgList = [];
+        }
+        this.sqlCfgList.push(model);
+    }
+}
+exports.RequestCfgModel = RequestCfgModel;

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

@@ -0,0 +1,25 @@
+import { IOrderByItem, IRequestModel, IVisitor } from '../interfaces';
+declare class RequestModel {
+    visitor: IVisitor;
+    method: string;
+    columns?: string[];
+    condition?: Record<string, any>;
+    data?: Record<string, any>;
+    limit: number;
+    offset: number;
+    orderBys?: IOrderByItem[];
+    constructor(req: IRequestModel, visitor: IVisitor);
+    private parseOrderBys;
+    private parseOffsetList;
+    /**
+     * 获取对象数据类型
+     * @param attrName
+     */
+    getCondOrDataJsonObject(attrName: string): any;
+    /**
+     * 获取基本数据类型
+     * @param attrName
+     */
+    getJsonObjectValue(attrName: string): any;
+}
+export { RequestModel };

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/ResModel.d.ts

@@ -0,0 +1,16 @@
+interface ResModelAffected {
+    insertId?: string | number;
+    affectedRows: number;
+}
+interface ResModelStandard {
+    row?: any;
+    rows?: any[];
+    total_count?: number;
+    affected?: ResModelAffected;
+    insert_affected?: ResModelAffected;
+    update_affected?: ResModelAffected;
+}
+declare type ResModelFlexible = ResModelStandard & {
+    [key: string]: any;
+};
+export { ResModelAffected, ResModelStandard, ResModelFlexible };

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

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

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;
+    sqlDbType?: 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;