midway-fatcms 0.0.7 → 0.0.8

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

@@ -1,5 +1,6 @@
 import { CrudPro } from '../../libs/crud-pro/CrudPro';
 import { IRequestModel, IRequestCfgModel } from '../../libs/crud-pro/interfaces';
+import { ExecuteContext } from '../../libs/crud-pro/models/ExecuteContext';
 import { ShardingCountCache } from './ShardingCountCache';
 /**
  * 分页查询结果
@@ -7,6 +8,14 @@ import { ShardingCountCache } from './ShardingCountCache';
 export interface IShardingPageQueryResult {
     rows: any[];
     total_count: number;
+    lastCtx: ExecuteContext | null;
+}
+/**
+ * 列表查询结果
+ */
+export interface IShardingListQueryResult {
+    rows: any[];
+    lastCtx: ExecuteContext | null;
 }
 /**
  * 分表查询结果合并器
@@ -65,7 +74,7 @@ export declare class ShardingMerger {
      * @param maxRows 最大返回行数（默认 10000，防止 OOM）
      * @returns 数据列表
      */
-    mergeQuery(crudPro: CrudPro, tables: string[], reqJson: IRequestModel, cfgJson: IRequestCfgModel, maxRows?: number): Promise<any[]>;
+    mergeQuery(crudPro: CrudPro, tables: string[], reqJson: IRequestModel, cfgJson: IRequestCfgModel, maxRows?: number): Promise<IShardingListQueryResult>;
     /**
      * 根据各表数量和分页偏移，直接定位目标表
      *
@@ -95,23 +104,6 @@ export declare class ShardingMerger {
      * 支持 COUNT 缓存：历史时间分表使用缓存，当前表实时查询
      */
     private queryCountSafe;
-    /**
-     * 安全查询数据行（表不存在时返回空数组）
-     */
-    private queryRowsSafe;
-    /**
-     * 安全查询数据行（支持表内偏移，表不存在时返回空数组）
-     *
-     * 用于分页定位后，直接从某张表指定偏移处取数据
-     *
-     * @param crudPro CrudPro 实例
-     * @param table 分表名
-     * @param reqJson 请求参数
-     * @param cfgJson 配置
-     * @param innerOffset 表内偏移（跳过前 N 条）
-     * @param innerLimit 取多少条
-     */
-    private queryRowsSafeWithOffset;
     /**
      * 执行 COUNT 查询
      */

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

@@ -46,25 +46,36 @@ class ShardingMerger {
         const { pageNo = 1, pageSize = 10 } = reqJson;
         const offset = (pageNo - 1) * pageSize;
         const targetEnd = offset + pageSize; // 需要取到第几条
-        // 1. 并行查询所有分表的记录数
-        const countPromises = tables.map(table => this.queryCountSafe(crudPro, table, reqJson, cfgJson));
-        const counts = await Promise.all(countPromises);
+        // 1. 串行查询所有分表的记录数
+        const counts = [];
+        for (const table of tables) {
+            const count = await this.queryCountSafe(crudPro, table, reqJson, cfgJson);
+            counts.push(count);
+        }
         const totalCount = counts.reduce((sum, c) => sum + c, 0);
         // 总数为0，直接返回
         if (totalCount === 0) {
-            return { rows: [], total_count: 0 };
+            return { rows: [], total_count: 0, lastCtx: null };
         }
         // 2. 根据累计数量直接定位目标表
         const targetTables = this.locateTargetTables(tables, counts, offset, targetEnd);
         // 3. 只查询包含目标数据的分表
         let allRows = [];
+        let lastCtx = null;
         for (const target of targetTables) {
-            const rows = await this.queryRowsSafeWithOffset(crudPro, target.table, reqJson, cfgJson, target.innerOffset, target.innerLimit);
-            allRows = allRows.concat(rows);
+            try {
+                const ctx = await this.executeQueryWithOffset(crudPro, target.table, reqJson, cfgJson, target.innerOffset, target.innerLimit);
+                lastCtx = ctx;
+                allRows = allRows.concat(ctx.getResRows() || []);
+            }
+            catch (e) {
+                // 表不存在或其他错误，跳过
+            }
         }
         return {
             rows: allRows,
             total_count: totalCount,
+            lastCtx,
         };
     }
     /**
@@ -88,20 +99,27 @@ class ShardingMerger {
     async mergeQuery(crudPro, tables, reqJson, cfgJson, maxRows = 10000) {
         // 串行查询分表，按表顺序拼接，达到上限即停
         let allRows = [];
+        let lastCtx = null;
         for (const table of tables) {
             const needMore = maxRows - allRows.length;
             if (needMore <= 0) {
                 break;
             }
-            const rows = await this.queryRowsSafe(crudPro, table, reqJson, cfgJson, needMore);
-            allRows = allRows.concat(rows);
+            try {
+                const ctx = await this.executeQuery(crudPro, table, reqJson, cfgJson, needMore);
+                lastCtx = ctx;
+                allRows = allRows.concat(ctx.getResRows() || []);
+            }
+            catch (e) {
+                // 表不存在或其他错误，跳过
+            }
             // 达到上限后停止，不再查询后续表
             if (allRows.length >= maxRows) {
                 allRows = allRows.slice(0, maxRows);
                 break;
             }
         }
-        return allRows;
+        return { rows: allRows, lastCtx };
     }
     // ============ 私有方法：分页定位 ============
     /**
@@ -192,41 +210,6 @@ class ShardingMerger {
             return 0;
         }
     }
-    /**
-     * 安全查询数据行（表不存在时返回空数组）
-     */
-    async queryRowsSafe(crudPro, table, reqJson, cfgJson, limit) {
-        try {
-            const ctx = await this.executeQuery(crudPro, table, reqJson, cfgJson, limit);
-            return ctx.getResRows() || [];
-        }
-        catch (e) {
-            // 表不存在或其他错误，返回空数组
-            return [];
-        }
-    }
-    /**
-     * 安全查询数据行（支持表内偏移，表不存在时返回空数组）
-     *
-     * 用于分页定位后，直接从某张表指定偏移处取数据
-     *
-     * @param crudPro CrudPro 实例
-     * @param table 分表名
-     * @param reqJson 请求参数
-     * @param cfgJson 配置
-     * @param innerOffset 表内偏移（跳过前 N 条）
-     * @param innerLimit 取多少条
-     */
-    async queryRowsSafeWithOffset(crudPro, table, reqJson, cfgJson, innerOffset, innerLimit) {
-        try {
-            const ctx = await this.executeQueryWithOffset(crudPro, table, reqJson, cfgJson, innerOffset, innerLimit);
-            return ctx.getResRows() || [];
-        }
-        catch (e) {
-            // 表不存在或其他错误，返回空数组
-            return [];
-        }
-    }
     /**
      * 执行 COUNT 查询
      */

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

