midway-fatcms 0.0.8 → 0.0.9

package/src/libs/crud-pro/services/CrudProDataTypeConvertService.ts

@@ -1,15 +1,42 @@
 import { CrudProServiceBase } from './CrudProServiceBase';
 import { RequestModel } from '../models/RequestModel';
 import { RequestCfgModel } from '../models/RequestCfgModel';
-import { KeysOfSimpleSQL, SqlDbType } from '../models/keys';
-import { ITableMetaQuery } from '../interfaces';
+import { KeysOfConditions, KeysOfSimpleSQL, SqlDbType } from '../models/keys';
+import { IRequestCondition, ITableMetaQuery } from '../interfaces';
+
+/** 预编译正则：整数类型（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<string>([
+  KeysOfSimpleSQL.SIMPLE_QUERY,
+  KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+  KeysOfSimpleSQL.SIMPLE_QUERY_PAGE,
+  KeysOfSimpleSQL.SIMPLE_QUERY_COUNT,
+  KeysOfSimpleSQL.SIMPLE_QUERY_EXIST,
+  KeysOfSimpleSQL.SIMPLE_DELETE,
+  KeysOfSimpleSQL.SIMPLE_UPDATE,
+]);
+
+/** INSERT/UPDATE 操作类型集合 */
+const INSERT_OR_UPDATE_TYPES = new Set<string>([
+  KeysOfSimpleSQL.SIMPLE_INSERT,
+  KeysOfSimpleSQL.SIMPLE_UPDATE,
+  KeysOfSimpleSQL.SIMPLE_INSERT_ON_DUPLICATE_UPDATE,
+  KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE,
+  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 {
 
@@ -150,21 +177,217 @@ class CrudProDataTypeConvertService extends CrudProServiceBase {
     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: RequestModel, cfgModel: RequestCfgModel): Promise<void> {
+    const sqlSimpleName = cfgModel.sqlSimpleName;
+    if (!this.isConditionType(sqlSimpleName)) {
+      return;
+    }
+
+    if (!reqModel.condition || Object.keys(reqModel.condition).length === 0) {
+      return;
+    }
+
+    const query: ITableMetaQuery = {
+      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<string, string>();
+    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 数据库类型
+   */
+  private convertConditionFields(
+    condition: IRequestCondition,
+    typeMap: Map<string, string>,
+    sqlDbType: SqlDbType
+  ): void {
+    if (!condition || typeof condition !== 'object') {
+      return;
+    }
+
+    for (const key of Object.keys(condition)) {
+      const value = condition[key];
+
+      // $or / $and 逻辑操作符：递归处理每个子条件
+      if (key === KeysOfConditions.$OR || key === KeysOfConditions.$AND) {
+        if (Array.isArray(value)) {
+          for (const subCondition of value) {
+            this.convertConditionFields(subCondition, typeMap, sqlDbType);
+          }
+        }
+        continue;
+      }
+
+      // 如果 key 是比较操作符（出现在内层），跳过
+      if (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 (KeysOfConditions.COMPARE_KEYS.has(opKey)) {
+            const opValue = value[opKey];
+            if (opKey === KeysOfConditions.$IN || opKey === KeysOfConditions.$NIN) {
+              // $in/$nin 的值是数组，逐个转换
+              if (Array.isArray(opValue)) {
+                value[opKey] = opValue.map(v => this.convertValueByType(v, fieldType, sqlDbType));
+              }
+            } else if (opKey === 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 转换后的值
+    */
+  private convertValueByType(value: any, fieldType: string, sqlDbType: SqlDbType): any {
+    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 三种数据库的整数类型名
+    */
+  private isIntegerType(type: string): boolean {
+    return REGEX_INTEGER_TYPE.test(type);
+  }
+
+  /**
+   * 判断字段类型是否为字符串类型
+   * 覆盖 MySQL/PostgreSQL/SQL Server 三种数据库的字符串类型名
+   */
+  private isStringType(type: string): boolean {
+    return REGEX_STRING_TYPE.test(type);
+  }
+
+
+  /**
+   * 判断 sqlSimpleName 是否为包含 WHERE 条件的操作类型（查询/删除/更新）
+   * 这些操作的 condition 会参与 WHERE 子句，索引失效问题同样存在
+   */
+  private isConditionType(sqlSimpleName: string): boolean {
+    return !!sqlSimpleName && CONDITION_TYPES.has(sqlSimpleName);
+  }
+
+  /**
+   * 判断值是否为基本类型（string | number | boolean）
+   */
+  private isBasicType(value: any): boolean {
+    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+  }
+
   /**
    * 判断 sqlSimpleName 是否为 INSERT/UPDATE 类型
    */
   private isInsertOrUpdateType(sqlSimpleName: string): boolean {
-    if (!sqlSimpleName) {
-      return false;
-    }
-    const types = [
-      KeysOfSimpleSQL.SIMPLE_INSERT,
-      KeysOfSimpleSQL.SIMPLE_UPDATE,
-      KeysOfSimpleSQL.SIMPLE_INSERT_ON_DUPLICATE_UPDATE,
-      KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE,
-      KeysOfSimpleSQL.SIMPLE_BATCH_INSERT,
-    ];
-    return types.includes(sqlSimpleName as KeysOfSimpleSQL);
+    return !!sqlSimpleName && INSERT_OR_UPDATE_TYPES.has(sqlSimpleName);
   }
 }
 

package/src/libs/crud-pro/services/CrudProTableMetaService.ts

@@ -39,6 +39,24 @@ class CrudProTableMetaCache {
       expiredTime: Date.now() + cacheTime,
     };
   }
+
+  /**
+   * 清空所有缓存
+   */
+  public clearAll(): void {
+    this.cacheMap = {};
+    this.tableInfoCacheMap = {};
+  }
+
+  /**
+   * 获取缓存统计信息
+   */
+  public getCacheStats(): { metaCacheCount: number; tableInfoCacheCount: number } {
+    return {
+      metaCacheCount: Object.keys(this.cacheMap).length,
+      tableInfoCacheCount: Object.keys(this.tableInfoCacheMap).length,
+    };
+  }
 }
 
 const metaCache = new CrudProTableMetaCache();
@@ -53,6 +71,40 @@ class CrudProTableMetaService extends CrudProServiceBase {
     return obj;
   }
 
+  /**
+   * 清空所有表元数据缓存
+   *
+   * 清空后，下次请求会自动从数据库重新加载。
+   * 适用于定时刷新或手动触发缓存失效的场景。
+   */
+  public clearAllCache(): void {
+    metaCache.clearAll();
+  }
+
+  /**
+   * 获取缓存统计信息
+   */
+  public getCacheStats(): { metaCacheCount: number; tableInfoCacheCount: number } {
+    return metaCache.getCacheStats();
+  }
+
+  /**
+   * 获取表的主键列名列表
+   *
+   * 复用 getTableMeta 的缓存机制，从 columnDetails 中筛选 isPrimaryKey 的列，
+   * 避免重复查询数据库。
+   *
+   * @param query 表元数据查询参数
+   * @returns 主键列名数组
+   */
+  public async getPrimaryKeyColumns(query: ITableMetaQuery): Promise<string[]> {
+    const meta = await this.getTableMeta(query);
+    const pks = (meta.columnDetails || [])
+      .filter(col => col.isPrimaryKey)
+      .map(col => col.name);
+    return pks;
+  }
+
   // ============ 获取表和视图信息（带类型） ============
 
 
@@ -84,7 +136,7 @@ class CrudProTableMetaService extends CrudProServiceBase {
 
     // 3. 更新缓存
     if (!skipCache || refreshCache) {
-      metaCache.setTableInfos(cacheKey, result, 1000 * 5);
+      metaCache.setTableInfos(cacheKey, result,  1000 * 3600 * 24 * 365);
     }
 
     return result;
@@ -244,12 +296,16 @@ class CrudProTableMetaService extends CrudProServiceBase {
     // 获取字段注释
     const commentMap = await this.loadPostgreSQLColumnComments(baseInfo, schemaname);
 
+    // 获取主键列
+    const pkSet = await this.loadPostgreSQLPrimaryKeys(baseInfo, schemaname);
+
     return columnArray.map((columnObj: any) => {
       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],
@@ -287,6 +343,27 @@ class CrudProTableMetaService extends CrudProServiceBase {
     return map;
   }
 
+  private async loadPostgreSQLPrimaryKeys(
+    baseInfo: IExecuteUnsafeQueryCtx,
+    schemaname: string
+  ): Promise<Set<string>> {
+    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: any) => row.attname));
+  }
+
   private async loadSQLServerColumnDetails(baseInfo: IExecuteUnsafeQueryCtx): Promise<ITableColumn[]> {
     const columnArraySql = `
       SELECT
@@ -310,19 +387,50 @@ class CrudProTableMetaService extends CrudProServiceBase {
     const queryRes = await this.executeUnsafeQuery(baseInfo, columnArraySql);
     const columnArray = queryRes.rows || [];
 
+    // 获取主键列
+    const pkSet = await this.loadSQLServerPrimaryKeys(baseInfo);
+
     return columnArray.map((columnObj: any) => {
       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,
       };
     });
   }
+
+  private async loadSQLServerPrimaryKeys(baseInfo: IExecuteUnsafeQueryCtx): Promise<Set<string>> {
+    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: any) => row.column_name));
+  }
 }
 
 export { CrudProTableMetaService };
+
+/**
+ * 清空所有表元数据缓存（独立函数，无需实例化 Service 即可调用）
+ *
+ * 适用于定时任务等无法通过 Service 实例访问的场景。
+ * 清空后，下次请求会自动从数据库重新加载（懒加载刷新）。
+ */
+export function clearTableMetaCache(): { metaCacheCount: number; tableInfoCacheCount: number } {
+  const stats = metaCache.getCacheStats();
+  metaCache.clearAll();
+  return stats;
+}

package/src/libs/crud-pro/services/CurdProServiceHub.ts

@@ -98,6 +98,10 @@ class CurdProServiceHub implements ICurdProServiceHub {
     return await this.tableMetaService.getTableMeta(query);
   }
 
+  async getPrimaryKeyColumns(query: ITableMetaQuery): Promise<string[]> {
+    return await this.tableMetaService.getPrimaryKeyColumns(query);
+  }
+
   async getAllTableInfos(query: ITableNamesQuery, options?: ITableNamesOptions): Promise<ITableListResult> {
     return await this.tableMetaService.getAllTableInfos(query, options);
   }
@@ -109,6 +113,10 @@ class CurdProServiceHub implements ICurdProServiceHub {
   async convertDataTypeByTableMeta(reqModel: RequestModel, cfgModel: RequestCfgModel): Promise<void> {
     return await this.dataTypeConvertService.convertDataTypeByTableMeta(reqModel, cfgModel);
   }
+
+  async convertConditionTypeByTableMeta(reqModel: RequestModel, cfgModel: RequestCfgModel): Promise<void> {
+    return await this.dataTypeConvertService.convertConditionTypeByTableMeta(reqModel, cfgModel);
+  }
 }
 
 export { CurdProServiceHub };