midway-fatcms 0.0.7 → 0.0.9

package/src/{service/curd → libs/crud-pro-quick}/fixSoftDelete.ts

@@ -1,28 +1,38 @@
 import { KeysOfSimpleSQL } from "@/libs/crud-pro/models/keys";
-import { IRequestModel } from "@/libs/crud-pro/interfaces";
-import { IRequestCfgModel2 } from "@/models/bizmodels";
-import { Context } from "@midwayjs/koa";
-import type { ICommonStandardColumns } from "@/models/StandardColumns";
+import { IRequestModel, IVisitor } from "@/libs/crud-pro/interfaces";
+import { IRequestCfgModel2, ICommonStandardColumns } from "./models";
+
+/**
+ * 软删除需要的用户信息（最小子集）
+ */
+interface ISoftDeleteUserInfo {
+  accountId: string;
+}
+
+/**
+ * 获取当前用户信息的函数类型
+ */
+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 ctx 请求上下文（用于获取当前用户信息）
+ * @param visitor 获取当前用户信息的函数（用于软删除时记录删除人）
  */
 function fixSoftDelete(
   oldSqlSimpleName: KeysOfSimpleSQL,
   cfgModel: IRequestCfgModel2,
   params: IRequestModel,
-  ctx?: Context
+  visitor?: IVisitor
 ): void {
 
   // 没有开启软删除，不做处理，直接物理删除
@@ -47,8 +57,6 @@ function fixSoftDelete(
       throw new Error('执行删除操作，必须指定删除条件');
     }
 
-    // 获取当前用户信息
-    const sessionInfo = ctx?.userSession?.getSessionInfo();
 
     // 在原有 data 对象上添加软删除字段
     if (!params.data) {
@@ -56,7 +64,7 @@ function fixSoftDelete(
     }
     const dataObj = params.data as ICommonStandardColumns;
     dataObj.deleted_at = Date.now();
-    dataObj.deleted_by = sessionInfo?.accountId || '';
+    dataObj.deleted_by = visitor?.accountId || '';
 
     // 改为执行 UPDATE 操作
     cfgModel.sqlSimpleName = KeysOfSimpleSQL.SIMPLE_UPDATE;
@@ -77,4 +85,6 @@ function fixSoftDelete(
 
 export {
   fixSoftDelete,
-}
+};
+
+export type { ISoftDeleteUserInfo, GetCurrentUserFunc };

package/src/libs/crud-pro-quick/index.ts

@@ -0,0 +1,52 @@
+/**
+ * 快捷 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/src/libs/crud-pro-quick/models.ts

@@ -0,0 +1,35 @@
+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[]; // 默认为true
+  enableStandardUpdateCfgCondition?: boolean | string[]; // 默认为false
+  enableSoftDelete?: boolean;
+}

package/src/libs/crud-sharding/ShardingBase.ts

@@ -0,0 +1,256 @@
+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 { fixSoftDelete } from '@/libs/crud-pro-quick/fixSoftDelete';
+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 abstract class ShardingBase {
+  protected readonly crudProFactory: CrudProFactory;
+  protected readonly config: IShardingConfig;
+  protected readonly tableCreator: ShardingTableCreator;
+
+  protected baseCfg: Partial<IRequestCfgModel> = {};
+  protected enableSoftDelete: boolean = false;
+
+  constructor(crudProFactory: CrudProFactory, config: IShardingConfig) {
+    this.config = config;
+
+    if (typeof crudProFactory === 'function') {
+      this.crudProFactory = crudProFactory;
+    } else {
+      throw new Error('[ShardingBase] 请使用 CrudProFactory 工厂函数模式');
+    }
+
+    this.tableCreator = new ShardingTableCreator(this.crudProFactory, config);
+  }
+
+  // ============ 配置方法 ============
+
+  public setBaseCfg(cfg: Partial<IRequestCfgModel>): this {
+    this.baseCfg = { ...this.baseCfg, ...cfg };
+    return this;
+  }
+
+  public getConfig(): IShardingConfig {
+    return this.config;
+  }
+
+  public setEnableSoftDelete(enable: boolean): this {
+    this.enableSoftDelete = enable;
+    return this;
+  }
+
+  // ============ 抽象 CRUD 方法（子类必须实现） ============
+
+  public abstract insert(reqJson: IRequestModel): Promise<CrudWriteResult>;
+  public abstract batchInsert(reqJson: IRequestModel): Promise<ShardingBatchInsertResult>;
+  public abstract update(reqJson: IRequestModel): Promise<CrudWriteResult>;
+  public abstract delete(reqJson: IRequestModel): Promise<CrudWriteResult>;
+  public abstract restore(reqJson: IRequestModel): Promise<CrudWriteResult>;
+  public abstract insertOrUpdate(reqJson: IRequestModel): Promise<CrudUpsertResult>;
+  public abstract findOne<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryOneResult<T>>;
+  public abstract findUniqueOne<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryOneResult<T>>;
+  public abstract findList<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryListResult<T>>;
+  public abstract findPage<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryPageResult<T>>;
+  public abstract findCount(reqJson: IRequestModel): Promise<CrudCountResult>;
+  public abstract isExist(reqJson: IRequestModel): Promise<CrudExistResult>;
+
+  /**
+   * 判断当前路由上下文是否处于「插入阶段」（应从 data 提取分表字段）
+   *
+   * - INSERT / BATCH_INSERT → 始终从 data
+   * - 其余操作（QUERY / UPDATE / DELETE / INSERT_OR_UPDATE）→ 从 condition
+   */
+  protected static isInsertPhase(ctx: IShardingRouterContext): boolean {
+    return [KeysOfSimpleSQL.SIMPLE_INSERT, KeysOfSimpleSQL.SIMPLE_BATCH_INSERT].includes(ctx.sqlSimpleName);
+  }
+
+  // ============ 执行基础设施 ============
+
+  protected buildCfg(sqlSimpleName: KeysOfSimpleSQL): IRequestCfgModel & { enableSoftDelete?: boolean } {
+    return {
+      method: `ShardingCrudProAnonymous_${sqlSimpleName}`,
+      ...this.baseCfg,
+      sqlTable: this.config.baseTable,
+      sqlSimpleName,
+    } as IRequestCfgModel & { enableSoftDelete?: boolean };
+  }
+
+  protected async executeOnTable(
+    table: string,
+    reqJson: IRequestModel,
+    sqlSimpleName: KeysOfSimpleSQL,
+    extraCfg?: Partial<IRequestCfgModel>
+  ): Promise<ExecuteContext> {
+    const cfg = this.buildCfg(sqlSimpleName);
+    cfg.sqlTable = table;
+    cfg.enableSoftDelete = this.enableSoftDelete;
+
+    if (extraCfg) {
+      Object.assign(cfg, extraCfg);
+    }
+
+    const crudPro = this.crudProFactory();
+    fixSoftDelete(sqlSimpleName, cfg as any, reqJson, crudPro.getVisitor());
+    return crudPro.executeCrudByCfg(reqJson, cfg);
+  }
+
+  // ============ 单表查询辅助 ============
+
+  protected async findCountFromTable(table: string, reqJson: IRequestModel): Promise<{ count: number; ctx: ExecuteContext | null }> {
+    try {
+      const ctx = await this.executeOnTable(table, reqJson, KeysOfSimpleSQL.SIMPLE_QUERY_COUNT);
+      return { count: ctx.getResModelItem('total_count') || 0, ctx };
+    } catch (e) {
+      return { count: 0, ctx: null };
+    }
+  }
+
+  protected async isExistInTable(table: string, reqJson: IRequestModel): Promise<{ exists: boolean; ctx: ExecuteContext | null }> {
+    try {
+      const ctx = await this.executeOnTable(table, reqJson, KeysOfSimpleSQL.SIMPLE_QUERY_EXIST);
+      return { exists: ctx.getResModelItem('is_exist') === true, ctx };
+    } catch (e) {
+      return { exists: false, ctx: null };
+    }
+  }
+
+  // ============ 表管理 ============
+
+  protected async getExistingTablesSet(skipCache = false): Promise<Set<string>> {
+    const { sqlDatabase, sqlDbType } = this.baseCfg;
+
+    if (!sqlDatabase || !sqlDbType) {
+      throw new Error('[ShardingBase] 未配置 sqlDatabase 或 sqlDbType');
+    }
+
+    const { tables } = await this.crudProFactory().getAllTableInfos(
+      { sqlDatabase, sqlDbType: sqlDbType as any },
+      { skipCache }
+    );
+
+    return new Set(tables.map(t => t.name));
+  }
+
+  protected async isTableExists(tableName: string): Promise<boolean> {
+    const existingSet = await this.getExistingTablesSet();
+    return existingSet.has(tableName);
+  }
+
+  protected async createShardingTableIfNeeded(tableName: string): Promise<void> {
+    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);
+    }
+  }
+
+  // ============ 辅助方法 ============
+
+  protected buildDebugInfo(sqlTable: string | undefined, condition: Record<string, any> | undefined): { sqlDatabase: string; sqlTable: string; condition?: Record<string, any> } {
+    const info: { sqlDatabase: string; sqlTable: string; condition?: Record<string, any> } = {
+      sqlDatabase: this.baseCfg.sqlDatabase || 'unknown',
+      sqlTable: sqlTable || this.config.baseTable,
+    };
+    if (condition) {
+      info.condition = condition;
+    }
+    return info;
+  }
+
+  protected formatUniqueError(
+    foundCount: number,
+    tables: string | string[],
+    condition: Record<string, any> | undefined,
+    isMultiTable: boolean = false
+  ): string {
+    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 {
+        parts.push(`条件: [无法序列化]`);
+      }
+    }
+
+    return parts.join(' | ');
+  }
+
+  /**
+   * 获取所有以 baseTable_ 开头的已存在分表（按字典序排序）
+   */
+  protected async getAllExistingShardingTables(): Promise<string[]> {
+    const existingTables = await this.getExistingTablesSet();
+    const prefix = `${this.config.baseTable}_`;
+    const tables = Array.from(existingTables).filter(t => t.startsWith(prefix));
+    tables.sort();
+    return tables;
+  }
+
+  /**
+   * 过滤出真实存在的分表
+   */
+  protected async filterExistingTables(candidateTables: string[]): Promise<string[]> {
+    const existingTables = await this.getExistingTablesSet();
+    return candidateTables.filter(table => existingTables.has(table));
+  }
+}