midway-fatcms 0.0.1-beta.1

package/dist/libs/crud-pro/services/CrudProExecuteSqlService.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudProExecuteSqlService = void 0;
+const _ = require("lodash");
+const CrudProServiceBase_1 = require("./CrudProServiceBase");
+const keys_1 = require("../models/keys");
+const exceptions_1 = require("../exceptions");
+const convertPgType_1 = require("../utils/sqlConvert/convertPgType");
+const convertPgSql_1 = require("../utils/sqlConvert/convertPgSql");
+const convertMsSql_1 = require("../utils/sqlConvert/convertMsSql");
+const ModelUtils_1 = require("../utils/ModelUtils");
+const MixinUtils_1 = require("../utils/MixinUtils");
+const FuncContext_1 = require("../models/FuncContext");
+const { checkFuncCfgValid } = ModelUtils_1.ModelUtils;
+const { isEmpty } = MixinUtils_1.MixinUtils;
+class CrudProExecuteSqlService extends CrudProServiceBase_1.CrudProServiceBase {
+    async executeSqlCfgModels() {
+        const exeCtx = this.getExecuteContext();
+        const sqlCfgModels = exeCtx.getSqlCfgModels();
+        for (let i = 0; i < sqlCfgModels.length; i++) {
+            const sqlCfgModel = sqlCfgModels[i];
+            const checkResult = this.executeSqlCfgModelPreCheck(sqlCfgModel);
+            if (checkResult) {
+                await this.executeSqlCfgModel(sqlCfgModel);
+            }
+        }
+    }
+    async executeSqlCfgModel(sqlCfgModel) {
+        this.logger.info('executeSqlCfgModel1', sqlCfgModel.executeSql, sqlCfgModel.executeSqlArgs);
+        const exeCtx = this.getExecuteContext();
+        const connection = await this.getTxConnectionBySqlCfg(sqlCfgModel);
+        const executeSqlArgs = this.handleExecuteSqlArgsByResModel(exeCtx, sqlCfgModel.executeSqlArgs || []);
+        let sqlRes;
+        let queryRes;
+        if (sqlCfgModel.sqlDdType === keys_1.SqlDbType.postgres) { // import { PoolClient } from 'pg';
+            const pgClient = connection;
+            const pgSql = (0, convertPgSql_1.replaceQuestionMarks)(sqlCfgModel.executeSql);
+            this.logger.info('executeSqlCfgModel_postgres', pgSql, executeSqlArgs, sqlCfgModel.resPicker);
+            queryRes = await pgClient.query({
+                text: pgSql,
+                values: executeSqlArgs || []
+            });
+            sqlRes = (0, convertPgType_1.pickAndConvertPgRows)(queryRes);
+        }
+        else if (sqlCfgModel.sqlDdType === keys_1.SqlDbType.sqlserver) {
+            const mssql = (0, convertMsSql_1.replaceQuestionMarksForMssql)(sqlCfgModel.executeSql);
+            this.logger.info('executeSqlCfgModel_sqlserver', mssql, executeSqlArgs, sqlCfgModel.resPicker);
+            // SQLServer
+            queryRes = await connection.query(mssql, executeSqlArgs);
+            sqlRes = _.get(queryRes, 'recordsets[0]') || [];
+        }
+        else {
+            this.logger.info('executeSqlCfgModel_mysql', sqlCfgModel.executeSql, executeSqlArgs, sqlCfgModel.resPicker);
+            // MYSQL
+            queryRes = await connection.query(sqlCfgModel.executeSql, executeSqlArgs);
+            sqlRes = queryRes[0];
+        }
+        const resObject = this.toQueryResByResPicker(sqlRes, queryRes, sqlCfgModel);
+        exeCtx.setResModelItem(sqlCfgModel.resName, resObject);
+    }
+    handleExecuteSqlArgsByResModel(exeCtx, executeSqlArgs) {
+        return executeSqlArgs.map((arg) => {
+            if (arg && typeof arg === 'object' && typeof arg.___GENERATE_GET_RES_ATTR___ === 'string') {
+                const word = arg.___GENERATE_GET_RES_ATTR___;
+                if (word.startsWith(keys_1.KeysOfCustomSQL.SQL_PICK_RES_AS_NUMBER)) {
+                    const resName = MixinUtils_1.MixinUtils.removeStringPrefix(word, keys_1.KeysOfCustomSQL.SQL_PICK_RES_AS_NUMBER);
+                    this.logger.info('handleExecuteSqlArgsByResModel resName', resName);
+                    this.logger.info('handleExecuteSqlArgsByResModel getResModel', exeCtx.getResModel());
+                    return Number(exeCtx.getResModelItemLodash(resName) || 0);
+                }
+                if (word.startsWith(keys_1.KeysOfCustomSQL.SQL_PICK_RES_AS_STRING)) {
+                    const resName = MixinUtils_1.MixinUtils.removeStringPrefix(word, keys_1.KeysOfCustomSQL.SQL_PICK_RES_AS_STRING);
+                    return String(exeCtx.getResModelItemLodash(resName) || "");
+                }
+            }
+            return arg;
+        });
+    }
+    executeSqlCfgModelPreCheck(sqlCfgModel) {
+        const crudType = sqlCfgModel.getCrudType();
+        if (keys_1.KeyOfCrudTypes.EMPTY_SQL === crudType) {
+            // 允许空SQL，没有需要执行的正常。
+            return false;
+        }
+        if (keys_1.KeyOfCrudTypes.NOT_CRUD === crudType) {
+            // 只支持增删改查，其他语句不支持。
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_NOT_SUPPORT_THE_SQL, sqlCfgModel.executeSql);
+        }
+        // 此SQL不需要执行
+        if (!this.isNeedExecute(sqlCfgModel)) {
+            return false;
+        }
+        // 执行之前，根据配置校验一下此SQL是否可以执行
+        this.assertByValidate(sqlCfgModel);
+        return true;
+    }
+    assertByValidate(sqlCfgModel) {
+        const exeCtx = this.getExecuteContext();
+        const funcCfg = sqlCfgModel.validate;
+        if (!funcCfg) {
+            return; // 没有配置。
+        }
+        if (!checkFuncCfgValid(funcCfg)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_SQL_CFG_EXECUTE_VALIDATE_EMPTY, {
+                funcCfg: funcCfg,
+                originSql: sqlCfgModel.originSql,
+            });
+        }
+        const errMsg = funcCfg.message || '执行前校验失败';
+        let result;
+        try {
+            const exeFunCtx = new FuncContext_1.FuncContext();
+            exeFunCtx.currentValue = null;
+            exeFunCtx.reqModel = exeCtx.getReqModel();
+            exeFunCtx.resModel = exeCtx.getResModel();
+            result = this.serviceHub.executeFuncCfg(funcCfg, exeFunCtx); // 可以抛出异常
+        }
+        catch (e) {
+            this.logger.debug('assertByValidate', e);
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.RUN_EXECUTE_VALIDATE, {
+                funcCfg: funcCfg,
+                originSql: sqlCfgModel.originSql,
+                error: '' + e,
+            });
+        }
+        if (!(typeof result === 'boolean')) {
+            // 自定义的校验函数，必须返回boolean类型的树枝
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_IS_NEED_EXECUTE_FUNC_MUST_RETURN_BOOL, {
+                funcCfg: funcCfg,
+                originSql: sqlCfgModel.originSql,
+            });
+        }
+        if (result === false) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.RUN_EXECUTE_VALIDATE, errMsg);
+        }
+    }
+    /**
+     * 判断此SQL是否需要执行
+     * @param sqlCfgModel
+     * @param exeCtx
+     * @private
+     */
+    isNeedExecute(sqlCfgModel) {
+        const exeCtx = this.getExecuteContext();
+        const funcCfg = sqlCfgModel.executeWhen;
+        if (!funcCfg || Object.keys(funcCfg).length === 0) {
+            return true; // 没有配置。默认，需要执行。
+        }
+        if (!checkFuncCfgValid(funcCfg)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_CHECK_EXECUTE_WHEN_EMPTY, {
+                funcCfg: funcCfg,
+                originSql: sqlCfgModel.originSql,
+            });
+        }
+        let result;
+        try {
+            const exeFunCtx = new FuncContext_1.FuncContext();
+            exeFunCtx.currentValue = null;
+            exeFunCtx.reqModel = exeCtx.getReqModel();
+            exeFunCtx.resModel = exeCtx.getResModel();
+            result = this.serviceHub.executeFuncCfg(funcCfg, exeFunCtx);
+        }
+        catch (e) {
+            this.logger.debug('isNeedExecute', e);
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.RUN_IS_NEED_EXECUTE_ERR, {
+                funcCfg: funcCfg,
+                originSql: sqlCfgModel.originSql,
+                error: '' + e,
+            });
+        }
+        if (!(typeof result === 'boolean')) {
+            // 自定义的校验函数，必须返回boolean类型的树枝
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_IS_NEED_EXECUTE_FUNC_MUST_RETURN_BOOL, {
+                funcCfg: funcCfg,
+                originSql: sqlCfgModel.originSql,
+            });
+        }
+        return result === true;
+    }
+    toQueryResByResPicker(sqlRes, queryRes, sqlCfgModel) {
+        const resPicker = sqlCfgModel.resPicker;
+        // 返回第一行
+        if (keys_1.KeysOfSqlResPicker.RESULT_FIRST_ROW === resPicker) {
+            const rows = sqlRes;
+            if (rows && rows.length > 0) {
+                return rows[0];
+            }
+            return null;
+        }
+        // $ResultSet[0].total_count ， 只取第一行的的total_count
+        if (keys_1.KeysOfSqlResPicker.RESULT_TOTAL_COUNT === resPicker) {
+            const rows = sqlRes;
+            if (isEmpty(rows)) {
+                return 0;
+            }
+            const map0 = rows[0];
+            return Number(map0['total_count'] || 0);
+        }
+        // 增删改res的内容是修改结果：包括： insert\delete\update
+        if (keys_1.KeysOfSqlResPicker.UPDATE_RESULT === resPicker) {
+            if (sqlCfgModel.sqlDdType === keys_1.SqlDbType.postgres) {
+                return {
+                    insertId: _.get(queryRes, 'rows[0].id'),
+                    affectedRows: _.get(queryRes, 'rowCount')
+                };
+            }
+            if (sqlCfgModel.sqlDdType === keys_1.SqlDbType.sqlserver) {
+                return {
+                    insertId: _.get(queryRes, 'recordset[0].id'),
+                    affectedRows: _.get(queryRes, 'rowsAffected[0]')
+                };
+            }
+            return sqlRes;
+        }
+        //其他配置：形如： sqlRes[0].total_count
+        if (typeof resPicker === 'string') {
+            if (resPicker.startsWith('sqlRes')) {
+                return _.get({ sqlRes }, resPicker);
+            }
+            else {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.RUN_EXECUTE_VALIDATE, 'resPicker必须是以sqlRes开头');
+            }
+        }
+        return sqlRes;
+    }
+}
+exports.CrudProExecuteSqlService = CrudProExecuteSqlService;

