midway-fatcms 0.0.7 → 0.0.9

package/src/libs/crud-pro/models/CrudResult.ts

@@ -0,0 +1,178 @@
+import { ResModelAffected } from './ResModel';
+import { ExecuteContext } from './ExecuteContext';
+
+/**
+ * 结果基类的辅助定位信息
+ * 用于错误排查和日志记录
+ */
+export interface CrudResultDebugInfo {
+  /** 数据库名 */
+  sqlDatabase?: string;
+  /** 表名 */
+  sqlTable?: string;
+  /** 方法名（配置中的 method 字段） */
+  method?: string;
+  /** 查询条件（用于定位问题） */
+  condition?: Record<string, any>;
+}
+
+/**
+ * 结果基类
+ *
+ * 使用 ES2022 私有字段 #rawContext 存储 ExecuteContext 引用。
+ * ES2022 私有字段特性：JSON.stringify 不会序列化 # 开头的私有字段。
+ * 因此结果对象可直接返回给 API 前端，自动过滤掉内部上下文。
+ *
+ * Node.js 兼容性：Node.js 14.6+ 完全支持 ES2022 私有字段。
+ */
+abstract class CrudResultBase {
+  #rawContext: ExecuteContext;
+  /** 辅助定位信息，用于错误排查 */
+  readonly debugInfo: CrudResultDebugInfo;
+
+  constructor(rawContext: ExecuteContext, debugInfo?: CrudResultDebugInfo) {
+    this.#rawContext = rawContext;
+    this.debugInfo = debugInfo || {};
+  }
+
+  getRawContext(): ExecuteContext {
+    return this.#rawContext;
+  }
+
+  /**
+   * 生成带辅助定位信息的错误消息
+   * @param baseMessage 基础错误信息
+   * @returns 包含定位信息的完整错误消息
+   */
+  protected buildErrorMessage(baseMessage: string): string {
+    const parts: string[] = [baseMessage];
+    
+    if (this.debugInfo.sqlDatabase) {
+      parts.push(`数据库: ${this.debugInfo.sqlDatabase}`);
+    }
+    if (this.debugInfo.sqlTable) {
+      parts.push(`表: ${this.debugInfo.sqlTable}`);
+    }
+    if (this.debugInfo.method) {
+      parts.push(`方法: ${this.debugInfo.method}`);
+    }
+    if (this.debugInfo.condition) {
+      try {
+        parts.push(`条件: ${JSON.stringify(this.debugInfo.condition)}`);
+      } catch {
+        parts.push(`条件: [无法序列化]`);
+      }
+    }
+    
+    return parts.join(' | ');
+  }
+}
+
+/** 写操作结果（INSERT/UPDATE/DELETE） */
+class CrudWriteResult extends CrudResultBase {
+  readonly affectedRows: number;
+  readonly insertId?: string | number;
+
+  constructor(data: {
+    affectedRows: number;
+    insertId?: string | number;
+    rawContext: ExecuteContext;
+    debugInfo?: CrudResultDebugInfo;
+  }) {
+    super(data.rawContext, data.debugInfo);
+    this.affectedRows = data.affectedRows;
+    this.insertId = data.insertId;
+  }
+}
+
+/** 单条查询结果 */
+class CrudQueryOneResult<T = Record<string, any>> extends CrudResultBase {
+  readonly row: T | null;
+  readonly found: boolean;
+  /** 数据来源的物理表名（分表场景下为实际分表名，如 t_order_202403） */
+  readonly fromTable: string;
+
+  constructor(data: { row: T | null; rawContext: ExecuteContext; debugInfo?: CrudResultDebugInfo; fromTable: string }) {
+    super(data.rawContext, data.debugInfo);
+    this.row = data.row;
+    this.found = (this.row !== null && this.row !== undefined);
+    this.fromTable = data.fromTable;
+  }
+}
+
+/** 列表查询结果 */
+class CrudQueryListResult<T = Record<string, any>> extends CrudResultBase {
+  readonly rows: T[];
+  readonly count: number;
+
+  constructor(data: { rows: T[]; rawContext: ExecuteContext; debugInfo?: CrudResultDebugInfo }) {
+    super(data.rawContext, data.debugInfo);
+    this.rows = data.rows || [];
+    this.count = this.rows.length;
+  }
+}
+
+/** 分页查询结果 */
+class CrudQueryPageResult<T = Record<string, any>> extends CrudResultBase {
+  readonly rows: T[];
+  readonly totalCount: number;
+  readonly count: number;
+
+  constructor(data: { rows: T[]; totalCount: number; rawContext: ExecuteContext; debugInfo?: CrudResultDebugInfo }) {
+    super(data.rawContext, data.debugInfo);
+    this.rows = data.rows || [];
+    this.totalCount = data.totalCount;
+    this.count = this.rows.length;
+  }
+}
+
+/** 存在性判断结果 */
+class CrudExistResult extends CrudResultBase {
+  readonly exists: boolean;
+
+  constructor(data: { exists: boolean; rawContext: ExecuteContext; debugInfo?: CrudResultDebugInfo }) {
+    super(data.rawContext, data.debugInfo);
+    this.exists = data.exists;
+  }
+}
+
+/** 计数结果 */
+class CrudCountResult extends CrudResultBase {
+  readonly count: number;
+
+  constructor(data: { count: number; rawContext: ExecuteContext; debugInfo?: CrudResultDebugInfo }) {
+    super(data.rawContext, data.debugInfo);
+    this.count = data.count;
+  }
+}
+
+/** InsertOrUpdate 结果 */
+class CrudUpsertResult extends CrudResultBase {
+  readonly insertAffected?: ResModelAffected;
+  readonly updateAffected?: ResModelAffected;
+  readonly isExist: boolean;
+
+  constructor(data: {
+    insertAffected?: ResModelAffected;
+    updateAffected?: ResModelAffected;
+    isExist: boolean;
+    rawContext: ExecuteContext;
+    debugInfo?: CrudResultDebugInfo;
+  }) {
+    super(data.rawContext, data.debugInfo);
+    this.insertAffected = data.insertAffected;
+    this.updateAffected = data.updateAffected;
+    this.isExist = data.isExist;
+  }
+}
+
+export {
+  CrudResultBase,
+  CrudWriteResult,
+  CrudQueryOneResult,
+  CrudQueryListResult,
+  CrudQueryPageResult,
+  CrudExistResult,
+  CrudCountResult,
+  CrudUpsertResult,
+};

