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

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;

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

@@ -0,0 +1,106 @@
+export declare enum SqlDbType {
+    mysql = "mysql",
+    postgres = "postgres",
+    sqlserver = "sqlserver"
+}
+export declare enum KeysOfFunCtx {
+    FUNC_CTX = "$",
+    CURRENT_VALUE = "$current",
+    VISITOR = "visitor",
+    VISITOR_ATTR = "visitor.",
+    REQUEST = "req.",
+    RESULT = "res."
+}
+export declare enum KeysOfAuthType {
+    free = "free",
+    login = "login",
+    byRoleCode = "byRoleCode",
+    byFuncCode = "byFuncCode"
+}
+export declare enum KeysOfValidators {
+    REQUIRED = "required",
+    BOOLEAN = "boolean",
+    OBJECT = "object",
+    ARRAY = "array",
+    ARRAY_STRING = "array:string",
+    ARRAY_NUMBER = "array:number",
+    STRING = "string",
+    EMAIL = "email",
+    NAME = "name",
+    PHONE_CN = "phone:cn",
+    INTEGER = "integer",
+    NUMBER = "number",
+    NUMERIC = "numeric",
+    MOMENT = "moment:",
+    SCALE = "scale:",
+    LENGTH = "length:",
+    REG_EXP = "regexp:",
+    ENUM = "enum:"
+}
+export declare enum KeyOfCrudTypes {
+    SELECT = "SELECT",
+    UPDATE = "UPDATE",
+    INSERT = "INSERT",
+    DELETE = "DELETE",
+    NOT_CRUD = "NOT_CRUD",
+    EMPTY_SQL = "EMPTY_SQL",
+    SYS_QUERY = "SYS_QUERY"
+}
+export declare enum KeysOfSimpleSQL {
+    SIMPLE_QUERY = "SIMPLE_QUERY",
+    SIMPLE_QUERY_ONE = "SIMPLE_QUERY_ONE",
+    SIMPLE_QUERY_PAGE = "SIMPLE_QUERY_PAGE",
+    SIMPLE_QUERY_COUNT = "SIMPLE_QUERY_COUNT",
+    SIMPLE_UPDATE = "SIMPLE_UPDATE",
+    SIMPLE_INSERT = "SIMPLE_INSERT",
+    SIMPLE_DELETE = "SIMPLE_DELETE",
+    SIMPLE_INSERT_ON_DUPLICATE_UPDATE = "SIMPLE_INSERT_ON_DUPLICATE_UPDATE",
+    SIMPLE_INSERT_OR_UPDATE = "SIMPLE_INSERT_OR_UPDATE",
+    CUSTOM = "CUSTOM"
+}
+export declare enum KeysOfSqlResPicker {
+    UPDATE_RESULT = "UPDATE_RESULT",
+    RESULT_FIRST_ROW = "RESULT_FIRST_ROW",
+    RESULT_TOTAL_COUNT = "RESULT_TOTAL_COUNT",
+    RESULT_ONE_VALUE = "RESULT_ONE_VALUE"
+}
+export declare const KeysOfCustomSQL: {
+    SQL_COLUMNS: string;
+    SQL_TABLE: string;
+    SQL_OFFSET_LIMIT: string;
+    SQL_ORDER_BYS: string;
+    SQL_AS_WHERE: string;
+    SQL_AS_UPDATE: string;
+    SQL_AS_INSERT_KEYS: string;
+    SQL_AS_INSERT_VALUES: string;
+    SQL_GET_DATA_ATTR_START: string;
+    SQL_GET_CONDITION_ATTR_START: string;
+    SQL_PICK_RES_AS_NUMBER: string;
+    SQL_PICK_RES_AS_STRING: string;
+    SQL_FUNCTION: string;
+};
+/**
+ * 查询条件中允许出现的关键词
+ * 与MongoDB的语法完全一致
+ */
+export declare const KeysOfConditions: {
+    $OR: string;
+    $NE: string;
+    $LT: string;
+    $LTE: string;
+    $GT: string;
+    $GTE: string;
+    $IN: string;
+    $NIN: string;
+    $NOT_NULL: string;
+    $NULL: string;
+    $RANGE: string;
+    $LIKE: string;
+    $NOT_LIKE: string;
+    $LIKE_INCLUDE: string;
+    $NOT_LIKE_INCLUDE: string;
+    $MATCH: string;
+    $MATCH_BOOL: string;
+    COMPARE_KEYS: Set<string>;
+    ALL_KEYS: Set<string>;
+};

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeysOfConditions = exports.KeysOfCustomSQL = exports.KeysOfSqlResPicker = exports.KeysOfSimpleSQL = exports.KeyOfCrudTypes = exports.KeysOfValidators = exports.KeysOfAuthType = exports.KeysOfFunCtx = exports.SqlDbType = void 0;
+var SqlDbType;
+(function (SqlDbType) {
+    SqlDbType["mysql"] = "mysql";
+    SqlDbType["postgres"] = "postgres";
+    SqlDbType["sqlserver"] = "sqlserver";
+})(SqlDbType = exports.SqlDbType || (exports.SqlDbType = {}));
+var KeysOfFunCtx;
+(function (KeysOfFunCtx) {
+    KeysOfFunCtx["FUNC_CTX"] = "$";
+    KeysOfFunCtx["CURRENT_VALUE"] = "$current";
+    KeysOfFunCtx["VISITOR"] = "visitor";
+    KeysOfFunCtx["VISITOR_ATTR"] = "visitor.";
+    KeysOfFunCtx["REQUEST"] = "req.";
+    KeysOfFunCtx["RESULT"] = "res.";
+})(KeysOfFunCtx = exports.KeysOfFunCtx || (exports.KeysOfFunCtx = {}));
+//鉴权类型；free无需鉴权，login仅登录即可，byRoleCode校验角色，byFuncCode校验功能点
+var KeysOfAuthType;
+(function (KeysOfAuthType) {
+    KeysOfAuthType["free"] = "free";
+    KeysOfAuthType["login"] = "login";
+    KeysOfAuthType["byRoleCode"] = "byRoleCode";
+    KeysOfAuthType["byFuncCode"] = "byFuncCode";
+})(KeysOfAuthType = exports.KeysOfAuthType || (exports.KeysOfAuthType = {}));
+var KeysOfValidators;
+(function (KeysOfValidators) {
+    KeysOfValidators["REQUIRED"] = "required";
+    KeysOfValidators["BOOLEAN"] = "boolean";
+    KeysOfValidators["OBJECT"] = "object";
+    KeysOfValidators["ARRAY"] = "array";
+    KeysOfValidators["ARRAY_STRING"] = "array:string";
+    KeysOfValidators["ARRAY_NUMBER"] = "array:number";
+    KeysOfValidators["STRING"] = "string";
+    KeysOfValidators["EMAIL"] = "email";
+    KeysOfValidators["NAME"] = "name";
+    KeysOfValidators["PHONE_CN"] = "phone:cn";
+    KeysOfValidators["INTEGER"] = "integer";
+    KeysOfValidators["NUMBER"] = "number";
+    KeysOfValidators["NUMERIC"] = "numeric";
+    KeysOfValidators["MOMENT"] = "moment:";
+    KeysOfValidators["SCALE"] = "scale:";
+    KeysOfValidators["LENGTH"] = "length:";
+    KeysOfValidators["REG_EXP"] = "regexp:";
+    KeysOfValidators["ENUM"] = "enum:";
+})(KeysOfValidators = exports.KeysOfValidators || (exports.KeysOfValidators = {}));
+var KeyOfCrudTypes;
+(function (KeyOfCrudTypes) {
+    KeyOfCrudTypes["SELECT"] = "SELECT";
+    KeyOfCrudTypes["UPDATE"] = "UPDATE";
+    KeyOfCrudTypes["INSERT"] = "INSERT";
+    KeyOfCrudTypes["DELETE"] = "DELETE";
+    KeyOfCrudTypes["NOT_CRUD"] = "NOT_CRUD";
+    KeyOfCrudTypes["EMPTY_SQL"] = "EMPTY_SQL";
+    KeyOfCrudTypes["SYS_QUERY"] = "SYS_QUERY";
+})(KeyOfCrudTypes = exports.KeyOfCrudTypes || (exports.KeyOfCrudTypes = {}));
+var KeysOfSimpleSQL;
+(function (KeysOfSimpleSQL) {
+    KeysOfSimpleSQL["SIMPLE_QUERY"] = "SIMPLE_QUERY";
+    KeysOfSimpleSQL["SIMPLE_QUERY_ONE"] = "SIMPLE_QUERY_ONE";
+    KeysOfSimpleSQL["SIMPLE_QUERY_PAGE"] = "SIMPLE_QUERY_PAGE";
+    KeysOfSimpleSQL["SIMPLE_QUERY_COUNT"] = "SIMPLE_QUERY_COUNT";
+    KeysOfSimpleSQL["SIMPLE_UPDATE"] = "SIMPLE_UPDATE";
+    KeysOfSimpleSQL["SIMPLE_INSERT"] = "SIMPLE_INSERT";
+    KeysOfSimpleSQL["SIMPLE_DELETE"] = "SIMPLE_DELETE";
+    KeysOfSimpleSQL["SIMPLE_INSERT_ON_DUPLICATE_UPDATE"] = "SIMPLE_INSERT_ON_DUPLICATE_UPDATE";
+    KeysOfSimpleSQL["SIMPLE_INSERT_OR_UPDATE"] = "SIMPLE_INSERT_OR_UPDATE";
+    KeysOfSimpleSQL["CUSTOM"] = "CUSTOM";
+})(KeysOfSimpleSQL = exports.KeysOfSimpleSQL || (exports.KeysOfSimpleSQL = {}));
+var KeysOfSqlResPicker;
+(function (KeysOfSqlResPicker) {
+    KeysOfSqlResPicker["UPDATE_RESULT"] = "UPDATE_RESULT";
+    KeysOfSqlResPicker["RESULT_FIRST_ROW"] = "RESULT_FIRST_ROW";
+    KeysOfSqlResPicker["RESULT_TOTAL_COUNT"] = "RESULT_TOTAL_COUNT";
+    KeysOfSqlResPicker["RESULT_ONE_VALUE"] = "RESULT_ONE_VALUE";
+})(KeysOfSqlResPicker = exports.KeysOfSqlResPicker || (exports.KeysOfSqlResPicker = {}));
+exports.KeysOfCustomSQL = {
+    SQL_COLUMNS: '@@columns',
+    SQL_TABLE: '@@table',
+    SQL_OFFSET_LIMIT: '@@offsetLimit',
+    SQL_ORDER_BYS: '@@orderBys',
+    SQL_AS_WHERE: '@@asWhere:',
+    SQL_AS_UPDATE: '@@asUpdate:',
+    SQL_AS_INSERT_KEYS: '@@asInsertKeys:',
+    SQL_AS_INSERT_VALUES: '@@asInsertValues:',
+    // 从Req中取值：单独取Data中的某个字段：获取单个值。
+    SQL_GET_DATA_ATTR_START: '@@data',
+    SQL_GET_CONDITION_ATTR_START: '@@condition',
+    // 从Res中取值
+    SQL_PICK_RES_AS_NUMBER: '@@pickResAsNumber:',
+    SQL_PICK_RES_AS_STRING: '@@pickResAsString:',
+    // 使用java函数：获取单个值
+    SQL_FUNCTION: '@@function:', // @@function:aaa
+};
+/**
+ * 查询条件中允许出现的关键词
+ * 与MongoDB的语法完全一致
+ */
+exports.KeysOfConditions = {
+    $OR: '$or',
+    $NE: '$ne',
+    $LT: '$lt',
+    $LTE: '$lte',
+    $GT: '$gt',
+    $GTE: '$gte',
+    $IN: '$in',
+    $NIN: '$nin',
+    $NOT_NULL: '$notNull',
+    $NULL: '$null',
+    $RANGE: '$range',
+    $LIKE: '$like',
+    $NOT_LIKE: '$notLike',
+    $LIKE_INCLUDE: '$likeInclude',
+    $NOT_LIKE_INCLUDE: '$notLikeInclude',
+    $MATCH: '$match',
+    $MATCH_BOOL: '$matchBool',
+    COMPARE_KEYS: new Set([]),
+    ALL_KEYS: new Set([]),
+};
+function initKeysOfConditions() {
+    const addIgnoreCase = (keys, key) => {
+        keys.add(key);
+        keys.add(key.toUpperCase());
+        keys.add(key.toLowerCase());
+    };
+    // 比较操作符, 支持忽略大小写
+    exports.KeysOfConditions.COMPARE_KEYS = new Set([]);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$NE);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$LT);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$LTE);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$GT);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$GTE);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$IN);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$NIN);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$LIKE);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$LIKE_INCLUDE);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$NOT_LIKE);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$NOT_LIKE_INCLUDE);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$MATCH);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$MATCH_BOOL);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$RANGE);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$NULL);
+    addIgnoreCase(exports.KeysOfConditions.COMPARE_KEYS, exports.KeysOfConditions.$NOT_NULL);
+    // 所有操作符
+    exports.KeysOfConditions.ALL_KEYS = new Set([...exports.KeysOfConditions.COMPARE_KEYS]);
+    addIgnoreCase(exports.KeysOfConditions.ALL_KEYS, exports.KeysOfConditions.$OR);
+}
+initKeysOfConditions();

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

