midway-fatcms 0.0.1-beta.1

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

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudProOriginToExecuteSql = void 0;
+const CrudProServiceBase_1 = require("./CrudProServiceBase");
+const MixinUtils_1 = require("../utils/MixinUtils");
+const SqlSegArg_1 = require("../models/SqlSegArg");
+const keys_1 = require("../models/keys");
+const exceptions_1 = require("../exceptions");
+const ModelUtils_1 = require("../utils/ModelUtils");
+const FuncContext_1 = require("../models/FuncContext");
+const TypeUtils_1 = require("../utils/TypeUtils");
+const SqlFuncUtils_1 = require("../utils/SqlFuncUtils");
+const convertColumnName_1 = require("../utils/sqlConvert/convertColumnName");
+const CrudProGenSqlCondition_1 = require("./CrudProGenSqlCondition");
+const KEYS_CUSTOM_PATTERN = /@@[0-9a-zA-Z:._]+/gm;
+/**
+ * 存在任何需要排除的
+ * @param columns
+ */
+function isAnyStartWithExclude(columns) {
+    if (MixinUtils_1.MixinUtils.isEmpty(columns)) {
+        return false;
+    }
+    for (let i = 0; i < columns.length; i++) {
+        const s = columns[i];
+        if (s.startsWith('!')) {
+            return true;
+        }
+    }
+    return false;
+}
+class CrudProOriginToExecuteSql extends CrudProServiceBase_1.CrudProServiceBase {
+    async convertOriginToExecuteSql(sqlCfgModel) {
+        const originSql = sqlCfgModel.originSql;
+        if (MixinUtils_1.MixinUtils.isEmpty(originSql)) {
+            // 允许配置中没有originSql，此时可能仅仅用来做校验逻辑
+            return;
+        }
+        if (MixinUtils_1.MixinUtils.isNotEmpty(sqlCfgModel.executeSql)) {
+            //直接传递可执行SQL ，不需要再转换。
+            return;
+        }
+        const sqlArgModelMap = await this.generateWordMap(originSql, sqlCfgModel);
+        const argList = [];
+        let executeSql = originSql;
+        // 发现有需要被替换的变量。
+        if (sqlArgModelMap) {
+            executeSql = originSql.replace(KEYS_CUSTOM_PATTERN, word => {
+                if (!word) {
+                    return '';
+                }
+                const sqlArgModel = sqlArgModelMap[word];
+                if (!sqlArgModel) {
+                    return '';
+                }
+                if (MixinUtils_1.MixinUtils.isNotEmpty(sqlArgModel.args) && Array.isArray(sqlArgModel.args)) {
+                    argList.push(...sqlArgModel.args);
+                }
+                return sqlArgModel.sql;
+            });
+        }
+        sqlCfgModel.executeSqlArgs = argList;
+        sqlCfgModel.executeSql = executeSql;
+    }
+    async generateWordMap(originSql, sqlCfgModel) {
+        // ['@@columns', '@@table', '@@asWhere:condition', '@@orderBys']
+        const sqlKeywords = originSql.match(KEYS_CUSTOM_PATTERN);
+        // 没有需要被替换的变量。
+        if (!sqlKeywords || sqlKeywords.length === 0) {
+            return null;
+        }
+        const sqlKeywordArgModelMap = {};
+        for (let i = 0; i < sqlKeywords.length; i++) {
+            const word = sqlKeywords[i]; // @@columns
+            if (word) {
+                const sqlArgModel = await this.generateWord(word, sqlCfgModel);
+                if (sqlArgModel) {
+                    sqlKeywordArgModelMap[word] = sqlArgModel;
+                }
+            }
+        }
+        return sqlKeywordArgModelMap;
+    }
+    async generateWord(word, sqlCfg) {
+        const exeCtx = this.getExecuteContext();
+        const reqCfg = exeCtx.getCfgModel();
+        const reqModel = exeCtx.getReqModel();
+        if (word === keys_1.KeysOfCustomSQL.SQL_TABLE) {
+            return this.generateTable(reqCfg, sqlCfg);
+        }
+        else if (word === keys_1.KeysOfCustomSQL.SQL_COLUMNS) {
+            return this.generateColumns(reqCfg, sqlCfg, reqModel);
+        }
+        else if (word.startsWith(keys_1.KeysOfCustomSQL.SQL_AS_WHERE)) {
+            return this.generateCondition(reqModel, sqlCfg, MixinUtils_1.MixinUtils.removeStringPrefix(word, keys_1.KeysOfCustomSQL.SQL_AS_WHERE));
+        }
+        else if (word === keys_1.KeysOfCustomSQL.SQL_OFFSET_LIMIT) {
+            return this.generateOffsetLimit(reqCfg, sqlCfg, reqModel);
+        }
+        else if (word === keys_1.KeysOfCustomSQL.SQL_ORDER_BYS) {
+            return this.generateOrderBys(reqModel, sqlCfg);
+        }
+        else if ((word.startsWith(keys_1.KeysOfCustomSQL.SQL_GET_DATA_ATTR_START) ||
+            word.startsWith(keys_1.KeysOfCustomSQL.SQL_GET_CONDITION_ATTR_START)) && word.indexOf('.') > 0) {
+            return this.generateGetAttr(reqModel, word); //// data.xxx, condition.xxx
+        }
+        else if (word.startsWith(keys_1.KeysOfCustomSQL.SQL_PICK_RES_AS_NUMBER) || word.startsWith(keys_1.KeysOfCustomSQL.SQL_PICK_RES_AS_STRING)) {
+            return this.generatePickResAs(reqModel, word); //  @@pickResAsNumber:replies_count
+        }
+        else if (word.startsWith(keys_1.KeysOfCustomSQL.SQL_AS_UPDATE)) {
+            return this.generateDataUpdate(reqModel, sqlCfg, MixinUtils_1.MixinUtils.removeStringPrefix(word, keys_1.KeysOfCustomSQL.SQL_AS_UPDATE));
+        }
+        else if (word.startsWith(keys_1.KeysOfCustomSQL.SQL_AS_INSERT_KEYS)) {
+            return this.generateDataAsInsertKeys(reqModel, sqlCfg, MixinUtils_1.MixinUtils.removeStringPrefix(word, keys_1.KeysOfCustomSQL.SQL_AS_INSERT_KEYS));
+        }
+        else if (word.startsWith(keys_1.KeysOfCustomSQL.SQL_AS_INSERT_VALUES)) {
+            return this.generateDataAsInsertValues(reqModel, MixinUtils_1.MixinUtils.removeStringPrefix(word, keys_1.KeysOfCustomSQL.SQL_AS_INSERT_VALUES));
+        }
+        else if (word.startsWith(keys_1.KeysOfCustomSQL.SQL_FUNCTION)) {
+            return this.generateSqlJavaFunction(reqCfg, MixinUtils_1.MixinUtils.removeStringPrefix(word, keys_1.KeysOfCustomSQL.SQL_FUNCTION));
+        }
+        else {
+            return new SqlSegArg_1.SqlSegArg(word.toString());
+        }
+    }
+    generateDataAsInsertKeys(req, sqlCfgModel, dataName) {
+        const data = req.getCondOrDataJsonObject(dataName);
+        if (MixinUtils_1.MixinUtils.isEmpty(data)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.DATA_GET_DATA_EMPTY_ON_INSERT_KEYS, dataName);
+        }
+        const keys = Object.keys(data).sort();
+        const columnList = keys.map(columnName => {
+            return (0, convertColumnName_1.toSqlColumnName)(columnName, sqlCfgModel);
+        });
+        const sql = columnList.join(','); // `column1`,`column2`,`column3`,
+        return new SqlSegArg_1.SqlSegArg(sql); // 只有sql，没有arg
+    }
+    generateTable(requestCfg, sqlCfgModel) {
+        const sqlTableName = ModelUtils_1.ModelUtils.getSqlTable(sqlCfgModel, requestCfg);
+        if (MixinUtils_1.MixinUtils.isEmpty(sqlTableName)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_EMPTY_TABLE_NAME);
+        }
+        const sqlSchema = ModelUtils_1.ModelUtils.getSqlSchema(sqlCfgModel, requestCfg);
+        if (MixinUtils_1.MixinUtils.isNotEmpty(sqlSchema)) {
+            return new SqlSegArg_1.SqlSegArg(`${(0, convertColumnName_1.toSqlColumnName)(sqlSchema, sqlCfgModel)}.${(0, convertColumnName_1.toSqlColumnName)(sqlTableName, sqlCfgModel)}`);
+        }
+        return new SqlSegArg_1.SqlSegArg((0, convertColumnName_1.toSqlColumnName)(sqlTableName, sqlCfgModel));
+    }
+    async generateColumns(cfg, sqlCfgModel, req) {
+        // req 和 cfg 都没有 columns字段
+        if (MixinUtils_1.MixinUtils.isEmpty(cfg.columns) && MixinUtils_1.MixinUtils.isEmpty(req.columns)) {
+            return new SqlSegArg_1.SqlSegArg('*');
+        }
+        const cfgColumns = await this.generateCfgColumns(sqlCfgModel); // 不会为空
+        const reqColumns = req.columns;
+        // req 为空
+        if (MixinUtils_1.MixinUtils.isEmpty(reqColumns)) {
+            return new SqlSegArg_1.SqlSegArg((0, convertColumnName_1.toSqlColumnNamesJoin)(cfgColumns, sqlCfgModel));
+        }
+        // req 不为空：1. 排除法
+        // cfgColumns与reqColumns 都不为空： 使用排除法
+        if (isAnyStartWithExclude(reqColumns)) {
+            const result = [];
+            for (let i = 0; i < cfgColumns.length; i++) {
+                const cfgColumn = cfgColumns[i];
+                if (reqColumns.indexOf('!' + cfgColumn) < 0) {
+                    result.push(cfgColumn);
+                }
+            }
+            return new SqlSegArg_1.SqlSegArg((0, convertColumnName_1.toSqlColumnNamesJoin)(result, sqlCfgModel));
+        }
+        // req 不为空：2. 取交集
+        const result = [];
+        for (let i = 0; i < reqColumns.length; i++) {
+            const reqColumn = reqColumns[i];
+            if (cfgColumns.indexOf(reqColumn) >= 0) {
+                result.push(reqColumn);
+            }
+        }
+        return new SqlSegArg_1.SqlSegArg((0, convertColumnName_1.toSqlColumnNamesJoin)(result, sqlCfgModel));
+    }
+    /**
+     * 生成查询条件
+     * @param req
+     * @param sqlCfg
+     * @param conditionName
+     * @private
+     */
+    generateCondition(req, sqlCfg, conditionName) {
+        if (MixinUtils_1.MixinUtils.isEmpty(conditionName)) {
+            conditionName = 'condition';
+        }
+        const condition = req.getCondOrDataJsonObject(conditionName);
+        const ss = new CrudProGenSqlCondition_1.CrudProGenSqlCondition(sqlCfg);
+        return ss.generateCondition(condition);
+    }
+    generateOffsetLimit(requestCfg, sqlCfg, req) {
+        const maxLimit = ModelUtils_1.ModelUtils.getMaxLimit(sqlCfg, requestCfg);
+        const reqLimit = req.limit;
+        const limit = Math.min(maxLimit, reqLimit);
+        if (sqlCfg.sqlDdType === keys_1.SqlDbType.postgres) {
+            return new SqlSegArg_1.SqlSegArg(' LIMIT ? OFFSET ? ', [limit, req.offset]);
+        }
+        if (sqlCfg.sqlDdType === keys_1.SqlDbType.sqlserver) {
+            return new SqlSegArg_1.SqlSegArg(' OFFSET ? ROWS FETCH NEXT ? ROWS ONLY ', [req.offset, limit]);
+        }
+        return new SqlSegArg_1.SqlSegArg(' limit ?,? ', [req.offset, limit]);
+    }
+    // 生成排序条件
+    generateOrderBys(req, sqlCfgModel) {
+        const orderBys = req.orderBys;
+        if (MixinUtils_1.MixinUtils.isEmpty(orderBys)) {
+            return null;
+        }
+        const orderByArr = orderBys.map(orderBy => {
+            return (0, convertColumnName_1.toSqlColumnName)(orderBy.fieldName, sqlCfgModel) + ' ' + orderBy.orderType;
+        });
+        const sql = 'order by ' + orderByArr.join(',');
+        return new SqlSegArg_1.SqlSegArg(sql);
+    }
+    generatePickResAs(req, world) {
+        return new SqlSegArg_1.SqlSegArg(' ? ', [{
+                ___GENERATE_GET_RES_ATTR___: world,
+            }]);
+    }
+    generateGetAttr(req, word) {
+        const attrName = MixinUtils_1.MixinUtils.removeStringPrefix(word, '@@');
+        if (MixinUtils_1.MixinUtils.isEmpty(attrName)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_GET_ATTR_NAME_EMPTY, word);
+        }
+        const dataValue = req.getJsonObjectValue(attrName);
+        if (typeof dataValue === 'undefined' || !TypeUtils_1.TypeUtils.isBasicType(dataValue)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_GET_ATTR_VALUE_ERROR, word);
+        }
+        return new SqlSegArg_1.SqlSegArg(' ? ', [dataValue]);
+    }
+    generateDataUpdate(req, sqlCfgModel, dataName) {
+        const data = req.getCondOrDataJsonObject(dataName);
+        if (MixinUtils_1.MixinUtils.isEmpty(data)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.DATA_GET_DATA_EMPTY_ON_UPDATE, dataName);
+        }
+        const keys = Object.keys(data).sort();
+        const sqlList = [];
+        const argList = [];
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const arg = data[key];
+            if (SqlFuncUtils_1.sqlFuncUtils.isSqlFuncArg(arg)) {
+                const funcSQL = SqlFuncUtils_1.sqlFuncUtils.toFuncSQL(arg);
+                sqlList.push((0, convertColumnName_1.toSqlColumnName)(key, sqlCfgModel) + '= ' + funcSQL);
+            }
+            else {
+                sqlList.push((0, convertColumnName_1.toSqlColumnName)(key, sqlCfgModel) + '= ?');
+                argList.push(arg);
+            }
+        }
+        const sql = sqlList.join(',');
+        return new SqlSegArg_1.SqlSegArg(sql, argList);
+    }
+    generateDataAsInsertValues(req, dataName) {
+        const data = req.getCondOrDataJsonObject(dataName);
+        if (MixinUtils_1.MixinUtils.isEmpty(data)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.DATA_GET_DATA_EMPTY_ON_INSERT_VALUES, dataName);
+        }
+        const keys = Object.keys(data).sort();
+        const sqlList = [];
+        const argList = [];
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const arg = data[key];
+            // 如 data: {xxxTime: {$byFunc:"NOW()"}}
+            if (SqlFuncUtils_1.sqlFuncUtils.isSqlFuncArg(arg)) {
+                const funcSQL = SqlFuncUtils_1.sqlFuncUtils.toFuncSQL(arg); //  values( ? , ? , NOW() , ?)
+                sqlList.push(funcSQL);
+            }
+            else {
+                sqlList.push('?');
+                argList.push(arg);
+            }
+        }
+        const sql = sqlList.join(','); // "?,?,?,?"
+        return new SqlSegArg_1.SqlSegArg(sql, argList);
+    }
+    generateSqlJavaFunction(requestCfg, tmpFuncName) {
+        const exeCtx = this.getExecuteContext();
+        const functionCfg = requestCfg.functionCfg;
+        if (MixinUtils_1.MixinUtils.isEmpty(functionCfg)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_SQL_FUNCTION_EMPTY, tmpFuncName);
+        }
+        const tmpFunCfg = functionCfg[tmpFuncName];
+        if (ModelUtils_1.ModelUtils.checkFuncCfgValid(tmpFunCfg)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_VALIDATE_CUSTOM_FUNCTION_EMPTY, tmpFuncName);
+        }
+        const exeFunCtx = new FuncContext_1.FuncContext();
+        exeFunCtx.currentValue = null;
+        exeFunCtx.reqModel = exeCtx.getReqModel();
+        exeFunCtx.resModel = exeCtx.getResModel();
+        const dataValue = this.serviceHub.executeFuncCfg(tmpFunCfg, exeFunCtx);
+        return new SqlSegArg_1.SqlSegArg(' ? ', [dataValue]);
+    }
+    /**
+     * 不会返回空。
+     * @param sqlCfgModel
+     * @private
+     */
+    async generateCfgColumns(sqlCfgModel) {
+        const tableMeta = await this.serviceHub.getTableMeta(sqlCfgModel);
+        const tableColumns = tableMeta.tableColumns;
+        const cfgColumns = sqlCfgModel.columns || [];
+        // 没有配置: 全量
+        if (MixinUtils_1.MixinUtils.isEmpty(cfgColumns)) {
+            return tableColumns;
+        }
+        // 黑名单：排除法
+        if (isAnyStartWithExclude(cfgColumns)) {
+            const excludeColumns = cfgColumns.filter(c => {
+                return c.startsWith('!');
+            });
+            const excludeColumnsSet = new Set(excludeColumns);
+            const result = [];
+            for (let i = 0; i < tableColumns.length; i++) {
+                const tableColumn = tableColumns[i];
+                if (!excludeColumnsSet.has('!' + tableColumn)) {
+                    result.push(tableColumn);
+                }
+            }
+            return result;
+        }
+        // 白名单
+        return cfgColumns;
+    }
+}
+exports.CrudProOriginToExecuteSql = CrudProOriginToExecuteSql;

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

