midway-fatcms 0.0.7 → 0.0.8

package/src/libs/crud-pro/CrudPro.ts

@@ -1,4 +1,4 @@
-import { ICrudProCfg, ILogger, IRequestCfgModel, IRequestModel, ISqlCfgModel, ITableListResult, ITableNamesOptions, ITableNamesQuery, IVisitor } from './interfaces';
+import { ICrudProCfg, ILogger, IRequestCfgModel, IRequestModel, ISqlCfgModel, ITableListResult, ITableNamesOptions, ITableNamesQuery, IVisitor, ExecuteSQLResult } from './interfaces';
 import { ExecuteContext } from './models/ExecuteContext';
 import { RequestModel } from './models/RequestModel';
 import { CurdProServiceHub } from './services/CurdProServiceHub';
@@ -13,11 +13,44 @@ class CrudPro {
   private readonly executeContext: ExecuteContext;
   private readonly serviceHub: CurdProServiceHub;
 
+  /** 标记是否已被使用（防止重复使用导致状态污染） */
+  private _isUsed: boolean = false;
+  /** 标记是否正在执行中（防止并发调用） */
+  private _isExecuting: boolean = false;
+
   constructor() {
     this.executeContext = new ExecuteContext();
     this.serviceHub = new CurdProServiceHub(this.executeContext);
   }
 
+  /**
+   * 检查是否可以开始执行
+   * @throws 如果已使用或正在执行中则抛出异常
+   */
+  private checkAndMarkExecuting(): void {
+    if (this._isUsed) {
+      throw new Error(
+        '[CrudPro] 此实例已被使用，不能重复使用。' +
+        '每次操作请创建新的 CrudPro 实例，可通过 curdProService.getCrudPro() 或工厂函数获取。'
+      );
+    }
+    if (this._isExecuting) {
+      throw new Error(
+        '[CrudPro] 此实例正在执行中，不能并发调用。' +
+        '请等待当前操作完成后再进行下一次调用，或创建新的实例。'
+      );
+    }
+    this._isExecuting = true;
+  }
+
+  /**
+   * 标记执行完成
+   */
+  private markExecutionComplete(): void {
+    this._isExecuting = false;
+    this._isUsed = true;
+  }
+
   // 必填
   set transaction(transaction: Transaction) {
     this.executeContext.setTransaction(transaction);
@@ -30,6 +63,10 @@ class CrudPro {
   set visitor(visitor: IVisitor) {
     this.executeContext.setVisitor(visitor);
   }
+  // 必填
+  getVisitor() {
+    return this.executeContext.getVisitor();
+  }
 
   set contextFunc(contextFunc: IExecuteContextFunc) {
     contextFunc.setExecuteContext(this.executeContext);
@@ -43,8 +80,11 @@ class CrudPro {
   /**
    * 直接执行一个SQL
    * @param sqlCfgModel
+   * @returns 返回未被包装的数据库原始结果（根据 resPicker 配置返回不同类型，无 {code, data, message} 包装层）
    */
-  public async executeSQL(sqlCfgModel: ISqlCfgModel): Promise<any> {
+  public async executeSQL(sqlCfgModel: ISqlCfgModel): Promise<ExecuteSQLResult> {
+    this.checkAndMarkExecuting();
+
     const RES_NAME = 'executeResult';
 
     const sqlCfgModel2 = {
@@ -64,8 +104,12 @@ class CrudPro {
       sqlCfgList: [sqlCfgModel2],
     };
 
-    const ss = await this.executeCrudByCfg({}, cfgModel);
-    return ss.getResModelItem(RES_NAME);
+    try {
+      const ss = await this.executeCrudByCfgInternal({}, cfgModel);
+      return ss.getResModelItem(RES_NAME);
+    } finally {
+      this.markExecutionComplete();
+    }
   }
 
   /**
@@ -87,6 +131,20 @@ class CrudPro {
    * @param cfgJson
    */
   public async executeCrudByCfg(reqJson: IRequestModel, cfgJson: IRequestCfgModel): Promise<ExecuteContext> {
+    this.checkAndMarkExecuting();
+    try {
+      return await this.executeCrudByCfgInternal(reqJson, cfgJson);
+    } finally {
+      this.markExecutionComplete();
+    }
+  }
+
+  /**
+   * 内部执行方法（不含检查逻辑，供内部调用）
+   * @param reqJson
+   * @param cfgJson
+   */
+  private async executeCrudByCfgInternal(reqJson: IRequestModel, cfgJson: IRequestCfgModel): Promise<ExecuteContext> {
     const logger = this.executeContext.getLogger();
     logger.info('CurdPro executeCrudByCfg', cfgJson);
 

package/src/libs/crud-pro/interfaces.ts

@@ -53,7 +53,7 @@ export interface IPoolConnectionClient {
 export interface IRequestModel {
   method?: string;
   columns?: string | string[]; // "columns": "id,name,age,sex,addr",
-  condition?: Record<string, any>; // 拼接查询条件
+  condition?: IRequestCondition; // 拼接查询条件
   data?: Record<string, any> | Record<string, any>[]; // 单条或批量插入/更新的数据部分
   orderBy?: string | IOrderByItem[];
   limit?: number;
@@ -64,23 +64,57 @@ export interface IRequestModel {
 
 type IBasicType = boolean | string | number;
 
+/**
+ * 比较操作符条件
+ * 支持 MongoDB 风格的所有查询操作符
+ */
 export interface ICompareCondition {
-  $gt?: IBasicType;
-  $gte?: IBasicType;
-  $lt?: IBasicType;
-  $lte?: IBasicType;
-  $ne?: IBasicType;
-
-  $in?: IRequestCondition[];
-  $nin?: IRequestCondition[];
-  $like?: IBasicType;
-  $match?: IBasicType;
-  $matchBool?: IBasicType;
-  $range?: number[];
+  // 比较操作符
+  $ne?: IBasicType;                    // 不等于
+  $lt?: IBasicType;                    // 小于
+  $lte?: IBasicType;                   // 小于或等于
+  $gt?: IBasicType;                    // 大于
+  $gte?: IBasicType;                   // 大于或等于
+
+  // 集合操作符
+  $in?: IBasicType[];                  // 在集合中
+  $nin?: IBasicType[];                 // 不在集合中
+
+  // 范围操作符
+  $range?: [number, number];           // 范围查询 [min, max]
+
+  // 模糊匹配操作符
+  $like?: string;                      // 前缀匹配 A%
+  $notLike?: string;                   // 非前缀匹配
+  $likeInclude?: string;               // 包含匹配 %A%
+  $notLikeInclude?: string;            // 不包含匹配
+
+  // 全文索引操作符
+  $match?: string;                     // MySQL 全文索引
+  $matchBool?: string | boolean;       // MySQL 布尔全文索引
+
+  // NULL 判断操作符
+  $null?: boolean;                     // IS NULL
+  $notNull?: boolean;                  // IS NOT NULL
+
+  // JSON 操作符
+  $jsonArrayContains?: string;         // JSON 数组包含
+}
+
+/**
+ * 逻辑操作符条件
+ */
+export interface ILogicalCondition {
+  $or?: IRequestCondition[];           // 逻辑或
+  $and?: IRequestCondition[];          // 逻辑与
 }
 
-export interface IRequestCondition extends Record<string, any>, ICompareCondition {
-  $or?: IRequestCondition[];
+/**
+ * 查询条件类型
+ * 支持字段值直接匹配或比较操作符
+ * 支持 $or, $and 逻辑组合
+ */
+export interface IRequestCondition extends Record<string, IBasicType | ICompareCondition | ILogicalCondition | IRequestCondition[] | undefined>, ILogicalCondition {
 }
 
 /**
@@ -163,6 +197,67 @@ export interface ISqlCfgModel extends IBaseCfgModel {
   crudType?: string;
 }
 
+/**
+ * executeSQL 的返回结果类型说明（未被包装的直接结果）
+ *
+ * 注意：executeSQL 返回的是数据库查询的原始结果，没有 {code, data, message} 包装层。
+ * 返回类型取决于 resPicker 配置，请根据实际 SQL 类型选择合适的类型断言。
+ *
+ * 使用示例：
+ *   // 查询列表 - 返回数组
+ *   const rows = await executeSQL({ executeSql: 'SELECT * FROM users', resPicker: KeysOfSqlResPicker.RESULT_ROWS }) as ExecuteSQLRowResult<User>;
+ *
+ *   // 查询单行 - 返回对象或null
+ *   const user = await executeSQL({ executeSql: 'SELECT * FROM users WHERE id=?', executeSqlArgs: [1], resPicker: KeysOfSqlResPicker.RESULT_FIRST_ROW }) as ExecuteSQLSingleResult<User>;
+ *
+ *   // 查询总数 - 返回数字
+ *   const count = await executeSQL({ executeSql: 'SELECT COUNT(*) as total_count FROM users', resPicker: KeysOfSqlResPicker.RESULT_TOTAL_COUNT }) as ExecuteSQLCountResult;
+ *
+ *   // 判断存在 - 返回布尔
+ *   const exists = await executeSQL({ executeSql: 'SELECT 1 as is_exist FROM users WHERE id=?', executeSqlArgs: [1], resPicker: KeysOfSqlResPicker.RESULT_IS_EXIST }) as ExecuteSQLExistResult;
+ *
+ *   // 增删改操作 - 返回受影响行数信息
+ *   const result = await executeSQL({ executeSql: 'INSERT INTO users(name) VALUES(?)', executeSqlArgs: ['张三'], resPicker: KeysOfSqlResPicker.UPDATE_RESULT }) as ExecuteSQLUpdateResult;
+ */
+
+/** 查询多行时的返回类型（默认情况）：原始数据行数组，无包装 */
+export type ExecuteSQLRowsResult<T = Record<string, any>> = T[];
+
+/** 查询单行时的返回类型：首行对象或null，无包装 */
+export type ExecuteSQLSingleResult<T = Record<string, any>> = T | null;
+
+/** 查询数量时的返回类型：数字，无包装 */
+export type ExecuteSQLCountResult = number;
+
+/** 判断存在时的返回类型：布尔值，无包装 */
+export type ExecuteSQLExistResult = boolean;
+
+/** 增删改操作时的返回类型：包含 insertId 和 affectedRows，无包装 */
+export interface ExecuteSQLUpdateResult {
+  /** 插入记录的自增ID（仅INSERT操作有效） */
+  insertId: any;
+  /** 受影响的行数 */
+  affectedRows: number;
+}
+
+/**
+ * executeSQL 的通用返回类型（未被包装的直接结果）
+ * 根据 resPicker 的不同配置，实际返回类型可能是：
+ * - ExecuteSQLRowResult<T> : 多行数据（默认）
+ * - ExecuteSQLSingleResult<T> : 单行数据或null
+ * - ExecuteSQLCountResult : 数字
+ * - ExecuteSQLExistResult : 布尔值
+ * - ExecuteSQLUpdateResult : 增删改结果
+ *
+ * 警告：此类型为联合类型，使用时建议根据实际 resPicker 进行类型断言以获得精确类型提示
+ */
+export type ExecuteSQLResult<T = Record<string, any>> =
+  | ExecuteSQLRowsResult<T>
+  | ExecuteSQLSingleResult<T>
+  | ExecuteSQLCountResult
+  | ExecuteSQLExistResult
+  | ExecuteSQLUpdateResult;
+
 /**
  * 自定义校验函数。如果不正确请抛出异常。{code:'xxx',message:'xxx'}
  */

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;
+
+  constructor(data: { row: T | null; rawContext: ExecuteContext; debugInfo?: CrudResultDebugInfo }) {
+    super(data.rawContext, data.debugInfo);
+    this.row = data.row;
+    this.found = (this.row !== null && this.row !== undefined );
+  }
+}
+
+/** 列表查询结果 */
+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 affected?: ResModelAffected;
+  readonly insertAffected?: ResModelAffected;
+  readonly updateAffected?: ResModelAffected;
+  readonly isExist: boolean;
+
+  constructor(data: {
+    affected?: ResModelAffected;
+    insertAffected?: ResModelAffected;
+    updateAffected?: ResModelAffected;
+    isExist: boolean;
+    rawContext: ExecuteContext;
+    debugInfo?: CrudResultDebugInfo;
+  }) {
+    super(data.rawContext, data.debugInfo);
+    this.affected = data.affected;
+    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/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)} > ?`;

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

@@ -84,8 +84,7 @@ class CrudProTableMetaService extends CrudProServiceBase {
 
     // 3. 更新缓存
     if (!skipCache || refreshCache) {
-      const { tableMetaCacheTime } = this.getContextCfg();
-      metaCache.setTableInfos(cacheKey, result, tableMetaCacheTime || 3600000);
+      metaCache.setTableInfos(cacheKey, result, 1000 * 5);
     }
 
     return result;