midway-fatcms 0.0.7 → 0.0.9

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

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardingByCustomCrud = void 0;
+const keys_1 = require("../../libs/crud-pro/models/keys");
+const ShardingBase_1 = require("./ShardingBase");
+const CrudResult_1 = require("../../libs/crud-pro/models/CrudResult");
+const ShardingResult_1 = require("./ShardingResult");
+/**
+ * 自定义分表 CRUD
+ *
+ * 分表名称完全由用户提供的 customRouter 函数决定。
+ * 适用于无法用时间/哈希/键值覆盖的复杂场景（如原 RANGE 分表）。
+ *
+ * 特性：
+ * - 路由：customRouter({ config, data?, condition? }) → 表名或表名数组
+ * - 插入：customRouter 返回单个表名
+ * - 查询：customRouter 返回表名数组 → 过滤已存在表
+ * - insertOrUpdate：统一由 condition 路由定位分表，查找与插入在同一分表
+ */
+class ShardingByCustomCrud extends ShardingBase_1.ShardingBase {
+    constructor(crudProFactory, config) {
+        super(crudProFactory, config);
+        if (!config.customRouter) {
+            throw new Error('[ShardingByCustomCrud] 自定义分表必须提供 customRouter 函数');
+        }
+    }
+    // ============ 路由 ============
+    resolveTableForInsert(data, sqlSimpleName) {
+        const context = { config: this.config, data, sqlSimpleName };
+        const result = this.config.customRouter(context);
+        if (Array.isArray(result)) {
+            if (result.length === 1) {
+                return result[0];
+            }
+            throw new Error(`[ShardingByCustomCrud] 插入操作需要 customRouter 返回单个表名，但返回了 ${result.length} 个: ${result.slice(0, 5).join(', ')}`);
+        }
+        if (typeof result === 'string' && result) {
+            return result;
+        }
+        throw new Error('[ShardingByCustomCrud] 插入操作需要 customRouter 返回单个表名, 实际返回了空值');
+    }
+    resolveTableForCondition(condition, sqlSimpleName) {
+        const context = { config: this.config, condition, sqlSimpleName };
+        const result = this.config.customRouter(context);
+        if (Array.isArray(result)) {
+            if (result.length === 1)
+                return result[0];
+            throw new Error(`[ShardingByCustomCrud] 写操作需要 customRouter 返回单个表名，但返回了 ${result.length} 个: ${result.slice(0, 5).join(', ')}`);
+        }
+        return result;
+    }
+    async resolveFindTables(reqJson, sqlSimpleName) {
+        const context = { config: this.config, condition: reqJson.condition, sqlSimpleName };
+        const result = this.config.customRouter(context);
+        const candidates = Array.isArray(result) ? result : [result];
+        return this.filterExistingTables(candidates);
+    }
+    // ============ 写操作 ============
+    async insert(reqJson) {
+        const targetTable = this.resolveTableForInsert(reqJson.data, keys_1.KeysOfSimpleSQL.SIMPLE_INSERT);
+        await this.createShardingTableIfNeeded(targetTable);
+        const ctx = await this.executeOnTable(targetTable, reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_INSERT);
+        const affected = ctx.getResModel().affected || { affectedRows: 0 };
+        return new CrudResult_1.CrudWriteResult({ affectedRows: affected.affectedRows, insertId: affected.insertId, rawContext: ctx });
+    }
+    async batchInsert(reqJson) {
+        var _a, _b;
+        const dataArray = reqJson.data;
+        if (!Array.isArray(dataArray) || dataArray.length === 0) {
+            throw new Error('[ShardingByCustomCrud] batchInsert requires non-empty data array');
+        }
+        const groupedData = new Map();
+        for (const item of dataArray) {
+            const table = this.resolveTableForInsert(item, keys_1.KeysOfSimpleSQL.SIMPLE_BATCH_INSERT);
+            if (!groupedData.has(table))
+                groupedData.set(table, []);
+            groupedData.get(table).push(item);
+        }
+        for (const tableName of groupedData.keys()) {
+            await this.createShardingTableIfNeeded(tableName);
+        }
+        const results = [];
+        let lastContext = null;
+        for (const [table, items] of groupedData.entries()) {
+            try {
+                const ctx = await this.executeOnTable(table, { data: items }, keys_1.KeysOfSimpleSQL.SIMPLE_BATCH_INSERT);
+                lastContext = ctx;
+                results.push({ table, affected: ((_a = ctx.getResModelItem('affected')) === null || _a === void 0 ? void 0 : _a.affectedRows) || items.length, rowCount: items.length, error: null, context: ctx });
+            }
+            catch (e) {
+                results.push({ table, affected: 0, rowCount: items.length, error: e, context: null });
+            }
+        }
+        const tableResults = results.map(r => ({ table: r.table, affected: r.affected, rowCount: r.rowCount }));
+        const errors = results.filter(r => r.error !== null).map(r => ({ table: r.table, error: r.error }));
+        const totalAffected = results.reduce((sum, r) => sum + r.affected, 0);
+        const finalContext = lastContext || ((_b = results.find(r => r.context)) === null || _b === void 0 ? void 0 : _b.context);
+        if (!finalContext)
+            throw new Error('[ShardingByCustomCrud] batchInsert failed - no successful inserts');
+        return new ShardingResult_1.ShardingBatchInsertResult({ totalAffected, tableResults, tableCount: groupedData.size, success: errors.length === 0, errors, lastContext: finalContext });
+    }
+    async update(reqJson) {
+        const targetTable = this.resolveTableForCondition(reqJson.condition, keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE);
+        const ctx = await this.executeOnTable(targetTable, reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE);
+        const affected = ctx.getResModel().affected || { affectedRows: 0 };
+        return new CrudResult_1.CrudWriteResult({ affectedRows: affected.affectedRows, insertId: affected.insertId, rawContext: ctx });
+    }
+    async delete(reqJson) {
+        const targetTable = this.resolveTableForCondition(reqJson.condition, keys_1.KeysOfSimpleSQL.SIMPLE_DELETE);
+        const ctx = await this.executeOnTable(targetTable, reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_DELETE);
+        const affected = ctx.getResModel().affected || { affectedRows: 0 };
+        return new CrudResult_1.CrudWriteResult({ affectedRows: affected.affectedRows, insertId: affected.insertId, rawContext: ctx });
+    }
+    async restore(reqJson) {
+        const targetTable = this.resolveTableForCondition(reqJson.condition, keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE);
+        if (!reqJson.condition || Object.keys(reqJson.condition).length === 0) {
+            throw new Error('[ShardingByCustomCrud] restore 操作必须指定恢复条件');
+        }
+        const restoreReqJson = {
+            ...reqJson,
+            data: { ...reqJson.data, deleted_at: 0, deleted_by: '' },
+        };
+        const ctx = await this.executeOnTable(targetTable, restoreReqJson, keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE);
+        const affected = ctx.getResModel().affected || { affectedRows: 0 };
+        return new CrudResult_1.CrudWriteResult({ affectedRows: affected.affectedRows, insertId: affected.insertId, rawContext: ctx });
+    }
+    async insertOrUpdate(reqJson) {
+        const targetTable = this.resolveTableForCondition(reqJson.condition, keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE);
+        const existCtx = await this.executeOnTable(targetTable, reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_EXIST);
+        const isExist = existCtx.getResModelItem('is_exist') === true;
+        if (isExist) {
+            const updateCtx = await this.executeOnTable(targetTable, reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE);
+            return new CrudResult_1.CrudUpsertResult({ insertAffected: undefined, updateAffected: updateCtx.getResModel().affected, isExist: true, rawContext: updateCtx });
+        }
+        await this.createShardingTableIfNeeded(targetTable);
+        const insertCtx = await this.executeOnTable(targetTable, reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_INSERT);
+        return new CrudResult_1.CrudUpsertResult({ insertAffected: insertCtx.getResModel().affected, updateAffected: undefined, isExist: false, rawContext: insertCtx });
+    }
+    // ============ 查询操作 ============
+    async findOne(reqJson) {
+        const targetTables = await this.resolveFindTables(reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE);
+        if (targetTables.length === 0)
+            throw new Error('[ShardingByCustomCrud] findOne: no matching tables found');
+        let lastCtx = null;
+        let lastTable;
+        for (const table of targetTables) {
+            try {
+                const ctx = await this.executeOnTable(table, reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE);
+                lastCtx = ctx;
+                lastTable = table;
+                const row = ctx.getOneObj();
+                if (row)
+                    return new CrudResult_1.CrudQueryOneResult({ row: row, rawContext: ctx, debugInfo: this.buildDebugInfo(table, reqJson.condition), fromTable: table });
+            }
+            catch (e) { /* skip */ }
+        }
+        return new CrudResult_1.CrudQueryOneResult({ row: null, rawContext: lastCtx, debugInfo: this.buildDebugInfo(targetTables[0], reqJson.condition), fromTable: lastTable });
+    }
+    async findUniqueOne(reqJson) {
+        const targetTables = await this.resolveFindTables(reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE);
+        if (targetTables.length === 0) {
+            return new CrudResult_1.CrudQueryOneResult({ row: null, rawContext: null, debugInfo: this.buildDebugInfo(undefined, reqJson.condition), fromTable: null });
+        }
+        const allRows = [];
+        const foundTables = [];
+        let firstCtx = null;
+        for (const table of targetTables) {
+            try {
+                const ctx = await this.executeOnTable(table, reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY, { maxLimit: 2 });
+                if (!firstCtx)
+                    firstCtx = ctx;
+                const rows = ctx.getResRows();
+                if (rows.length > 0) {
+                    allRows.push(...rows);
+                    foundTables.push(table);
+                    if (allRows.length > 1)
+                        throw new Error(this.formatUniqueError(allRows.length, foundTables, reqJson.condition, foundTables.length > 1));
+                }
+            }
+            catch (e) {
+                if (e instanceof Error && e.message.startsWith('[ShardingBase] findUniqueOne'))
+                    throw e;
+            }
+        }
+        const fromTable = foundTables[0] || null;
+        return new CrudResult_1.CrudQueryOneResult({ row: allRows[0] || null, rawContext: firstCtx, debugInfo: this.buildDebugInfo(fromTable || targetTables[0], reqJson.condition), fromTable: fromTable || targetTables[0] });
+    }
+    async findList(reqJson) {
+        const targetTables = await this.resolveFindTables(reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY);
+        if (targetTables.length === 0)
+            return new CrudResult_1.CrudQueryListResult({ rows: [], rawContext: null });
+        if (targetTables.length === 1) {
+            const ctx = await this.executeOnTable(targetTables[0], reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY);
+            return new CrudResult_1.CrudQueryListResult({ rows: ctx.getResRows(), rawContext: ctx });
+        }
+        let allRows = [];
+        let lastCtx = null;
+        for (const table of targetTables) {
+            try {
+                const ctx = await this.executeOnTable(table, reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY);
+                lastCtx = ctx;
+                allRows = allRows.concat(ctx.getResRows() || []);
+            }
+            catch (e) { /* skip */ }
+        }
+        return new CrudResult_1.CrudQueryListResult({ rows: allRows, rawContext: lastCtx });
+    }
+    async findPage(reqJson) {
+        const targetTables = await this.resolveFindTables(reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_PAGE);
+        if (targetTables.length === 0)
+            throw new Error('[ShardingByCustomCrud] findPage: no matching tables found');
+        if (targetTables.length === 1) {
+            const ctx = await this.executeOnTable(targetTables[0], reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_PAGE);
+            const pageResult = ctx.getResModelForQueryPage();
+            return new CrudResult_1.CrudQueryPageResult({ rows: pageResult.rows, totalCount: pageResult.total_count, rawContext: ctx });
+        }
+        const { pageNo = 1, pageSize = 10 } = reqJson;
+        const offset = (pageNo - 1) * pageSize;
+        let totalCount = 0;
+        const tableCounts = [];
+        for (const table of targetTables) {
+            const { count } = await this.findCountFromTable(table, reqJson);
+            tableCounts.push({ table, count });
+            totalCount += count;
+        }
+        if (totalCount === 0) {
+            return new CrudResult_1.CrudQueryPageResult({ rows: [], totalCount: 0, rawContext: null });
+        }
+        let accumulated = 0;
+        let allRows = [];
+        let lastCtx = null;
+        const targetEnd = offset + pageSize;
+        for (const { table, count } of tableCounts) {
+            if (count === 0)
+                continue;
+            const tableEnd = accumulated + count;
+            if (tableEnd <= offset) {
+                accumulated = tableEnd;
+                continue;
+            }
+            if (accumulated >= targetEnd)
+                break;
+            const innerOffset = Math.max(0, offset - accumulated);
+            const innerLimit = Math.min(count, targetEnd - accumulated) - innerOffset;
+            try {
+                const ctx = await this.executeOnTable(table, { ...reqJson, offset: innerOffset, limit: innerLimit }, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY);
+                lastCtx = ctx;
+                allRows = allRows.concat(ctx.getResRows() || []);
+            }
+            catch (e) { /* skip */ }
+            accumulated = tableEnd;
+            if (accumulated >= targetEnd)
+                break;
+        }
+        return new CrudResult_1.CrudQueryPageResult({ rows: allRows, totalCount, rawContext: lastCtx });
+    }
+    async findCount(reqJson) {
+        const targetTables = await this.resolveFindTables(reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_COUNT);
+        if (targetTables.length === 0)
+            throw new Error('[ShardingByCustomCrud] findCount: no matching tables found');
+        if (targetTables.length === 1) {
+            const ctx = await this.executeOnTable(targetTables[0], reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_COUNT);
+            return new CrudResult_1.CrudCountResult({ count: ctx.getResModelItem('total_count') || 0, rawContext: ctx });
+        }
+        let totalCount = 0;
+        let firstCtx = null;
+        for (const table of targetTables) {
+            const { count, ctx } = await this.findCountFromTable(table, reqJson);
+            totalCount += count;
+            if (!firstCtx && ctx)
+                firstCtx = ctx;
+        }
+        return new CrudResult_1.CrudCountResult({ count: totalCount, rawContext: firstCtx });
+    }
+    async isExist(reqJson) {
+        const targetTables = await this.resolveFindTables(reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_EXIST);
+        if (targetTables.length === 0)
+            throw new Error('[ShardingByCustomCrud] isExist: no matching tables found');
+        if (targetTables.length === 1) {
+            const ctx = await this.executeOnTable(targetTables[0], reqJson, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_EXIST);
+            return new CrudResult_1.CrudExistResult({ exists: ctx.getResModelItem('is_exist') === true, rawContext: ctx });
+        }
+        let exists = false;
+        let firstCtx = null;
+        for (const table of targetTables) {
+            const result = await this.isExistInTable(table, reqJson);
+            if (!firstCtx && result.ctx)
+                firstCtx = result.ctx;
+            if (result.exists) {
+                exists = true;
+                break;
+            }
+        }
+        return new CrudResult_1.CrudExistResult({ exists, rawContext: firstCtx });
+    }
+}
+exports.ShardingByCustomCrud = ShardingByCustomCrud;

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

