midway-fatcms 0.0.7 → 0.0.9

package/dist/configuration.js

@@ -27,6 +27,8 @@ const global_middleware_1 = require("./middleware/global.middleware");
 const forbidden_middleware_1 = require("./middleware/forbidden.middleware");
 const schedule_1 = require("./schedule");
 const crypto_utils_1 = require("./libs/utils/crypto-utils");
+const TableMetaCacheRedisSubscriber_1 = require("./service/TableMetaCacheRedisSubscriber");
+const redis_1 = require("@midwayjs/redis");
 let ContainerLifeCycle = class ContainerLifeCycle {
     async onConfigLoad() {
         const config = this.app.getConfig();
@@ -53,6 +55,10 @@ let ContainerLifeCycle = class ContainerLifeCycle {
          * 让ANONYMOUS_CONTEXT获取app对象
          */
         schedule_1.ANONYMOUS_CONTEXT.setApp(this.app);
+        /**
+         * 初始化表元数据缓存 Redis 广播
+         */
+        await this.initTableMetaCacheRedis();
         /**
          * 启动定时任务
          */
@@ -63,6 +69,26 @@ let ContainerLifeCycle = class ContainerLifeCycle {
         // add filter
         // this.app.useFilter([NotFoundFilter, DefaultErrorFilter]);
     }
+    /**
+     * 初始化表元数据缓存的 Redis Pub/Sub 广播
+     *
+     * - 发布客户端：复用已有的 RedisService 实例
+     * - 订阅客户端：通过 duplicate() 创建独立连接
+     *
+     * 集群部署时，任意节点调用 clearTableMetaCacheWithBroadcast()
+     * 会通过 Redis 广播通知所有节点清空本地缓存。
+     */
+    async initTableMetaCacheRedis() {
+        try {
+            const redisService = await this.app.getApplicationContext().getAsync(redis_1.RedisService);
+            (0, TableMetaCacheRedisSubscriber_1.initTableMetaCachePublishClient)(redisService);
+            (0, TableMetaCacheRedisSubscriber_1.initTableMetaCacheSubscriber)(redisService);
+        }
+        catch (e) {
+            // Redis 未配置或不可用时，降级为单节点模式（仅清空本地缓存）
+            this.app.getLogger().warn('ContainerLifeCycle ==> initTableMetaCacheRedis Redis不可用，降级为单节点模式:', e.message);
+        }
+    }
     async startScheduleOnReady() {
         const logger = this.app.getLogger();
         const config = this.app.getConfig();

package/dist/controller/base/BaseApiController.d.ts

@@ -33,7 +33,7 @@ export declare class BaseApiController extends BaseService {
      */
     protected checkUserActionTimeLimit(actionCode: string, limitSecond?: number): Promise<void>;
     protected getUserSessionInfo(): import("../../models/userSession").ISessionInfo;
-    executeSysSQL(executeSql: string, executeSqlArgs: any[]): Promise<any>;
+    executeSysSQL(executeSql: string, executeSqlArgs: any[]): Promise<import("../../libs/crud-pro/interfaces").ExecuteSQLResult<Record<string, any>>>;
     /**
      * 查询sys表中的SQL语句。sys表的表结构都是标准的。
      * @param sqlTable
@@ -42,7 +42,6 @@ export declare class BaseApiController extends BaseService {
      * @protected
      */
     protected executeSysSimpleSQL(sqlTable: string, sqlSimpleName: KeysOfSimpleSQL, extParams?: IExecuteSimpleSqlParams): Promise<import("../../libs/crud-pro/models/ExecuteContext").ExecuteContext>;
-    protected get sysDBUtil(): import("../..").CrudProQuick;
     private addAccountBasicInfoCfgModel;
     private addWorkbenchBasicInfoCfgModel;
     protected decodeBodyBySession<T>(body: any): Promise<any>;

package/dist/controller/base/BaseApiController.js

@@ -89,10 +89,6 @@ let BaseApiController = class BaseApiController extends BaseService_1.BaseServic
         }
         return await this.curdMixService.executeCrudByCfg(body, cfgModel);
     }
-    get sysDBUtil() {
-        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
-        return this.curdMixService.getBbUtil(SystemDbName, SystemDbType);
-    }
     addAccountBasicInfoCfgModel(cfgModel) {
         let columnsRelation = cfgModel.columnsRelation;
         if (!columnsRelation) {

package/dist/controller/gateway/DocGatewayController.js

@@ -106,7 +106,7 @@ let DocGatewayController = class DocGatewayController extends BaseApiController_
             condition: {
                 doc_lib_id: parseInt(docLibId),
                 doc_category_code: {
-                    $notNull: '',
+                    $notNull: true,
                 },
             },
         }, {

package/dist/controller/helpers.controller.d.ts

@@ -32,5 +32,11 @@ export declare class HelpersApi {
      * @param queryData
      */
     cryptoAes128CBC(queryData: any): Promise<CommonResult>;
+    /**
+     * 工具函数: 清空表元数据缓存（集群广播）
+     * 清空本节点缓存，并通过 Redis Pub/Sub 广播通知集群中其他节点。
+     * 清空后，下次请求会自动从数据库重新加载（懒加载刷新）。
+     */
+    clearTableMetaCacheApi(): Promise<CommonResult>;
     private checkLocalPermissionEnv;
 }

package/dist/controller/helpers.controller.js

@@ -21,6 +21,7 @@ const functions_1 = require("../libs/utils/functions");
 const crypto_utils_1 = require("../libs/utils/crypto-utils");
 const common_dto_1 = require("../libs/utils/common-dto");
 const SystemPerm_1 = require("../models/SystemPerm");
+const TableMetaCacheRedisSubscriber_1 = require("../service/TableMetaCacheRedisSubscriber");
 // http://127.0.0.1:7002/ns/api/helpers/getApiScript?prefix=/ns/api/manage
 // http://127.0.0.1:7002/ns/api/helpers/getApiScript
 // http://127.0.0.1:7002/ns/api/helpers/getApiEnv
@@ -124,6 +125,18 @@ let HelpersApi = class HelpersApi {
             isEqual: input === decrypted,
         });
     }
+    /**
+     * 工具函数: 清空表元数据缓存（集群广播）
+     * 清空本节点缓存，并通过 Redis Pub/Sub 广播通知集群中其他节点。
+     * 清空后，下次请求会自动从数据库重新加载（懒加载刷新）。
+     */
+    async clearTableMetaCacheApi() {
+        const stats = (0, TableMetaCacheRedisSubscriber_1.clearTableMetaCacheWithBroadcast)();
+        return common_dto_1.CommonResult.successRes({
+            message: '表元数据缓存已清空（已广播集群）',
+            beforeClear: stats,
+        });
+    }
     checkLocalPermissionEnv() {
         //是否是开发者
         const isDevelopUser = () => {
@@ -181,6 +194,12 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], HelpersApi.prototype, "cryptoAes128CBC", null);
+__decorate([
+    (0, core_1.Get)('/clearTableMetaCache'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HelpersApi.prototype, "clearTableMetaCacheApi", null);
 HelpersApi = __decorate([
     (0, core_1.Controller)('/ns/api/helpers')
 ], HelpersApi);

package/dist/controller/manage/FlowConfigManageApi.js

@@ -40,7 +40,8 @@ let FlowConfigManageApi = class FlowConfigManageApi extends BaseApiController_1.
     }
     async updateFlowConfig() {
         const body = this.ctx.request.body;
-        const { flow_code, flow_version } = body.condition;
+        const flow_code = String(body.condition.flow_code);
+        const flow_version = Number(body.condition.flow_version);
         await this.flowConfigService.remove_cache_flow_config_one(flow_code, flow_version);
         return this.executeSysSimpleSQL(FlowModel_1.FLOW_TABLES.flow_config, keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE, {
             enableSoftDelete: true,
@@ -53,7 +54,8 @@ let FlowConfigManageApi = class FlowConfigManageApi extends BaseApiController_1.
     }
     async deleteFlowConfig() {
         const body = this.ctx.request.body;
-        const { flow_code, flow_version } = body.condition;
+        const flow_code = String(body.condition.flow_code);
+        const flow_version = Number(body.condition.flow_version);
         await this.flowConfigService.remove_cache_flow_config_one(flow_code, flow_version);
         return this.executeSysSimpleSQL(FlowModel_1.FLOW_TABLES.flow_config, keys_1.KeysOfSimpleSQL.SIMPLE_DELETE, {
             enableSoftDelete: true,

package/dist/controller/manage/SysConfigMangeApi.js

@@ -55,7 +55,12 @@ let SysConfigMangeApi = class SysConfigMangeApi extends BaseApiController_1.Base
         if (!id) {
             return common_dto_1.CommonResult.errorRes('id不能为空');
         }
-        const sysConfig = await this.curdMixService.getBbUtil(SystemDbName, SystemDbType).getUniqueOne({ condition: body.condition }, SystemTables_1.SystemTables.sys_configs);
+        const sysConfigRes = await this.curdMixService.getQuickCrud({
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+            sqlTable: SystemTables_1.SystemTables.sys_configs,
+        }).findOne({ condition: body.condition });
+        const sysConfig = sysConfigRes.row;
         if (!sysConfig) {
             return common_dto_1.CommonResult.errorRes('配置项不存在');
         }

package/dist/controller/manage/UserAccountManageApi.js

@@ -50,9 +50,14 @@ let UserAccountManageApi = class UserAccountManageApi extends BaseApiController_
         if (!id) {
             return common_dto_1.CommonResult.errorRes('id不能为空');
         }
-        const userAccountInfo = await this.curdMixService.getBbUtil(SystemDbName, SystemDbType).getUniqueOne({
+        const userAccountInfoRes = await this.curdMixService.getQuickCrud({
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+            sqlTable: SystemTables_1.SystemTables.sys_user_account,
+        }).findUniqueOne({
             condition: body.condition
-        }, SystemTables_1.SystemTables.sys_user_account);
+        });
+        const userAccountInfo = userAccountInfoRes.row;
         if (!userAccountInfo) {
             return common_dto_1.CommonResult.errorRes('用户信息不存在');
         }

package/dist/index.d.ts

@@ -70,7 +70,7 @@ export * from './service/curd/CurdMixByWorkbenchService';
 export * from './service/curd/CurdMixService';
 export * from './service/curd/CurdMixUtils';
 export * from './service/curd/CurdProService';
-export * from './service/curd/CrudProQuick';
+export * from './libs/crud-pro-quick';
 export * from './service/flow/FlowConfigService';
 export * from './service/flow/FlowInstanceService';
 export * from './service/flow/FlowInstanceCrudService';
@@ -87,7 +87,6 @@ export * from './models/contextLogger';
 export * from './models/devops';
 export * from './models/SystemTables';
 export * from './models/AsyncTaskModel';
-export * from './models/StandardColumns';
 export * from './schedule/index';
 export * from './libs/utils/common-dto';
 export * from './libs/utils/crypto-utils';
@@ -110,4 +109,5 @@ export * from './libs/crud-pro/models/RequestCfgModel';
 export * from './libs/crud-pro/models/SqlSegArg';
 export * from './libs/crud-pro/models/ResModel';
 export * from './libs/crud-sharding/index';
+export * from './libs/crud-pro-quick/index';
 export * from './libs/global-config/global-config';

package/dist/index.js

@@ -88,7 +88,7 @@ __exportStar(require("./service/curd/CurdMixByWorkbenchService"), exports);
 __exportStar(require("./service/curd/CurdMixService"), exports);
 __exportStar(require("./service/curd/CurdMixUtils"), exports);
 __exportStar(require("./service/curd/CurdProService"), exports);
-__exportStar(require("./service/curd/CrudProQuick"), exports);
+__exportStar(require("./libs/crud-pro-quick"), exports);
 __exportStar(require("./service/flow/FlowConfigService"), exports);
 __exportStar(require("./service/flow/FlowInstanceService"), exports);
 __exportStar(require("./service/flow/FlowInstanceCrudService"), exports);
@@ -105,7 +105,6 @@ __exportStar(require("./models/contextLogger"), exports);
 __exportStar(require("./models/devops"), exports);
 __exportStar(require("./models/SystemTables"), exports);
 __exportStar(require("./models/AsyncTaskModel"), exports);
-__exportStar(require("./models/StandardColumns"), exports);
 __exportStar(require("./schedule/index"), exports);
 __exportStar(require("./libs/utils/common-dto"), exports);
 __exportStar(require("./libs/utils/crypto-utils"), exports);
@@ -128,4 +127,5 @@ __exportStar(require("./libs/crud-pro/models/RequestCfgModel"), exports);
 __exportStar(require("./libs/crud-pro/models/SqlSegArg"), exports);
 __exportStar(require("./libs/crud-pro/models/ResModel"), exports);
 __exportStar(require("./libs/crud-sharding/index"), exports);
+__exportStar(require("./libs/crud-pro-quick/index"), exports);
 __exportStar(require("./libs/global-config/global-config"), exports);

package/dist/libs/crud-pro/CrudPro.d.ts

@@ -1,21 +1,36 @@
-import { ICrudProCfg, ILogger, IRequestCfgModel, IRequestModel, ISqlCfgModel, ITableListResult, ITableNamesOptions, ITableNamesQuery, IVisitor } from './interfaces';
+import { ICrudProCfg, ILogger, IRequestCfgModel, IRequestModel, ISqlCfgModel, ITableListResult, ITableMetaQuery, ITableNamesOptions, ITableNamesQuery, IVisitor, ExecuteSQLResult } from './interfaces';
 import { ExecuteContext } from './models/ExecuteContext';
 import { Transaction } from './models/Transaction';
 import { IExecuteContextFunc } from './models/ExecuteContextFunc';
 declare class CrudPro {
     private readonly executeContext;
     private readonly serviceHub;
+    /** 标记是否已被使用（防止重复使用导致状态污染） */
+    private _isUsed;
+    /** 标记是否正在执行中（防止并发调用） */
+    private _isExecuting;
     constructor();
+    /**
+     * 检查是否可以开始执行
+     * @throws 如果已使用或正在执行中则抛出异常
+     */
+    private checkAndMarkExecuting;
+    /**
+     * 标记执行完成
+     */
+    private markExecutionComplete;
     set transaction(transaction: Transaction);
     set logger(logger: ILogger);
     set visitor(visitor: IVisitor);
+    getVisitor(): IVisitor;
     set contextFunc(contextFunc: IExecuteContextFunc);
     set contextCfg(contextCfg: ICrudProCfg);
     /**
      * 直接执行一个SQL
      * @param sqlCfgModel
+     * @returns 返回未被包装的数据库原始结果（根据 resPicker 配置返回不同类型，无 {code, data, message} 包装层）
      */
-    executeSQL(sqlCfgModel: ISqlCfgModel): Promise<any>;
+    executeSQL(sqlCfgModel: ISqlCfgModel): Promise<ExecuteSQLResult>;
     /**
      * 从DB中读取配置
      * @param reqJson
@@ -28,8 +43,24 @@ declare class CrudPro {
      * @param cfgJson
      */
     executeCrudByCfg(reqJson: IRequestModel, cfgJson: IRequestCfgModel): Promise<ExecuteContext>;
+    /**
+     * 内部执行方法（不含检查逻辑，供内部调用）
+     * @param reqJson
+     * @param cfgJson
+     */
+    private executeCrudByCfgInternal;
     getCachedCfgByMethod(method: string, isEnableCache: boolean): Promise<IRequestCfgModel>;
     getAllTableInfos(query: ITableNamesQuery, options?: ITableNamesOptions): Promise<ITableListResult>;
+    /**
+     * 获取表的主键列名列表
+     *
+     * 复用 CrudProTableMetaService 的 getTableMeta 缓存，
+     * 从 columnDetails 中筛选 isPrimaryKey 的列。
+     *
+     * @param query 表元数据查询参数
+     * @returns 主键列名数组
+     */
+    getPrimaryKeyColumns(query: ITableMetaQuery): Promise<string[]>;
     /**
      * 如果是 INSERT/UPDATE 操作（sqlSimpleName 模式），根据真实表结构过滤 reqModel.data 中的字段
      * 避免传入不存在的字段导致 SQL 执行报错
@@ -38,6 +69,16 @@ declare class CrudPro {
      * @param cfgModel 配置模型
      */
     private filterDataByTableMetaIfNeeded;
+    /**
+     * 校验特定操作的必填参数
+     *
+     * - insertOrUpdate 和 update：condition 和 data 均为必填
+     * - insertOnDuplicateUpdate 和 insert：只有data 为必填
+     * @param reqModel 请求模型
+     * @param cfgModel 配置模型
+     * @throws CommonException 如果缺少必填参数
+     */
+    private validateParamsIfNeeded;
     /**
      * 判断 sqlSimpleName 是否为 INSERT/UPDATE 类型
      * @param sqlSimpleName 简单 SQL 名称
@@ -45,12 +86,19 @@ declare class CrudPro {
      */
     private isSimpleInsertOrUpdateType;
     /**
-     * 根据表结构字段类型，自动转换数据格式
+     * 根据表结构字段类型，自动转换 data 数据格式
      * 例如：PostgreSQL 的 ARRAY 类型字段，需要将 JSON 数组转为 PG 数组字面量格式
      * @param reqModel 请求模型
      * @param cfgModel 配置模型
      */
     private convertDataFieldTypeIfNeeded;
+    /**
+     * 查询时：根据表结构字段类型，自动转换 condition 数据格式
+     * 防止数据库隐式类型转换导致索引失效（如 WHERE int_col = '123' 导致索引无法命中）
+     * @param reqModel 请求模型
+     * @param cfgModel 配置模型
+     */
+    private convertConditionTypeIfNeeded;
     private executeSQLList;
     private parseRunSqlException;
     private afterExecuteSQLList;

package/dist/libs/crud-pro/CrudPro.js

@@ -10,9 +10,35 @@ const MixinUtils_1 = require("./utils/MixinUtils");
 const keys_1 = require("./models/keys");
 class CrudPro {
     constructor() {
+        /** 标记是否已被使用（防止重复使用导致状态污染） */
+        this._isUsed = false;
+        /** 标记是否正在执行中（防止并发调用） */
+        this._isExecuting = false;
         this.executeContext = new ExecuteContext_1.ExecuteContext();
         this.serviceHub = new CurdProServiceHub_1.CurdProServiceHub(this.executeContext);
     }
+    /**
+     * 检查是否可以开始执行
+     * @throws 如果已使用或正在执行中则抛出异常
+     */
+    checkAndMarkExecuting() {
+        if (this._isUsed) {
+            throw new Error('[CrudPro] 此实例已被使用，不能重复使用。' +
+                '每次操作请创建新的 CrudPro 实例，可通过 curdProService.getCrudPro() 或工厂函数获取。');
+        }
+        if (this._isExecuting) {
+            throw new Error('[CrudPro] 此实例正在执行中，不能并发调用。' +
+                '请等待当前操作完成后再进行下一次调用，或创建新的实例。');
+        }
+        this._isExecuting = true;
+    }
+    /**
+     * 标记执行完成
+     */
+    markExecutionComplete() {
+        this._isExecuting = false;
+        this._isUsed = true;
+    }
     // 必填
     set transaction(transaction) {
         this.executeContext.setTransaction(transaction);
@@ -25,6 +51,10 @@ class CrudPro {
     set visitor(visitor) {
         this.executeContext.setVisitor(visitor);
     }
+    // 必填
+    getVisitor() {
+        return this.executeContext.getVisitor();
+    }
     set contextFunc(contextFunc) {
         contextFunc.setExecuteContext(this.executeContext);
         this.executeContext.contextFunc = contextFunc;
@@ -35,8 +65,10 @@ class CrudPro {
     /**
      * 直接执行一个SQL
      * @param sqlCfgModel
+     * @returns 返回未被包装的数据库原始结果（根据 resPicker 配置返回不同类型，无 {code, data, message} 包装层）
      */
     async executeSQL(sqlCfgModel) {
+        this.checkAndMarkExecuting();
         const RES_NAME = 'executeResult';
         const sqlCfgModel2 = {
             resName: RES_NAME,
@@ -53,8 +85,13 @@ class CrudPro {
             sqlDatabase: sqlCfgModel.sqlDatabase,
             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();
+        }
     }
     /**
      * 从DB中读取配置
@@ -74,6 +111,20 @@ class CrudPro {
      * @param cfgJson
      */
     async executeCrudByCfg(reqJson, cfgJson) {
+        this.checkAndMarkExecuting();
+        try {
+            return await this.executeCrudByCfgInternal(reqJson, cfgJson);
+        }
+        finally {
+            this.markExecutionComplete();
+        }
+    }
+    /**
+     * 内部执行方法（不含检查逻辑，供内部调用）
+     * @param reqJson
+     * @param cfgJson
+     */
+    async executeCrudByCfgInternal(reqJson, cfgJson) {
         const logger = this.executeContext.getLogger();
         logger.info('CurdPro executeCrudByCfg', cfgJson);
         // 在执行之前可以根据业务需要修改需要执行的内容。
@@ -87,10 +138,14 @@ class CrudPro {
         const cfgModel = new RequestCfgModel_1.RequestCfgModel(cfgJson);
         exeCtx.setReqModel(reqModel);
         exeCtx.setCfgModel(cfgModel);
+        // insertOrUpdate 参数校验
+        this.validateParamsIfNeeded(reqModel, cfgModel);
         // 如果是 sqlSimpleName模式的 update/insert，则需要将 reqJson.data 部分根据真实的表结构进行过滤
         await this.filterDataByTableMetaIfNeeded(reqModel, cfgModel);
-        // 根据表结构字段类型，自动转换数据格式（如 PostgreSQL ARRAY 字段）
+        //插入和更新时： 根据表结构字段类型，自动转换 data 数据格式（如 PostgreSQL ARRAY 字段）
         await this.convertDataFieldTypeIfNeeded(reqModel, cfgModel);
+        //查询时：根据表结构字段类型，自动转换 condition 数据格式（防止数据库隐式类型转换导致索引失效）
+        await this.convertConditionTypeIfNeeded(reqModel, cfgModel);
         // 参数校验
         this.serviceHub.validateDataType(cfgModel, reqModel);
         this.serviceHub.validateByAllow(cfgModel, reqModel);
@@ -124,6 +179,18 @@ class CrudPro {
     async getAllTableInfos(query, options) {
         return this.serviceHub.getAllTableInfos(query, options);
     }
+    /**
+     * 获取表的主键列名列表
+     *
+     * 复用 CrudProTableMetaService 的 getTableMeta 缓存，
+     * 从 columnDetails 中筛选 isPrimaryKey 的列。
+     *
+     * @param query 表元数据查询参数
+     * @returns 主键列名数组
+     */
+    async getPrimaryKeyColumns(query) {
+        return this.serviceHub.getPrimaryKeyColumns(query);
+    }
     /**
      * 如果是 INSERT/UPDATE 操作（sqlSimpleName 模式），根据真实表结构过滤 reqModel.data 中的字段
      * 避免传入不存在的字段导致 SQL 执行报错
@@ -168,6 +235,37 @@ class CrudPro {
         // 直接修改 reqModel.data，只保留表中存在的字段
         reqModel.data = filteredData;
     }
+    /**
+     * 校验特定操作的必填参数
+     *
+     * - insertOrUpdate 和 update：condition 和 data 均为必填
+     * - insertOnDuplicateUpdate 和 insert：只有data 为必填
+     * @param reqModel 请求模型
+     * @param cfgModel 配置模型
+     * @throws CommonException 如果缺少必填参数
+     */
+    validateParamsIfNeeded(reqModel, cfgModel) {
+        // insertOrUpdate 和 update：condition 和 data 均为必填
+        if (cfgModel.sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE ||
+            cfgModel.sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE) {
+            if (!reqModel.condition || Object.keys(reqModel.condition).length === 0) {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.INSERT_OR_UPDATE_CONDITION_EMPTY, '[CrudPro] insertOrUpdate/update 操作的 condition 不能为空。' +
+                    'condition 用于判断记录是否存在或定位更新目标。');
+            }
+            if (!reqModel.data || Object.keys(reqModel.data).length === 0) {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.INSERT_OR_UPDATE_DATA_EMPTY, '[CrudPro] insertOrUpdate/update 操作的 data 不能为空。' +
+                    'data 用于指定插入或更新的内容。');
+            }
+        }
+        // insertOnDuplicateUpdate 和 insert：只有 data 为必填
+        if (cfgModel.sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_ON_DUPLICATE_UPDATE ||
+            cfgModel.sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_INSERT) {
+            if (!reqModel.data || Object.keys(reqModel.data).length === 0) {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.INSERT_OR_DUPLICATE_UPDATE_DATA_EMPTY, '[CrudPro] insert/insertOnDuplicateUpdate 操作的 data 不能为空。' +
+                    'data 用于指定插入或更新的内容。');
+            }
+        }
+    }
     /**
      * 判断 sqlSimpleName 是否为 INSERT/UPDATE 类型
      * @param sqlSimpleName 简单 SQL 名称
@@ -183,7 +281,7 @@ class CrudPro {
         return insertOrUpdateTypes.includes(sqlSimpleName);
     }
     /**
-     * 根据表结构字段类型，自动转换数据格式
+     * 根据表结构字段类型，自动转换 data 数据格式
      * 例如：PostgreSQL 的 ARRAY 类型字段，需要将 JSON 数组转为 PG 数组字面量格式
      * @param reqModel 请求模型
      * @param cfgModel 配置模型
@@ -191,6 +289,15 @@ class CrudPro {
     async convertDataFieldTypeIfNeeded(reqModel, cfgModel) {
         await this.serviceHub.convertDataTypeByTableMeta(reqModel, cfgModel);
     }
+    /**
+     * 查询时：根据表结构字段类型，自动转换 condition 数据格式
+     * 防止数据库隐式类型转换导致索引失效（如 WHERE int_col = '123' 导致索引无法命中）
+     * @param reqModel 请求模型
+     * @param cfgModel 配置模型
+     */
+    async convertConditionTypeIfNeeded(reqModel, cfgModel) {
+        await this.serviceHub.convertConditionTypeByTableMeta(reqModel, cfgModel);
+    }
     async executeSQLList() {
         try {
             await this.serviceHub.executeSqlCfgModels();

package/dist/libs/crud-pro/exceptions.d.ts

@@ -56,6 +56,12 @@ export declare enum Exceptions {
     DATA_GET_DATA_EMPTY_ON_INSERT_KEYS = "DATA_GET_DATA_EMPTY_ON_INSERT_KEYS",
     DATA_GET_DATA_EMPTY_ON_INSERT_VALUES = "DATA_GET_DATA_EMPTY_ON_INSERT_VALUES",
     BATCH_INSERT_KEYS_MISMATCH = "BATCH_INSERT_KEYS_MISMATCH",
+    /**
+     * insertOrUpdate 参数缺失
+     */
+    INSERT_OR_UPDATE_CONDITION_EMPTY = "INSERT_OR_UPDATE_CONDITION_EMPTY",
+    INSERT_OR_UPDATE_DATA_EMPTY = "INSERT_OR_UPDATE_DATA_EMPTY",
+    INSERT_OR_DUPLICATE_UPDATE_DATA_EMPTY = "INSERT_ON_DUPLICATE_UPDATE_DATA_EMPTY",
     /**
      * 请求的Method字段为空
      */
@@ -79,6 +85,7 @@ export declare enum Exceptions {
     RUN_PICK_ERR_VISITOR_FIELD_NULL = "RUN_PICK_ERR_VISITOR_FIELD_NULL",
     RUN_EXECUTE_VALIDATE = "RUN_EXECUTE_VALIDATE",
     RUN_FUNCTION_NOT_FOUND = "RUN_FUNCTION_NOT_FOUND",
+    MORE_THAN_ONE_RECORDS_FOUND = "MORE_THAN_ONE_RECORDS_FOUND",
     /**
      * 参数校验错误
      */

package/dist/libs/crud-pro/exceptions.js

@@ -60,6 +60,12 @@ var Exceptions;
     Exceptions["DATA_GET_DATA_EMPTY_ON_INSERT_KEYS"] = "DATA_GET_DATA_EMPTY_ON_INSERT_KEYS";
     Exceptions["DATA_GET_DATA_EMPTY_ON_INSERT_VALUES"] = "DATA_GET_DATA_EMPTY_ON_INSERT_VALUES";
     Exceptions["BATCH_INSERT_KEYS_MISMATCH"] = "BATCH_INSERT_KEYS_MISMATCH";
+    /**
+     * insertOrUpdate 参数缺失
+     */
+    Exceptions["INSERT_OR_UPDATE_CONDITION_EMPTY"] = "INSERT_OR_UPDATE_CONDITION_EMPTY";
+    Exceptions["INSERT_OR_UPDATE_DATA_EMPTY"] = "INSERT_OR_UPDATE_DATA_EMPTY";
+    Exceptions["INSERT_OR_DUPLICATE_UPDATE_DATA_EMPTY"] = "INSERT_ON_DUPLICATE_UPDATE_DATA_EMPTY";
     /**
      * 请求的Method字段为空
      */
@@ -83,6 +89,7 @@ var Exceptions;
     Exceptions["RUN_PICK_ERR_VISITOR_FIELD_NULL"] = "RUN_PICK_ERR_VISITOR_FIELD_NULL";
     Exceptions["RUN_EXECUTE_VALIDATE"] = "RUN_EXECUTE_VALIDATE";
     Exceptions["RUN_FUNCTION_NOT_FOUND"] = "RUN_FUNCTION_NOT_FOUND";
+    Exceptions["MORE_THAN_ONE_RECORDS_FOUND"] = "MORE_THAN_ONE_RECORDS_FOUND";
     /**
      * 参数校验错误
      */