midway-fatcms 0.0.8 → 0.0.9

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>;
+}

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>;
+}