midway-fatcms 0.0.7 → 0.0.9

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

@@ -3,12 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CrudProDataTypeConvertService = void 0;
 const CrudProServiceBase_1 = require("./CrudProServiceBase");
 const keys_1 = require("../models/keys");
+/** 预编译正则：整数类型（MySQL/PostgreSQL/SQL Server） */
+const REGEX_INTEGER_TYPE = /^(int|bigint|smallint|tinyint|mediumint|integer|serial|bigserial)/;
+/** 预编译正则：字符串类型（MySQL/PostgreSQL/SQL Server） */
+const REGEX_STRING_TYPE = /^(varchar|char|text|longtext|mediumtext|tinytext|nvarchar|nchar|ntext|character varying|character)/;
+/** 包含 WHERE 条件的操作类型集合（查询/删除/更新） */
+const CONDITION_TYPES = new Set([
+    keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+    keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+    keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_PAGE,
+    keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_COUNT,
+    keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_EXIST,
+    keys_1.KeysOfSimpleSQL.SIMPLE_DELETE,
+    keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
+]);
+/** INSERT/UPDATE 操作类型集合 */
+const INSERT_OR_UPDATE_TYPES = new Set([
+    keys_1.KeysOfSimpleSQL.SIMPLE_INSERT,
+    keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
+    keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_ON_DUPLICATE_UPDATE,
+    keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE,
+    keys_1.KeysOfSimpleSQL.SIMPLE_BATCH_INSERT,
+]);
 /**
  * 数据类型转换服务
- * 根据表结构字段类型，在 INSERT/UPDATE 操作前自动转换数据格式，确保数据与数据库方言兼容
+ * 根据表结构字段类型，自动转换数据格式，确保数据与数据库方言兼容，防止隐式类型转换导致索引失效
  *
  * 当前支持的转换：
- * - PostgreSQL ARRAY 类型：JSON 数组 → PG 数组字面量 {"a","b","c"}
+ * - PostgreSQL ARRAY 类型（INSERT/UPDATE data）：JSON 数组 → PG 数组字面量 {"a","b","c"}
+ * - 查询条件类型强转（SELECT/DELETE/UPDATE condition）：字符串 → 数字/布尔，防止隐式类型转换导致索引失效
  */
 class CrudProDataTypeConvertService extends CrudProServiceBase_1.CrudProServiceBase {
     /**
@@ -138,21 +161,190 @@ class CrudProDataTypeConvertService extends CrudProServiceBase_1.CrudProServiceB
             .replace(/"/g, '\\"');
         return '"' + escaped + '"';
     }
+    /**
+     * 查询时：根据表结构字段类型，自动转换 condition 中的数据格式
+     * 防止数据库隐式类型转换导致索引失效
+     *
+     * 实现步骤：
+     * 1. 判断操作类型是否为查询/删除/更新（这些操作包含 WHERE 条件）
+     * 2. 获取表元数据，构建字段名→类型映射
+     * 3. 递归遍历 condition（支持 $or/$and 嵌套），按字段类型转换值
+     *
+     * 转换规则（双向保护，仅处理最常建索引的列类型）：
+     * - 整数列(int/bigint/smallint/tinyint/mediumint) + 字符串值 → number
+     * - 整数列 + 布尔值 → 0/1
+     * - 字符串列(varchar/char/text等) + 数字值 → string
+     * - 字符串列 + 布尔值 → string
+     *
+     * @param reqModel 请求模型
+     * @param cfgModel 配置模型
+     */
+    async convertConditionTypeByTableMeta(reqModel, cfgModel) {
+        const sqlSimpleName = cfgModel.sqlSimpleName;
+        if (!this.isConditionType(sqlSimpleName)) {
+            return;
+        }
+        if (!reqModel.condition || Object.keys(reqModel.condition).length === 0) {
+            return;
+        }
+        const query = {
+            sqlTable: cfgModel.sqlTable,
+            sqlDatabase: cfgModel.sqlDatabase,
+            sqlDbType: cfgModel.sqlDbType,
+            sqlSchema: cfgModel.sqlSchema,
+        };
+        const tableMeta = await this.serviceHub.getTableMeta(query);
+        if (!tableMeta || !tableMeta.columnDetails || tableMeta.columnDetails.length === 0) {
+            this.logger.warn('CrudProDataTypeConvertService: 无法获取表结构信息，跳过条件类型转换', cfgModel.sqlTable);
+            return;
+        }
+        // 构建字段名→类型映射（全小写便于匹配）
+        const typeMap = new Map();
+        for (const col of tableMeta.columnDetails) {
+            typeMap.set(col.name, ('' + col.type).toLowerCase());
+        }
+        this.convertConditionFields(reqModel.condition, typeMap, cfgModel.sqlDbType);
+    }
+    /**
+     * 递归遍历 condition，对每个字段值做类型转换
+     *
+     * 实现步骤：
+     * 1. 遍历 condition 的每个 key
+     * 2. 若 key 为 $or/$and 逻辑操作符，递归处理子条件数组
+     * 3. 若 key 为字段名且值为基本类型，直接转换
+     * 4. 若 key 为字段名且值为比较操作符对象($gt/$in等)，遍历操作符逐值转换
+     *
+     * @param condition 查询条件对象
+     * @param typeMap 字段名→类型映射
+     * @param sqlDbType 数据库类型
+     */
+    convertConditionFields(condition, typeMap, sqlDbType) {
+        if (!condition || typeof condition !== 'object') {
+            return;
+        }
+        for (const key of Object.keys(condition)) {
+            const value = condition[key];
+            // $or / $and 逻辑操作符：递归处理每个子条件
+            if (key === keys_1.KeysOfConditions.$OR || key === keys_1.KeysOfConditions.$AND) {
+                if (Array.isArray(value)) {
+                    for (const subCondition of value) {
+                        this.convertConditionFields(subCondition, typeMap, sqlDbType);
+                    }
+                }
+                continue;
+            }
+            // 如果 key 是比较操作符（出现在内层），跳过
+            if (keys_1.KeysOfConditions.COMPARE_KEYS.has(key)) {
+                continue;
+            }
+            // key 是字段名
+            const fieldType = typeMap.get(key);
+            if (!fieldType) {
+                continue; // condition 中引用的字段不在表结构中，不做转换
+            }
+            if (this.isBasicType(value)) {
+                // 简单等值条件：{ age: "18" } → { age: 18 }
+                condition[key] = this.convertValueByType(value, fieldType, sqlDbType);
+            }
+            else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                // 比较操作符条件：{ age: { "$gt": "18", "$lt": "30" } }
+                for (const opKey of Object.keys(value)) {
+                    if (keys_1.KeysOfConditions.COMPARE_KEYS.has(opKey)) {
+                        const opValue = value[opKey];
+                        if (opKey === keys_1.KeysOfConditions.$IN || opKey === keys_1.KeysOfConditions.$NIN) {
+                            // $in/$nin 的值是数组，逐个转换
+                            if (Array.isArray(opValue)) {
+                                value[opKey] = opValue.map(v => this.convertValueByType(v, fieldType, sqlDbType));
+                            }
+                        }
+                        else if (opKey === keys_1.KeysOfConditions.$RANGE) {
+                            // $range 的值是 [min, max]
+                            if (Array.isArray(opValue)) {
+                                value[opKey] = opValue.map(v => this.convertValueByType(v, fieldType, sqlDbType));
+                            }
+                        }
+                        else {
+                            value[opKey] = this.convertValueByType(opValue, fieldType, sqlDbType);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /**
+      * 根据字段类型转换单个值，防止隐式类型转换导致索引失效
+      *
+      * 转换规则（双向保护）：
+      * - 整数列 + 字符串值 → number（WHERE int_col = '123' 索引失效）
+      * - 整数列 + 布尔值 → 0/1
+      * - 字符串列 + 数字值 → string（WHERE varchar_col = 123 索引失效）
+      * - 字符串列 + 布尔值 → string
+      *
+      * @param value 原始值
+      * @param fieldType 字段类型（小写）
+      * @param sqlDbType 数据库类型
+      * @returns 转换后的值
+      */
+    convertValueByType(value, fieldType, sqlDbType) {
+        if (value === null || value === undefined) {
+            return value;
+        }
+        const valueType = typeof value;
+        // 整数列：string → number, boolean → 0/1
+        if (this.isIntegerType(fieldType)) {
+            if (valueType === 'string') {
+                const num = Number(value);
+                if (!isNaN(num) && Number.isInteger(num)) {
+                    return num;
+                }
+            }
+            if (valueType === 'boolean') {
+                return value ? 1 : 0;
+            }
+        }
+        // 字符串列：number → string, boolean → string
+        if (this.isStringType(fieldType)) {
+            if (valueType === 'number') {
+                return '' + value;
+            }
+            if (valueType === 'boolean') {
+                return value ? 'true' : 'false';
+            }
+        }
+        return value;
+    }
+    /**
+      * 判断字段类型是否为整数类型
+      * 覆盖 MySQL/PostgreSQL/SQL Server 三种数据库的整数类型名
+      */
+    isIntegerType(type) {
+        return REGEX_INTEGER_TYPE.test(type);
+    }
+    /**
+     * 判断字段类型是否为字符串类型
+     * 覆盖 MySQL/PostgreSQL/SQL Server 三种数据库的字符串类型名
+     */
+    isStringType(type) {
+        return REGEX_STRING_TYPE.test(type);
+    }
+    /**
+     * 判断 sqlSimpleName 是否为包含 WHERE 条件的操作类型（查询/删除/更新）
+     * 这些操作的 condition 会参与 WHERE 子句，索引失效问题同样存在
+     */
+    isConditionType(sqlSimpleName) {
+        return !!sqlSimpleName && CONDITION_TYPES.has(sqlSimpleName);
+    }
+    /**
+     * 判断值是否为基本类型（string | number | boolean）
+     */
+    isBasicType(value) {
+        return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+    }
     /**
      * 判断 sqlSimpleName 是否为 INSERT/UPDATE 类型
      */
     isInsertOrUpdateType(sqlSimpleName) {
-        if (!sqlSimpleName) {
-            return false;
-        }
-        const types = [
-            keys_1.KeysOfSimpleSQL.SIMPLE_INSERT,
-            keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
-            keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_ON_DUPLICATE_UPDATE,
-            keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE,
-            keys_1.KeysOfSimpleSQL.SIMPLE_BATCH_INSERT,
-        ];
-        return types.includes(sqlSimpleName);
+        return !!sqlSimpleName && INSERT_OR_UPDATE_TYPES.has(sqlSimpleName);
     }
 }
 exports.CrudProDataTypeConvertService = CrudProDataTypeConvertService;

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

@@ -16,6 +16,7 @@ class CrudProExecuteSqlService extends CrudProServiceBase_1.CrudProServiceBase {
     async executeSqlCfgModels() {
         const exeCtx = this.getExecuteContext();
         const sqlCfgModels = exeCtx.getSqlCfgModels();
+        console.log("CrudProExecuteSqlService===> " + JSON.stringify(sqlCfgModels));
         for (let i = 0; i < sqlCfgModels.length; i++) {
             const sqlCfgModel = sqlCfgModels[i];
             const checkResult = this.executeSqlCfgModelPreCheck(sqlCfgModel);
@@ -73,9 +74,42 @@ class CrudProExecuteSqlService extends CrudProServiceBase_1.CrudProServiceBase {
             // 允许空SQL，没有需要执行的正常。
             return false;
         }
+        const errorMsg = `禁止执行的SQL: ${sqlCfgModel.executeSql}`;
         if (keys_1.KeyOfCrudTypes.NOT_CRUD === crudType) {
-            // 只支持增删改查，其他语句不支持。
-            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_NOT_SUPPORT_THE_SQL, sqlCfgModel.executeSql);
+            // 在 isNativeSQL 模式下，允许特定的 DDL 操作（CREATE TABLE、CREATE INDEX 等），但禁止 DROP TABLE
+            if (sqlCfgModel.isNativeSQL) {
+                // 禁止的 DDL 操作（破坏性操作）
+                const forbiddenPatterns = [
+                    /^\s*DROP\s+TABLE/i,
+                    /^\s*DROP\s+DATABASE/i,
+                    /^\s*DROP\s+SCHEMA/i,
+                    /^\s*TRUNCATE\s+TABLE/i,
+                ];
+                for (const pattern of forbiddenPatterns) {
+                    if (pattern.test(sqlCfgModel.executeSql)) {
+                        throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_NOT_SUPPORT_THE_SQL, errorMsg);
+                    }
+                }
+                // 允许的 DDL 操作白名单
+                const allowedPatterns = [
+                    /^\s*CREATE\s+TABLE/i,
+                    /^\s*CREATE\s+INDEX/i,
+                    /^\s*CREATE\s+UNIQUE\s+INDEX/i,
+                    /^\s*ALTER\s+TABLE/i,
+                ];
+                const isAllowed = allowedPatterns.some(pattern => pattern.test(sqlCfgModel.executeSql));
+                if (isAllowed) {
+                    // 允许的 DDL 操作，继续执行后续校验
+                }
+                else {
+                    // 非允许的 DDL 操作，仍然抛出异常
+                    throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_NOT_SUPPORT_THE_SQL, errorMsg);
+                }
+            }
+            else {
+                // 非 isNativeSQL 模式下，只支持增删改查，其他语句不支持。
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_NOT_SUPPORT_THE_SQL, errorMsg);
+            }
         }
         // 此SQL不需要执行
         if (!this.isNeedExecute(sqlCfgModel)) {

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

@@ -174,12 +174,16 @@ class CrudProGenSqlCondition {
                 const value0 = map[compare];
                 let tmpSql = '';
                 if (equalsIgnoreCase(keys_1.KeysOfConditions.$NULL, compare)) {
-                    tmpSql = `${toSqlColumnName(key)} is null `;
-                    hasNoArgSql = true;
+                    if (value0 === true) {
+                        tmpSql = `${toSqlColumnName(key)} is null `;
+                        hasNoArgSql = true;
+                    }
                 }
                 else if (equalsIgnoreCase(keys_1.KeysOfConditions.$NOT_NULL, compare)) {
-                    tmpSql = `${toSqlColumnName(key)} is not null `;
-                    hasNoArgSql = true;
+                    if (value0 === true) {
+                        tmpSql = `${toSqlColumnName(key)} is not null `;
+                        hasNoArgSql = true;
+                    }
                 }
                 else if (equalsIgnoreCase(keys_1.KeysOfConditions.$GT, compare)) {
                     tmpArgList.push(value0);

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

@@ -2,6 +2,30 @@ import { CrudProServiceBase } from './CrudProServiceBase';
 import { ITableListResult, ITableMeta, ITableMetaQuery, ITableNamesQuery, ITableNamesOptions } from '../interfaces';
 declare class CrudProTableMetaService extends CrudProServiceBase {
     getTableMeta(query: ITableMetaQuery): Promise<ITableMeta>;
+    /**
+     * 清空所有表元数据缓存
+     *
+     * 清空后，下次请求会自动从数据库重新加载。
+     * 适用于定时刷新或手动触发缓存失效的场景。
+     */
+    clearAllCache(): void;
+    /**
+     * 获取缓存统计信息
+     */
+    getCacheStats(): {
+        metaCacheCount: number;
+        tableInfoCacheCount: number;
+    };
+    /**
+     * 获取表的主键列名列表
+     *
+     * 复用 getTableMeta 的缓存机制，从 columnDetails 中筛选 isPrimaryKey 的列，
+     * 避免重复查询数据库。
+     *
+     * @param query 表元数据查询参数
+     * @returns 主键列名数组
+     */
+    getPrimaryKeyColumns(query: ITableMetaQuery): Promise<string[]>;
     /**
      * 获取数据库所有表和视图信息（包含类型）
      *
@@ -21,6 +45,18 @@ declare class CrudProTableMetaService extends CrudProServiceBase {
     private loadMySQLColumnDetails;
     private loadPostgreSQLColumnDetails;
     private loadPostgreSQLColumnComments;
+    private loadPostgreSQLPrimaryKeys;
     private loadSQLServerColumnDetails;
+    private loadSQLServerPrimaryKeys;
 }
 export { CrudProTableMetaService };
+/**
+ * 清空所有表元数据缓存（独立函数，无需实例化 Service 即可调用）
+ *
+ * 适用于定时任务等无法通过 Service 实例访问的场景。
+ * 清空后，下次请求会自动从数据库重新加载（懒加载刷新）。
+ */
+export declare function clearTableMetaCache(): {
+    metaCacheCount: number;
+    tableInfoCacheCount: number;
+};

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CrudProTableMetaService = void 0;
+exports.clearTableMetaCache = exports.CrudProTableMetaService = void 0;
 const CrudProServiceBase_1 = require("./CrudProServiceBase");
 const keys_1 = require("../models/keys");
 // import { pickAndConvertRowsByMix } from '../utils/sqlConvert/convertMix';
@@ -37,6 +37,22 @@ class CrudProTableMetaCache {
             expiredTime: Date.now() + cacheTime,
         };
     }
+    /**
+     * 清空所有缓存
+     */
+    clearAll() {
+        this.cacheMap = {};
+        this.tableInfoCacheMap = {};
+    }
+    /**
+     * 获取缓存统计信息
+     */
+    getCacheStats() {
+        return {
+            metaCacheCount: Object.keys(this.cacheMap).length,
+            tableInfoCacheCount: Object.keys(this.tableInfoCacheMap).length,
+        };
+    }
 }
 const metaCache = new CrudProTableMetaCache();
 class CrudProTableMetaService extends CrudProServiceBase_1.CrudProServiceBase {
@@ -48,6 +64,37 @@ class CrudProTableMetaService extends CrudProServiceBase_1.CrudProServiceBase {
         }
         return obj;
     }
+    /**
+     * 清空所有表元数据缓存
+     *
+     * 清空后，下次请求会自动从数据库重新加载。
+     * 适用于定时刷新或手动触发缓存失效的场景。
+     */
+    clearAllCache() {
+        metaCache.clearAll();
+    }
+    /**
+     * 获取缓存统计信息
+     */
+    getCacheStats() {
+        return metaCache.getCacheStats();
+    }
+    /**
+     * 获取表的主键列名列表
+     *
+     * 复用 getTableMeta 的缓存机制，从 columnDetails 中筛选 isPrimaryKey 的列，
+     * 避免重复查询数据库。
+     *
+     * @param query 表元数据查询参数
+     * @returns 主键列名数组
+     */
+    async getPrimaryKeyColumns(query) {
+        const meta = await this.getTableMeta(query);
+        const pks = (meta.columnDetails || [])
+            .filter(col => col.isPrimaryKey)
+            .map(col => col.name);
+        return pks;
+    }
     // ============ 获取表和视图信息（带类型） ============
     /**
      * 获取数据库所有表和视图信息（包含类型）
@@ -71,8 +118,7 @@ class CrudProTableMetaService extends CrudProServiceBase_1.CrudProServiceBase {
         const result = await this.loadAllTableInfos(query);
         // 3. 更新缓存
         if (!skipCache || refreshCache) {
-            const { tableMetaCacheTime } = this.getContextCfg();
-            metaCache.setTableInfos(cacheKey, result, tableMetaCacheTime || 3600000);
+            metaCache.setTableInfos(cacheKey, result, 1000 * 3600 * 24 * 365);
         }
         return result;
     }
@@ -202,12 +248,15 @@ class CrudProTableMetaService extends CrudProServiceBase_1.CrudProServiceBase {
         const columnArray = queryRes.rows || [];
         // 获取字段注释
         const commentMap = await this.loadPostgreSQLColumnComments(baseInfo, schemaname);
+        // 获取主键列
+        const pkSet = await this.loadPostgreSQLPrimaryKeys(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',
+                isPrimaryKey: pkSet.has(column_name),
                 defaultValue: column_default,
                 maxLength: character_maximum_length,
                 comment: commentMap[column_name],
@@ -237,6 +286,22 @@ class CrudProTableMetaService extends CrudProServiceBase_1.CrudProServiceBase {
         });
         return map;
     }
+    async loadPostgreSQLPrimaryKeys(baseInfo, schemaname) {
+        const pkSql = `
+      SELECT a.attname
+      FROM pg_index i
+      JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+      JOIN pg_class c ON c.oid = i.indrelid
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      WHERE n.nspname = '${schemaname}'
+        AND c.relname = '${baseInfo.sqlTable}'
+        AND i.indisprimary
+      ORDER BY array_position(i.indkey, a.attnum);
+    `.trim();
+        const queryRes = await this.executeUnsafeQuery(baseInfo, pkSql);
+        const pkRows = queryRes.rows || [];
+        return new Set(pkRows.map((row) => row.attname));
+    }
     async loadSQLServerColumnDetails(baseInfo) {
         const columnArraySql = `
       SELECT
@@ -258,18 +323,46 @@ class CrudProTableMetaService extends CrudProServiceBase_1.CrudProServiceBase {
     `.trim();
         const queryRes = await this.executeUnsafeQuery(baseInfo, columnArraySql);
         const columnArray = queryRes.rows || [];
+        // 获取主键列
+        const pkSet = await this.loadSQLServerPrimaryKeys(baseInfo);
         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,
+                isPrimaryKey: pkSet.has(column_name),
                 defaultValue: column_default,
                 comment: column_comment,
                 maxLength: max_length,
-                isPrimaryKey: is_identity,
+                isIdentity: is_identity,
             };
         });
     }
+    async loadSQLServerPrimaryKeys(baseInfo) {
+        const pkSql = `
+      SELECT COL_NAME(ic.object_id, ic.column_id) AS column_name
+      FROM sys.indexes i
+      INNER JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+      WHERE i.object_id = OBJECT_ID('${baseInfo.sqlTable}')
+        AND i.is_primary_key = 1
+      ORDER BY ic.key_ordinal;
+    `.trim();
+        const queryRes = await this.executeUnsafeQuery(baseInfo, pkSql);
+        const pkRows = queryRes.rows || [];
+        return new Set(pkRows.map((row) => row.column_name));
+    }
 }
 exports.CrudProTableMetaService = CrudProTableMetaService;
+/**
+ * 清空所有表元数据缓存（独立函数，无需实例化 Service 即可调用）
+ *
+ * 适用于定时任务等无法通过 Service 实例访问的场景。
+ * 清空后，下次请求会自动从数据库重新加载（懒加载刷新）。
+ */
+function clearTableMetaCache() {
+    const stats = metaCache.getCacheStats();
+    metaCache.clearAll();
+    return stats;
+}
+exports.clearTableMetaCache = clearTableMetaCache;

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

@@ -31,8 +31,10 @@ declare class CurdProServiceHub implements ICurdProServiceHub {
     convertOriginToExecuteSql(sqlCfgModel: SqlCfgModel): Promise<void>;
     executeFuncCfg(funCfg: IFuncCfgModel, funcContext: FuncContext): any;
     getTableMeta(query: ITableMetaQuery): Promise<ITableMeta>;
+    getPrimaryKeyColumns(query: ITableMetaQuery): Promise<string[]>;
     getAllTableInfos(query: ITableNamesQuery, options?: ITableNamesOptions): Promise<ITableListResult>;
     filterDataByTableMeta(data: Record<string, any>, sqlCfgModel: ISqlCfgModel | SqlCfgModel): Promise<Record<string, any>>;
     convertDataTypeByTableMeta(reqModel: RequestModel, cfgModel: RequestCfgModel): Promise<void>;
+    convertConditionTypeByTableMeta(reqModel: RequestModel, cfgModel: RequestCfgModel): Promise<void>;
 }
 export { CurdProServiceHub };

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

@@ -67,6 +67,9 @@ class CurdProServiceHub {
     async getTableMeta(query) {
         return await this.tableMetaService.getTableMeta(query);
     }
+    async getPrimaryKeyColumns(query) {
+        return await this.tableMetaService.getPrimaryKeyColumns(query);
+    }
     async getAllTableInfos(query, options) {
         return await this.tableMetaService.getAllTableInfos(query, options);
     }
@@ -76,5 +79,8 @@ class CurdProServiceHub {
     async convertDataTypeByTableMeta(reqModel, cfgModel) {
         return await this.dataTypeConvertService.convertDataTypeByTableMeta(reqModel, cfgModel);
     }
+    async convertConditionTypeByTableMeta(reqModel, cfgModel) {
+        return await this.dataTypeConvertService.convertConditionTypeByTableMeta(reqModel, cfgModel);
+    }
 }
 exports.CurdProServiceHub = CurdProServiceHub;