@@ -0,0 +1,11 @@
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { IRequestCfgModel } from '../interfaces';
+import { ICurdProServiceHub } from '../models/ServiceHub';
+declare class CrudProCachedCfgService extends CrudProServiceBase {
+    constructor(serviceHub: ICurdProServiceHub);
+    getCachedCfgByMethod(method: string, isEnableCache: boolean): Promise<IRequestCfgModel | null>;
+    private getCachedCfgByMethodInner;
+    private loadMethodInfo;
+    private loadMethodInfoList;
+}
+export { CrudProCachedCfgService };

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudProCachedCfgService = void 0;
+const humps_1 = require("humps");
+const CrudProServiceBase_1 = require("./CrudProServiceBase");
+const MixinUtils_1 = require("../utils/MixinUtils");
+const convertMix_1 = require("../utils/sqlConvert/convertMix");
+const MemoryRefreshCache_1 = require("../utils/MemoryRefreshCache");
+const methodCache = new MemoryRefreshCache_1.default();
+function parseMethodInfo(methodInfo) {
+    const row = (0, humps_1.camelizeKeys)(methodInfo); //转换成驼峰
+    const configObject = MixinUtils_1.MixinUtils.parseJsonObject(row.moreConfig) || {};
+    const sqlCfgList = MixinUtils_1.MixinUtils.parseJsonObject(row.sqlCfgList) || [];
+    return { ...configObject, ...row, sqlCfgList };
+}
+class CrudProCachedCfgService extends CrudProServiceBase_1.CrudProServiceBase {
+    constructor(serviceHub) {
+        super(serviceHub);
+    }
+    async getCachedCfgByMethod(method, isEnableCache) {
+        const methodInfo = await this.getCachedCfgByMethodInner(method, isEnableCache);
+        if (!methodInfo) {
+            return null;
+        }
+        return { ...methodInfo };
+    }
+    async getCachedCfgByMethodInner(method, isEnableCache) {
+        // 不使用缓存
+        if (!isEnableCache) {
+            return await this.loadMethodInfo(method);
+        }
+        methodCache.setProps({
+            keepTime: 1000 * 60 * 2,
+            requestFn: () => this.loadMethodInfoList(),
+            getKeyFn: item => item.method,
+        });
+        const methodInfo = await methodCache.getItem(method);
+        if (methodInfo) {
+            return methodInfo;
+        }
+        return await this.loadMethodInfo(method);
+    }
+    async loadMethodInfo(method) {
+        const { methodsTableName, sysDatabaseName, sysDatabaseDbType } = this.getContextCfg();
+        const sql = `select * from ${methodsTableName} where method = ? `; // 全部加载到内存
+        const baseInfo = {
+            sqlTable: methodsTableName,
+            sqlDatabase: sysDatabaseName,
+            sqlDbType: sysDatabaseDbType,
+        };
+        const queryRes = await this.executeUnsafeQuery(baseInfo, sql, [method]);
+        const rows2 = (0, convertMix_1.pickAndConvertRowsByMix)(queryRes, sysDatabaseDbType);
+        if (rows2.length > 0) {
+            return parseMethodInfo(rows2[0]);
+        }
+        return null;
+    }
+    async loadMethodInfoList() {
+        const { methodsTableName, sysDatabaseName, sysDatabaseDbType } = this.getContextCfg();
+        const sql = `select * from ${methodsTableName}`; // 全部加载到内存
+        const baseInfo = {
+            sqlTable: methodsTableName,
+            sqlDatabase: sysDatabaseName,
+            sqlDbType: sysDatabaseDbType,
+        };
+        const queryRes = await this.executeUnsafeQuery(baseInfo, sql);
+        const rows2 = (0, convertMix_1.pickAndConvertRowsByMix)(queryRes, sysDatabaseDbType);
+        return rows2.map(row => {
+            return parseMethodInfo(row);
+        });
+    }
+}
+exports.CrudProCachedCfgService = CrudProCachedCfgService;

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

