midway-fatcms 0.0.7 → 0.0.9

package/dist/service/curd/CurdProService.d.ts

@@ -1,12 +1,34 @@
 import { Context } from '@midwayjs/koa';
-import { IRequestCfgModel, IRequestModel, ISqlCfgModel, ITableListResult, ITableNamesOptions, ITableNamesQuery } from '../../libs/crud-pro/interfaces';
+import { IRequestCfgModel, IRequestModel, ISqlCfgModel, ITableListResult, ITableNamesOptions, ITableNamesQuery, ExecuteSQLResult } from '../../libs/crud-pro/interfaces';
 import { SqlDbType } from '../../libs/crud-pro/models/keys';
 import { ExecuteContext, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
 import { RelatedType } from './CurdMixUtils';
 import { BaseService } from '../base/BaseService';
 import { IRequestCfgModel2 } from '../../models/bizmodels';
-import { CrudProQuick } from './CrudProQuick';
-import { ShardingCrudPro, IShardingConfig } from '../../libs/crud-sharding';
+import { CrudProQuick } from '../../libs/crud-pro-quick';
+import { ShardingBase, IShardingConfig } from '../../libs/crud-sharding';
+/**
+ * getQuickCrud 参数接口
+ */
+export interface IGetQuickCrudParam {
+    /** 数据库名 */
+    sqlDatabase: string;
+    /** 数据库类型 */
+    sqlDbType: SqlDbType;
+    /** 表名（可选） */
+    sqlTable?: string;
+}
+/**
+ * getShardingCrud 参数接口
+ */
+export interface IGetShardingCrudParam {
+    /** 数据库名 */
+    sqlDatabase: string;
+    /** 数据库类型 */
+    sqlDbType: SqlDbType;
+    /** 分表配置 */
+    shardingConfig: IShardingConfig;
+}
 export declare class CurdProService extends BaseService {
     protected ctx: Context;
     private mysql2Config;
@@ -14,7 +36,37 @@ export declare class CurdProService extends BaseService {
     private sqlserver2Config;
     private crudProCfg;
     private responseCfgHandlers;
+    /**
+     * 注册“响应配置处理器”（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 等进行二次加工
+     *   },
+     * });
+     */
     setResponseCfgHandlers(key: RelatedType, handler: IExecuteContextHandler): void;
+    /**
+     * 获取当前已注册的“响应配置处理器”集合。
+     *
+     * 一般用于调试或在外层框架中统一检查/复用已有 handler。
+     *
+     * @returns 以 `RelatedType` 为 key 的处理器映射表
+     *
+     * @example
+     * const handlers = curdProService.getResponseCfgHandlers();
+     * const userHandler = handlers[RelatedType.USER];
+     */
     getResponseCfgHandlers(): Record<RelatedType, IExecuteContextHandler>;
     /**
      * Execute级别：每次调用都会产生新的
@@ -22,53 +74,121 @@ export declare class CurdProService extends BaseService {
      */
     private getCrudPro;
     /**
-     * 依赖缓存中与加载的配置
-     * @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);
      */
     executeCrud(reqJson: IRequestModel): Promise<ExecuteContext>;
-    executeSQL(sqlCfgModel: ISqlCfgModel): Promise<any>;
-    executeCrudByCfg(reqJson: IRequestModel, cfgModel: IRequestCfgModel2): Promise<ExecuteContext>;
     /**
-     * 获取 CrudProQuick 工具类（已废弃）
+     * 直接执行一段 SQL（不依赖 `method` 配置）。
      *
-     * @deprecated 请使用 getQuickCrud 替代
-     * @param sqlDatabase 数据库名
-     * @param sqlDbType 数据库类型
-     * @param sqlTable 表名（可选）
-     * @returns CrudProQuick 实例
+     * 适用于：后台管理/运维脚本/内部工具需要直接跑 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],
+     * });
      */
-    getBbUtil(sqlDatabase: string, sqlDbType: SqlDbType, sqlTable?: string): CrudProQuick;
+    executeSQL(sqlCfgModel: ISqlCfgModel): Promise<ExecuteSQLResult>;
+    /**
+     * 直接按指定配置执行一次 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
+     * );
+     */
+    executeCrudByCfg(reqJson: IRequestModel, cfgModel: IRequestCfgModel2): Promise<ExecuteContext>;
     /**
      * 获取 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' });
      */
-    getQuickCrud(sqlDatabase: string, sqlDbType: SqlDbType, sqlTable?: string): CrudProQuick;
+    getQuickCrud(param: IGetQuickCrudParam): CrudProQuick;
     /**
      * 获取分表 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',
+     *   },
      * });
      */
-    getShardingCrud(sqlDatabase: string, sqlDbType: SqlDbType, shardingConfig: IShardingConfig): ShardingCrudPro;
+    getShardingCrud(param: IGetShardingCrudParam): ShardingBase;
+    /**
+     * 根据 `method` 获取（可能来自缓存的）CRUD 配置。
+     *
+     * 适用于：你只想先拿到配置做检查/二次加工/审计，再决定是否执行。
+     * 非调试模式会启用缓存（调试模式关闭缓存）。
+     *
+     * @param method 配置方法名，例如：`user.list`
+     * @returns CRUD 配置模型
+     *
+     * @example
+     * const cfg = await curdProService.getCachedCfgByMethod('user.list');
+     * console.log(cfg.sqlSimpleName);
+     */
     getCachedCfgByMethod(method: string): Promise<IRequestCfgModel>;
+    /**
+     * 获取数据库的表/视图等结构信息列表（用于数据源探测、表选择器、代码生成等场景）。
+     *
+     * @param query 查询条件（例如：指定数据库、关键字过滤、分页等）
+     * @param options 可选项（例如：是否包含视图/系统表、大小写处理等，具体以接口定义为准）
+     * @returns 表信息列表结果
+     *
+     * @example
+     * const tables = await curdProService.getAllTableInfos(
+     *   { sqlDbType: SqlDbType.mysql, sqlDatabase: 'mydb' },
+     *   { skipCache: true }
+     * );
+     */
     getAllTableInfos(query: ITableNamesQuery, options?: ITableNamesOptions): Promise<ITableListResult>;
 }

package/dist/service/curd/CurdProService.js

@@ -20,11 +20,11 @@ const keys_1 = require("../../libs/crud-pro/models/keys");
 const exceptions_1 = require("../../libs/crud-pro/exceptions");
 const ExecuteContextFunc_1 = require("../../libs/crud-pro/models/ExecuteContextFunc");
 const BaseService_1 = require("../base/BaseService");
-const CrudProQuick_1 = require("./CrudProQuick");
+const crud_pro_quick_1 = require("../../libs/crud-pro-quick");
 const crud_sharding_1 = require("../../libs/crud-sharding");
 const fixCfgModel_1 = require("./fixCfgModel");
 const global_config_1 = require("../../libs/global-config/global-config");
-const fixSoftDelete_1 = require("../../service/curd/fixSoftDelete");
+const fixSoftDelete_1 = require("../../libs/crud-pro-quick/fixSoftDelete");
 function toVisitor(ctx) {
     const workbenchInfo = ctx.workbenchInfo;
     const userSession = ctx.userSession;
@@ -123,9 +123,39 @@ let CurdProService = class CurdProService extends BaseService_1.BaseService {
         super(...arguments);
         this.responseCfgHandlers = {};
     }
+    /**
+     * 注册“响应配置处理器”（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 等进行二次加工
+     *   },
+     * });
+     */
     setResponseCfgHandlers(key, handler) {
         this.responseCfgHandlers[key] = handler;
     }
+    /**
+     * 获取当前已注册的“响应配置处理器”集合。
+     *
+     * 一般用于调试或在外层框架中统一检查/复用已有 handler。
+     *
+     * @returns 以 `RelatedType` 为 key 的处理器映射表
+     *
+     * @example
+     * const handlers = curdProService.getResponseCfgHandlers();
+     * const userHandler = handlers[RelatedType.USER];
+     */
     getResponseCfgHandlers() {
         return this.responseCfgHandlers;
     }
@@ -153,8 +183,21 @@ let CurdProService = class CurdProService extends BaseService_1.BaseService {
         return crudPro;
     }
     /**
-     * 依赖缓存中与加载的配置
-     * @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) {
         if (!reqJson.method) {
@@ -165,77 +208,153 @@ let CurdProService = class CurdProService extends BaseService_1.BaseService {
         const isEnableCache = !this.isEnableDebug();
         return curdPro.executeCrud(reqJson, isEnableCache);
     }
-    // 直接执行一个SQL
+    /**
+     * 直接执行一段 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],
+     * });
+     */
     async executeSQL(sqlCfgModel) {
         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
+     * );
+     */
     async executeCrudByCfg(reqJson, cfgModel) {
         this.logInfo('executeCrudByCfg', cfgModel);
         const curdPro = this.getCrudPro();
         // 应用标准的updateCfg。
         (0, fixCfgModel_1.fixCfgModel)(cfgModel);
         // 应用软删除动作。
-        (0, fixSoftDelete_1.fixSoftDelete)(cfgModel.sqlSimpleName, cfgModel, reqJson, this.ctx);
+        (0, fixSoftDelete_1.fixSoftDelete)(cfgModel.sqlSimpleName, cfgModel, reqJson, curdPro.getVisitor());
         return await curdPro.executeCrudByCfg(reqJson, cfgModel);
     }
-    /**
-     * 获取 CrudProQuick 工具类（已废弃）
-     *
-     * @deprecated 请使用 getQuickCrud 替代
-     * @param sqlDatabase 数据库名
-     * @param sqlDbType 数据库类型
-     * @param sqlTable 表名（可选）
-     * @returns CrudProQuick 实例
-     */
-    getBbUtil(sqlDatabase, sqlDbType, sqlTable) {
-        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' });
      */
-    getQuickCrud(sqlDatabase, sqlDbType, sqlTable) {
-        const curdPro = this.getCrudPro();
-        return new CrudProQuick_1.CrudProQuick({ curdPro, sqlDatabase, sqlDbType, sqlTable, ctx: this.ctx });
+    getQuickCrud(param) {
+        const { sqlDatabase, sqlDbType, sqlTable } = param;
+        // 传入工厂函数，每次需要时创建新的 CrudPro 实例
+        return new crud_pro_quick_1.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',
+     *   },
      * });
      */
-    getShardingCrud(sqlDatabase, sqlDbType, shardingConfig) {
-        const curdPro = this.getCrudPro();
-        const sharding = new crud_sharding_1.ShardingCrudPro(curdPro, shardingConfig);
+    getShardingCrud(param) {
+        const { sqlDatabase, sqlDbType, shardingConfig } = param;
+        const factory = () => this.getCrudPro();
+        let sharding;
+        switch (shardingConfig.type) {
+            case crud_sharding_1.ShardingType.YEAR:
+            case crud_sharding_1.ShardingType.MONTH:
+            case crud_sharding_1.ShardingType.DAY:
+                sharding = new crud_sharding_1.ShardingByTimeCrud(factory, shardingConfig);
+                break;
+            case crud_sharding_1.ShardingType.HASH:
+                sharding = new crud_sharding_1.ShardingByHashCrud(factory, shardingConfig);
+                break;
+            case crud_sharding_1.ShardingType.KEY:
+                sharding = new crud_sharding_1.ShardingByKeyCrud(factory, shardingConfig);
+                break;
+            case crud_sharding_1.ShardingType.CUSTOM:
+                sharding = new crud_sharding_1.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);
+     */
     async getCachedCfgByMethod(method) {
         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 }
+     * );
+     */
     async getAllTableInfos(query, options) {
         const curdPro = this.getCrudPro();
         return curdPro.getAllTableInfos(query, options);

package/dist/service/flow/FlowConfigService.js

@@ -47,7 +47,11 @@ exports.ParsedFlowConfig = ParsedFlowConfig;
 let FlowConfigService = class FlowConfigService extends BaseService_1.BaseService {
     get flow_config() {
         const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
-        return this.curdProService.getQuickCrud(SystemDbName, SystemDbType, FlowModel_1.FLOW_TABLES.flow_config);
+        return this.curdProService.getQuickCrud({
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+            sqlTable: FlowModel_1.FLOW_TABLES.flow_config,
+        });
     }
     toCacheKey(flow_code, flow_version) {
         if (!flow_code || typeof flow_code !== 'string') {
@@ -64,9 +68,10 @@ let FlowConfigService = class FlowConfigService extends BaseService_1.BaseServic
             cacheKey: cacheKey,
             cacheName: bizmodels_1.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;
             },
         });
     }

package/dist/service/flow/FlowInstanceCrudService.js

@@ -23,7 +23,10 @@ exports.getCurrentDateTime = getCurrentDateTime;
 let FlowInstanceCrudService = class FlowInstanceCrudService extends BaseService_1.BaseService {
     get flowDB() {
         const { FlowDbName, FlowDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
-        const util = this.curdProService.getQuickCrud(FlowDbName, FlowDbType);
+        const util = this.curdProService.getQuickCrud({
+            sqlDatabase: FlowDbName,
+            sqlDbType: FlowDbType,
+        });
         util.setBaseCfgModel({ maxLimit: 100000 });
         return util;
     }
@@ -67,7 +70,7 @@ let FlowInstanceCrudService = class FlowInstanceCrudService extends BaseService_
             modified_at: getCurrentDateTime(),
             deleted_at: 0,
         };
-        const nodeInstanceId = await this.flowDB.insertObject({
+        const nodeInstanceId = await this.flowDB.insert({
             data: nodeInstance,
         }, FlowModel_1.FLOW_TABLES.flow_instance_node);
         nodeInstance.id = nodeInstanceId.insertId;
@@ -89,7 +92,7 @@ let FlowInstanceCrudService = class FlowInstanceCrudService extends BaseService_
             modified_at: getCurrentDateTime(),
             deleted_at: 0,
         };
-        const taskInstanceId = await this.flowDB.insertObject({
+        const taskInstanceId = await this.flowDB.insert({
             data: taskInstance,
         }, FlowModel_1.FLOW_TABLES.flow_instance_task);
         taskInstance.id = taskInstanceId.insertId;
@@ -99,7 +102,7 @@ let FlowInstanceCrudService = class FlowInstanceCrudService extends BaseService_
         if (updateNodeInstance.id) {
             updateNodeInstance.modified_by = this.getCurrentUserAccountId();
             updateNodeInstance.modified_at = getCurrentDateTime();
-            await this.flowDB.updateObject({
+            await this.flowDB.update({
                 condition: {
                     id: updateNodeInstance.id,
                 },
@@ -110,7 +113,7 @@ let FlowInstanceCrudService = class FlowInstanceCrudService extends BaseService_
         else {
             updateNodeInstance.created_by = this.getCurrentUserAccountId();
             updateNodeInstance.created_at = getCurrentDateTime();
-            const res = await this.flowDB.insertObject({
+            const res = await this.flowDB.insert({
                 data: updateNodeInstance,
             }, FlowModel_1.FLOW_TABLES.flow_instance_node);
             return res.insertId || '';
@@ -124,7 +127,7 @@ let FlowInstanceCrudService = class FlowInstanceCrudService extends BaseService_
         if (taskInstance.id) {
             taskInstance.modified_by = this.getCurrentUserAccountId();
             taskInstance.modified_at = getCurrentDateTime();
-            await this.flowDB.updateObject({
+            await this.flowDB.update({
                 condition: {
                     id: taskInstance.id,
                 },
@@ -135,7 +138,7 @@ let FlowInstanceCrudService = class FlowInstanceCrudService extends BaseService_
         else {
             taskInstance.created_by = this.getCurrentUserAccountId();
             taskInstance.created_at = getCurrentDateTime();
-            const res = await this.flowDB.insertObject({
+            const res = await this.flowDB.insert({
                 data: taskInstance,
             }, FlowModel_1.FLOW_TABLES.flow_instance_task);
             return res.insertId || '';
@@ -155,7 +158,7 @@ let FlowInstanceCrudService = class FlowInstanceCrudService extends BaseService_
         if (flowInstance.id) {
             flowInstance.modified_by = this.getCurrentUserAccountId();
             flowInstance.modified_at = getCurrentDateTime();
-            await this.flowDB.updateObject({
+            await this.flowDB.update({
                 condition: {
                     id: flowInstance.id,
                 },
@@ -166,7 +169,7 @@ let FlowInstanceCrudService = class FlowInstanceCrudService extends BaseService_
         else {
             flowInstance.created_by = this.getCurrentUserAccountId();
             flowInstance.created_at = getCurrentDateTime();
-            const res = await this.flowDB.insertObject({
+            const res = await this.flowDB.insert({
                 data: flowInstance,
             }, FlowModel_1.FLOW_TABLES.flow_instance);
             return res.insertId || '';
@@ -186,10 +189,10 @@ let FlowInstanceCrudService = class FlowInstanceCrudService extends BaseService_
         else {
             throw new Error('flow_instance_id is required');
         }
-        const res = await this.flowDB.getUniqueOne({
+        const res = await this.flowDB.findUniqueOne({
             condition: condition,
         }, FlowModel_1.FLOW_TABLES.flow_instance_node);
-        return res;
+        return res.row;
     }
     async getFlowInstance(flow_instance_id, ticket_no) {
         const condition = {};
@@ -202,10 +205,10 @@ let FlowInstanceCrudService = class FlowInstanceCrudService extends BaseService_
         if (Object.keys(condition).length === 0) {
             throw new Error('flow_instance_id or ticket_no is required');
         }
-        const res = await this.flowDB.getUniqueOne({
+        const res = await this.flowDB.findUniqueOne({
             condition: condition,
         }, FlowModel_1.FLOW_TABLES.flow_instance);
-        return res;
+        return res.row;
     }
     async getTaskInstance(task_instance_id) {
         const condition = {};
@@ -215,10 +218,10 @@ let FlowInstanceCrudService = class FlowInstanceCrudService extends BaseService_
         if (Object.keys(condition).length === 0) {
             throw new Error('task_instance_id is required');
         }
-        const res = await this.flowDB.getUniqueOne({
+        const res = await this.flowDB.findUniqueOne({
             condition: condition,
         }, FlowModel_1.FLOW_TABLES.flow_instance_task);
-        return res;
+        return res.row;
     }
     async getTaskInstanceListByFlowInstanceId(flow_instance_id) {
         const condition = {};
@@ -228,10 +231,10 @@ let FlowInstanceCrudService = class FlowInstanceCrudService extends BaseService_
         if (Object.keys(condition).length === 0) {
             throw new Error('flow_instance_id is required');
         }
-        const res = await this.flowDB.getList({
+        const res = await this.flowDB.findList({
             condition: condition,
         }, FlowModel_1.FLOW_TABLES.flow_instance_task);
-        return res;
+        return res.rows;
     }
     async getNodeInstanceListByFlowInstanceId(flowInstanceId) {
         const condition = {};
@@ -241,10 +244,10 @@ let FlowInstanceCrudService = class FlowInstanceCrudService extends BaseService_
         if (Object.keys(condition).length === 0) {
             throw new Error('flowInstanceId is required');
         }
-        const res = await this.flowDB.getList({
+        const res = await this.flowDB.findList({
             condition: condition,
         }, FlowModel_1.FLOW_TABLES.flow_instance_node);
-        return res;
+        return res.rows;
     }
 };
 __decorate([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "midway-fatcms",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "This is a midway component sample",
   "main": "dist/index.js",
   "typings": "index.d.ts",