package/src/libs/crud-pro/models/RequestModel.ts

@@ -1,5 +1,5 @@
 import * as _ from 'lodash';
-import { ILimitOffset, IOrderByItem, IRequestModel, IVisitor } from '../interfaces';
+import { ILimitOffset, IOrderByItem, IRequestModel, IVisitor, IRequestCondition } from '../interfaces';
 import { MixinUtils } from '../utils/MixinUtils';
 import { OrderByUtils } from '../utils/OrderByUtils';
 import { CommonException, Exceptions } from '../exceptions';
@@ -10,7 +10,7 @@ class RequestModel {
 
   method: string;
   columns?: string[]; // "columns": "id,name,age,sex,addr",
-  condition?: Record<string, any>;
+  condition?: IRequestCondition;
   data?: Record<string, any> | Record<string, any>[]; // 支持单条或批量数据
   limit: number;
   offset: number;

package/src/libs/crud-pro/models/ServiceHub.ts

@@ -30,5 +30,9 @@ export interface ICurdProServiceHub {
 
   getTableMeta(query: ITableMetaQuery): Promise<ITableMeta>;
 
+  getPrimaryKeyColumns(query: ITableMetaQuery): Promise<string[]>;
+
   convertDataTypeByTableMeta(reqModel: RequestModel, cfgModel: RequestCfgModel): Promise<void>;
+
+  convertConditionTypeByTableMeta(reqModel: RequestModel, cfgModel: RequestCfgModel): Promise<void>;
 }

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/CrudProExecuteSqlService.ts

@@ -18,6 +18,9 @@ class CrudProExecuteSqlService extends CrudProServiceBase {
   async executeSqlCfgModels(): Promise<void> {
     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);
@@ -87,9 +90,45 @@ class CrudProExecuteSqlService extends CrudProServiceBase {
       return false;
     }
 
+    const errorMsg = `禁止执行的SQL: ${sqlCfgModel.executeSql}`;
+
     if (KeyOfCrudTypes.NOT_CRUD === crudType) {
-      // 只支持增删改查，其他语句不支持。
-      throw new CommonException(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 CommonException(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 CommonException(Exceptions.CFG_NOT_SUPPORT_THE_SQL, errorMsg);
+        }
+      } else {
+        // 非 isNativeSQL 模式下，只支持增删改查，其他语句不支持。
+        throw new CommonException(Exceptions.CFG_NOT_SUPPORT_THE_SQL, errorMsg);
+      }
     }
 
     // 此SQL不需要执行

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

@@ -86,7 +86,7 @@ class CrudProGenSqlCondition {
         if (equalsIgnoreCase(KeysOfConditions.$OR, key)) {
           TypeUtils.assertJsonArray(value, Exceptions.REQUEST_OR_PARAM_MUST_ARRAY);
 
-          const a = this.generateByLogicalOR(value);
+          const a = this.generateByLogicalOR(value as IRequestCondition[]);
           if (a != null) {
             tmpSqlList.push(a.sql);
             if (isNotEmpty(a.args)) {
@@ -99,7 +99,7 @@ class CrudProGenSqlCondition {
         if (equalsIgnoreCase(KeysOfConditions.$AND, key)) {
           TypeUtils.assertJsonArray(value, Exceptions.REQUEST_OR_PARAM_MUST_ARRAY);
 
-          const a = this.generateByLogicalAnd(value);
+          const a = this.generateByLogicalAnd(value as IRequestCondition[]);
           if (a != null) {
             tmpSqlList.push(a.sql);
             if (isNotEmpty(a.args)) {
@@ -114,7 +114,7 @@ class CrudProGenSqlCondition {
           tmpArgList.push(value);
         } else {
           // AND
-          const a = this.generateByCompareKey(key, value);
+          const a = this.generateByCompareKey(key, value as ICompareCondition);
 
           if (a != null) {
             tmpSqlList.push(a.sql);
@@ -209,11 +209,15 @@ class CrudProGenSqlCondition {
         let tmpSql = '';
 
         if (equalsIgnoreCase(KeysOfConditions.$NULL, compare)) {
-          tmpSql = `${toSqlColumnName(key)} is null `;
-          hasNoArgSql = true;
+          if (value0 === true) {
+            tmpSql = `${toSqlColumnName(key)} is null `;
+            hasNoArgSql = true;
+          }
         } else if (equalsIgnoreCase(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(KeysOfConditions.$GT, compare)) {
           tmpArgList.push(value0);
           tmpSql = `${toSqlColumnName(key)} > ?`;