midway-fatcms 0.0.7 → 0.0.9

package/dist/libs/crud-pro-quick/fixSoftDelete.d.ts

@@ -0,0 +1,30 @@
+import { KeysOfSimpleSQL } from "../../libs/crud-pro/models/keys";
+import { IRequestModel, IVisitor } from "../../libs/crud-pro/interfaces";
+import { IRequestCfgModel2 } from "./models";
+/**
+ * 软删除需要的用户信息（最小子集）
+ */
+interface ISoftDeleteUserInfo {
+    accountId: string;
+}
+/**
+ * 获取当前用户信息的函数类型
+ */
+declare type GetCurrentUserFunc = () => ISoftDeleteUserInfo | null | undefined;
+/**
+ * 软删除处理函数
+ *
+ * 当 cfgModel.enableSoftDelete === true 时，自动处理软删除逻辑：
+ *
+ * 1. INSERT 操作：自动设置 deleted_at = 0
+ * 2. DELETE 操作：转为 UPDATE，设置 deleted_at = 时间戳, deleted_by = 当前用户
+ * 3. QUERY 操作：自动添加 deleted_at = 0 条件
+ *
+ * @param oldSqlSimpleName 原始 SQL 类型
+ * @param cfgModel 配置模型
+ * @param params 请求参数（会被修改）
+ * @param visitor 获取当前用户信息的函数（用于软删除时记录删除人）
+ */
+declare function fixSoftDelete(oldSqlSimpleName: KeysOfSimpleSQL, cfgModel: IRequestCfgModel2, params: IRequestModel, visitor?: IVisitor): void;
+export { fixSoftDelete, };
+export type { ISoftDeleteUserInfo, GetCurrentUserFunc };

package/dist/{service/curd → libs/crud-pro-quick}/fixSoftDelete.js

@@ -14,10 +14,9 @@ const keys_1 = require("../../libs/crud-pro/models/keys");
  * @param oldSqlSimpleName 原始 SQL 类型
  * @param cfgModel 配置模型
  * @param params 请求参数（会被修改）
- * @param ctx 请求上下文（用于获取当前用户信息）
+ * @param visitor 获取当前用户信息的函数（用于软删除时记录删除人）
  */
