midway-fatcms 0.0.7 → 0.0.9

package/src/service/SysConfigService.ts

@@ -20,10 +20,14 @@ export class SysConfigService extends BaseService {
 
   private get sysConfigsDao(){
     const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-    return this.curdProService.getQuickCrud(SystemDbName, SystemDbType, SystemTables.sys_configs)
+    return this.curdProService.getQuickCrud({
+      sqlDatabase: SystemDbName,
+      sqlDbType: SystemDbType,
+      sqlTable: SystemTables.sys_configs,
+    })
   }
 
-  async getSysConfigOne(config_code: string): Promise<any> {
+  async getSysConfigOne(config_code: string): Promise<Record<string, any>> {
     if (!config_code || typeof config_code !== 'string') {
       throw new Error('[getSysAppOne] config_code required');
     }
@@ -31,9 +35,10 @@ export class SysConfigService extends BaseService {
       cacheKey: config_code,
       cacheName: CacheNameEnum.GetSysConfigOne,
       getter: async () => {
-        return await this.sysConfigsDao.getUniqueOne({
+        const res = await this.sysConfigsDao.findOne({
           condition: {config_code, deleted_at: 0}
         });
+        return res.row;
       },
     });
   }

package/src/service/SysDictDataService.ts

@@ -17,12 +17,20 @@ export class SysDictDataService extends BaseService {
 
   private get sys_data_dict_item() {
     const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-    return this.curdProService.getQuickCrud(SystemDbName, SystemDbType, SystemTables.sys_data_dict_item)
+    return this.curdProService.getQuickCrud({
+      sqlDatabase: SystemDbName,
+      sqlDbType: SystemDbType,
+      sqlTable: SystemTables.sys_data_dict_item,
+    })
   }
 
   // private get sys_data_dict(){
   //   const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-  //   return this.curdProService.getQuickCrud(SystemDbName, SystemDbType, SystemTables.sys_data_dict)
+  //   return this.curdProService.getQuickCrud({
+  //     sqlDatabase: SystemDbName,
+  //     sqlDbType: SystemDbType,
+  //     sqlTable: SystemTables.sys_data_dict,
+  //   })
   // }
 
 
@@ -34,15 +42,17 @@ export class SysDictDataService extends BaseService {
       cacheKey: dict_code,
       cacheName: CacheNameEnum.GetDataDictItemsByDictCode,
       getter: async () => {
-        return await this.sys_data_dict_item.getList({
+        const res =  await this.sys_data_dict_item.findList({
           condition: { dict_code, status: 1, deleted_at: 0 }
         });
+        return res.rows;
       },
     });
   }
 
   public async removeCacheByDictItemId(dict_item_id: string) {
-    const dictItemObj = await this.sys_data_dict_item.getUniqueOne({ condition: { id: dict_item_id } });
+    const res = await this.sys_data_dict_item.findOne({ condition: { id: dict_item_id } });
+    const dictItemObj = res.row;
     return this.removeCacheByDictCode(dictItemObj['dict_code']);
   }
 

package/src/service/SysMenuService.ts

@@ -57,7 +57,11 @@ export class SysMenuService extends BaseService {
 
   private get sys_menus_table() {
     const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-    return this.curdProService.getQuickCrud(SystemDbName, SystemDbType, SystemTables.sys_menus)
+    return this.curdProService.getQuickCrud({
+      sqlDatabase: SystemDbName,
+      sqlDbType: SystemDbType,
+      sqlTable: SystemTables.sys_menus,
+    })
   }
 
 
@@ -70,9 +74,10 @@ export class SysMenuService extends BaseService {
       cacheKey: CacheNameEnum.GetSysMenusList,
       cacheName: CacheNameEnum.GetSysMenusList,
       getter: async () => {
-        return await this.sys_menus_table.getList({
+        const res =  await this.sys_menus_table.findList({
           condition: {}
         });
+        return res.rows;
       },
     });
   }

package/src/service/TableMetaCacheRedisSubscriber.ts

@@ -0,0 +1,105 @@
+import { RedisService } from '@midwayjs/redis';
+import { clearTableMetaCache } from '@/libs/crud-pro/services/CrudProTableMetaService';
+import { RedisKeys } from '@/models/RedisKeys';
+
+const CHANNEL = RedisKeys.TABLE_META_CACHE_INVALIDATE_CHANNEL;
+
+/**
+ * 本节点唯一标识，用于区分是自己发出的广播还是其他节点发出的
+ * 避免重复清空（本节点已在发布前清空过）
+ */
+const NODE_ID = `node_${process.pid}_${Date.now()}`;
+
+/**
+ * 用于发布消息的 Redis 客户端（复用 @midwayjs/redis 注入的实例）
+ */
+let publishClient: RedisService | null = null;
+
+/**
+ * 用于订阅的 Redis 客户端（独立连接，ioredis 规定订阅连接不能执行普通命令）
+ */
+let subscribeClient: RedisService | null = null;
+
+/**
+ * 初始化发布客户端
+ *
+ * 在 Midway 容器初始化完成后调用，注入已有的 RedisService 实例
+ * @param client RedisService 实例
+ */
+export function initTableMetaCachePublishClient(client: RedisService): void {
+  publishClient = client;
+}
+
+/**
+ * 初始化 Redis 订阅，监听缓存失效广播
+ *
+ * 使用 RedisService.duplicate() 创建独立的订阅连接。
+ * 收到广播后自动清空本节点的本地缓存。
+ *
+ * @param mainClient 已有的 RedisService 实例，用于 duplicate 出订阅连接
+ */
+export function initTableMetaCacheSubscriber(mainClient: RedisService): void {
+  if (subscribeClient) {
+    return; // 防止重复初始化
+  }
+
+  // duplicate() 创建一个同配置的独立连接
+  subscribeClient = mainClient.duplicate() as RedisService;
+
+  subscribeClient.subscribe(CHANNEL).catch((err: Error) => {
+    console.error('[TableMetaCacheRedis] subscribe failed:', err.message);
+  });
+
+  subscribeClient.on('message', (channel: string, message: string) => {
+    if (channel !== CHANNEL) return;
+
+    try {
+      const data = JSON.parse(message);
+      // 跳过自己发出的广播（本节点已在发布前清空过）
+      if (data.nodeId === NODE_ID) return;
+
+      const stats = clearTableMetaCache();
+      console.info(`[TableMetaCacheRedis] 收到其他节点(${data.nodeId})的缓存清空广播，已清空本地缓存:`, stats);
+    } catch (e) {
+      console.error('[TableMetaCacheRedis] 处理缓存失效广播异常:', e);
+    }
+  });
+
+  subscribeClient.on('error', (err: Error) => {
+    console.error('[TableMetaCacheRedis] subscriber connection error:', err.message);
+  });
+
+  console.info('[TableMetaCacheRedis] 订阅已启动，监听频道:', CHANNEL);
+}
+
+/**
+ * 清空本节点缓存并广播通知集群中其他节点
+ *
+ * 调用流程：
+ * 1. 清空本节点本地缓存
+ * 2. 通过 Redis PUBLISH 广播消息
+ * 3. 其他节点收到消息后清空各自的本地缓存
+ *
+ * @returns 清空前的缓存统计
+ */
+export function clearTableMetaCacheWithBroadcast(): { metaCacheCount: number; tableInfoCacheCount: number } {
+  // 1. 清空本节点缓存
+  const stats = clearTableMetaCache();
+
+  // 2. 广播通知其他节点
+  if (publishClient && typeof publishClient.publish === 'function') {
+    const message = JSON.stringify({
+      nodeId: NODE_ID,
+      timestamp: Date.now(),
+      beforeClear: stats,
+    });
+    publishClient.publish(CHANNEL, message).catch((err: Error) => {
+      console.error('[TableMetaCacheRedis] publish failed:', err.message);
+    });
+  } else {
+    // 没有 Redis 连接时仅清空本地（单节点部署降级）
+    console.info('[TableMetaCacheRedis] 无 Redis 发布客户端，仅清空本节点缓存');
+  }
+
+  return stats;
+}

package/src/service/crudstd/CrudStdService.ts

@@ -98,7 +98,7 @@ export class CrudStdService extends ApiBaseService {
     if (!appInfo || appInfo.status !== 1) {
       throw new BizException('应用不存在或已下线：' + appCode);
     }
-    
+
     const stdCrudCfgObj = appInfo.stdCrudCfgObj;
 
     //删除策略
@@ -296,7 +296,7 @@ export class CrudStdService extends ApiBaseService {
     if (!appInfo) {
       return null;
     }
-    const { app_schema, ...others } = appInfo;
+    const { app_schema, ...others } = appInfo as any;
     const stdCrudCfgObj = parseJsonObject(app_schema);
 
     const handleArrayCfg = (arrayCfg: any[]) => {

package/src/service/curd/CurdMixService.ts

@@ -1,15 +1,17 @@
 import { Inject, Provide } from '@midwayjs/core';
 import { CurdProService } from './CurdProService';
 import { CurdMixByDictService } from './CurdMixByDictService';
-import { ColumnRelation, IRequestCfgModel, IRequestModel, ISqlCfgModel, ITableListResult, ITableNamesOptions, ITableNamesQuery } from '@/libs/crud-pro/interfaces';
+import { ColumnRelation, IRequestCfgModel, IRequestModel, ISqlCfgModel, ITableListResult, ITableNamesOptions, ITableNamesQuery, ExecuteSQLResult } from '@/libs/crud-pro/interfaces';
 import { CurdMixBySysConfigService } from './CurdMixBySysConfigService';
 import { CurdMixByAccountService } from './CurdMixByAccountService';
 import { RelatedType } from './CurdMixUtils';
 import { CurdMixByWorkbenchService } from './CurdMixByWorkbenchService';
 import { IRequestCfgModel2 } from '@/models/bizmodels';
 import { CurdMixByLinkToCustomService } from './CurdMixByLinkToCustomService';
-import { SqlDbType } from '@/libs/crud-pro/models/keys';
+// import { SqlDbType } from '@/libs/crud-pro/models/keys';
 import { ExecuteContext, IExecuteContextCustom } from '@/libs/crud-pro/models/ExecuteContext';
+import { ShardingBase } from "@/libs/crud-sharding";
+import { IGetQuickCrudParam, IGetShardingCrudParam } from './CurdProService';
 
 export interface ILinkColumnRelationParam {
   columnsRelations: ColumnRelation[];
@@ -48,12 +50,31 @@ export class CurdMixService {
     return this.curdProService.executeCrudByCfg(reqJson, cfgModel);
   }
 
-  getBbUtil(sqlDatabase: string, sqlDbType: SqlDbType, sqlTable?: string) {
+
+  // /**
+  //  * @deprecated 请使用 getQuickCrud 替代
+  //  * @param sqlDatabase
+  //  * @param sqlDbType
+  //  * @param sqlTable
+  //  */
+  // getBbUtil(sqlDatabase: string, sqlDbType: SqlDbType, sqlTable?: string) {
+  //   this.prepare();
+  //   return this.curdProService.getQuickCrud({ sqlDatabase, sqlDbType, sqlTable });
+  // }
+
+  getQuickCrud(param: IGetQuickCrudParam) {
     this.prepare();
-    return this.curdProService.getQuickCrud(sqlDatabase, sqlDbType, sqlTable);
+    return this.curdProService.getQuickCrud(param);
   }
 
-  async executeSQL(sqlCfgModel: ISqlCfgModel) {
+
+  public getShardingCrud(param: IGetShardingCrudParam): ShardingBase {
+    this.prepare();
+    return this.curdProService.getShardingCrud(param);
+  }
+
+
+  async executeSQL(sqlCfgModel: ISqlCfgModel): Promise<ExecuteSQLResult> {
     this.prepare();
     return this.curdProService.executeSQL(sqlCfgModel);
   }

package/src/service/curd/CurdProService.ts

@@ -2,7 +2,7 @@ import * as _ from 'lodash';
 import { Config, Inject, Provide } from '@midwayjs/core';
 import { CrudPro } from '@/libs/crud-pro/CrudPro';
 import { Context } from '@midwayjs/koa';
-import { IConnectionPool, ICrudProCfg, IRequestCfgModel, IRequestModel, ISqlCfgModel, ITableListResult, ITableNamesOptions, ITableNamesQuery } from '@/libs/crud-pro/interfaces';
+import { IConnectionPool, ICrudProCfg, IRequestCfgModel, IRequestModel, ISqlCfgModel, ITableListResult, ITableNamesOptions, ITableNamesQuery, ExecuteSQLResult } from '@/libs/crud-pro/interfaces';
 import { SqlCfgModel } from '@/libs/crud-pro/models/SqlCfgModel';
 import { getConnectionPool as getMySQLConnectionPool } from '../../libs/crud-pro/utils/pool/MySQLUtils';
 import { getConnectionPool as getPostgresConnectionPool } from '../../libs/crud-pro/utils/pool/PostgresUtils';
@@ -16,11 +16,35 @@ import { RelatedType } from './CurdMixUtils';
 import { BaseService } from '../base/BaseService';
 import { IRequestCfgModel2, IVisitorExt } from '@/models/bizmodels';
 import { IWorkbenchEntity } from '@/models/SystemEntities';
-import { CrudProQuick } from './CrudProQuick';
-import { ShardingCrudPro, IShardingConfig } from '@/libs/crud-sharding';
+import { CrudProQuick } from '@/libs/crud-pro-quick';
+import { ShardingBase, ShardingByTimeCrud, ShardingByHashCrud, ShardingByKeyCrud, ShardingByCustomCrud, ShardingType, IShardingConfig } from '@/libs/crud-sharding';
 import { fixCfgModel } from './fixCfgModel';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
-import { fixSoftDelete } from "@/service/curd/fixSoftDelete";
+import { fixSoftDelete } from "@/libs/crud-pro-quick/fixSoftDelete";
+
+/**
+ * getQuickCrud 参数接口
+ */
+export interface IGetQuickCrudParam {
+  /** 数据库名 */
+  sqlDatabase: string;
+  /** 数据库类型 */
+  sqlDbType: SqlDbType;
+  /** 表名（可选） */
+  sqlTable?: string;
+}
+
+/**
+ * getShardingCrud 参数接口
+ */
+export interface IGetShardingCrudParam {
+  /** 数据库名 */
+  sqlDatabase: string;
+  /** 数据库类型 */
+  sqlDbType: SqlDbType;
+  /** 分表配置 */
+  shardingConfig: IShardingConfig;
+}
 
 function toVisitor(ctx: Context): IVisitorExt {
   const workbenchInfo: IWorkbenchEntity = ctx.workbenchInfo;
@@ -148,10 +172,40 @@ export class CurdProService extends BaseService {
 
   private responseCfgHandlers: Record<RelatedType, IExecuteContextHandler> = {} as any;
 
+  /**
+   * 注册“响应配置处理器”（response cfg handler）。
+   *
+   * 这些处理器会在一次 CRUD/SQL 执行完成后被调用，用于对 `ExecuteContext` 做统一的二次加工，
+   * 例如：追加扩展数据、做字段脱敏、统一包装返回结构等。
+   *
+   * @param key 处理器类型标识（业务自定义枚举/常量）
+   * @param handler 处理器实现
+   *
+   * @example
+   * curdProService.setResponseCfgHandlers(RelatedType.USER, {
+   *   async handleExecuteContextPrepare(ctx) {
+   *     // 可在执行结果处理前做准备
+   *   },
+   *   async handleExecuteContext(ctx) {
+   *     // 对 ctx.result / ctx.data 等进行二次加工
+   *   },
+   * });
+   */
   public setResponseCfgHandlers(key: RelatedType, handler: IExecuteContextHandler) {
     this.responseCfgHandlers[key] = handler;
   }
 
+  /**
+   * 获取当前已注册的“响应配置处理器”集合。
+   *
+   * 一般用于调试或在外层框架中统一检查/复用已有 handler。
+   *
+   * @returns 以 `RelatedType` 为 key 的处理器映射表
+   *
+   * @example
+   * const handlers = curdProService.getResponseCfgHandlers();
+   * const userHandler = handlers[RelatedType.USER];
+   */
   public getResponseCfgHandlers(): Record<RelatedType, IExecuteContextHandler> {
     return this.responseCfgHandlers;
   }
@@ -189,8 +243,21 @@ export class CurdProService extends BaseService {
   }
 
   /**
-   * 依赖缓存中与加载的配置
-   * @param reqJson
+   * 通过 `method` 走配置化 CRUD 执行（从缓存/加载的配置中解析）。
+   *
+   * 适用于：前端/调用方只传 `method` + 入参，由服务端根据 `method` 找到对应的 CRUD 配置并执行。
+   * 在非调试模式下会启用配置缓存（调试模式关闭缓存，便于开发即时生效）。
+   *
+   * @param reqJson 请求模型，必须包含 `method`
+   * @returns `ExecuteContext`（包含执行过程与结果数据）
+   *
+   * @example
+   * const ctx = await curdProService.executeCrud({
+   *   method: 'user.list',
+   *   pageNo: 1,
+   *   pageSize: 20,
+   * });
+   * console.log(ctx.result);
    */
   async executeCrud(reqJson: IRequestModel): Promise<ExecuteContext> {
     if (!reqJson.method) {
@@ -204,87 +271,161 @@ export class CurdProService extends BaseService {
     return curdPro.executeCrud(reqJson, isEnableCache);
   }
 
-  // 直接执行一个SQL
-  public async executeSQL(sqlCfgModel: ISqlCfgModel): Promise<any> {
+  /**
+   * 直接执行一段 SQL（不依赖 `method` 配置）。
+   *
+   * 适用于：后台管理/运维脚本/内部工具需要直接跑 SQL 的场景（仍会复用本服务的连接池、日志、visitor、事务等上下文）。
+   *
+   * @param sqlCfgModel SQL 执行配置（数据库、类型、SQL、参数等）
+   * @returns SQL 执行结果
+   *
+   * @example
+   * const res = await curdProService.executeSQL({
+   *   sqlDbType: SqlDbType.mysql,
+   *   sqlDatabase: 'mydb',
+   *   executeSql: 'select * from t_user where id = ?',
+   *   executeSqlArgs: [1],
+   * });
+   */
+  public async executeSQL(sqlCfgModel: ISqlCfgModel): Promise<ExecuteSQLResult> {
     const curdPro = this.getCrudPro();
     return curdPro.executeSQL(sqlCfgModel);
   }
 
-  // 直接执行一个请求
+  /**
+   * 直接按指定配置执行一次 CRUD（不走缓存查找）。
+   *
+   * 适用于：调用方已经拿到了/动态生成了本次要执行的 CRUD 配置，想直接执行并得到结果。
+   * 该方法会对 `cfgModel` 做两类标准化处理：
+   * - 统一修正/补全配置（`fixCfgModel`）
+   * - 应用软删除规则（`fixSoftDelete`）
+   *
+   * @param reqJson 本次请求入参
+   * @param cfgModel 本次请求对应的 CRUD 配置
+   * @returns `ExecuteContext`
+   *
+   * @example
+   * const cfg = await curdProService.getCachedCfgByMethod('user.list');
+   * const ctx = await curdProService.executeCrudByCfg(
+   *   { method: 'user.list', pageNo: 1, pageSize: 20 },
+   *   cfg as any
+   * );
+   */
   public async executeCrudByCfg(reqJson: IRequestModel, cfgModel: IRequestCfgModel2): Promise<ExecuteContext> {
     this.logInfo('executeCrudByCfg', cfgModel);
     const curdPro = this.getCrudPro();
     // 应用标准的updateCfg。
     fixCfgModel(cfgModel);
     // 应用软删除动作。
-    fixSoftDelete(cfgModel.sqlSimpleName, cfgModel, reqJson, this.ctx);
+    fixSoftDelete(cfgModel.sqlSimpleName, cfgModel, reqJson, curdPro.getVisitor());
     return await curdPro.executeCrudByCfg(reqJson, cfgModel);
   }
 
-  /**
-   * 获取 CrudProQuick 工具类（已废弃）
-   *
-   * @deprecated 请使用 getQuickCrud 替代
-   * @param sqlDatabase 数据库名
-   * @param sqlDbType 数据库类型
-   * @param sqlTable 表名（可选）
-   * @returns CrudProQuick 实例
-   */
-  public getBbUtil(sqlDatabase: string, sqlDbType: SqlDbType, sqlTable?: string): CrudProQuick {
-    return this.getQuickCrud(sqlDatabase, sqlDbType, sqlTable);
-  }
 
   /**
    * 获取 CrudProQuick 工具类
    *
    * 提供快速 CRUD 操作的便捷方法，封装了常用的数据库操作。
    *
-   * @param sqlDatabase 数据库名
-   * @param sqlDbType 数据库类型
-   * @param sqlTable 表名（可选）
+   * @param param 参数对象
    * @returns CrudProQuick 实例
    *
    * @example
-   * const quick = curdProService.getQuickCrud('mydb', SqlDbType.mysql, 't_user');
-   * const users = await quick.query({ status: 'active' });
+   * const quick = curdProService.getQuickCrud({
+   *   sqlDatabase: 'mydb',
+   *   sqlDbType: SqlDbType.mysql,
+   *   sqlTable: 't_user',
+   * });
+   * const users = await quick.find({ status: 'active' });
    */
-  public getQuickCrud(sqlDatabase: string, sqlDbType: SqlDbType, sqlTable?: string): CrudProQuick {
-    const curdPro = this.getCrudPro();
-    return new CrudProQuick({ curdPro, sqlDatabase, sqlDbType, sqlTable, ctx: this.ctx });
+  public getQuickCrud(param: IGetQuickCrudParam): CrudProQuick {
+    const { sqlDatabase, sqlDbType, sqlTable } = param;
+    // 传入工厂函数，每次需要时创建新的 CrudPro 实例
+    return new CrudProQuick({
+      crudProFactory: () => this.getCrudPro(),
+      sqlDatabase,
+      sqlDbType,
+      sqlTable,
+    });
   }
 
   /**
    * 获取分表 CRUD 操作器
    *
-   * @param sqlDatabase 数据库名
-   * @param sqlDbType 数据库类型
-   * @param shardingConfig 分表配置
-   * @returns ShardingCrudPro 实例
+   * @param param 参数对象
+   * @returns ShardingBase 实例（实际类型根据 shardingConfig.type 决定）
    *
    * @example
-   * const sharding = curdProService.getShardingCrud('mydb', SqlDbType.mysql, {
-   *   type: ShardingType.MONTH,
-   *   baseTable: 't_order',
-   *   timeColumn: 'created_at',
+   * const sharding = curdProService.getShardingCrud({
+   *   sqlDatabase: 'mydb',
+   *   sqlDbType: SqlDbType.mysql,
+   *   shardingConfig: {
+   *     type: ShardingType.MONTH,
+   *     baseTable: 't_order',
+   *     timeColumn: 'created_at',
+   *   },
    * });
    */
-  public getShardingCrud(
-    sqlDatabase: string,
-    sqlDbType: SqlDbType,
-    shardingConfig: IShardingConfig
-  ): ShardingCrudPro {
-    const curdPro = this.getCrudPro();
-    const sharding = new ShardingCrudPro(curdPro, shardingConfig);
+  public getShardingCrud(param: IGetShardingCrudParam): ShardingBase {
+    const { sqlDatabase, sqlDbType, shardingConfig } = param;
+    const factory = () => this.getCrudPro();
+
+    let sharding: ShardingBase;
+    switch (shardingConfig.type) {
+      case ShardingType.YEAR:
+      case ShardingType.MONTH:
+      case ShardingType.DAY:
+        sharding = new ShardingByTimeCrud(factory, shardingConfig);
+        break;
+      case ShardingType.HASH:
+        sharding = new ShardingByHashCrud(factory, shardingConfig);
+        break;
+      case ShardingType.KEY:
+        sharding = new ShardingByKeyCrud(factory, shardingConfig);
+        break;
+      case ShardingType.CUSTOM:
+        sharding = new ShardingByCustomCrud(factory, shardingConfig);
+        break;
+      default:
+        throw new Error(`[CurdProService] 不支持的分表类型: ${shardingConfig.type}`);
+    }
+
     sharding.setBaseCfg({ sqlDatabase, sqlDbType });
     return sharding;
   }
 
+  /**
+   * 根据 `method` 获取（可能来自缓存的）CRUD 配置。
+   *
+   * 适用于：你只想先拿到配置做检查/二次加工/审计，再决定是否执行。
+   * 非调试模式会启用缓存（调试模式关闭缓存）。
+   *
+   * @param method 配置方法名，例如：`user.list`
+   * @returns CRUD 配置模型
+   *
+   * @example
+   * const cfg = await curdProService.getCachedCfgByMethod('user.list');
+   * console.log(cfg.sqlSimpleName);
+   */
   public async getCachedCfgByMethod(method: string): Promise<IRequestCfgModel> {
     const curdPro = this.getCrudPro();
     const isEnableCache = !this.isEnableDebug(); // 开发环境不使用缓存
     return curdPro.getCachedCfgByMethod(method, isEnableCache);
   }
 
+  /**
+   * 获取数据库的表/视图等结构信息列表（用于数据源探测、表选择器、代码生成等场景）。
+   *
+   * @param query 查询条件（例如：指定数据库、关键字过滤、分页等）
+   * @param options 可选项（例如：是否包含视图/系统表、大小写处理等，具体以接口定义为准）
+   * @returns 表信息列表结果
+   *
+   * @example
+   * const tables = await curdProService.getAllTableInfos(
+   *   { sqlDbType: SqlDbType.mysql, sqlDatabase: 'mydb' },
+   *   { skipCache: true }
+   * );
+   */
   public async getAllTableInfos(query: ITableNamesQuery, options?: ITableNamesOptions): Promise<ITableListResult> {
     const curdPro = this.getCrudPro();
     return curdPro.getAllTableInfos(query, options);

package/src/service/flow/FlowConfigService.ts

@@ -62,7 +62,11 @@ export class FlowConfigService extends BaseService {
 
   private get flow_config(){
     const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-    return this.curdProService.getQuickCrud(SystemDbName, SystemDbType, FLOW_TABLES.flow_config)
+    return this.curdProService.getQuickCrud({
+      sqlDatabase: SystemDbName,
+      sqlDbType: SystemDbType,
+      sqlTable: FLOW_TABLES.flow_config,
+    })
   }
 
   private toCacheKey(flow_code: string, flow_version: number): string {
@@ -81,9 +85,10 @@ export class FlowConfigService extends BaseService {
       cacheKey: cacheKey,
       cacheName: CacheNameEnum.GetFlowConfigOne,
       getter: async () => {
-        return await this.flow_config.getUniqueOne({
+        const res = await this.flow_config.findUniqueOne({
           condition: {flow_code, flow_version, deleted_at: 0}
         });
+        return res.row;
       },
     });
   }