@@ -0,0 +1,38 @@
+import { IRequestModel, IRequestCfgModel } 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
+ *
+ * 根据 shardingColumn 的哈希值取模 tableCount，定位到固定数量的分表。
+ * 表名格式：baseTable_XX（如 t_order_00 ~ t_order_15）
+ *
+ * 内部委托 ShardingByCustomCrud 实现所有 CRUD 操作，
+ * 通过 customRouter 实现哈希路由逻辑。
+ *
+ * 规范：所有操作必须提供 shardingColumn，否则抛出异常。
+ *
+ * 特性：
+ * - 路由：hash(shardingColumn) % tableCount → 固定分表
+ * - insertOrUpdate：统一由 condition 路由定位分表
+ */
+export declare class ShardingByHashCrud extends ShardingBase {
+    private delegate;
+    constructor(crudProFactory: CrudProFactory, config: IShardingConfig);
+    setBaseCfg(cfg: Partial<IRequestCfgModel>): this;
+    setEnableSoftDelete(enable: boolean): this;
+    insert(r: IRequestModel): Promise<CrudWriteResult>;
+    batchInsert(r: IRequestModel): Promise<ShardingBatchInsertResult>;
+    update(r: IRequestModel): Promise<CrudWriteResult>;
+    delete(r: IRequestModel): Promise<CrudWriteResult>;
+    restore(r: IRequestModel): Promise<CrudWriteResult>;
+    insertOrUpdate(r: IRequestModel): Promise<CrudUpsertResult>;
+    findOne<T = Record<string, any>>(r: IRequestModel): Promise<CrudQueryOneResult<T>>;
+    findUniqueOne<T = Record<string, any>>(r: IRequestModel): Promise<CrudQueryOneResult<T>>;
+    findList<T = Record<string, any>>(r: IRequestModel): Promise<CrudQueryListResult<T>>;
+    findPage<T = Record<string, any>>(r: IRequestModel): Promise<CrudQueryPageResult<T>>;
+    findCount(r: IRequestModel): Promise<CrudCountResult>;
+    isExist(r: IRequestModel): Promise<CrudExistResult>;
+}

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardingByHashCrud = void 0;
+const ShardingBase_1 = require("./ShardingBase");
+const ShardingByCustomCrud_1 = require("./ShardingByCustomCrud");
+/**
+ * 哈希分表 CRUD
+ *
+ * 根据 shardingColumn 的哈希值取模 tableCount，定位到固定数量的分表。
+ * 表名格式：baseTable_XX（如 t_order_00 ~ t_order_15）
+ *
+ * 内部委托 ShardingByCustomCrud 实现所有 CRUD 操作，
+ * 通过 customRouter 实现哈希路由逻辑。
+ *
+ * 规范：所有操作必须提供 shardingColumn，否则抛出异常。
+ *
+ * 特性：
+ * - 路由：hash(shardingColumn) % tableCount → 固定分表
+ * - insertOrUpdate：统一由 condition 路由定位分表
+ */
+class ShardingByHashCrud extends ShardingBase_1.ShardingBase {
+    constructor(crudProFactory, config) {
+        super(crudProFactory, config);
+        if (!config.shardingColumn) {
+            throw new Error('[ShardingByHashCrud] 哈希分表必须指定 shardingColumn');
+        }
+        if (!config.tableCount || config.tableCount <= 0) {
+            throw new Error('[ShardingByHashCrud] 哈希分表必须指定 tableCount（大于 0）');
+        }
+        const col = config.shardingColumn;
+        const count = config.tableCount;
+        const baseTable = config.baseTable;
+        const fmt = config.suffixFormatter;
+        /** 格式化表名：baseTable + _ + 后缀（可选 suffixFormatter） */
+        const formatTable = (suffix) => {
+            const formatted = fmt ? fmt(suffix) : suffix;
+            return `${baseTable}_${formatted}`;
+        };
+        /** djb2 哈希 → 取模 → 零填充后缀 → 表名 */
+        const hashRoute = (value) => {
+            const str = String(value);
+            let hash = 5381;
+            for (let i = 0; i < str.length; i++) {
+                hash = ((hash << 5) + hash) + str.charCodeAt(i);
+                hash = hash & hash;
+            }
+            return formatTable(String(Math.abs(hash) % count).padStart(2, '0'));
+        };
+        const customRouter = (ctx) => {
+            var _a, _b;
+            // 根据操作类型确定字段来源：insert 类从 data，其余从 condition
+            const fromData = ShardingBase_1.ShardingBase.isInsertPhase(ctx);
+            const val = fromData ? (_a = ctx.data) === null || _a === void 0 ? void 0 : _a[col] : (_b = ctx.condition) === null || _b === void 0 ? void 0 : _b[col];
+            if (val != null && val !== '' && val !== undefined) {
+                return hashRoute(val);
+            }
+            throw new Error(`[ShardingByHashCrud] ${fromData ? 'data' : 'condition'} 必须包含分表字段 '${col}'`);
+        };
+        this.delegate = new ShardingByCustomCrud_1.ShardingByCustomCrud(crudProFactory, { ...config, customRouter });
+    }
+    // ============ 状态同步 ============
+    setBaseCfg(cfg) {
+        super.setBaseCfg(cfg);
+        this.delegate.setBaseCfg(cfg);
+        return this;
+    }
+    setEnableSoftDelete(enable) {
+        super.setEnableSoftDelete(enable);
+        this.delegate.setEnableSoftDelete(enable);
+        return this;
+    }
+    // ============ CRUD 方法：全部委托 ============
+    insert(r) { return this.delegate.insert(r); }
+    batchInsert(r) { return this.delegate.batchInsert(r); }
+    update(r) { return this.delegate.update(r); }
+    delete(r) { return this.delegate.delete(r); }
+    restore(r) { return this.delegate.restore(r); }
+    insertOrUpdate(r) { return this.delegate.insertOrUpdate(r); }
+    findOne(r) { return this.delegate.findOne(r); }
+    findUniqueOne(r) { return this.delegate.findUniqueOne(r); }
+    findList(r) { return this.delegate.findList(r); }
+    findPage(r) { return this.delegate.findPage(r); }
+    findCount(r) { return this.delegate.findCount(r); }
+    isExist(r) { return this.delegate.isExist(r); }
+}
+exports.ShardingByHashCrud = ShardingByHashCrud;

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