@@ -0,0 +1,28 @@
+import { ICurdProServiceHub } from '../models/ServiceHub';
+import { ICrudProCfg, ILogger, IPoolConnectionClient } from '../interfaces';
+import { SqlCfgModel } from '../models/SqlCfgModel';
+import { ExecuteContext } from '../models/ExecuteContext';
+import { IExecuteContextFunc } from '../models/ExecuteContextFunc';
+interface ExecuteUnsafeQueryCtx {
+    tableName: string;
+    dbName: string;
+}
+declare class CrudProServiceBase {
+    protected serviceHub: ICurdProServiceHub;
+    constructor(serviceHub: ICurdProServiceHub);
+    protected getExecuteContext(): ExecuteContext;
+    protected getContextFunc(): IExecuteContextFunc;
+    protected get logger(): ILogger;
+    protected getTxConnectionBySqlCfg(sqlCfgModel: SqlCfgModel): Promise<IPoolConnectionClient>;
+    /**
+     * 不做任何检验，直接执行SQL，只能CrudPro内部使用，不对外使用
+     * @param obj
+     * @param sql
+     * @param values
+     * @protected
+     */
+    protected executeUnsafeQuery(obj: ExecuteUnsafeQueryCtx, sql: string, values?: any): Promise<any[]>;
+    protected getContextCfg(): ICrudProCfg;
+    protected getExecuteFunction(funcName: string): any;
+}
+export { CrudProServiceBase };

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudProServiceBase = void 0;
+const _ = require("lodash");
+const MixinUtils_1 = require("../utils/MixinUtils");
+const TypeUtils_1 = require("../utils/TypeUtils");
+const CompareUtils_1 = require("../utils/CompareUtils");
+const DateTimeUtils_1 = require("../utils/DateTimeUtils");
+const defaultConfigs_1 = require("../defaultConfigs");
+function createBuildInExecuteFuncMap() {
+    return {
+        ...DateTimeUtils_1.DateTimeUtils,
+        ...CompareUtils_1.CompareUtils,
+        ...MixinUtils_1.MixinUtils,
+        ...TypeUtils_1.TypeUtils,
+    };
+}
+const buildInExecuteFuncMap = createBuildInExecuteFuncMap();
+class CrudProServiceBase {
+    constructor(serviceHub) {
+        this.serviceHub = serviceHub;
+    }
+    getExecuteContext() {
+        return this.serviceHub.getExecuteContext();
+    }
+    getContextFunc() {
+        return this.getExecuteContext().contextFunc;
+    }
+    get logger() {
+        return this.getExecuteContext().getLogger();
+    }
+    async getTxConnectionBySqlCfg(sqlCfgModel) {
+        const executeContext = this.getExecuteContext();
+        const transaction = executeContext.getTransaction();
+        const contextFunc = this.getContextFunc();
+        const pool = await contextFunc.getConnectionPool(sqlCfgModel);
+        return transaction.getTxConnection(pool);
+    }
+    /**
+     * 不做任何检验，直接执行SQL，只能CrudPro内部使用，不对外使用
+     * @param obj
+     * @param sql
+     * @param values
+     * @protected
+     */
+    async executeUnsafeQuery(obj, sql, values) {
+        const sqlCfgModel = {
+            sqlTable: obj.tableName,
+            sqlDatabase: obj.dbName,
+            columns: [],
+            columnsRelation: [],
+            maxLimit: defaultConfigs_1.DEFAULT_MAX_LIMIT,
+            resName: 'executeUnsafeQuery',
+            originSql: sql,
+            executeSql: sql,
+            executeSqlArgs: values,
+            crudType: null,
+        };
+        const connection = await this.getTxConnectionBySqlCfg(sqlCfgModel);
+        return await connection.query(sql, values);
+    }
+    getContextCfg() {
+        return this.getExecuteContext().getContextCfg();
+    }
+    getExecuteFunction(funcName) {
+        const contextFunc = this.getContextFunc();
+        const functionMap = contextFunc.getFunctionMap();
+        if (functionMap) {
+            const func = _.get(functionMap, funcName);
+            if (typeof func === 'function') {
+                return func;
+            }
+        }
+        console.log('buildInExecuteFuncMap', Object.keys(buildInExecuteFuncMap));
+        return _.get(buildInExecuteFuncMap, funcName);
+    }
+}
+exports.CrudProServiceBase = CrudProServiceBase;

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