package/dist/libs/crud-pro/services/CrudProFieldUpdateService.d.ts

@@ -0,0 +1,9 @@
+import { RequestModel } from '../models/RequestModel';
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { RequestCfgModel } from '../models/RequestCfgModel';
+declare class CrudProFieldUpdateService extends CrudProServiceBase {
+    updateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
+    private updateByJsonObject;
+    private getUpdateNewValueByCfg;
+}
+export { CrudProFieldUpdateService };

package/dist/libs/crud-pro/services/CrudProFieldUpdateService.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudProFieldUpdateService = void 0;
+const CrudProServiceBase_1 = require("./CrudProServiceBase");
+const MixinUtils_1 = require("../utils/MixinUtils");
+const _ = require("lodash");
+const ModelUtils_1 = require("../utils/ModelUtils");
+const exceptions_1 = require("../exceptions");
+const FuncContext_1 = require("../models/FuncContext");
+const { checkFuncCfgValid } = ModelUtils_1.ModelUtils;
+const { isEmpty } = MixinUtils_1.MixinUtils;
+class CrudProFieldUpdateService extends CrudProServiceBase_1.CrudProServiceBase {
+    updateByCfg(cfgModel, reqModel) {
+        const updateCfgMap = cfgModel.updateCfg;
+        if (isEmpty(updateCfgMap)) {
+            return;
+        }
+        const keys = Object.keys(updateCfgMap);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i]; // data.name
+            const updateCfg = updateCfgMap[key];
+            this.updateByJsonObject(updateCfg, key, reqModel);
+        }
+    }
+    updateByJsonObject(updateCfg, key, reqModel) {
+        if (isEmpty(updateCfg)) {
+            return;
+        }
+        const itemOldValue = _.get(reqModel, key);
+        const newValue = this.getUpdateNewValueByCfg(updateCfg, itemOldValue, key, reqModel);
+        _.set(reqModel, key, newValue);
+    }
+    getUpdateNewValueByCfg(updateCfg, itemOldValue, key, reqModel) {
+        if (!checkFuncCfgValid(updateCfg)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_UPDATE_ITEM_MUST_FUNC_CFG, 'updateCfg配置项必须是满足IFuncCfgModel' + key);
+        }
+        let result;
+        try {
+            const exeFunCtx = new FuncContext_1.FuncContext();
+            exeFunCtx.currentValue = itemOldValue;
+            exeFunCtx.reqModel = reqModel;
+            result = this.serviceHub.executeFuncCfg(updateCfg, exeFunCtx);
+        }
+        catch (e) {
+            this.logger.error('getUpdateNewValueByCfg->executeFuncCfg', e);
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.UPDATE_EXCEPTION, key + '.' + e);
+        }
+        return result;
+    }
+}
+exports.CrudProFieldUpdateService = CrudProFieldUpdateService;