@@ -0,0 +1,39 @@
+import { IRequestModel, IRequestCfgModel } 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
+ *
+ * 字段原值即表后缀，一值一表。
+ * 表名格式：baseTable_{shardingColumn值}（如 t_log_east, t_log_west）
+ *
+ * 内部委托 ShardingByCustomCrud 实现所有 CRUD 操作，
+ * 通过 customRouter 实现键值路由逻辑。
+ *
+ * 规范：所有操作必须提供 shardingColumn，否则抛出异常。
+ *
+ * 特性：
+ * - 路由：shardingColumn 的原始值直接作为表后缀
+ * - 不预定义 keyValues，表按需动态创建
+ * - insertOrUpdate：统一由 condition 路由定位分表
+ */
+export declare class ShardingByKeyCrud extends ShardingBase {
+    private delegate;
+    constructor(crudProFactory: CrudProFactory, config: IShardingConfig);
+    setBaseCfg(cfg: Partial<IRequestCfgModel>): this;
+    setEnableSoftDelete(enable: boolean): this;
+    insert(r: IRequestModel): Promise<CrudWriteResult>;
+    batchInsert(r: IRequestModel): Promise<ShardingBatchInsertResult>;
+    update(r: IRequestModel): Promise<CrudWriteResult>;
+    delete(r: IRequestModel): Promise<CrudWriteResult>;
+    restore(r: IRequestModel): Promise<CrudWriteResult>;
+    insertOrUpdate(r: IRequestModel): Promise<CrudUpsertResult>;
+    findOne<T = Record<string, any>>(r: IRequestModel): Promise<CrudQueryOneResult<T>>;
+    findUniqueOne<T = Record<string, any>>(r: IRequestModel): Promise<CrudQueryOneResult<T>>;
+    findList<T = Record<string, any>>(r: IRequestModel): Promise<CrudQueryListResult<T>>;
+    findPage<T = Record<string, any>>(r: IRequestModel): Promise<CrudQueryPageResult<T>>;
+    findCount(r: IRequestModel): Promise<CrudCountResult>;
+    isExist(r: IRequestModel): Promise<CrudExistResult>;
+}

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardingByKeyCrud = void 0;
+const ShardingBase_1 = require("./ShardingBase");
+const ShardingByCustomCrud_1 = require("./ShardingByCustomCrud");
+/**
+ * 键值分表 CRUD
+ *
+ * 字段原值即表后缀，一值一表。
+ * 表名格式：baseTable_{shardingColumn值}（如 t_log_east, t_log_west）
+ *
+ * 内部委托 ShardingByCustomCrud 实现所有 CRUD 操作，
+ * 通过 customRouter 实现键值路由逻辑。
+ *
+ * 规范：所有操作必须提供 shardingColumn，否则抛出异常。
+ *
+ * 特性：
+ * - 路由：shardingColumn 的原始值直接作为表后缀
+ * - 不预定义 keyValues，表按需动态创建
+ * - insertOrUpdate：统一由 condition 路由定位分表
+ */
+class ShardingByKeyCrud extends ShardingBase_1.ShardingBase {
+    constructor(crudProFactory, config) {
+        super(crudProFactory, config);
+        if (!config.shardingColumn) {
+            throw new Error('[ShardingByKeyCrud] 键值分表必须指定 shardingColumn');
+        }
+        const col = config.shardingColumn;
+        const baseTable = config.baseTable;
+        const fmt = config.suffixFormatter;
+        /** 格式化表名：baseTable + _ + 后缀（可选 suffixFormatter） */
+        const formatTable = (suffix) => {
+            const formatted = fmt ? fmt(suffix) : suffix;
+            return `${baseTable}_${formatted}`;
+        };
+        const customRouter = (ctx) => {
+            var _a, _b;
+            // 根据操作类型确定字段来源：insert 类从 data，其余从 condition
+            const fromData = ShardingBase_1.ShardingBase.isInsertPhase(ctx);
+            const val = fromData ? (_a = ctx.data) === null || _a === void 0 ? void 0 : _a[col] : (_b = ctx.condition) === null || _b === void 0 ? void 0 : _b[col];
+            if (val != null && val !== '' && val !== undefined) {
+                return formatTable(String(val));
+            }
+            ;
+            throw new Error(`[ShardingByKeyCrud] ${fromData ? 'data' : 'condition'} 必须包含分表字段 '${col}'`);
+        };
+        this.delegate = new ShardingByCustomCrud_1.ShardingByCustomCrud(crudProFactory, { ...config, customRouter });
+    }
+    // ============ 状态同步 ============
+    setBaseCfg(cfg) {
+        super.setBaseCfg(cfg);
+        this.delegate.setBaseCfg(cfg);
+        return this;
+    }
+    setEnableSoftDelete(enable) {
+        super.setEnableSoftDelete(enable);
+        this.delegate.setEnableSoftDelete(enable);
+        return this;
+    }
+    // ============ CRUD 方法：全部委托 ============
+    insert(r) { return this.delegate.insert(r); }
+    batchInsert(r) { return this.delegate.batchInsert(r); }
+    update(r) { return this.delegate.update(r); }
+    delete(r) { return this.delegate.delete(r); }
+    restore(r) { return this.delegate.restore(r); }
+    insertOrUpdate(r) { return this.delegate.insertOrUpdate(r); }
+    findOne(r) { return this.delegate.findOne(r); }
+    findUniqueOne(r) { return this.delegate.findUniqueOne(r); }
+    findList(r) { return this.delegate.findList(r); }
+    findPage(r) { return this.delegate.findPage(r); }
+    findCount(r) { return this.delegate.findCount(r); }
+    isExist(r) { return this.delegate.isExist(r); }
+}
+exports.ShardingByKeyCrud = ShardingByKeyCrud;

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