@@ -0,0 +1,8 @@
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { SqlCfgModel } from '../models/SqlCfgModel';
+import { ITableMeta } from '../interfaces';
+declare class CrudProTableMetaService extends CrudProServiceBase {
+    getTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta>;
+    private loadTableMeta;
+}
+export { CrudProTableMetaService };

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudProTableMetaService = void 0;
+const CrudProServiceBase_1 = require("./CrudProServiceBase");
+class CrudProTableMetaCache {
+    constructor() {
+        this.cacheMap = {};
+    }
+    getCacheKey(sqlCfgModel) {
+        return `${sqlCfgModel.sqlDatabase}:::${sqlCfgModel.sqlSchema}:::${sqlCfgModel.sqlTable}`;
+    }
+    getMeta(sqlCfgModel) {
+        const cacheKey = this.getCacheKey(sqlCfgModel);
+        const obj = this.cacheMap[cacheKey];
+        if (obj && obj.expiredTime < Date.now()) {
+            return obj;
+        }
+        return null;
+    }
+    setMeta(sqlCfgModel, metaObj) {
+        const cacheKey = this.getCacheKey(sqlCfgModel);
+        this.cacheMap[cacheKey] = metaObj;
+    }
+}
+const metaCache = new CrudProTableMetaCache();
+class CrudProTableMetaService extends CrudProServiceBase_1.CrudProServiceBase {
+    async getTableMeta(sqlCfgModel) {
+        let obj = metaCache.getMeta(sqlCfgModel);
+        if (!obj) {
+            obj = await this.loadTableMeta(sqlCfgModel);
+            metaCache.setMeta(sqlCfgModel, obj);
+        }
+        return obj;
+    }
+    async loadTableMeta(sqlCfgModel) {
+        const { tableMetaCacheTime } = this.getContextCfg();
+        const obj = {
+            expiredTime: Date.now() + tableMetaCacheTime || 1000 * 3600 * 24 * 365,
+            tableColumns: [],
+        };
+        const baseInfo = {
+            tableName: sqlCfgModel.sqlTable,
+            dbName: sqlCfgModel.sqlDatabase,
+        };
+        const [tableDescribe] = await this.executeUnsafeQuery(baseInfo, 'describe ' + sqlCfgModel.sqlTable);
+        const tableDescribe2 = JSON.parse(JSON.stringify(tableDescribe));
+        obj.tableColumns = tableDescribe2.map(fieldObj => {
+            return fieldObj['Field'];
+        });
+        return obj;
+    }
+}
+exports.CrudProTableMetaService = CrudProTableMetaService;

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

