midway-fatcms 0.0.5 → 0.0.7

package/dist/service/curd/CrudProQuick.js

@@ -15,6 +15,11 @@ class CrudProQuick {
         this.curdPro = args.curdPro;
         this.sqlTable = args.sqlTable; // 全局sqlTable为空时，单独调用时就必须传sqlTable参数。
     }
+    /**
+     * 设置基础配置模型，合并到实例的 baseCfgModel 中，后续所有 CRUD 操作都会携带这些配置
+     * 例如可以统一设置 maxLimit、sqlSimpleName 等公共参数，避免每次调用都重复传入
+     * @param baseCfgModel 要合并的配置项
+     */
     setBaseCfgModel(baseCfgModel) {
         Object.assign(this.baseCfgModel, baseCfgModel);
     }
@@ -89,6 +94,13 @@ class CrudProQuick {
         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,
@@ -97,6 +109,28 @@ class CrudProQuick {
         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,
@@ -105,6 +139,13 @@ class CrudProQuick {
         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,
@@ -113,6 +154,36 @@ class CrudProQuick {
         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,
@@ -121,6 +192,13 @@ class CrudProQuick {
         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,
@@ -129,6 +207,37 @@ class CrudProQuick {
         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,
@@ -137,6 +246,13 @@ class CrudProQuick {
         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,
@@ -148,9 +264,45 @@ class CrudProQuick {
         return await this.curdPro.executeSQL(sqlCfgModel);
     }
     /**
-     * 执行数据库的原生SQL语句，不做任何封装的SQL
-     * @param executeNativeSql
-     * @param args
+     * 执行数据库的原生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 = {

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

@@ -1,4 +1,4 @@
-import { ColumnRelation, IRequestCfgModel, IRequestModel, ISqlCfgModel } from '../../libs/crud-pro/interfaces';
+import { ColumnRelation, IRequestCfgModel, IRequestModel, ISqlCfgModel, ITableListResult, ITableNamesOptions, ITableNamesQuery } from '../../libs/crud-pro/interfaces';
 import { IRequestCfgModel2 } from '../../models/bizmodels';
 import { SqlDbType } from '../../libs/crud-pro/models/keys';
 import { ExecuteContext } from '../../libs/crud-pro/models/ExecuteContext';
@@ -25,4 +25,5 @@ export declare class CurdMixService {
      * @returns
      */
     linkColumnRelationDatas(rows: any[], param: ILinkColumnRelationParam): Promise<void>;
+    getAllTableInfos(query: ITableNamesQuery, options?: ITableNamesOptions): Promise<ITableListResult>;
 }

package/dist/service/curd/CurdMixService.js

@@ -32,7 +32,7 @@ let CurdMixService = class CurdMixService {
     }
     getBbUtil(sqlDatabase, sqlDbType, sqlTable) {
         this.prepare();
-        return this.curdProService.getBbUtil(sqlDatabase, sqlDbType, sqlTable);
+        return this.curdProService.getQuickCrud(sqlDatabase, sqlDbType, sqlTable);
     }
     async executeSQL(sqlCfgModel) {
         this.prepare();
@@ -69,6 +69,10 @@ let CurdMixService = class CurdMixService {
             await handler.handleExecuteContext(exeCtx);
         }
     }
+    async getAllTableInfos(query, options) {
+        this.prepare();
+        return this.curdProService.getAllTableInfos(query, options);
+    }
 };
 __decorate([
     (0, core_1.Inject)(),

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

@@ -1,11 +1,12 @@
 import { Context } from '@midwayjs/koa';
-import { IRequestCfgModel, IRequestModel, ISqlCfgModel } from '../../libs/crud-pro/interfaces';
+import { IRequestCfgModel, IRequestModel, ISqlCfgModel, ITableListResult, ITableNamesOptions, ITableNamesQuery } 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 '../../service/curd/CrudProQuick';
+import { CrudProQuick } from './CrudProQuick';
+import { ShardingCrudPro, IShardingConfig } from '../../libs/crud-sharding';
 export declare class CurdProService extends BaseService {
     protected ctx: Context;
     private mysql2Config;
@@ -27,6 +28,47 @@ export declare class CurdProService extends BaseService {
     executeCrud(reqJson: IRequestModel): Promise<ExecuteContext>;
     executeSQL(sqlCfgModel: ISqlCfgModel): Promise<any>;
     executeCrudByCfg(reqJson: IRequestModel, cfgModel: IRequestCfgModel2): Promise<ExecuteContext>;
+    /**
+     * 获取 CrudProQuick 工具类（已废弃）
+     *
+     * @deprecated 请使用 getQuickCrud 替代
+     * @param sqlDatabase 数据库名
+     * @param sqlDbType 数据库类型
+     * @param sqlTable 表名（可选）
+     * @returns CrudProQuick 实例
+     */
     getBbUtil(sqlDatabase: string, sqlDbType: SqlDbType, sqlTable?: string): CrudProQuick;
+    /**
+     * 获取 CrudProQuick 工具类
+     *
+     * 提供快速 CRUD 操作的便捷方法，封装了常用的数据库操作。
+     *
+     * @param sqlDatabase 数据库名
+     * @param sqlDbType 数据库类型
+     * @param sqlTable 表名（可选）
+     * @returns CrudProQuick 实例
+     *
+     * @example
+     * const quick = curdProService.getQuickCrud('mydb', SqlDbType.mysql, 't_user');
+     * const users = await quick.query({ status: 'active' });
+     */
+    getQuickCrud(sqlDatabase: string, sqlDbType: SqlDbType, sqlTable?: string): CrudProQuick;
+    /**
+     * 获取分表 CRUD 操作器
+     *
+     * @param sqlDatabase 数据库名
+     * @param sqlDbType 数据库类型
+     * @param shardingConfig 分表配置
+     * @returns ShardingCrudPro 实例
+     *
+     * @example
+     * const sharding = curdProService.getShardingCrud('mydb', SqlDbType.mysql, {
+     *   type: ShardingType.MONTH,
+     *   baseTable: 't_order',
+     *   timeColumn: 'created_at',
+     * });
+     */
+    getShardingCrud(sqlDatabase: string, sqlDbType: SqlDbType, shardingConfig: IShardingConfig): ShardingCrudPro;
     getCachedCfgByMethod(method: string): Promise<IRequestCfgModel>;
+    getAllTableInfos(query: ITableNamesQuery, options?: ITableNamesOptions): Promise<ITableListResult>;
 }

package/dist/service/curd/CurdProService.js

@@ -20,7 +20,8 @@ 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("../../service/curd/CrudProQuick");
+const CrudProQuick_1 = require("./CrudProQuick");
+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");
@@ -179,15 +180,66 @@ let CurdProService = class CurdProService extends BaseService_1.BaseService {
         (0, fixSoftDelete_1.fixSoftDelete)(cfgModel.sqlSimpleName, cfgModel, reqJson, this.ctx);
         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 表名（可选）
+     * @returns CrudProQuick 实例
+     *
+     * @example
+     * const quick = curdProService.getQuickCrud('mydb', SqlDbType.mysql, 't_user');
+     * const users = await quick.query({ status: 'active' });
+     */
+    getQuickCrud(sqlDatabase, sqlDbType, sqlTable) {
         const curdPro = this.getCrudPro();
         return new CrudProQuick_1.CrudProQuick({ curdPro, sqlDatabase, sqlDbType, sqlTable, ctx: this.ctx });
     }
+    /**
+     * 获取分表 CRUD 操作器
+     *
+     * @param sqlDatabase 数据库名
+     * @param sqlDbType 数据库类型
+     * @param shardingConfig 分表配置
+     * @returns ShardingCrudPro 实例
+     *
+     * @example
+     * const sharding = curdProService.getShardingCrud('mydb', SqlDbType.mysql, {
+     *   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);
+        sharding.setBaseCfg({ sqlDatabase, sqlDbType });
+        return sharding;
+    }
     async getCachedCfgByMethod(method) {
         const curdPro = this.getCrudPro();
         const isEnableCache = !this.isEnableDebug(); // 开发环境不使用缓存
         return curdPro.getCachedCfgByMethod(method, isEnableCache);
     }
+    async getAllTableInfos(query, options) {
+        const curdPro = this.getCrudPro();
+        return curdPro.getAllTableInfos(query, options);
+    }
 };
 __decorate([
     (0, core_1.Inject)(),