@@ -0,0 +1,33 @@
+import { ExecuteContext } from '../../libs/crud-pro/models/ExecuteContext';
+import { CrudResultBase } from '../../libs/crud-pro/models/CrudResult';
+/** 分表批量插入结果 */
+declare class ShardingBatchInsertResult extends CrudResultBase {
+    readonly totalAffected: number;
+    readonly tableResults: Array<{
+        table: string;
+        affected: number;
+        rowCount: number;
+    }>;
+    readonly tableCount: number;
+    readonly success: boolean;
+    readonly errors: Array<{
+        table: string;
+        error: Error;
+    }>;
+    constructor(data: {
+        totalAffected: number;
+        tableResults: Array<{
+            table: string;
+            affected: number;
+            rowCount: number;
+        }>;
+        tableCount: number;
+        success: boolean;
+        errors: Array<{
+            table: string;
+            error: Error;
+        }>;
+        lastContext: ExecuteContext;
+    });
+}
+export { ShardingBatchInsertResult };

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardingBatchInsertResult = void 0;
+const CrudResult_1 = require("../../libs/crud-pro/models/CrudResult");
+/** 分表批量插入结果 */
+class ShardingBatchInsertResult extends CrudResult_1.CrudResultBase {
+    constructor(data) {
+        super(data.lastContext);
+        this.totalAffected = data.totalAffected;
+        this.tableResults = data.tableResults;
+        this.tableCount = data.tableCount;
+        this.success = data.success;
+        this.errors = data.errors;
+    }
+}
+exports.ShardingBatchInsertResult = ShardingBatchInsertResult;

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

@@ -62,6 +62,7 @@ export declare class ShardingRouter {
     private generateTablesInRange;
     private getRecentTables;
     private getRecentCountByGranularity;
+    private getDefaultRecentCount;
     private calculateRangeIndex;
     private calculateHash;
     private simpleHash;

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

@@ -114,6 +114,8 @@ class ShardingRouter {
             const suffix = (0, ShardingUtils_1.getTimeSuffix)(singleTimeValue, granularity);
             return this.formatTableName(baseTable, suffix, config);
         }
+        // 时间分表写操作必须包含时间字段
+        // 但查询操作允许回退到 recentTableCount
         const recentCount = this.getRecentCountByGranularity(granularity, config);
         return this.getRecentTables(baseTable, granularity, recentCount, config);
     }
@@ -167,9 +169,10 @@ class ShardingRouter {
             const recentTables = shardingTables.slice(-config.recentTableCount);
             return this.intersectWithCondition(recentTables, config, condition);
         }
