midway-fatcms 0.0.3 → 0.0.4

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

@@ -1,24 +1,24 @@
-import { ICurdProServiceHub } from '../models/ServiceHub';
-import { ICrudProCfg, IExecuteUnsafeQueryCtx, ILogger, IPoolConnectionClient } from '../interfaces';
-import { SqlCfgModel } from '../models/SqlCfgModel';
-import { ExecuteContext } from '../models/ExecuteContext';
-import { IExecuteContextFunc } from '../models/ExecuteContextFunc';
-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: IExecuteUnsafeQueryCtx, sql: string, values?: any): Promise<import("../interfaces").IPoolConnectionQueryResult>;
-    protected getContextCfg(): ICrudProCfg;
-    protected getExecuteFunction(funcName: string): any;
-}
-export { CrudProServiceBase };
+import { ICurdProServiceHub } from '../models/ServiceHub';
+import { ICrudProCfg, IExecuteUnsafeQueryCtx, ILogger, IPoolConnectionClient } from '../interfaces';
+import { SqlCfgModel } from '../models/SqlCfgModel';
+import { ExecuteContext } from '../models/ExecuteContext';
+import { IExecuteContextFunc } from '../models/ExecuteContextFunc';
+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: IExecuteUnsafeQueryCtx, sql: string, values?: any): Promise<import("../interfaces").IPoolConnectionQueryResult>;
+    protected getContextCfg(): ICrudProCfg;
+    protected getExecuteFunction(funcName: string): any;
+}
+export { CrudProServiceBase };

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

@@ -1,88 +1,88 @@
-"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");
-const keys_1 = require("../models/keys");
-const convertPgSql_1 = require("../utils/sqlConvert/convertPgSql");
-const convertMsSql_1 = require("../utils/sqlConvert/convertMsSql");
-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.sqlTable,
-            sqlDatabase: obj.sqlDatabase,
-            sqlDbType: obj.sqlDbType,
-            columns: [],
-            columnsRelation: [],
-            maxLimit: defaultConfigs_1.DEFAULT_MAX_LIMIT,
-            resName: 'executeUnsafeQuery',
-            originSql: sql,
-            executeSql: sql,
-            executeSqlArgs: values,
-            crudType: null,
-        };
-        if (sqlCfgModel.sqlDbType === keys_1.SqlDbType.postgres) {
-            sqlCfgModel.executeSql = (0, convertPgSql_1.replaceQuestionMarks)(sqlCfgModel.executeSql, false);
-        }
-        else if (sqlCfgModel.sqlDbType === keys_1.SqlDbType.sqlserver) {
-            sqlCfgModel.executeSql = (0, convertMsSql_1.replaceQuestionMarksForMssql)(sqlCfgModel.executeSql, false);
-        }
-        const connection = await this.getTxConnectionBySqlCfg(sqlCfgModel);
-        return await connection.query(sqlCfgModel.executeSql, 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;
+"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");
+const keys_1 = require("../models/keys");
+const convertPgSql_1 = require("../utils/sqlConvert/convertPgSql");
+const convertMsSql_1 = require("../utils/sqlConvert/convertMsSql");
+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.sqlTable,
+            sqlDatabase: obj.sqlDatabase,
+            sqlDbType: obj.sqlDbType,
+            columns: [],
+            columnsRelation: [],
+            maxLimit: defaultConfigs_1.DEFAULT_MAX_LIMIT,
+            resName: 'executeUnsafeQuery',
+            originSql: sql,
+            executeSql: sql,
+            executeSqlArgs: values,
+            crudType: null,
+        };
+        if (sqlCfgModel.sqlDbType === keys_1.SqlDbType.postgres) {
+            sqlCfgModel.executeSql = (0, convertPgSql_1.replaceQuestionMarks)(sqlCfgModel.executeSql, false);
+        }
+        else if (sqlCfgModel.sqlDbType === keys_1.SqlDbType.sqlserver) {
+            sqlCfgModel.executeSql = (0, convertMsSql_1.replaceQuestionMarksForMssql)(sqlCfgModel.executeSql, false);
+        }
+        const connection = await this.getTxConnectionBySqlCfg(sqlCfgModel);
+        return await connection.query(sqlCfgModel.executeSql, 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

@@ -1,9 +1,12 @@
-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;
-    private loadTableColumnInfo;
-}
-export { CrudProTableMetaService };
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { ITableMeta, ITableMetaQuery } from '../interfaces';
+declare class CrudProTableMetaService extends CrudProServiceBase {
+    getTableMeta(query: ITableMetaQuery): Promise<ITableMeta>;
+    private loadTableMeta;
+    private loadTableColumnDetails;
+    private loadMySQLColumnDetails;
+    private loadPostgreSQLColumnDetails;
+    private loadPostgreSQLColumnComments;
+    private loadSQLServerColumnDetails;
+}
+export { CrudProTableMetaService };

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