@@ -0,0 +1,32 @@
+import { IFuncCfgModel, IRequestCfgModel, ITableMeta } from '../interfaces';
+import { RequestModel } from '../models/RequestModel';
+import { ExecuteContext } from '../models/ExecuteContext';
+import { SqlCfgModel } from '../models/SqlCfgModel';
+import { RequestCfgModel } from '../models/RequestCfgModel';
+import { ICurdProServiceHub } from '../models/ServiceHub';
+import { FuncContext } from '../models/FuncContext';
+declare class CurdProServiceHub implements ICurdProServiceHub {
+    private readonly executeContext;
+    private readonly fieldValidateService;
+    private readonly fieldUpdateService;
+    private readonly cachedCfgService;
+    private readonly executeSqlService;
+    private readonly genSqlService;
+    private readonly originToExecuteSql;
+    private readonly executeFuncService;
+    private readonly tableMetaService;
+    constructor(executeContext: ExecuteContext);
+    getExecuteContext(): ExecuteContext;
+    validateByAllow(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
+    validateByReject(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
+    validateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
+    validateByAuthCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): Promise<any>;
+    updateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
+    getCachedCfgByMethod(method: string, isEnableCache: boolean): Promise<IRequestCfgModel>;
+    generateSQLList(): Promise<void>;
+    executeSqlCfgModels(): Promise<void>;
+    convertOriginToExecuteSql(sqlCfgModel: SqlCfgModel): Promise<void>;
+    executeFuncCfg(funCfg: IFuncCfgModel, funcContext: FuncContext): any;
+    getTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta>;
+}
+export { CurdProServiceHub };

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurdProServiceHub = void 0;
+const CrudProFieldValidateService_1 = require("./CrudProFieldValidateService");
+const CrudProFieldUpdateService_1 = require("./CrudProFieldUpdateService");
+const CrudProCachedCfgService_1 = require("./CrudProCachedCfgService");
+const CrudProExecuteSqlService_1 = require("./CrudProExecuteSqlService");
+const CrudProGenSqlService_1 = require("./CrudProGenSqlService");
+const CrudProOriginToExecuteSql_1 = require("./CrudProOriginToExecuteSql");
+const CrudProExecuteFuncService_1 = require("./CrudProExecuteFuncService");
+const CrudProTableMetaService_1 = require("./CrudProTableMetaService");
+class CurdProServiceHub {
+    constructor(executeContext) {
+        this.executeContext = executeContext;
+        this.fieldValidateService = new CrudProFieldValidateService_1.CrudProFieldValidateService(this);
+        this.fieldUpdateService = new CrudProFieldUpdateService_1.CrudProFieldUpdateService(this);
+        this.cachedCfgService = new CrudProCachedCfgService_1.CrudProCachedCfgService(this);
+        this.executeSqlService = new CrudProExecuteSqlService_1.CrudProExecuteSqlService(this);
+        this.genSqlService = new CrudProGenSqlService_1.CrudProGenSqlService(this);
+        this.originToExecuteSql = new CrudProOriginToExecuteSql_1.CrudProOriginToExecuteSql(this);
+        this.executeFuncService = new CrudProExecuteFuncService_1.CrudProExecuteFuncService(this);
+        this.tableMetaService = new CrudProTableMetaService_1.CrudProTableMetaService(this);
+    }
+    getExecuteContext() {
+        return this.executeContext;
+    }
+    validateByAllow(cfgModel, reqModel) {
+        return this.fieldValidateService.validateByAllow(cfgModel, reqModel);
+    }
+    validateByReject(cfgModel, reqModel) {
+        return this.fieldValidateService.validateByReject(cfgModel, reqModel);
+    }
+    validateByCfg(cfgModel, reqModel) {
+        return this.fieldValidateService.validateByCfg(cfgModel, reqModel);
+    }
+    async validateByAuthCfg(cfgModel, reqModel) {
+        const contextFunc = this.executeContext.contextFunc;
+        if (contextFunc && contextFunc.validateByAuthCfg) {
+            return contextFunc.validateByAuthCfg(cfgModel, reqModel);
+        }
+    }
+    updateByCfg(cfgModel, reqModel) {
+        return this.fieldUpdateService.updateByCfg(cfgModel, reqModel);
+    }
+    async getCachedCfgByMethod(method, isEnableCache) {
+        return this.cachedCfgService.getCachedCfgByMethod(method, isEnableCache);
+    }
+    async generateSQLList() {
+        return this.genSqlService.generateSQLList();
+    }
+    async executeSqlCfgModels() {
+        return this.executeSqlService.executeSqlCfgModels();
+    }
+    async convertOriginToExecuteSql(sqlCfgModel) {
+        return this.originToExecuteSql.convertOriginToExecuteSql(sqlCfgModel);
+    }
+    executeFuncCfg(funCfg, funcContext) {
+        return this.executeFuncService.executeFuncCfg(funCfg, funcContext);
+    }
+    async getTableMeta(sqlCfgModel) {
+        return await this.tableMetaService.getTableMeta(sqlCfgModel);
+    }
+}
+exports.CurdProServiceHub = CurdProServiceHub;