midway-fatcms 0.0.7 → 0.0.8

package/dist/models/StandardColumns.d.ts

@@ -1,71 +0,0 @@
-/**
- * 标准表结构字段类型定义
- *
- * 常用标准字段（推荐所有表都包含）：
- * - deleted_at: 软删除标记，0=未删除，时间戳=已删除
- * - deleted_by: 删除人ID
- * - created_by: 创建人ID
- * - created_at: 创建时间
- * - modified_by: 最后修改人ID
- * - modified_at: 最后修改时间
- *
- * 完整标准字段（需要记录详细用户信息时使用）：
- * - created_account_type: 创建人账号类型
- * - created_avatar: 创建人头像
- * - created_nickname: 创建人昵称
- * - modified_account_type: 修改人账号类型
- * - modified_avatar: 修改人头像
- * - modified_nickname: 修改人昵称
- */
-/**
- * 常用标准表结构字段（6个字段）
- *
- * 推荐所有业务表都包含这些字段：
- * - deleted_at: 删除时间戳，0=未删除
- * - deleted_by: 删除人ID
- * - created_by: 创建人ID
- * - created_at: 创建时间（毫秒时间戳）
- * - modified_by: 修改人ID
- * - modified_at: 修改时间（毫秒时间戳）
- */
-export interface ICommonStandardColumns {
-    deleted_at?: number;
-    deleted_by?: string;
-    created_by?: string;
-    created_at?: number;
-    modified_by?: string;
-    modified_at?: number;
-}
-/**
- * 完整标准表结构字段（12个字段）
- *
- * 在常用字段基础上增加用户详细信息：
- * - created_account_type: 创建人账号类型
- * - created_avatar: 创建人头像URL
- * - created_nickname: 创建人昵称
- * - modified_account_type: 修改人账号类型
- * - modified_avatar: 修改人头像URL
- * - modified_nickname: 修改人昵称
- */
-export interface IFullStandardColumns extends ICommonStandardColumns {
-    created_account_type?: string;
-    created_avatar?: string;
-    created_nickname?: string;
-    modified_account_type?: string;
-    modified_avatar?: string;
-    modified_nickname?: string;
-}
-/**
- * 包含常用标准字段的数据模型
- */
-export declare type StandardDataModel<T = {}> = T & ICommonStandardColumns;
-/**
- * 包含完整标准字段的数据模型
- */
-export declare type FullStandardDataModel<T = {}> = T & IFullStandardColumns;
-/**
- * 未删除查询条件
- */
-export declare const NotDeletedCondition: {
-    deleted_at: 0;
-};

package/dist/models/StandardColumns.js

@@ -1,28 +0,0 @@
-"use strict";
-/**
- * 标准表结构字段类型定义
- *
- * 常用标准字段（推荐所有表都包含）：
- * - deleted_at: 软删除标记，0=未删除，时间戳=已删除
- * - deleted_by: 删除人ID
- * - created_by: 创建人ID
- * - created_at: 创建时间
- * - modified_by: 最后修改人ID
- * - modified_at: 最后修改时间
- *
- * 完整标准字段（需要记录详细用户信息时使用）：
- * - created_account_type: 创建人账号类型
- * - created_avatar: 创建人头像
- * - created_nickname: 创建人昵称
- * - modified_account_type: 修改人账号类型
- * - modified_avatar: 修改人头像
- * - modified_nickname: 修改人昵称
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotDeletedCondition = void 0;
-/**
- * 未删除查询条件
- */
-exports.NotDeletedCondition = {
-    deleted_at: 0,
-};

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