-function fixSoftDelete(oldSqlSimpleName, cfgModel, params, ctx) {
-    var _a;
+function fixSoftDelete(oldSqlSimpleName, cfgModel, params, visitor) {
     // 没有开启软删除，不做处理，直接物理删除
     if (cfgModel.enableSoftDelete !== true) {
         return;
@@ -36,15 +35,13 @@ function fixSoftDelete(oldSqlSimpleName, cfgModel, params, ctx) {
         if (!params.condition || Object.keys(params.condition).length === 0) {
             throw new Error('执行删除操作，必须指定删除条件');
         }
-        // 获取当前用户信息
-        const sessionInfo = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.userSession) === null || _a === void 0 ? void 0 : _a.getSessionInfo();
         // 在原有 data 对象上添加软删除字段
         if (!params.data) {
             params.data = {};
         }
         const dataObj = params.data;
         dataObj.deleted_at = Date.now();
-        dataObj.deleted_by = (sessionInfo === null || sessionInfo === void 0 ? void 0 : sessionInfo.accountId) || '';
+        dataObj.deleted_by = (visitor === null || visitor === void 0 ? void 0 : visitor.accountId) || '';
         // 改为执行 UPDATE 操作
         cfgModel.sqlSimpleName = keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE;
     }

package/dist/libs/crud-pro-quick/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 快捷 CRUD 操作模块
+ *
+ * 在 CrudPro 之上封装便捷方法，提供简洁的 API 进行单表 CRUD 操作。
+ * 内部使用工厂函数模式，每次操作都会获取新的 CrudPro 实例，因此**可以安全复用**。
+ *
+ * **与 CrudPro 的关系：**
+ * - CrudPro 是有状态执行器，禁止复用
+ * - CrudProQuick 内部每次调用工厂函数获取新 CrudPro，可以安全复用
+ *
+ * **使用方式：**
+ * 必须通过 CurdProService.getQuickCrud() 获取实例，不要直接构造。
+ *
+ * @example
+ * // 通过 CurdProService 获取实例
+ * const quick = curdProService.getQuickCrud('mydb', SqlDbType.mysql, 't_user');
+ *
+ * // 设置公共配置
+ * quick.setBaseCfgModel({
+ *   enableSoftDelete: true,
+ *   enableStandardUpdateCfg: true,
+ * });
+ *
+ * // 查询列表（新 API）
+ * const result = await quick.findList({ condition: { status: 1 } });
+ * console.log(result.rows, result.count);
+ *
+ * // 插入数据（新 API）
+ * const insertResult = await quick.insert({ data: { name: '张三', age: 20 } });
+ * console.log(insertResult.affectedRows, insertResult.insertId);
+ */
+export { CrudProQuick } from './CrudProQuick';
+export type { ICrudProQuickFactory } from './CrudProQuick';
+export type { IRequestCfgModel2, ICommonStandardColumns } from './models';
+export { fixSoftDelete } from './fixSoftDelete';
+export { CrudWriteResult, CrudQueryOneResult, CrudQueryListResult, CrudQueryPageResult, CrudExistResult, CrudCountResult, CrudUpsertResult, } from '../../libs/crud-pro/models/CrudResult';

package/dist/libs/crud-pro-quick/index.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * 快捷 CRUD 操作模块
+ *
+ * 在 CrudPro 之上封装便捷方法，提供简洁的 API 进行单表 CRUD 操作。
+ * 内部使用工厂函数模式，每次操作都会获取新的 CrudPro 实例，因此**可以安全复用**。
+ *
+ * **与 CrudPro 的关系：**
+ * - CrudPro 是有状态执行器，禁止复用
+ * - CrudProQuick 内部每次调用工厂函数获取新 CrudPro，可以安全复用
+ *
+ * **使用方式：**
+ * 必须通过 CurdProService.getQuickCrud() 获取实例，不要直接构造。
+ *
+ * @example
+ * // 通过 CurdProService 获取实例
+ * const quick = curdProService.getQuickCrud('mydb', SqlDbType.mysql, 't_user');
+ *
+ * // 设置公共配置
+ * quick.setBaseCfgModel({
+ *   enableSoftDelete: true,
+ *   enableStandardUpdateCfg: true,
+ * });
+ *
+ * // 查询列表（新 API）
+ * const result = await quick.findList({ condition: { status: 1 } });
+ * console.log(result.rows, result.count);
+ *
+ * // 插入数据（新 API）
+ * const insertResult = await quick.insert({ data: { name: '张三', age: 20 } });
+ * console.log(insertResult.affectedRows, insertResult.insertId);
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudUpsertResult = exports.CrudCountResult = exports.CrudExistResult = exports.CrudQueryPageResult = exports.CrudQueryListResult = exports.CrudQueryOneResult = exports.CrudWriteResult = exports.fixSoftDelete = exports.CrudProQuick = void 0;
+// 核心类
+var CrudProQuick_1 = require("./CrudProQuick");
+Object.defineProperty(exports, "CrudProQuick", { enumerable: true, get: function () { return CrudProQuick_1.CrudProQuick; } });
+// 工具函数
+var fixSoftDelete_1 = require("./fixSoftDelete");
+Object.defineProperty(exports, "fixSoftDelete", { enumerable: true, get: function () { return fixSoftDelete_1.fixSoftDelete; } });
+// 重新导出结果类型
+var CrudResult_1 = require("../../libs/crud-pro/models/CrudResult");
+Object.defineProperty(exports, "CrudWriteResult", { enumerable: true, get: function () { return CrudResult_1.CrudWriteResult; } });
+Object.defineProperty(exports, "CrudQueryOneResult", { enumerable: true, get: function () { return CrudResult_1.CrudQueryOneResult; } });
+Object.defineProperty(exports, "CrudQueryListResult", { enumerable: true, get: function () { return CrudResult_1.CrudQueryListResult; } });
+Object.defineProperty(exports, "CrudQueryPageResult", { enumerable: true, get: function () { return CrudResult_1.CrudQueryPageResult; } });
+Object.defineProperty(exports, "CrudExistResult", { enumerable: true, get: function () { return CrudResult_1.CrudExistResult; } });
+Object.defineProperty(exports, "CrudCountResult", { enumerable: true, get: function () { return CrudResult_1.CrudCountResult; } });
+Object.defineProperty(exports, "CrudUpsertResult", { enumerable: true, get: function () { return CrudResult_1.CrudUpsertResult; } });

package/dist/libs/crud-pro-quick/models.d.ts

@@ -0,0 +1,33 @@
+import { IRequestCfgModel } from '../../libs/crud-pro/interfaces';
+/**
+ * 常用标准表结构字段（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;
+}
+/**
+ * 扩展的请求配置模型
+ *
+ * 在 IRequestCfgModel 基础上添加了业务层常用的配置项：
+ * - enableStandardUpdateCfg: 启用标准字段自动填充
+ * - enableStandardUpdateCfgCondition: 启用标准字段条件注入
+ * - enableSoftDelete: 启用软删除
+ */
+export interface IRequestCfgModel2 extends IRequestCfgModel {
+    enableStandardUpdateCfg?: boolean | string[];
+    enableStandardUpdateCfgCondition?: boolean | string[];
+    enableSoftDelete?: boolean;
+}

package/dist/libs/crud-pro-quick/models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/libs/crud-sharding/ShardingBase.d.ts

@@ -0,0 +1,78 @@
+import { IRequestModel, IRequestCfgModel } from '../../libs/crud-pro/interfaces';
+import { ExecuteContext } from '../../libs/crud-pro/models/ExecuteContext';
+import { KeysOfSimpleSQL } from '../../libs/crud-pro/models/keys';
+import { IShardingConfig, IShardingRouterContext, CrudProFactory } from './ShardingConfig';
+import { ShardingTableCreator } from './ShardingTableCreator';
+import { CrudWriteResult, CrudQueryOneResult, CrudQueryListResult, CrudQueryPageResult, CrudExistResult, CrudCountResult, CrudUpsertResult } from '../../libs/crud-pro/models/CrudResult';
+import { ShardingBatchInsertResult } from './ShardingResult';
+/**
+ * 分表 CRUD 基类
+ *
+ * 提供所有分表子类共用的基础设施方法，不包含任何路由逻辑。
+ * 路由逻辑由各子类自行实现。
+ *
+ * 子类：
+ * - ShardingByTimeCrud: 时间分表（YEAR/MONTH/DAY）
+ * - ShardingByHashCrud: 哈希分表
+ * - ShardingByKeyCrud: 键值分表
+ * - ShardingByCustomCrud: 自定义分表
+ */
+export declare abstract class ShardingBase {
+    protected readonly crudProFactory: CrudProFactory;
+    protected readonly config: IShardingConfig;
+    protected readonly tableCreator: ShardingTableCreator;
+    protected baseCfg: Partial<IRequestCfgModel>;
+    protected enableSoftDelete: boolean;
+    constructor(crudProFactory: CrudProFactory, config: IShardingConfig);
+    setBaseCfg(cfg: Partial<IRequestCfgModel>): this;
+    getConfig(): IShardingConfig;
+    setEnableSoftDelete(enable: boolean): this;
+    abstract insert(reqJson: IRequestModel): Promise<CrudWriteResult>;
+    abstract batchInsert(reqJson: IRequestModel): Promise<ShardingBatchInsertResult>;
+    abstract update(reqJson: IRequestModel): Promise<CrudWriteResult>;
+    abstract delete(reqJson: IRequestModel): Promise<CrudWriteResult>;
+    abstract restore(reqJson: IRequestModel): Promise<CrudWriteResult>;
+    abstract insertOrUpdate(reqJson: IRequestModel): Promise<CrudUpsertResult>;
+    abstract findOne<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryOneResult<T>>;
+    abstract findUniqueOne<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryOneResult<T>>;
+    abstract findList<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryListResult<T>>;
+    abstract findPage<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryPageResult<T>>;
+    abstract findCount(reqJson: IRequestModel): Promise<CrudCountResult>;
+    abstract isExist(reqJson: IRequestModel): Promise<CrudExistResult>;
+    /**
+     * 判断当前路由上下文是否处于「插入阶段」（应从 data 提取分表字段）
+     *
+     * - INSERT / BATCH_INSERT → 始终从 data
+     * - 其余操作（QUERY / UPDATE / DELETE / INSERT_OR_UPDATE）→ 从 condition
+     */
+    protected static isInsertPhase(ctx: IShardingRouterContext): boolean;
+    protected buildCfg(sqlSimpleName: KeysOfSimpleSQL): IRequestCfgModel & {
+        enableSoftDelete?: boolean;
+    };
+    protected executeOnTable(table: string, reqJson: IRequestModel, sqlSimpleName: KeysOfSimpleSQL, extraCfg?: Partial<IRequestCfgModel>): Promise<ExecuteContext>;
+    protected findCountFromTable(table: string, reqJson: IRequestModel): Promise<{
+        count: number;
+        ctx: ExecuteContext | null;
+    }>;
+    protected isExistInTable(table: string, reqJson: IRequestModel): Promise<{
+        exists: boolean;
+        ctx: ExecuteContext | null;
+    }>;
+    protected getExistingTablesSet(skipCache?: boolean): Promise<Set<string>>;
+    protected isTableExists(tableName: string): Promise<boolean>;
+    protected createShardingTableIfNeeded(tableName: string): Promise<void>;
+    protected buildDebugInfo(sqlTable: string | undefined, condition: Record<string, any> | undefined): {
+        sqlDatabase: string;
+        sqlTable: string;
+        condition?: Record<string, any>;
+    };
+    protected formatUniqueError(foundCount: number, tables: string | string[], condition: Record<string, any> | undefined, isMultiTable?: boolean): string;
+    /**
+     * 获取所有以 baseTable_ 开头的已存在分表（按字典序排序）
+     */
+    protected getAllExistingShardingTables(): Promise<string[]>;
+    /**
+     * 过滤出真实存在的分表
+     */
+    protected filterExistingTables(candidateTables: string[]): Promise<string[]>;
+}

package/dist/libs/crud-sharding/ShardingBase.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardingBase = void 0;
+const keys_1 = require("../../libs/crud-pro/models/keys");
+const fixSoftDelete_1 = require("../../libs/crud-pro-quick/fixSoftDelete");
+const ShardingTableCreator_1 = require("./ShardingTableCreator");
+/**
+ * 分表 CRUD 基类
+ *
+ * 提供所有分表子类共用的基础设施方法，不包含任何路由逻辑。
+ * 路由逻辑由各子类自行实现。
+ *
+ * 子类：
+ * - ShardingByTimeCrud: 时间分表（YEAR/MONTH/DAY）
+ * - ShardingByHashCrud: 哈希分表
+ * - ShardingByKeyCrud: 键值分表
+ * - ShardingByCustomCrud: 自定义分表
+ */
+class ShardingBase {
+    constructor(crudProFactory, config) {
+        this.baseCfg = {};
+        this.enableSoftDelete = false;
+        this.config = config;
+        if (typeof crudProFactory === 'function') {
+            this.crudProFactory = crudProFactory;
+        }
+        else {
+            throw new Error('[ShardingBase] 请使用 CrudProFactory 工厂函数模式');
+        }
+        this.tableCreator = new ShardingTableCreator_1.ShardingTableCreator(this.crudProFactory, config);
+    }
+    // ============ 配置方法 ============
+    setBaseCfg(cfg) {
+        this.baseCfg = { ...this.baseCfg, ...cfg };
+        return this;
+    }
+    getConfig() {
+        return this.config;
+    }
+    setEnableSoftDelete(enable) {
+        this.enableSoftDelete = enable;
+        return this;
+    }
+    /**
+     * 判断当前路由上下文是否处于「插入阶段」（应从 data 提取分表字段）
+     *
+     * - INSERT / BATCH_INSERT → 始终从 data
+     * - 其余操作（QUERY / UPDATE / DELETE / INSERT_OR_UPDATE）→ 从 condition
+     */
+    static isInsertPhase(ctx) {
+        return [keys_1.KeysOfSimpleSQL.SIMPLE_INSERT, keys_1.KeysOfSimpleSQL.SIMPLE_BATCH_INSERT].includes(ctx.sqlSimpleName);
+    }
+    // ============ 执行基础设施 ============
+    buildCfg(sqlSimpleName) {
+        return {
+            method: `ShardingCrudProAnonymous_${sqlSimpleName}`,
+            ...this.baseCfg,
+            sqlTable: this.config.baseTable,
+            sqlSimpleName,
+        };
+    }
+    async executeOnTable(table, reqJson, sqlSimpleName, extraCfg) {
+        const cfg = this.buildCfg(sqlSimpleName);
+        cfg.sqlTable = table;
+        cfg.enableSoftDelete = this.enableSoftDelete;
+        if (extraCfg) {
+            Object.assign(cfg, extraCfg);
+        }
+        const crudPro = this.crudProFactory();
+        (0, fixSoftDelete_1.fixSoftDelete)(sqlSimpleName, cfg, reqJson, crudPro.getVisitor());
+        return crudPro.executeCrudByCfg(reqJson, cfg);
+    }
+    // ============ 单表查询辅助 ============
+    async findCountFromTable(table, reqJson) {
+        try {
+            const ctx = await this.executeOnTable(table, reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_COUNT);
+            return { count: ctx.getResModelItem('total_count') || 0, ctx };
+        }
+        catch (e) {
+            return { count: 0, ctx: null };
+        }
+    }
+    async isExistInTable(table, reqJson) {
+        try {
+            const ctx = await this.executeOnTable(table, reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_EXIST);
+            return { exists: ctx.getResModelItem('is_exist') === true, ctx };
+        }
+        catch (e) {
+            return { exists: false, ctx: null };
+        }
+    }
+    // ============ 表管理 ============
+    async getExistingTablesSet(skipCache = false) {
+        const { sqlDatabase, sqlDbType } = this.baseCfg;
+        if (!sqlDatabase || !sqlDbType) {
+            throw new Error('[ShardingBase] 未配置 sqlDatabase 或 sqlDbType');
+        }
+        const { tables } = await this.crudProFactory().getAllTableInfos({ sqlDatabase, sqlDbType: sqlDbType }, { skipCache });
+        return new Set(tables.map(t => t.name));
+    }
+    async isTableExists(tableName) {
+        const existingSet = await this.getExistingTablesSet();
+        return existingSet.has(tableName);
+    }
+    async createShardingTableIfNeeded(tableName) {
+        if (!this.config.autoCreateTable) {
+            if (!(await this.isTableExists(tableName))) {
+                throw new Error(`[ShardingBase] 分表 ${tableName} 不存在。请先创建分表，或设置 autoCreateTable: true 自动创建`);
+            }
+            return;
+        }
+        if (!this.baseCfg.sqlDatabase || !this.baseCfg.sqlDbType) {
+            throw new Error('[ShardingBase] 请先调用 setBaseCfg 设置数据库配置');
+        }
+        const result = await this.tableCreator.createTableIfNeeded(tableName, {
+            sqlDatabase: this.baseCfg.sqlDatabase,
+            sqlDbType: this.baseCfg.sqlDbType,
+        }, this.config.tableCreateOptions);
+        if (!result.success) {
+            throw result.error || new Error(`[ShardingBase] 创建分表 ${tableName} 失败`);
+        }
+        if (result.createSql) {
+            await this.getExistingTablesSet(true);
+        }
+    }
+    // ============ 辅助方法 ============
+    buildDebugInfo(sqlTable, condition) {
+        const info = {
+            sqlDatabase: this.baseCfg.sqlDatabase || 'unknown',
+            sqlTable: sqlTable || this.config.baseTable,
+        };
+        if (condition) {
+            info.condition = condition;
+        }
+        return info;
+    }
+    formatUniqueError(foundCount, tables, condition, isMultiTable = false) {
+        const parts = [
+            `[ShardingBase] findUniqueOne 期望唯一一条记录，但查询到 ${foundCount} 条`,
+        ];
+        if (this.baseCfg.sqlDatabase) {
+            parts.push(`数据库: ${this.baseCfg.sqlDatabase}`);
+        }
+        if (isMultiTable && Array.isArray(tables)) {
+            parts.push(`基表: ${this.config.baseTable}`);
+            parts.push(`分表: [${tables.join(', ')}]`);
+        }
+        else {
+            parts.push(`表: ${typeof tables === 'string' ? tables : tables[0]}`);
+        }
+        if (condition) {
+            try {
+                parts.push(`条件: ${JSON.stringify(condition)}`);
+            }
+            catch (_a) {
+                parts.push(`条件: [无法序列化]`);
+            }
+        }
+        return parts.join(' | ');
+    }
+    /**
+     * 获取所有以 baseTable_ 开头的已存在分表（按字典序排序）
+     */
+    async getAllExistingShardingTables() {
+        const existingTables = await this.getExistingTablesSet();
+        const prefix = `${this.config.baseTable}_`;
+        const tables = Array.from(existingTables).filter(t => t.startsWith(prefix));
+        tables.sort();
+        return tables;
+    }
+    /**
+     * 过滤出真实存在的分表
+     */
+    async filterExistingTables(candidateTables) {
+        const existingTables = await this.getExistingTablesSet();
+        return candidateTables.filter(table => existingTables.has(table));
+    }
+}
+exports.ShardingBase = ShardingBase;

package/dist/libs/crud-sharding/ShardingByCustomCrud.d.ts

@@ -0,0 +1,35 @@
+import { IRequestModel } from '../../libs/crud-pro/interfaces';
+import { IShardingConfig, CrudProFactory } from './ShardingConfig';
+import { ShardingBase } from './ShardingBase';
+import { CrudWriteResult, CrudQueryOneResult, CrudQueryListResult, CrudQueryPageResult, CrudExistResult, CrudCountResult, CrudUpsertResult } from '../../libs/crud-pro/models/CrudResult';
+import { ShardingBatchInsertResult } from './ShardingResult';
+/**
+ * 自定义分表 CRUD
+ *
+ * 分表名称完全由用户提供的 customRouter 函数决定。
+ * 适用于无法用时间/哈希/键值覆盖的复杂场景（如原 RANGE 分表）。
+ *
+ * 特性：
+ * - 路由：customRouter({ config, data?, condition? }) → 表名或表名数组
+ * - 插入：customRouter 返回单个表名
+ * - 查询：customRouter 返回表名数组 → 过滤已存在表
+ * - insertOrUpdate：统一由 condition 路由定位分表，查找与插入在同一分表
+ */
+export declare class ShardingByCustomCrud extends ShardingBase {
+    constructor(crudProFactory: CrudProFactory, config: IShardingConfig);
+    private resolveTableForInsert;
+    private resolveTableForCondition;
+    private resolveFindTables;
+    insert(reqJson: IRequestModel): Promise<CrudWriteResult>;
+    batchInsert(reqJson: IRequestModel): Promise<ShardingBatchInsertResult>;
+    update(reqJson: IRequestModel): Promise<CrudWriteResult>;
+    delete(reqJson: IRequestModel): Promise<CrudWriteResult>;
+    restore(reqJson: IRequestModel): Promise<CrudWriteResult>;
+    insertOrUpdate(reqJson: IRequestModel): Promise<CrudUpsertResult>;
+    findOne<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryOneResult<T>>;
+    findUniqueOne<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryOneResult<T>>;
+    findList<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryListResult<T>>;
+    findPage<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryPageResult<T>>;
+    findCount(reqJson: IRequestModel): Promise<CrudCountResult>;
+    isExist(reqJson: IRequestModel): Promise<CrudExistResult>;
+}