@@ -0,0 +1,66 @@
+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
+ *
+ * 支持 YEAR / MONTH / DAY 三种时间粒度分表。
+ * 路由规则：根据 timeColumn 的值计算时间后缀，定位到对应分表。
+ *
+ * 特性：
+ * - 插入：data 中的 timeColumn 决定目标分表
+ * - 更新/删除：condition 中的 timeColumn 定位分表
+ * - 查询：时间范围条件交叉过滤候选表，无条件时回退到 recentTableCount
+ * - insertOrUpdate：condition 路由查找，data 路由插入（双路由）
+ * - 智能清理：timeColumn 在有主键时仅用于路由，不参与 WHERE 条件
+ * - COUNT 缓存：历史表缓存，当前表实时查
+ * - orderBy 约束：多表查询必须以 timeColumn 排序
+ */
+export declare class ShardingByTimeCrud extends ShardingBase {
+    private readonly merger;
+    private readonly granularity;
+    constructor(crudProFactory: CrudProFactory, config: IShardingConfig);
+    private typeToGranularity;
+    /** 从 data 中提取时间字段，计算目标分表名 */
+    private resolveTableForInsert;
+    /** 从 condition 中提取时间字段，计算目标分表名（单表） */
+    private resolveTableForCondition;
+    /** 解析查询目标表列表 */
+    private resolveFindTables;
+    private intersectWithCondition;
+    private intersectTablesByTimeRange;
+    private extractTimeRange;
+    private tryExtractTimeFromCondition;
+    private sortTablesByTimeDesc;
+    private getDefaultRecentCount;
+    private formatTableName;
+    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>;
+    /**
+     * 插入或更新（双路由）
+     *
+     * 1. condition 路由定位查找分表
+     * 2. 检查记录是否存在
+     * 3. 存在 → UPDATE（conditionTable）
+     * 4. 不存在 → data 路由定位插入分表，INSERT（dataTable）
+     */
+    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>;
+    private validateTimeColumnForData;
+    private validateTimeColumnForBatchData;
+    private validateRoutingFieldForCondition;
+    private validateFindOrderBy;
+    private sortTablesForOrderBy;
+    private cleanTimeColumnForSingleTableQuery;
+    private validateTimeOperatorPrecision;
+}