@@ -1,190 +0,0 @@
-import { SqlDbType } from '../../libs/crud-pro/models/keys';
-import { IRequestModel } from '../../libs/crud-pro/interfaces';
-import { IRequestCfgModel2 } from '../../models/bizmodels';
-import { CrudPro } from '../../libs/crud-pro/CrudPro';
-import { ResModelAffected, ResModelPageQuery, ResModelStandard } from '../../libs/crud-pro/models/ResModel';
-import { Context } from "@midwayjs/koa";
-interface ICrudProQuick {
-    curdPro: CrudPro;
-    sqlDatabase: string;
-    sqlDbType: SqlDbType;
-    sqlTable?: string;
-    ctx?: Context;
-}
-export declare class CrudProQuick {
-    private readonly curdPro;
-    private readonly sqlDbType;
-    private readonly sqlDatabase;
-    private readonly sqlTable?;
-    private readonly ctx?;
-    private baseCfgModel;
-    constructor(args: ICrudProQuick);
-    /**
-     * 设置基础配置模型，合并到实例的 baseCfgModel 中，后续所有 CRUD 操作都会携带这些配置
-     * 例如可以统一设置 maxLimit、sqlSimpleName 等公共参数，避免每次调用都重复传入
-     * @param baseCfgModel 要合并的配置项
-     */
-    setBaseCfgModel(baseCfgModel: IRequestCfgModel2): void;
-    private executeCrudByCfg;
-    /**
-     * 随便获取一个。不推荐使用。建议使用getUniqueOne。
-     * @deprecated
-     * @param reqJson
-     * @param sqlTable
-     * @returns 返回一条数据对象
-     */
-    getOne(reqJson: IRequestModel, sqlTable?: string): Promise<any>;
-    /**
-     * 期望获取唯一的一个对象，如果数据库中的数量不唯一，则报错。
-     * @param reqJson
-     * @param sqlTable
-     * @returns 返回一条数据对象
-     */
-    getUniqueOne(reqJson: IRequestModel, sqlTable?: string): Promise<any>;
-    /**
-     * 获取数据列表
-     * @param reqJson
-     * @param sqlTable 数据库表名称
-     * @returns 返回多条数据对象组成的数组
-     */
-    getList(reqJson: IRequestModel, sqlTable?: string): Promise<any[]>;
-    /**
-     * 分页查询数据列表，返回包含 rows 和 total_count 的分页结果
-     * 内部使用 SIMPLE_QUERY_PAGE 模式，reqJson 中可传入 pageNo、pageSize 控制分页
-     * @param reqJson 请求参数，支持 condition（查询条件）、pageNo、pageSize 等
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns ResModelPageQuery 包含 rows（数据行数组）和 total_count（总记录数）
-     */
-    getListPage(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelPageQuery>;
-    /**
-     * 判断满足条件的记录是否存在
-     * 内部使用 SIMPLE_QUERY_EXIST 模式，通过 SELECT EXISTS 子查询实现，找到首条匹配即返回，比 COUNT(*) 更高效
-     * @param reqJson 请求参数，通过 condition 指定查询条件
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns boolean 存在返回 true，不存在返回 false
-     */
-    isExist(reqJson: IRequestModel, sqlTable?: string): Promise<boolean>;
-    /**
-     * 查询满足条件的记录总数
-     * 内部使用 SIMPLE_QUERY_COUNT 模式，仅返回 count 结果
-     * @param reqJson 请求参数，通过 condition 指定查询条件
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns number 满足条件的记录总数
-     */
-    getTotalCount(reqJson: IRequestModel, sqlTable?: string): Promise<number>;
-    /**
-     * 插入一条数据记录
-     * 内部使用 SIMPLE_INSERT 模式，通过 reqJson.data 传入要插入的字段和值
-     * @param reqJson 请求参数，data 字段中包含要插入的键值对
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns ResModelAffected 包含受影响的行数信息
-     */
-    insertObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected>;
-    /**
-     * 批量插入数据记录
-     * 内部使用 SIMPLE_BATCH_INSERT 模式，单条 SQL 插入多行数据，效率远高于循环单条插入
-     *
-     * @param reqJson 请求参数，data 为对象数组 [{name:'a'},{name:'b'}]
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns ResModelAffected 包含受影响的行数信息
-     *
-     * 注意事项：
-     * - affectedRows: 返回实际插入的行数，所有数据库均正确返回
-     * - insertId: 仅返回第一条记录的自增ID，后续记录的ID需通过 insertId + index 推算
-     *   - MySQL: 返回第一条的 insertId
-     *   - PostgreSQL: RETURNING * 返回所有行，但仅取第一条的 id
-     *   - SQL Server: OUTPUT 返回所有行，但仅取第一条的 id
-     */
-    batchInsert(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected>;
-    /**
-     * 更新数据记录
-     * 内部使用 SIMPLE_UPDATE 模式，通过 reqJson.data 传入要更新的字段和值，通过 reqJson.condition 指定更新条件
-     * @param reqJson 请求参数，data 为更新内容，condition 为更新条件
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns ResModelAffected 包含受影响的行数信息
-     */
-    updateObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected>;
-    /**
-     * 插入或更新数据记录（upsert）
-     * 内部使用 SIMPLE_INSERT_OR_UPDATE 模式，若记录已存在则更新，不存在则插入
-     * @param reqJson 请求参数，data 为要插入/更新的内容，condition 为判断条件
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns ResModelStandard 返回完整的结果模型，包含 affected、insertId 等多种返回值
-     */
-    insertOrUpdate(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelStandard>;
-    /**
-     * 使用数据库原生 upsert 语法插入或更新（ON DUPLICATE KEY UPDATE / ON CONFLICT / MERGE）
-     * 内部使用 SIMPLE_INSERT_ON_DUPLICATE_UPDATE 模式，单条 SQL 完成 upsert，效率更高
-     *
-     * 数据库差异：
-     * - MySQL: ON DUPLICATE KEY UPDATE（依赖唯一索引/主键）
-     * - PostgreSQL: ON CONFLICT (...) DO UPDATE（需配置 uniqueColumn）
-     * - SQL Server: IF EXISTS ... ELSE ...（需配置 uniqueColumn，仅支持单列）
-     *
-     * @param reqJson 请求参数，data 为要插入/更新的内容
-     * @param uniqueColumn 唯一列名（PostgreSQL/SQL Server 必需），PostgreSQL 支持多列，SQL Server 仅支持单列
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns ResModelAffected 包含受影响的行数信息
-     */
-    insertOnDuplicate(reqJson: IRequestModel, uniqueColumn?: string[], sqlTable?: string): Promise<ResModelAffected>;
-    /**
-     * 删除数据记录
-     * 内部使用 SIMPLE_DELETE 模式，通过 reqJson.condition 指定删除条件
-     * 注意：如果启用了软删除，实际执行的是更新操作而非物理删除
-     * @param reqJson 请求参数，condition 为删除条件
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns ResModelAffected 包含受影响的行数信息
-     */
-    deleteObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected>;
-    /**
-     * 执行自定义 SQL 语句（经 CrudPro 框架封装处理）
-     * 与 executeNativeSQL 不同，此方法执行的 SQL 会经过框架的参数绑定等安全处理
-     * @param executeSql 要执行的 SQL 语句，支持参数占位符
-     * @param args SQL 参数数组，与占位符一一对应
-     * @returns any SQL 执行结果
-     */
-    executeSQL(executeSql: string, args?: any[]): Promise<any>;
-    /**
-     * 执行数据库的原生SQL语句，不做任何封装
-     *
-     * 返回值结构取决于 SQL 类型和数据库类型：
-     *
-     * **SELECT 查询**: 返回行数据数组
-     *
-     * **INSERT/UPDATE/DELETE**: 返回数据库驱动的原始结果
-     * - MySQL: `NativeSqlResultMySQL` - 包含 insertId、affectedRows、changedRows 等
-     * - PostgreSQL: 空数组（pg 驱动返回 rows 为空）
-     * - SQL Server: 空数组（mssql 驱动返回 recordset 为空）
-     *
-     * **注意**:
-     * - 使用 `?` 作为占位符，框架会自动转换为对应数据库的占位符
-     * - PostgreSQL/SQL Server 会将 `?` 转换为 `$1, $2, ...` 或 `@fatcms_ms1, @fatcms_ms2, ...`
-     *
-     * @typeParam T 返回值类型，默认 any。
-     * 预定义类型位于 `@/libs/crud-pro/models/ResModel`：
-     * - `NativeSqlSelectResult` - SELECT 查询返回的行数组
-     * - `NativeSqlResultMySQL` - MySQL INSERT/UPDATE/DELETE 返回结果
-     * - 或自定义行类型数组，如 `{id: number, name: string}[]`
-     *
-     * @param executeNativeSql 原生 SQL 语句，使用 `?` 作为参数占位符
-     * @param args 参数数组，与 SQL 中的 `?` 一一对应
-     * @returns 根据 SQL 类型返回对应结果
-     *
-     * @example
-     * // SELECT 查询 - 使用自定义行类型
-     * const rows = await crudProQuick.executeNativeSQL<{id: number, name: string}[]>(
-     *   'SELECT id, name FROM user WHERE age > ?',
-     *   [18]
-     * );
-     *
-     * // INSERT - MySQL 返回 NativeSqlResultMySQL
-     * // 需先导入: import { NativeSqlResultMySQL } from '../../libs/crud-pro/models/ResModel';
-     * const result = await crudProQuick.executeNativeSQL<NativeSqlResultMySQL>(
-     *   'INSERT INTO user (name, age) VALUES (?, ?)',
-     *   ['张三', 20]
-     * );
-     * console.log(result.insertId, result.affectedRows);
-     */
-    executeNativeSQL<T = any>(executeNativeSql: string, args?: any[]): Promise<T>;
-}
-export {};

package/dist/service/curd/CrudProQuick.js

@@ -1,319 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CrudProQuick = void 0;
-const keys_1 = require("../../libs/crud-pro/models/keys");
-const fixSoftDelete_1 = require("../../service/curd/fixSoftDelete");
-const DEFAULT_MAX_LIMIT = 10 * 10000;
-class CrudProQuick {
-    constructor(args) {
-        this.baseCfgModel = {
-            maxLimit: DEFAULT_MAX_LIMIT,
-        };
-        this.ctx = args.ctx;
-        this.sqlDatabase = args.sqlDatabase;
-        this.sqlDbType = args.sqlDbType;
-        this.curdPro = args.curdPro;
-        this.sqlTable = args.sqlTable; // 全局sqlTable为空时，单独调用时就必须传sqlTable参数。
-    }
-    /**
-     * 设置基础配置模型，合并到实例的 baseCfgModel 中，后续所有 CRUD 操作都会携带这些配置
-     * 例如可以统一设置 maxLimit、sqlSimpleName 等公共参数，避免每次调用都重复传入
-     * @param baseCfgModel 要合并的配置项
-     */
-    setBaseCfgModel(baseCfgModel) {
-        Object.assign(this.baseCfgModel, baseCfgModel);
-    }
-    async executeCrudByCfg(reqJson, cfgModel2) {
-        const cfgModel = { ...this.baseCfgModel };
-        Object.assign(cfgModel, cfgModel2);
-        cfgModel.method = 'CrudProQuickAnonymous';
-        cfgModel.updateCfg = {};
-        cfgModel.sqlDatabase = this.sqlDatabase;
-        cfgModel.sqlDbType = this.sqlDbType;
-        if (!cfgModel.sqlTable) {
-            cfgModel.sqlTable = this.sqlTable;
-        }
-        if (!cfgModel.sqlTable) {
-            throw new Error('[CrudProQuick] sqlTable not found');
-        }
-        // 应用软删除动作。
-        (0, fixSoftDelete_1.fixSoftDelete)(cfgModel2.sqlSimpleName, cfgModel2, reqJson, this.ctx);
-        return await this.curdPro.executeCrudByCfg(reqJson, cfgModel);
-    }
-    /**
-     * 随便获取一个。不推荐使用。建议使用getUniqueOne。
-     * @deprecated
-     * @param reqJson
-     * @param sqlTable
-     * @returns 返回一条数据对象
-     */
-    async getOne(reqJson, sqlTable) {
-        const cfgModel = {
-            sqlTable,
-            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
-        };
-        const res = await this.executeCrudByCfg(reqJson, cfgModel);
-        return res.getOneObj();
-    }
-    /**
-     * 期望获取唯一的一个对象，如果数据库中的数量不唯一，则报错。
-     * @param reqJson
-     * @param sqlTable
-     * @returns 返回一条数据对象
-     */
-    async getUniqueOne(reqJson, sqlTable) {
-        const cfgModel = {
-            sqlTable,
-            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_PAGE,
-        };
-        reqJson.pageNo = 1;
-        reqJson.pageSize = 1;
-        const res = await this.executeCrudByCfg(reqJson, cfgModel);
-        const resModel = res.getResModel();
-        const total_count = resModel.total_count;
-        const rows = resModel.rows;
-        if (total_count === 0) {
-            return null;
-        }
-        if (total_count > 1) {
-            throw new Error(`[CrudProQuick][getUniqueOne] only one object is required, but got ${total_count}`);
-        }
-        return rows[0];
-    }
-    /**
-     * 获取数据列表
-     * @param reqJson
-     * @param sqlTable 数据库表名称
-     * @returns 返回多条数据对象组成的数组
-     */
-    async getList(reqJson, sqlTable) {
-        const cfgModel = {
-            sqlTable,
-            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
-        };
-        const res = await this.executeCrudByCfg(reqJson, cfgModel);
-        return res.getResRows();
-    }
-    /**
-     * 分页查询数据列表，返回包含 rows 和 total_count 的分页结果
-     * 内部使用 SIMPLE_QUERY_PAGE 模式，reqJson 中可传入 pageNo、pageSize 控制分页
-     * @param reqJson 请求参数，支持 condition（查询条件）、pageNo、pageSize 等
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns ResModelPageQuery 包含 rows（数据行数组）和 total_count（总记录数）
-     */
-    async getListPage(reqJson, sqlTable) {
-        const cfgModel = {
-            sqlTable,
-            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_PAGE,
-        };
-        const res = await this.executeCrudByCfg(reqJson, cfgModel);
-        return res.getResModelForQueryPage();
-    }
-    /**
-     * 判断满足条件的记录是否存在
-     * 内部使用 SIMPLE_QUERY_EXIST 模式，通过 SELECT EXISTS 子查询实现，找到首条匹配即返回，比 COUNT(*) 更高效
-     * @param reqJson 请求参数，通过 condition 指定查询条件
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns boolean 存在返回 true，不存在返回 false
-     */
-    async isExist(reqJson, sqlTable) {
-        const cfgModel = {
-            sqlTable,
-            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_EXIST,
-        };
-        const res = await this.executeCrudByCfg(reqJson, cfgModel);
-        return res.getResModel().is_exist;
-    }
-    /**
-     * 查询满足条件的记录总数
-     * 内部使用 SIMPLE_QUERY_COUNT 模式，仅返回 count 结果
-     * @param reqJson 请求参数，通过 condition 指定查询条件
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns number 满足条件的记录总数
-     */
-    async getTotalCount(reqJson, sqlTable) {
-        const cfgModel = {
-            sqlTable,
-            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_COUNT,
-        };
-        const res = await this.executeCrudByCfg(reqJson, cfgModel);
-        return res.getResModel().total_count;
-    }
-    /**
-     * 插入一条数据记录
-     * 内部使用 SIMPLE_INSERT 模式，通过 reqJson.data 传入要插入的字段和值
-     * @param reqJson 请求参数，data 字段中包含要插入的键值对
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns ResModelAffected 包含受影响的行数信息
-     */
-    async insertObject(reqJson, sqlTable) {
-        const cfgModel = {
-            sqlTable,
-            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_INSERT,
-        };
-        const res = await this.executeCrudByCfg(reqJson, cfgModel);
-        return res.getResModel().affected;
-    }
-    /**
-     * 批量插入数据记录
-     * 内部使用 SIMPLE_BATCH_INSERT 模式，单条 SQL 插入多行数据，效率远高于循环单条插入
-     *
-     * @param reqJson 请求参数，data 为对象数组 [{name:'a'},{name:'b'}]
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns ResModelAffected 包含受影响的行数信息
-     *
-     * 注意事项：
-     * - affectedRows: 返回实际插入的行数，所有数据库均正确返回
-     * - insertId: 仅返回第一条记录的自增ID，后续记录的ID需通过 insertId + index 推算
-     *   - MySQL: 返回第一条的 insertId
-     *   - PostgreSQL: RETURNING * 返回所有行，但仅取第一条的 id
-     *   - SQL Server: OUTPUT 返回所有行，但仅取第一条的 id
-     */
-    async batchInsert(reqJson, sqlTable) {
-        const cfgModel = {
-            sqlTable,
-            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_BATCH_INSERT,
-        };
-        const res = await this.executeCrudByCfg(reqJson, cfgModel);
-        return res.getResModel().affected;
-    }
-    /**
-     * 更新数据记录
-     * 内部使用 SIMPLE_UPDATE 模式，通过 reqJson.data 传入要更新的字段和值，通过 reqJson.condition 指定更新条件
-     * @param reqJson 请求参数，data 为更新内容，condition 为更新条件
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns ResModelAffected 包含受影响的行数信息
-     */
-    async updateObject(reqJson, sqlTable) {
-        const cfgModel = {
-            sqlTable,
-            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
-        };
-        const res = await this.executeCrudByCfg(reqJson, cfgModel);
-        return res.getResModel().affected;
-    }
-    /**
-     * 插入或更新数据记录（upsert）
-     * 内部使用 SIMPLE_INSERT_OR_UPDATE 模式，若记录已存在则更新，不存在则插入
-     * @param reqJson 请求参数，data 为要插入/更新的内容，condition 为判断条件
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns ResModelStandard 返回完整的结果模型，包含 affected、insertId 等多种返回值
-     */
-    async insertOrUpdate(reqJson, sqlTable) {
-        const cfgModel = {
-            sqlTable,
-            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE,
-        };
-        const res = await this.executeCrudByCfg(reqJson, cfgModel);
-        return res.getResModel(); // 因为它有三个返回值
-    }
-    /**
-     * 使用数据库原生 upsert 语法插入或更新（ON DUPLICATE KEY UPDATE / ON CONFLICT / MERGE）
-     * 内部使用 SIMPLE_INSERT_ON_DUPLICATE_UPDATE 模式，单条 SQL 完成 upsert，效率更高
-     *
-     * 数据库差异：
-     * - MySQL: ON DUPLICATE KEY UPDATE（依赖唯一索引/主键）
-     * - PostgreSQL: ON CONFLICT (...) DO UPDATE（需配置 uniqueColumn）
-     * - SQL Server: IF EXISTS ... ELSE ...（需配置 uniqueColumn，仅支持单列）
-     *
-     * @param reqJson 请求参数，data 为要插入/更新的内容
-     * @param uniqueColumn 唯一列名（PostgreSQL/SQL Server 必需），PostgreSQL 支持多列，SQL Server 仅支持单列
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns ResModelAffected 包含受影响的行数信息
-     */
-    async insertOnDuplicate(reqJson, uniqueColumn, sqlTable) {
-        const cfgModel = {
-            sqlTable,
-            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_ON_DUPLICATE_UPDATE,
-            uniqueColumn,
-        };
-        const res = await this.executeCrudByCfg(reqJson, cfgModel);
-        return res.getResModel().affected;
-    }
-    /**
-     * 删除数据记录
-     * 内部使用 SIMPLE_DELETE 模式，通过 reqJson.condition 指定删除条件
-     * 注意：如果启用了软删除，实际执行的是更新操作而非物理删除
-     * @param reqJson 请求参数，condition 为删除条件
-     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
-     * @returns ResModelAffected 包含受影响的行数信息
-     */
-    async deleteObject(reqJson, sqlTable) {
-        const cfgModel = {
-            sqlTable,
-            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_DELETE,
-        };
-        const res = await this.executeCrudByCfg(reqJson, cfgModel);
-        return res.getResModel().affected;
-    }
-    /**
-     * 执行自定义 SQL 语句（经 CrudPro 框架封装处理）
-     * 与 executeNativeSQL 不同，此方法执行的 SQL 会经过框架的参数绑定等安全处理
-     * @param executeSql 要执行的 SQL 语句，支持参数占位符
-     * @param args SQL 参数数组，与占位符一一对应
-     * @returns any SQL 执行结果
-     */
-    async executeSQL(executeSql, args) {
-        const sqlCfgModel = {
-            executeSql: executeSql,
-            executeSqlArgs: args,
-            sqlDatabase: this.sqlDatabase,
-            sqlDbType: this.sqlDbType,
-            maxLimit: this.baseCfgModel.maxLimit || DEFAULT_MAX_LIMIT,
-        };
-        return await this.curdPro.executeSQL(sqlCfgModel);
-    }
-    /**
-     * 执行数据库的原生SQL语句，不做任何封装
-     *
-     * 返回值结构取决于 SQL 类型和数据库类型：
-     *
-     * **SELECT 查询**: 返回行数据数组
-     *
-     * **INSERT/UPDATE/DELETE**: 返回数据库驱动的原始结果
-     * - MySQL: `NativeSqlResultMySQL` - 包含 insertId、affectedRows、changedRows 等
-     * - PostgreSQL: 空数组（pg 驱动返回 rows 为空）
-     * - SQL Server: 空数组（mssql 驱动返回 recordset 为空）
-     *
-     * **注意**:
-     * - 使用 `?` 作为占位符，框架会自动转换为对应数据库的占位符
-     * - PostgreSQL/SQL Server 会将 `?` 转换为 `$1, $2, ...` 或 `@fatcms_ms1, @fatcms_ms2, ...`
-     *
-     * @typeParam T 返回值类型，默认 any。
-     * 预定义类型位于 `@/libs/crud-pro/models/ResModel`：
-     * - `NativeSqlSelectResult` - SELECT 查询返回的行数组
-     * - `NativeSqlResultMySQL` - MySQL INSERT/UPDATE/DELETE 返回结果
-     * - 或自定义行类型数组，如 `{id: number, name: string}[]`
-     *
-     * @param executeNativeSql 原生 SQL 语句，使用 `?` 作为参数占位符
-     * @param args 参数数组，与 SQL 中的 `?` 一一对应
-     * @returns 根据 SQL 类型返回对应结果
-     *
-     * @example
-     * // SELECT 查询 - 使用自定义行类型
-     * const rows = await crudProQuick.executeNativeSQL<{id: number, name: string}[]>(
-     *   'SELECT id, name FROM user WHERE age > ?',
-     *   [18]
-     * );
-     *
-     * // INSERT - MySQL 返回 NativeSqlResultMySQL
-     * // 需先导入: import { NativeSqlResultMySQL } from '../../libs/crud-pro/models/ResModel';
-     * const result = await crudProQuick.executeNativeSQL<NativeSqlResultMySQL>(
-     *   'INSERT INTO user (name, age) VALUES (?, ?)',
-     *   ['张三', 20]
-     * );
-     * console.log(result.insertId, result.affectedRows);
-     */
-    async executeNativeSQL(executeNativeSql, args) {
-        const sqlCfgModel = {
-            isNativeSQL: true,
-            executeSql: executeNativeSql,
-            executeSqlArgs: args,
-            sqlDatabase: this.sqlDatabase,
-            sqlDbType: this.sqlDbType,
-            maxLimit: this.baseCfgModel.maxLimit || DEFAULT_MAX_LIMIT,
-        };
-        return await this.curdPro.executeSQL(sqlCfgModel);
-    }
-}
-exports.CrudProQuick = CrudProQuick;