-        // 未配置 recentTableCount：所有表与条件取交集，最多取3张
+        // 未配置 recentTableCount：所有表与条件取交集，最多取默认数量
         const intersected = this.intersectWithCondition(shardingTables, config, condition);
-        return intersected.slice(0, 3);
+        const defaultCount = this.getDefaultRecentCount(config);
+        return intersected.slice(0, defaultCount);
     }
     intersectWithCondition(tables, config, condition) {
         if (!condition) {
@@ -186,6 +189,7 @@ class ShardingRouter {
             const targetTable = `${config.baseTable}_${suffix}`;
             return tables.includes(targetTable) ? [targetTable] : [];
         }
+        // condition 存在但不包含时间字段，返回所有表（按时间降序）
         return this.sortTablesByTimeDesc(tables);
     }
     intersectTablesByTimeRange(tables, timeRange, config) {
@@ -317,6 +321,7 @@ class ShardingRouter {
         }
         return tables;
     }
+    // ============ 格式化 ============
     getRecentTables(baseTable, granularity, count, config) {
         const tables = [];
         const current = moment();
@@ -343,14 +348,28 @@ class ShardingRouter {
         }
         switch (granularity) {
             case 'year':
-                return 3;
+                return 2;
             case 'month':
-                return 12;
+                return 3;
             case 'day':
                 return 7;
         }
     }
-    // ============ 计算相关 ============
+    getDefaultRecentCount(config) {
+        if (config.recentTableCount !== undefined && config.recentTableCount > 0) {
+            return config.recentTableCount;
+        }
+        switch (config.type) {
+            case ShardingConfig_1.ShardingType.YEAR:
+                return 2;
+            case ShardingConfig_1.ShardingType.MONTH:
+                return 3;
+            case ShardingConfig_1.ShardingType.DAY:
+                return 7;
+            default:
+                return 3;
+        }
+    }
     calculateRangeIndex(value, count) {
         if (typeof value === 'number') {
             return Math.abs(value) % count;
@@ -368,7 +387,7 @@ class ShardingRouter {
         }
         return hash;
     }
-    // ============ 格式化 ============
+    // ============ 表名格式化 ============
     formatTableName(baseTable, suffix, config) {
         const formattedSuffix = config.suffixFormatter ? config.suffixFormatter(suffix) : suffix;
         return `${baseTable}_${formattedSuffix}`;

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

@@ -1,6 +1,5 @@
-import { CrudPro } from '../../libs/crud-pro/CrudPro';
 import { SqlDbType } from '../../libs/crud-pro/models/keys';
-import { IShardingConfig, IShardingTableCreateOptions, IShardingTableCreateResult } from './ShardingConfig';
+import { CrudProFactory, IShardingConfig, IShardingTableCreateOptions, IShardingTableCreateResult } from './ShardingConfig';
 /**
  * 分表自动创建器
  *
@@ -14,9 +13,9 @@ import { IShardingConfig, IShardingTableCreateOptions, IShardingTableCreateResul
  * });
  */
 export declare class ShardingTableCreator {
-    private readonly crudPro;
+    private readonly crudProFactory;
     private readonly config;
-    constructor(crudPro: CrudPro, config: IShardingConfig);
+    constructor(crudProFactory: CrudProFactory, config: IShardingConfig);
     /**
      * 校验表名格式，防止 SQL 注入
      * 只允许合法的数据库标识符：以字母或下划线开头，后续只能包含字母数字下划线
@@ -34,6 +33,12 @@ export declare class ShardingTableCreator {
         sqlDatabase: string;
         sqlDbType: SqlDbType;
     }, options?: IShardingTableCreateOptions): Promise<IShardingTableCreateResult>;
+    /**
+     * 检查表是否已存在
+     * 复用 CrudPro.getAllTableInfos 接口，使用缓存提升性能
+     * DDL 操作本身具有幂等性（CREATE TABLE IF NOT EXISTS），缓存短暂延迟可接受
+     */
+    private checkTableExists;
     /**
      * 获取基表列信息
      */
@@ -102,6 +107,10 @@ export declare class ShardingTableCreator {
      * 执行建表 SQL
      */
     private executeCreateSql;
+    /**
+     * 判断是否为"已存在"类错误（表已存在、索引已存在等）
+     */
+    private isDuplicateError;
     /**
      * 复制索引（可选功能）
      *
@@ -109,6 +118,14 @@ export declare class ShardingTableCreator {
      * 注意：主键索引已在建表时创建，此处只复制普通索引。
      */
     private copyIndexes;
+    /**
+     * 获取目标表已存在的所有索引名
+     */
+    private getExistingIndexNames;
+    /**
+     * 从 CREATE INDEX 语句中提取索引名
+     */
+    private extractIndexName;
     /**
      * 在索引 SQL 中替换表名
      *