@@ -1,78 +1,168 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CrudProTableMetaService = void 0;
-const CrudProServiceBase_1 = require("./CrudProServiceBase");
-const keys_1 = require("../models/keys");
-// import { pickAndConvertRowsByMix } from '../utils/sqlConvert/convertMix';
-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 = {
-            sqlTable: sqlCfgModel.sqlTable,
-            sqlDatabase: sqlCfgModel.sqlDatabase,
-            sqlDbType: sqlCfgModel.sqlDbType,
-        };
-        obj.tableColumns = await this.loadTableColumnInfo(baseInfo);
-        return obj;
-    }
-    async loadTableColumnInfo(baseInfo) {
-        if (baseInfo.sqlDbType === keys_1.SqlDbType.mysql) {
-            const queryRes = await this.executeUnsafeQuery(baseInfo, 'describe ' + baseInfo.sqlTable);
-            const tableDescribe = queryRes.rows || []; //pickAndConvertRowsByMix(queryRes, baseInfo.sqlDbType);
-            const tableDescribe2 = JSON.parse(JSON.stringify(tableDescribe));
-            return tableDescribe2.map(fieldObj => {
-                return fieldObj['Field'];
-            });
-        }
-        else if (baseInfo.sqlDbType === keys_1.SqlDbType.postgres) {
-            const schemaname = 'public';
-            const columnArraySql = `
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudProTableMetaService = void 0;
+const CrudProServiceBase_1 = require("./CrudProServiceBase");
+const keys_1 = require("../models/keys");
+// import { pickAndConvertRowsByMix } from '../utils/sqlConvert/convertMix';
+class CrudProTableMetaCache {
+    constructor() {
+        this.cacheMap = {};
+    }
+    getCacheKey(query) {
+        return `${query.sqlDatabase}:::${query.sqlSchema}:::${query.sqlDbType}:::${query.sqlTable}`;
+    }
+    getMeta(query) {
+        const cacheKey = this.getCacheKey(query);
+        const obj = this.cacheMap[cacheKey];
+        if (obj && obj.expiredTime > Date.now()) {
+            return obj;
+        }
+        return null;
+    }
+    setMeta(query, metaObj) {
+        const cacheKey = this.getCacheKey(query);
+        this.cacheMap[cacheKey] = metaObj;
+    }
+}
+const metaCache = new CrudProTableMetaCache();
+class CrudProTableMetaService extends CrudProServiceBase_1.CrudProServiceBase {
+    async getTableMeta(query) {
+        let obj = metaCache.getMeta(query);
+        if (!obj) {
+            obj = await this.loadTableMeta(query);
+            metaCache.setMeta(query, obj);
+        }
+        return obj;
+    }
+    async loadTableMeta(query) {
+        const { tableMetaCacheTime } = this.getContextCfg();
+        const obj = {
+            expiredTime: Date.now() + (tableMetaCacheTime || 1000 * 3600 * 24 * 365),
+            tableColumns: [],
+            columnDetails: [],
+        };
+        const baseInfo = {
+            sqlTable: query.sqlTable,
+            sqlDatabase: query.sqlDatabase,
+            sqlDbType: query.sqlDbType,
+        };
+        obj.columnDetails = await this.loadTableColumnDetails(baseInfo);
+        obj.tableColumns = obj.columnDetails.map(col => col.name);
+        return obj;
+    }
+    async loadTableColumnDetails(baseInfo) {
+        if (baseInfo.sqlDbType === keys_1.SqlDbType.mysql) {
+            return this.loadMySQLColumnDetails(baseInfo);
+        }
+        else if (baseInfo.sqlDbType === keys_1.SqlDbType.postgres) {
+            return this.loadPostgreSQLColumnDetails(baseInfo);
+        }
+        else if (baseInfo.sqlDbType === keys_1.SqlDbType.sqlserver) {
+            return this.loadSQLServerColumnDetails(baseInfo);
+        }
+        throw new Error('暂不支持的数据库类型：' + baseInfo.sqlDbType);
+    }
+    async loadMySQLColumnDetails(baseInfo) {
+        const queryRes = await this.executeUnsafeQuery(baseInfo, 'DESCRIBE ' + baseInfo.sqlTable);
+        const tableDescribe = queryRes.rows || [];
+        return tableDescribe.map((fieldObj) => {
+            const { Field, Type, Null, Key, Default, Extra } = fieldObj;
+            return {
+                name: Field,
+                type: Type,
+                isNullable: Null === 'YES',
+                isPrimaryKey: Key === 'PRI',
+                defaultValue: Default,
+                comment: Extra,
+            };
+        });
+    }
+    async loadPostgreSQLColumnDetails(baseInfo) {
+        const schemaname = baseInfo.sqlSchema || 'public';
+        // 获取列基本信息
+        const columnArraySql = `
       SELECT
-        *
-        FROM information_schema.columns
-        WHERE table_schema = '${schemaname}' and table_name = '${baseInfo.sqlTable}'
-        ORDER BY ordinal_position;
-      `.trim();
-            const queryRes = await this.executeUnsafeQuery(baseInfo, columnArraySql);
-            const tableDescribe = queryRes.rows || [];
-            return tableDescribe.map(fieldObj => {
-                return fieldObj['column_name'];
-            });
-        }
-        throw new Error('暂不支持的数据库类型：' + baseInfo.sqlDbType);
-    }
-}
-exports.CrudProTableMetaService = CrudProTableMetaService;
+        column_name,
+        data_type,
+        is_nullable,
+        column_default,
+        character_maximum_length
+      FROM information_schema.columns
+      WHERE table_schema = '${schemaname}' AND table_name = '${baseInfo.sqlTable}'
+      ORDER BY ordinal_position;
+    `.trim();
+        const queryRes = await this.executeUnsafeQuery(baseInfo, columnArraySql);
+        const columnArray = queryRes.rows || [];
+        // 获取字段注释
+        const commentMap = await this.loadPostgreSQLColumnComments(baseInfo, schemaname);
+        return columnArray.map((columnObj) => {
+            const { column_name, data_type, is_nullable, column_default, character_maximum_length } = columnObj;
+            return {
+                name: column_name,
+                type: data_type,
+                isNullable: is_nullable === 'YES',
+                defaultValue: column_default,
+                maxLength: character_maximum_length,
+                comment: commentMap[column_name],
+            };
+        });
+    }
+    async loadPostgreSQLColumnComments(baseInfo, schemaname) {
+        const commentArraySql = `
+      SELECT
+        a.attname AS column_name,
+        d.description AS column_comment
+      FROM pg_class c
+      JOIN pg_namespace n ON c.relnamespace = n.oid
+      JOIN pg_attribute a ON c.oid = a.attrelid
+      LEFT JOIN pg_description d ON c.oid = d.objoid AND a.attnum = d.objsubid
+      WHERE n.nspname = '${schemaname}'
+        AND c.relname = '${baseInfo.sqlTable}'
+        AND a.attnum > 0
+      ORDER BY a.attnum;
+    `.trim();
+        const queryRes = await this.executeUnsafeQuery(baseInfo, commentArraySql);
+        const commentArray = queryRes.rows || [];
+        const map = {};
+        commentArray.forEach((commentObj) => {
+            const { column_name, column_comment } = commentObj;
+            map[column_name] = column_comment || '';
+        });
+        return map;
+    }
+    async loadSQLServerColumnDetails(baseInfo) {
+        const columnArraySql = `
+      SELECT
+        c.name AS column_name,
+        t.name AS data_type,
+        c.max_length,
+        c.precision,
+        c.scale,
+        c.is_nullable,
+        c.is_identity,
+        dc.definition AS column_default,
+        ep.value AS column_comment
+      FROM sys.columns c
+      JOIN sys.types t ON c.user_type_id = t.user_type_id
+      LEFT JOIN sys.default_constraints dc ON c.default_object_id = dc.object_id
+      LEFT JOIN sys.extended_properties ep ON c.object_id = ep.major_id AND c.column_id = ep.minor_id
+      WHERE c.object_id = OBJECT_ID('${baseInfo.sqlTable}')
+      ORDER BY c.column_id;
+    `.trim();
+        const queryRes = await this.executeUnsafeQuery(baseInfo, columnArraySql);
+        const columnArray = queryRes.rows || [];
+        return columnArray.map((columnObj) => {
+            const { column_name, data_type, is_nullable, column_default, column_comment, max_length, is_identity } = columnObj;
+            return {
+                name: column_name,
+                type: data_type,
+                isNullable: is_nullable,
+                defaultValue: column_default,
+                comment: column_comment,
+                maxLength: max_length,
+                isPrimaryKey: is_identity,
+            };
+        });
+    }
+}
+exports.CrudProTableMetaService = CrudProTableMetaService;

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

@@ -1,32 +1,34 @@
-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 };
+import { IFuncCfgModel, IRequestCfgModel, ISqlCfgModel, ITableMeta, ITableMetaQuery } 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;
+    private readonly dataFilterService;
+    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(query: ITableMetaQuery): Promise<ITableMeta>;
+    filterDataByTableMeta(data: Record<string, any>, sqlCfgModel: ISqlCfgModel | SqlCfgModel): Promise<Record<string, any>>;
+}
+export { CurdProServiceHub };