package/dist/libs/crud-pro/services/CrudProFieldValidateService.d.ts

@@ -0,0 +1,13 @@
+import { RequestModel } from '../models/RequestModel';
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { RequestCfgModel } from '../models/RequestCfgModel';
+declare class CrudProFieldValidateService extends CrudProServiceBase {
+    validateByAllow(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
+    validateByReject(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
+    validateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
+    private validateByCfgCustomFunction;
+    private validateByCfgString;
+    private validateByCfgFunc;
+    private validateRequired;
+}
+export { CrudProFieldValidateService };

package/dist/libs/crud-pro/services/CrudProFieldValidateService.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudProFieldValidateService = void 0;
+const CrudProServiceBase_1 = require("./CrudProServiceBase");
+const MixinUtils_1 = require("../utils/MixinUtils");
+const keys_1 = require("../models/keys");
+const exceptions_1 = require("../exceptions");
+const ModelUtils_1 = require("../utils/ModelUtils");
+const FuncContext_1 = require("../models/FuncContext");
+const ValidateUtils_1 = require("../utils/ValidateUtils");
+const { checkFuncCfgValid } = ModelUtils_1.ModelUtils;
+const { isEmpty, isNotEmpty, deepTravelObject } = MixinUtils_1.MixinUtils;
+class CrudProFieldValidateService extends CrudProServiceBase_1.CrudProServiceBase {
+    validateByAllow(cfgModel, reqModel) {
+        const allowCfg = cfgModel.allowCfg; //  allowCfg: {data: ['login_name', 'nick_name', 'avatar', 'status'],},
+        if (isEmpty(allowCfg)) {
+            return;
+        }
+        const keys = Object.keys(allowCfg);
+        const validateAllowByJsonObject = (allowList, targetObj, key) => {
+            if (isEmpty(allowList)) {
+                return;
+            }
+            const isCondition = key.startsWith('condition');
+            // 任意一个key，不在allow列表中，就不合法
+            deepTravelObject(targetObj, (value, key, index, keyPath) => {
+                if (isCondition) {
+                    if (!keys_1.KeysOfConditions.ALL_KEYS.has(key) && !allowList.includes(key)) {
+                        throw new exceptions_1.CommonException(exceptions_1.Exceptions.VALIDATE_ALLOW_ERR, keyPath);
+                    }
+                }
+                else {
+                    if (!allowList.includes(key)) {
+                        throw new exceptions_1.CommonException(exceptions_1.Exceptions.VALIDATE_ALLOW_ERR, keyPath);
+                    }
+                }
+            }, key);
+        };
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i]; // demo: data or condition
+            const allowList = MixinUtils_1.MixinUtils.parseStringArray(allowCfg[key]);
+            if (Array.isArray(allowList) && allowList.length > 0) {
+                const targetObj = reqModel.getCondOrDataJsonObject(key);
+                validateAllowByJsonObject(allowList, targetObj, key);
+            }
+        }
+    }
+    validateByReject(cfgModel, reqModel) {
+        const rejectCfgMap = cfgModel.rejectCfg;
+        if (isEmpty(rejectCfgMap)) {
+            return;
+        }
+        const keys = Object.keys(rejectCfgMap);
+        const validateRejectByJsonObject = (rejectList, targetObj, conditionName) => {
+            if (isEmpty(rejectList)) {
+                return;
+            }
+            // 任意一个key，出现在reject列表中，就不合法
+            deepTravelObject(targetObj, (value, key, index, keyPath) => {
+                if (rejectList.includes(key)) {
+                    throw new exceptions_1.CommonException(exceptions_1.Exceptions.VALIDATE_REJECT_ERR, keyPath);
+                }
+            }, conditionName);
+        };
+        for (let i = 0; i < keys.length; i++) {
+            const conditionName = keys[i];
+            const rejectList = MixinUtils_1.MixinUtils.parseStringArray(rejectCfgMap[conditionName]);
+            if (Array.isArray(rejectList) && rejectList.length > 0) {
+                const targetObj = reqModel.getCondOrDataJsonObject(conditionName);
+                validateRejectByJsonObject(rejectList, targetObj, conditionName);
+            }
+        }
+    }
+    validateByCfg(cfgModel, reqModel) {
+        const validateCfg = cfgModel.validateCfg;
+        if (isEmpty(validateCfg)) {
+            return;
+        }
+        const keys = Object.keys(validateCfg);
+        for (const key of keys) {
+            const itemValue = reqModel.getJsonObjectValue(key);
+            const cfgList = validateCfg[key];
+            if (isNotEmpty(cfgList)) {
+                // 先校验是否必填。
+                this.validateRequired(cfgList, itemValue, key);
+                // 除REQUIRED之外的其他配置
+                const cfgList2 = cfgList.filter(cfg => {
+                    return cfg !== keys_1.KeysOfValidators.REQUIRED;
+                });
+                // 只有数值不为空时，才需要校验。非必填情况下：内容为空，不需要校验
+                if (isNotEmpty(itemValue)) {
+                    for (const cfg of cfgList2) {
+                        if (typeof cfg === 'string') {
+                            this.validateByCfgString(cfg, reqModel, itemValue, key);
+                        }
+                        else if (typeof cfg === 'function') {
+                            this.validateByCfgCustomFunction(cfg, reqModel, itemValue, key);
+                        }
+                        else {
+                            this.validateByCfgFunc(cfg, reqModel, itemValue, key);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    validateByCfgCustomFunction(cfg, reqModel, itemValue, key) {
+        // 使用自定义函数校验
+        cfg(itemValue);
+    }
+    validateByCfgString(itemCfg, reqModel, itemValue, errPath) {
+        return (0, ValidateUtils_1.validateByCfgString)(itemCfg, itemValue, errPath);
+    }
+    validateByCfgFunc(funcCfg, reqModel, itemValue, errPath) {
+        if (!checkFuncCfgValid(funcCfg)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_VALIDATE_CUSTOM_FUNCTION_EMPTY);
+        }
+        let result;
+        try {
+            const exeFunCtx = new FuncContext_1.FuncContext();
+            exeFunCtx.currentValue = itemValue;
+            exeFunCtx.reqModel = reqModel;
+            result = this.serviceHub.executeFuncCfg(funcCfg, exeFunCtx);
+        }
+        catch (e) {
+            this.logger.error('validateByCfgFunc', e);
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.VALIDATE_EXCEPTION, errPath + '.' + e);
+        }
+        if (!(typeof result === 'boolean')) {
+            // 自定义的校验函数，必须返回boolean类型的树枝
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_VALIDATE_CUSTOM_FUNCTION_MUST_RETURN_BOOL, errPath);
+        }
+        if (result === false) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.VALIDATE_ERR, funcCfg.message || errPath);
+        }
+    }
+    validateRequired(cfgList, itemValue, errPath) {
+        const required = cfgList.find(cfg => {
+            return cfg === keys_1.KeysOfValidators.REQUIRED;
+        });
+        if (required) {
+            if (isEmpty(itemValue)) {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.VALIDATE_ERR, '参数校验错误，缺少必填字段：' + errPath);
+            }
+        }
+    }
+}
+exports.CrudProFieldValidateService = CrudProFieldValidateService;

package/dist/libs/crud-pro/services/CrudProGenSqlCondition.d.ts

@@ -0,0 +1,24 @@
+import { SqlSegArg } from '../models/SqlSegArg';
+import { SqlCfgModel } from "../models/SqlCfgModel";
+declare class CrudProGenSqlCondition {
+    private readonly sqlCfg;
+    constructor(sqlCfg: SqlCfgModel);
+    generateCondition(condition: any): SqlSegArg;
+    /**
+     * condition = {$or:[{name:'zhangsan'},{name:'lisi'},{age: {$gt:18}}],sex:1}
+     * where (name = 'zhangsan' or name = 'lisi' or age > 18) and sex = 1
+     * @param condition
+     * @private
+     */
+    private generateByLogicalKey;
+    private generateByLogicalOR;
+    private generateByCompareKey;
+    /**
+     * 参数校验
+     * @param key
+     * @param map
+     * @private
+     */
+    private generateByCompareKeyCheckParam;
+}
+export { CrudProGenSqlCondition };