@@ -0,0 +1,9 @@
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { IFuncCfgModel } from '../interfaces';
+import { FuncContext } from '../models/FuncContext';
+declare class CrudProExecuteFuncService extends CrudProServiceBase {
+    executeFuncCfg(funCfg: IFuncCfgModel, funcContext: FuncContext): any;
+    private pickContextValue;
+    private getFunctionParamValues;
+}
+export { CrudProExecuteFuncService };

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudProExecuteFuncService = void 0;
+const CrudProServiceBase_1 = require("./CrudProServiceBase");
+const TypeUtils_1 = require("../utils/TypeUtils");
+const MixinUtils_1 = require("../utils/MixinUtils");
+const _ = require("lodash");
+const exceptions_1 = require("../exceptions");
+const keys_1 = require("../models/keys");
+const { isNil, isNumeric } = TypeUtils_1.TypeUtils;
+const { isEmpty } = MixinUtils_1.MixinUtils;
+function isNotNil(obj) {
+    return !isNil(obj);
+}
+class CrudProExecuteFuncService extends CrudProServiceBase_1.CrudProServiceBase {
+    executeFuncCfg(funCfg, funcContext) {
+        if (isNil(funCfg)) {
+            return null;
+        }
+        if (funCfg.___PLAIN_OBJECT___ === true) {
+            return funCfg;
+        }
+        if (isNotNil(funCfg.const)) {
+            return funCfg.const;
+        }
+        if (isNotNil(funCfg.constString)) {
+            return '' + funCfg.constString;
+        }
+        if (isNotNil(funCfg.constNumber) && isNumeric(funCfg.constNumber)) {
+            return Number(funCfg.constNumber);
+        }
+        if (isNotNil(funCfg.constBool)) {
+            return Boolean(funCfg.constBool);
+        }
+        if (isNotNil(funCfg.context)) {
+            return this.pickContextValue(funCfg.context, funcContext);
+        }
+        if (isNotNil(funCfg.contextAsString)) {
+            return '' + this.pickContextValue(funCfg.contextAsString, funcContext);
+        }
+        if (isNotNil(funCfg.contextAsNumber)) {
+            return Number(this.pickContextValue(funCfg.contextAsNumber, funcContext));
+        }
+        if (isNotNil(funCfg.contextAsBool)) {
+            return Boolean(this.pickContextValue(funCfg.contextAsBool, funcContext));
+        }
+        if (isNotNil(funCfg.functionName)) {
+            const func = this.getExecuteFunction(funCfg.functionName);
+            if (!func) {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.RUN_FUNCTION_NOT_FOUND, funCfg.functionName);
+            }
+            const functionParamValues = this.getFunctionParamValues(funCfg.functionParams, funcContext);
+            return func.apply(funcContext, functionParamValues);
+        }
+        return null;
+    }
+    pickContextValue(pickString, funcCtx) {
+        var _a;
+        if (!pickString) {
+            return null;
+        }
+        if (pickString === keys_1.KeysOfFunCtx.FUNC_CTX) {
+            return funcCtx;
+        }
+        if (pickString === keys_1.KeysOfFunCtx.CURRENT_VALUE) {
+            return funcCtx.currentValue;
+        }
+        // 例如：accountId, 访问此变量，用户必须登录。
+        if (pickString.startsWith(keys_1.KeysOfFunCtx.VISITOR_ATTR)) {
+            const reqModel = funcCtx === null || funcCtx === void 0 ? void 0 : funcCtx.reqModel;
+            const attrValue = _.get(reqModel, pickString); // visitor.nickName
+            if (isNil(attrValue)) {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.RUN_PICK_ERR_VISITOR_NULL, '获取用户ID失败, 可能用户没有登陆');
+            }
+            return attrValue;
+        }
+        // 例如：accountId, 访问此变量，用户必须登录。
+        if (pickString === keys_1.KeysOfFunCtx.VISITOR) {
+            const visitor = (_a = funcCtx === null || funcCtx === void 0 ? void 0 : funcCtx.reqModel) === null || _a === void 0 ? void 0 : _a.visitor;
+            if (isNil(visitor)) {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.RUN_PICK_ERR_VISITOR_NULL, '获取用户对象失败, 可能用户没有登陆');
+            }
+            return visitor;
+        }
+        // 例如： req.data.name
+        if (pickString.startsWith(keys_1.KeysOfFunCtx.REQUEST)) {
+            const reqExpress = pickString.substring(keys_1.KeysOfFunCtx.REQUEST.length);
+            return _.get(funcCtx.reqModel, reqExpress);
+        }
+        // 例如： res.total_count
+        if (pickString.startsWith(keys_1.KeysOfFunCtx.RESULT)) {
+            const reqExpress = pickString.substring(keys_1.KeysOfFunCtx.RESULT.length);
+            return _.get(funcCtx.resModel, reqExpress);
+        }
+        return null;
+    }
+    getFunctionParamValues(functionParams, funcContext) {
+        if (isNil(functionParams) || isEmpty(functionParams)) {
+            return [];
+        }
+        return functionParams.map(p => {
+            if (typeof p === 'undefined' || p === null) {
+                return null;
+            }
+            if (typeof p === 'string' || typeof p === 'number' || typeof p === 'boolean') {
+                return p;
+            }
+            return this.executeFuncCfg(p, funcContext);
+        });
+    }
+}
+exports.CrudProExecuteFuncService = CrudProExecuteFuncService;

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

@@ -0,0 +1,17 @@
+import { CrudProServiceBase } from './CrudProServiceBase';
+declare class CrudProExecuteSqlService extends CrudProServiceBase {
+    executeSqlCfgModels(): Promise<void>;
+    private executeSqlCfgModel;
+    private handleExecuteSqlArgsByResModel;
+    private executeSqlCfgModelPreCheck;
+    private assertByValidate;
+    /**
+     * 判断此SQL是否需要执行
+     * @param sqlCfgModel
+     * @param exeCtx
+     * @private
+     */
+    private isNeedExecute;
+    private toQueryResByResPicker;
+}
+export { CrudProExecuteSqlService };