// app/model/wms_order_delivery_factory.js 'use strict'; const { ensureShardWarehouseId, clearShardWarehouseValidationCache, } = require('../lib/warehouse_shard_guard'); const { normalizeManagedType, isOutsourcedType, normalizeIndexDefinition, parseNumericConstraint, buildTableAttributes, buildTableName: buildManagedTableName, buildTableComment, buildTableOptions, buildIndexOptions, buildColumnLine, buildColumnLines, buildIndexLines, isColumnDefinitionDifferent, parseManagedTableName, AUTO_INCREMENT_SAFE_MARGIN, } = require('./order_delivery_table_schema'); const LANES = Object.freeze({ M4: 'm4', M5: 'm5', }); /** * 判断两个索引定义是否存在结构差异。 * @param {Object} expectedIndex 预期索引定义。 * @param {Object} actualIndex 实际索引定义。 * @return {boolean} 是否存在结构差异。 */ function isIndexDefinitionDifferent(expectedIndex, actualIndex) { const normalizedExpected = normalizeIndexDefinition(expectedIndex); const normalizedActual = normalizeIndexDefinition(actualIndex); if (!normalizedActual.name) { return true; } const actualUniqueDefined = Object.prototype.hasOwnProperty.call(actualIndex || {}, 'unique') || Object.prototype.hasOwnProperty.call(actualIndex || {}, 'Unique') || Object.prototype.hasOwnProperty.call(actualIndex || {}, 'nonUnique'); if (actualUniqueDefined && normalizedExpected.unique !== normalizedActual.unique) { return true; } if (!Array.isArray(actualIndex && actualIndex.fields) || !actualIndex.fields.length) { return false; } if (normalizedExpected.fields.length !== normalizedActual.fields.length) { return true; } for (let index = 0; index < normalizedExpected.fields.length; index += 1) { const expectedField = normalizedExpected.fields[index]; const actualField = normalizedActual.fields[index]; if (!expectedField.attribute || !actualField.attribute) { return true; } if (expectedField.attribute !== actualField.attribute) { return true; } if (Object.prototype.hasOwnProperty.call(expectedField, 'length') && expectedField.length !== actualField.length) { return true; } } return false; } /** * 转义 SQL 标识符。 * @param {string} identifier 标识符。 * @return {string} 转义后的标识符。 */ function quoteIdentifier(identifier) { return `\`${String(identifier).replace(/`/g, '``')}\``; } /** * 构造表数据约束违规错误。 * @param {string} tableName 表名。 * @param {string} columnName 列名。 * @param {string} violationType 违规类型。 * @param {string} [detail] 违规详情。 * @return {Error} 错误对象。 */ function buildManagedTableConstraintError(tableName, columnName, violationType, detail = '') { const suffix = detail ? `, detail=${detail}` : ''; const error = new Error(`数据不满足约束: table=${tableName}, column=${columnName}, violation=${violationType}${suffix}`); error.code = 'ORDER_DELIVERY_TABLE_CONSTRAINT_VIOLATION'; error.tableName = tableName; error.columnName = columnName; error.violationType = violationType; return error; } module.exports = app => { class OrderDeliveryFactory { constructor() { this.modelCache = new Map(); this.inflightInitCache = new Map(); this.locationTableReady = new Map(); this.app = app; } /** * 复用并发中的模型初始化,避免重复执行建模与结构自检。 * @param {string} lockKey 并发锁键。 * @param {Function} initializer 初始化函数。 * @return {Promise} 模型实例。 */ async runModelInitializer(lockKey, initializer) { if (this.inflightInitCache.has(lockKey)) { return await this.inflightInitCache.get(lockKey); } const initPromise = (async () => { try { return await initializer(); } finally { this.inflightInitCache.delete(lockKey); } })(); this.inflightInitCache.set(lockKey, initPromise); return await initPromise; } /** * 获取配送域车道常量。 * @return {Object} 车道常量。 */ get LANES() { return LANES; } /** * 判断是否为配送域模型。 * @param {string} type 模型类型。 * @return {boolean} 是否为配送域模型。 */ isDispatchType(type) { return type === 'dispatch'; } /** * 解析模型类型。 * @param {string} type 模型类型。 * @return {string} 解析后的模型类型。 */ resolveModelType(type) { return normalizeManagedType(type); } isOutsourcedModel(type) { return isOutsourcedType(type); } /** * 获取当前表模型 * @param {number} warehouseId 仓库ID * @return {Promise} 当前表模型 */ async getCurrentModel(warehouseId) { return await this.getOrCreateModel(warehouseId, 'current'); } /** * 获取历史表模型 * @param {number} warehouseId 仓库ID * @return {Promise} 历史表模型 */ async getHistoryModel(warehouseId) { return await this.getOrCreateModel(warehouseId, 'history'); } /** * 获取配送域模型。 * @param {number|string} warehouseId 仓库ID。 * @return {Promise} 配送域模型。 */ async getDispatchModel(warehouseId) { return await this.getOrCreateModel(warehouseId, 'dispatch'); } async getOutsourcedModel(warehouseId) { return await this.getOrCreateModel(warehouseId, 'outsourced'); } /** * 获取配送正常模型。 * @param {number|string} warehouseId 仓库ID。 * @return {Promise} 配送域模型。 */ async getM4Model(warehouseId) { return await this.getDispatchModel(warehouseId); } /** * 获取配送异常模型。 * @param {number|string} warehouseId 仓库ID。 * @return {Promise} 配送域模型。 */ async getM5Model(warehouseId) { return await this.getDispatchModel(warehouseId); } /** * 根据表名直接获取模型 * @param {string} tableName 表名 * @return {Promise} 动态模型 */ async getModelByTableName(tableName) { const cacheKey = `table_${tableName}`; const lockKey = `init_table_${tableName}`; if (this.modelCache.has(cacheKey)) { return this.modelCache.get(cacheKey); } return await this.runModelInitializer(lockKey, async () => { if (this.modelCache.has(cacheKey)) { return this.modelCache.get(cacheKey); } try { const parsed = parseManagedTableName(tableName); if (!parsed) { throw new Error(`表 ${tableName} 不是订单工厂管理表`); } const tableExists = await this.checkTableExists(tableName); if (!tableExists) { throw new Error(`表 ${tableName} 不存在`); } const DynamicModel = this.buildManagedModel(parsed.warehouseId, parsed.type, tableName); await this.ensureManagedTableSchema(tableName, parsed.type, parsed.warehouseId, DynamicModel); this.modelCache.set(cacheKey, DynamicModel); return DynamicModel; } catch (error) { this.app.logger.error(`获取模型失败 ${tableName}:`, error); throw error; } }); } /** * 获取或创建模型 * @param {number} warehouseId 仓库ID * @param {string} type 模型类型 * @return {Promise} 动态模型 */ async getOrCreateModel(warehouseId, type) { const warehouseIdStr = await ensureShardWarehouseId(this.app, warehouseId); const modelType = this.resolveModelType(type); const tableName = this.generateTableName(warehouseIdStr, modelType); const cacheKey = `${warehouseIdStr}_${modelType}`; const tableCacheKey = `table_${tableName}`; // 与 getModelByTableName 统一使用“物理表名锁”,避免不同入口并发重复初始化同一张表 const lockKey = `init_table_${tableName}`; // 检查缓存 if (this.modelCache.has(cacheKey)) { return this.modelCache.get(cacheKey); } return await this.runModelInitializer(lockKey, async () => { if (this.modelCache.has(cacheKey)) { return this.modelCache.get(cacheKey); } try { const DynamicModel = this.buildManagedModel(warehouseIdStr, modelType, tableName); await this.ensureManagedTableSchema(tableName, modelType, warehouseIdStr, DynamicModel); // 设置关联关系 this.setupAssociations(DynamicModel, warehouseIdStr, modelType); // 缓存模型(按业务键和表名键双写,避免跨入口重复初始化) this.modelCache.set(cacheKey, DynamicModel); this.modelCache.set(tableCacheKey, DynamicModel); this.app.logger.info(`创建动态模型成功: ${tableName}`); return DynamicModel; } catch (error) { this.app.logger.error(`创建动态模型失败 ${tableName}:`, error); throw error; } }); } /** * 获取模型配置选项 * @param {number} warehouseId 仓库ID * @param {string} type 模型类型 * @return {Object} Sequelize 模型配置 */ getModelOptions(warehouseId, type) { return buildTableOptions(this.app, warehouseId, type); } /** * 构建动态模型。 * @param {number|string} warehouseId 仓库ID。 * @param {string} type 模型类型。 * @param {string} tableName 表名。 * @return {Object} 动态模型。 */ buildManagedModel(warehouseId, type, tableName) { const modelType = this.resolveModelType(type); const attributes = this.getTableAttributes(modelType); const modelOptions = this.getModelOptions(warehouseId, modelType); return this.app.model.define(tableName, attributes, modelOptions); } /** * 获取订单工厂管理的属性定义。 * @param {string} type 模型类型。 * @return {Object} 属性定义。 */ getTableAttributes(type) { return buildTableAttributes(this.app, type); } /** * 获取索引配置 * @param {number} warehouseId 仓库ID * @param {string} type 模型类型 * @return {Array} 索引配置 */ getIndexes(warehouseId, type) { return buildIndexOptions(warehouseId, type); } /** * 获取当前表通用列定义行。 * * @param {string} type 模型类型 * @return {Array} 当前表列定义行 */ getCurrentTableColumnLines(type = 'current') { return buildColumnLines(this.app, type); } /** * 获取当前表通用索引定义行。 * * @param {number} warehouseId 仓库ID * @param {string} type 模型类型 * @return {Array} 当前表索引定义行 */ getCurrentTableIndexLines(warehouseId, type = 'current') { return buildIndexLines(warehouseId, type); } /** * 获取配送域物理表名。 * @param {number|string} warehouseId 仓库ID。 * @return {Promise} 配送域物理表名。 */ async getDispatchTableName(warehouseId) { const warehouseIdStr = await ensureShardWarehouseId(this.app, warehouseId); return `wms_order_delivery_${warehouseIdStr}_dispatch`; } /** * 获取配送域表列定义行。 * @return {Array} 配送域表列定义行。 */ getDispatchTableColumnLines() { return buildColumnLines(this.app, 'dispatch'); } /** * 获取配送域表索引定义行。 * @param {string} warehouseIdStr 仓库ID字符串。 * @return {Array} 配送域表索引定义行。 */ getDispatchTableIndexLines(warehouseIdStr) { return buildIndexLines(warehouseIdStr, 'dispatch'); } /** * 获取配送域索引配置。 * @param {string} warehouseIdStr 仓库ID字符串。 * @return {Array} Sequelize 索引配置。 */ getDispatchTableIndexOptions(warehouseIdStr) { return buildIndexOptions(warehouseIdStr, 'dispatch'); } /** * 获取配送域属性定义。 * @return {Object} 配送域属性定义。 */ getDispatchAttributes() { return this.getTableAttributes('dispatch'); } buildDispatchAttributes() { return this.getDispatchAttributes(); } /** * 设置关联关系 * @param {Object} DynamicModel 动态模型 * @param {number} warehouseId 仓库ID * @param {string} type 模型类型 * @return {Promise} */ async setupAssociations(DynamicModel, warehouseId, type) { try { // 配送域不挂商品明细关联,其余模式保持原行为。 if (!this.isDispatchType(type) && this.app.model.OrderItemsFactory) { const ItemsModel = await this.app.model.OrderItemsFactory.getOrCreateModel(warehouseId, type); // 发货单 -> 商品 (1:N) DynamicModel.hasMany(ItemsModel, { foreignKey: 'order_id', sourceKey: 'id', as: 'orderItems', constraints: false, }); // 商品 -> 发货单 (N:1) ItemsModel.belongsTo(DynamicModel, { foreignKey: 'order_id', targetKey: 'id', as: 'delivery', constraints: false, }); } // 关联店铺表 if (this.app.model.Store) { DynamicModel.belongsTo(this.app.model.Store, { foreignKey: 'store_id', targetKey: 'id', as: 'store', constraints: false, }); DynamicModel.belongsTo(this.app.model.Store, { foreignKey: 'warehouse_id', targetKey: 'id', as: 'warehouse', constraints: false, }); } } catch (error) { this.app.logger.warn('设置关联关系失败:', error.message); } } /** * 检查表是否存在 * @param {string} tableName 表名 * @return {Promise} 是否存在 */ async checkTableExists(tableName) { const sequelize = this.app.model; const queryInterface = sequelize.getQueryInterface(); try { const tables = await queryInterface.showAllTables(); return tables.includes(tableName); } catch (error) { // 备用方案:使用原始查询 const checkSQL = ` SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? `; const [ results ] = await sequelize.query(checkSQL, { replacements: [ tableName ], }); return results.length > 0; } } /** * 判断目标表是否需要进行结构同步。 * @param {string} tableName 表名。 * @param {string} type 模型类型。 * @param {number|string} warehouseId 仓库ID。 * @param {boolean|null} [tableExists=null] 是否已确认表存在。 * @return {Promise} 是否需要同步。 */ async needsTableSchemaSync(tableName, type, warehouseId, tableExists = null) { const queryInterface = this.app.model.getQueryInterface(); const managedTableExists = typeof tableExists === 'boolean' ? tableExists : await this.checkTableExists(tableName); if (!managedTableExists) { return true; } const [ tables, indexes ] = await Promise.all([ queryInterface.describeTable(tableName), typeof queryInterface.showIndex === 'function' ? queryInterface.showIndex(tableName) : Promise.resolve([]), ]); const expectedAttributes = this.getTableAttributes(type); const expectedAttributeNames = Object.keys(expectedAttributes); const actualAttributeNames = Object.keys(tables || {}); if (expectedAttributeNames.length !== actualAttributeNames.length) { return true; } const actualColumnNames = new Set(actualAttributeNames); for (const columnName of expectedAttributeNames) { if (!actualColumnNames.has(columnName)) { return true; } } for (const columnName of expectedAttributeNames) { if (isColumnDefinitionDifferent(columnName, expectedAttributes[columnName], tables[columnName])) { return true; } } const expectedIndexes = this.getIndexes(warehouseId, type); const actualIndexes = Array.isArray(indexes) ? indexes : []; for (const expectedIndex of expectedIndexes) { const actualIndex = actualIndexes.find(index => (index.Key_name || index.name) === expectedIndex.name); if (!actualIndex) { return true; } if (isIndexDefinitionDifferent(expectedIndex, actualIndex)) { return true; } } return false; } /** * 在结构同步前预检现有数据是否满足非空和数值范围约束。 * @param {string} tableName 表名。 * @param {string} type 模型类型。 * @return {Promise} */ async assertManagedTableDataConstraints(tableName, type) { const queryInterface = this.app.model.getQueryInterface(); const sequelize = this.app.model; const tableColumns = await queryInterface.describeTable(tableName); const expectedAttributes = this.getTableAttributes(type); const columnNames = new Set(Object.keys(tableColumns || {})); const quotedTableName = quoteIdentifier(tableName); // 收集需要检查的列 const notNullColumns = []; const numericColumns = []; for (const columnName of Object.keys(expectedAttributes)) { if (!columnNames.has(columnName)) { continue; } const expectedAttribute = expectedAttributes[columnName]; if (expectedAttribute.allowNull === false) { notNullColumns.push(columnName); } const numericConstraint = parseNumericConstraint(expectedAttribute); if (numericConstraint) { numericColumns.push({ columnName, numericConstraint }); } } // 一条 SQL 检查所有 NOT NULL 约束 if (notNullColumns.length > 0) { const conditions = notNullColumns .map(col => `${quoteIdentifier(col)} IS NULL`) .join(' OR '); const selectCols = notNullColumns .map(col => `MAX(CASE WHEN ${quoteIdentifier(col)} IS NULL THEN 1 ELSE 0 END) AS ${quoteIdentifier(col)}`) .join(', '); const [ nullRows ] = await sequelize.query( `SELECT ${selectCols} FROM ${quotedTableName} WHERE ${conditions} LIMIT 1` ); if (Array.isArray(nullRows) && nullRows.length > 0) { const row = nullRows[0]; for (const columnName of notNullColumns) { if (row[columnName] === 1) { throw buildManagedTableConstraintError(tableName, columnName, 'NOT_NULL'); } } } } // 一条 SQL 检查所有数值范围约束 if (numericColumns.length > 0) { const selectCols = numericColumns .map(({ columnName, numericConstraint }) => { const qCol = quoteIdentifier(columnName); return `MAX(CASE WHEN ${qCol} IS NOT NULL AND (${qCol} < ${numericConstraint.min} OR ${qCol} > ${numericConstraint.max}) THEN 1 ELSE 0 END) AS ${quoteIdentifier(columnName)}`; }) .join(', '); const conditions = numericColumns .map(({ columnName, numericConstraint }) => { const qCol = quoteIdentifier(columnName); return `(${qCol} IS NOT NULL AND (${qCol} < ${numericConstraint.min} OR ${qCol} > ${numericConstraint.max}))`; }) .join(' OR '); const [ rangeRows ] = await sequelize.query( `SELECT ${selectCols} FROM ${quotedTableName} WHERE ${conditions} LIMIT 1` ); if (Array.isArray(rangeRows) && rangeRows.length > 0) { const row = rangeRows[0]; for (const { columnName, numericConstraint } of numericColumns) { if (row[columnName] === 1) { throw buildManagedTableConstraintError( tableName, columnName, 'NUMERIC_RANGE', `expected=[${numericConstraint.min}, ${numericConstraint.max}]` ); } } } } } /** * 获取同仓库共享 id 序列的全部分表的 MAX(id) 基线。 * * 多表共用 id 契约:订单迁移到配送表时显式复制源 id,因此新分配的 * id 必须大于所有分表已占用的 id。 * * @param {number|string} warehouseId 仓库ID。 * @return {Promise} 最大 id,无任何分表时返回 0。 */ async getSharedIdBaseline(warehouseId) { const tables = [ buildManagedTableName(warehouseId, 'current'), buildManagedTableName(warehouseId, 'dispatch'), buildManagedTableName(warehouseId, 'history'), buildManagedTableName(warehouseId, 'outsourced'), ]; let existingTableSet = null; try { existingTableSet = new Set(await this.app.model.getQueryInterface().showAllTables()); } catch (error) { existingTableSet = null; } let baseline = 0; for (const relatedTable of tables) { const exists = existingTableSet ? existingTableSet.has(relatedTable) : await this.checkTableExists(relatedTable); if (!exists) { continue; } const [ rows ] = await this.app.model.query( `SELECT COALESCE(MAX(id), 0) AS maxId FROM ${quoteIdentifier(relatedTable)}` ); const maxId = Number(rows && rows[0] && rows[0].maxId || 0); if (Number.isFinite(maxId) && maxId > baseline) { baseline = maxId; } } return baseline; } /** * 核对并修复表自增水位,确保 AUTO_INCREMENT 大于同仓库共享 id 序列 * 的全部分表(current/dispatch/history/outsourced)的 MAX(id)。 * * 多表共用 id 契约:订单迁移到配送表时显式复制源 id。因此 current 表的 * 自增序列必须全局单调——新分配的 id 不能与任何分表已占用的 id 重叠。 * 若高 id 订单已迁走(current 表 MAX(id) 变小),表重建会把水位重置为 * current.MAX(id)+1,与配送表已占用的 id 重叠,后续迁移显式插入会撞主键。 * 所以水位基准必须取所有分表的最大 MAX(id)。 * * @param {string} tableName 表名。 * @return {Promise} */ async ensureAutoIncrementWatermark(tableName) { const parsed = parseManagedTableName(tableName); if (!parsed) { return; } const baseline = await this.getSharedIdBaseline(parsed.warehouseId); if (!Number.isFinite(baseline) || baseline <= 0) { return; } const autoIncrement = await this.getTableAutoIncrement(tableName); if (autoIncrement === null || autoIncrement > baseline) { return; } // 修复目标加安全余量:防止读取 MAX(id) 与 SET 之间的并发插入抢先占号, // 导致修复后水位再次低于已分配 id(MySQL 不会把计数器降到当前已分配值以下, // 余量仅作为并发窗口的缓冲) const safeTarget = baseline + AUTO_INCREMENT_SAFE_MARGIN; await this.app.model.query(`ALTER TABLE ${quoteIdentifier(tableName)} AUTO_INCREMENT = ${safeTarget}`); this.app.logger.warn( `订单工厂表 ${tableName} 自增水位低于共享 id 序列最大 id(auto=${autoIncrement}, max=${baseline}),已修复为 ${safeTarget}` ); } /** * 确保单个目标表与模型结构一致。 * @param {string} tableName 表名。 * @param {string} type 模型类型。 * @param {number|string} warehouseId 仓库ID。 * @param {Object} [DynamicModel] 已构建的动态模型。 * @return {Promise} 是否执行了同步。 */ async ensureManagedTableSchema(tableName, type, warehouseId, DynamicModel = null) { const modelType = this.resolveModelType(type); const dynamicModel = DynamicModel || this.buildManagedModel(warehouseId, modelType, tableName); const tableExists = await this.checkTableExists(tableName); const needsSync = tableExists ? await this.needsTableSchemaSync(tableName, modelType, warehouseId, tableExists) : true; if (!tableExists) { await dynamicModel.sync({ force: false }); return true; } if (needsSync) { await this.assertManagedTableDataConstraints(tableName, modelType); await this.alterManagedTableSchema(tableName, modelType, warehouseId); } // 无论是否同步结构,都核对自增水位(表重建/迁移/手工修复都可能破坏水位) await this.ensureAutoIncrementWatermark(tableName); return needsSync; } /** * 读取表的当前 AUTO_INCREMENT 水位。 * @param {string} tableName 表名。 * @return {Promise} 自增水位,非自增表返回 null。 */ async getTableAutoIncrement(tableName) { const [ rows ] = await this.app.model.query( 'SELECT AUTO_INCREMENT AS autoIncrement FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?', { replacements: [ tableName ] } ); const rawValue = rows && rows[0] && rows[0].autoIncrement; const value = Number(rawValue); return Number.isFinite(value) ? value : null; } /** * 获取仓库订单 id 序列表名。 * * 每仓库一张序列表:id 自增发号,location 记录订单数据当前所在表位。 * * @param {number|string} warehouseId 仓库ID。 * @return {string} 序列表名。 */ getLocationSequenceTableName(warehouseId) { return `wms_order_id_location_${warehouseId}`; } /** * 确保仓库订单 id 序列表存在,并将其自增水位抬升到同仓库所有 * 订单分表 MAX(id) 之上(避开存量订单 id)。 * * 注意:本方法可能执行 DDL(隐式提交),必须在事务外调用。 * * @param {number|string} warehouseId 仓库ID。 * @return {Promise} */ async ensureLocationSequenceTable(warehouseId) { const tableName = this.getLocationSequenceTableName(warehouseId); // 进程内已初始化过则跳过:避免每次建单都重复 showAllTables + 分表 MAX 核对 if (this.locationTableReady.get(warehouseId)) { return; } // 并发去重:同一仓库并发的 ensure 共享同一个初始化 Promise, // 保证「建表 + 抬水位」只执行一次,其余调用等待完成后直接返回。 return await this.runModelInitializer(`init_seq_${warehouseId}`, async () => { if (this.locationTableReady.get(warehouseId)) { return; } // 先算基线再建表:建表语句直接携带正确水位。 // 消除「先建表(水位=1)再 ALTER」之间的发号窗口——否则窗口内 // 并发建单/多 worker 发号会拿到 1,与存量订单 id 冲突。 const baseline = await this.getSharedIdBaseline(warehouseId); const safeTarget = baseline > 0 ? baseline + AUTO_INCREMENT_SAFE_MARGIN : 0; const exists = await this.checkTableExists(tableName); if (!exists) { const autoIncrementClause = safeTarget > 0 ? ` AUTO_INCREMENT = ${safeTarget}` : ''; try { await this.app.model.query( `CREATE TABLE ${quoteIdentifier(tableName)} ( \`id\` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT, \`location\` VARCHAR(20) NOT NULL DEFAULT 'current', PRIMARY KEY (\`id\`) ) ENGINE=InnoDB${autoIncrementClause} DEFAULT CHARSET=utf8mb4 COMMENT='仓库订单全局id序列与位置索引(极简,不迁移)'` ); this.app.logger.info(`创建订单 id 序列表成功: ${tableName}${safeTarget > 0 ? `, 初始水位=${safeTarget}` : ''}`); } catch (createError) { const errorCode = createError && ((createError.original && createError.original.code) || (createError.parent && createError.parent.code) || createError.code); if (errorCode !== 'ER_TABLE_EXISTS') { throw createError; } // 并发窗口:其他 worker 已建表,转入下方已存在核对分支 this.app.logger.warn(`订单 id 序列表 ${tableName} 已被并发创建,转入水位核对`); } } // 表已存在(或刚被并发创建):核对并抬升水位 if (safeTarget > 0) { const autoIncrement = await this.getTableAutoIncrement(tableName); // ai 为 null(MariaDB 新建表/计数器未初始化)同样视为需要抬升 if (autoIncrement === null || autoIncrement <= baseline) { await this.app.model.query( `ALTER TABLE ${quoteIdentifier(tableName)} AUTO_INCREMENT = ${safeTarget}` ); this.app.logger.warn( `订单 id 序列表 ${tableName} 水位抬升至 ${safeTarget}(分表最大 id=${baseline},原水位=${autoIncrement ?? 'null'})` ); } } this.locationTableReady.set(warehouseId, true); }); } /** * 启动初检:为当前库中已存在的订单分表仓库确保序列表存在且水位正确。 * * 仅做「建表 + 水位抬升」,不迁移任何数据——存量订单的位置指针回填由 * `script/backfill-order-id-location.cjs` 脚本负责。单个仓库失败仅告警, * 不影响其他仓库与服务启动。 * * @return {Promise} 完成初检的仓库数。 */ async ensureAllLocationSequenceTables() { const managedTableNames = await this.listManagedTableNames(); const warehouseIds = Array.from(new Set( managedTableNames .map(tableName => { const parsed = parseManagedTableName(tableName); return parsed ? parsed.warehouseId : null; }) .filter(Boolean) )); let checkedCount = 0; for (const warehouseId of warehouseIds) { try { await this.ensureLocationSequenceTable(warehouseId); checkedCount += 1; } catch (error) { this.app.logger.warn(`[启动初检] 仓库 ${warehouseId} 序列表初始化失败: ${error.message}`); } } if (warehouseIds.length > 0) { this.app.logger.info(`[启动初检] 订单 id 序列表初检完成: ${checkedCount}/${warehouseIds.length} 个仓库`); } return checkedCount; } /** * 从仓库序列表分配全局订单 id(在调用方事务内执行,随事务回滚)。 * * 调用方必须在事务外先调用 ensureLocationSequenceTable 完成建表。 * * @param {number|string} warehouseId 仓库ID。 * @param {Object} [transaction] Sequelize 事务。 * @param {string} [location='current'] 初始位置(current/dispatch/history/outsourced)。 * @return {Promise} 新分配的订单 id。 */ async allocateOrderId(warehouseId, transaction = null, location = 'current') { const tableName = this.getLocationSequenceTableName(warehouseId); if (!this.locationTableReady.get(warehouseId)) { const exists = await this.checkTableExists(tableName); if (!exists) { // 不允许在事务内隐式 DDL,交给调用方在事务外初始化 throw new Error(`订单 id 序列表 ${tableName} 不存在,请先调用 ensureLocationSequenceTable`); } this.locationTableReady.set(warehouseId, true); } const options = transaction ? { transaction } : {}; const queryResult = await this.app.model.query( `INSERT INTO ${quoteIdentifier(tableName)} (\`location\`) VALUES (?)`, { replacements: [ location ], ...options } ); // sequelize.query 对 INSERT 的返回形态随驱动不同,兼容解析: // - mysql2: [ insertId, affectedRows ](首个元素是数字) // - 其他包装: [{ insertId, affectedRows }, ...] const raw = Array.isArray(queryResult) ? queryResult[0] : queryResult; let insertId = 0; if (typeof raw === 'number') { insertId = raw; } else if (raw && typeof raw === 'object' && !Array.isArray(raw)) { insertId = Number(raw.insertId || 0); } else if (Array.isArray(raw) && raw.length > 0 && typeof raw[0] === 'number') { insertId = Number(raw[0]); } if (!Number.isFinite(insertId) || insertId <= 0) { throw new Error('订单 id 分配失败'); } return insertId; } /** * 更新订单在序列表中的位置指针(迁移时调用)。 * * 存量订单(序列表无记录)以显式 id 补录;显式插入值大于当前水位时 * MySQL 会自动推进序列表自增,保证后续发号不与存量 id 冲突。 * * @param {number|string} orderId 订单ID。 * @param {number|string} warehouseId 仓库ID。 * @param {string} location 新位置。 * @param {Object} [transaction] Sequelize 事务。 * @return {Promise} */ async updateOrderLocation(orderId, warehouseId, location, transaction = null) { const tableName = this.getLocationSequenceTableName(warehouseId); const options = transaction ? { transaction } : {}; await this.app.model.query( `INSERT INTO ${quoteIdentifier(tableName)} (\`id\`, \`location\`) VALUES (?, ?) ON DUPLICATE KEY UPDATE \`location\` = VALUES(\`location\`)`, { replacements: [ Number(orderId), location ], ...options } ); } /** * 查询单个订单当前所在表位。 * * @param {number|string} orderId 订单ID。 * @param {number|string} warehouseId 仓库ID。 * @param {Object} [transaction] Sequelize 事务。 * @return {Promise} 位置(current/dispatch/history/outsourced), * 无记录返回 null(存量订单未回填)。 */ async getOrderLocation(orderId, warehouseId, transaction = null) { const tableName = this.getLocationSequenceTableName(warehouseId); if (!this.locationTableReady.get(warehouseId)) { const exists = await this.checkTableExists(tableName); if (!exists) { return null; } this.locationTableReady.set(warehouseId, true); } const options = transaction ? { transaction } : {}; const [ rows ] = await this.app.model.query( `SELECT \`location\` FROM ${quoteIdentifier(tableName)} WHERE \`id\` = ? LIMIT 1`, { replacements: [ Number(orderId) ], ...options } ); return rows && rows[0] ? String(rows[0].location) : null; } /** * 批量查询订单当前所在表位。 * * @param {Array} orderIds 订单ID列表。 * @param {number|string} warehouseId 仓库ID。 * @param {Object} [transaction] Sequelize 事务。 * @return {Promise>} orderId → location; * 无记录的订单不在 Map 中(存量订单未回填)。 */ async getOrderLocations(orderIds, warehouseId, transaction = null) { const result = new Map(); const normalizedIds = Array.from(new Set( (Array.isArray(orderIds) ? orderIds : [ orderIds ]) .map(id => Number(id)) .filter(id => Number.isFinite(id) && id > 0) )); if (normalizedIds.length === 0) { return result; } const tableName = this.getLocationSequenceTableName(warehouseId); if (!this.locationTableReady.get(warehouseId)) { const exists = await this.checkTableExists(tableName); if (!exists) { return result; } this.locationTableReady.set(warehouseId, true); } const options = transaction ? { transaction } : {}; const placeholders = normalizedIds.map(() => '?').join(','); const [ rows ] = await this.app.model.query( `SELECT \`id\`, \`location\` FROM ${quoteIdentifier(tableName)} WHERE \`id\` IN (${placeholders})`, { replacements: normalizedIds, ...options } ); for (const row of rows || []) { result.set(Number(row.id), String(row.location)); } return result; } /** * 将现有表的列结构与期望模型对齐,所有变更合并为单条 ALTER TABLE 语句。 * * 自增保护:对自增主键 id 列不做 CHANGE——对 AUTO_INCREMENT 列重新声明 * 列定义可能触发表重建(ALGORITHM=COPY),重建后 AUTO_INCREMENT 被重置为 * MAX(id)+1。待处理表的高 id 订单已迁移删除,重置会使自增水位回退到历史 * 低值,与配送表已复制的 id 重叠,导致后续迁移主键冲突。 * * @param {string} tableName 表名。 * @param {string} type 模型类型。 * @param {number|string} warehouseId 仓库ID。 * @return {Promise} */ async alterManagedTableSchema(tableName, type, warehouseId) { const queryInterface = this.app.model.getQueryInterface(); const sequelize = this.app.model; const actualColumns = await queryInterface.describeTable(tableName); const expectedAttributes = this.getTableAttributes(type); const quotedTableName = quoteIdentifier(tableName); const actualColumnNames = new Set(Object.keys(actualColumns || {})); const expectedColumnNames = Object.keys(expectedAttributes); const clauses = []; // ADD 新增列 / CHANGE 差异列;id 主键列永不参与 CHANGE——对 AUTO_INCREMENT // 列重新声明列定义可能触发表重建(ALGORITHM=COPY),重建后 AUTO_INCREMENT 被重置为 // MAX(id)+1。待处理表的高 id 订单已迁移删除,重置会使自增水位回退到历史低值, // 与配送表已复制的 id 重叠,导致后续迁移主键冲突。 for (const columnName of expectedColumnNames) { const expectedAttribute = expectedAttributes[columnName]; if (columnName === 'id') { continue; } const columnDef = buildColumnLine(columnName, expectedAttribute); if (!actualColumnNames.has(columnName)) { clauses.push(`ADD COLUMN ${columnDef}`); } else if (isColumnDefinitionDifferent(columnName, expectedAttribute, actualColumns[columnName])) { clauses.push(`CHANGE ${quoteIdentifier(columnName)} ${columnDef}`); } } // DROP 多余列(现有表有但期望模型没有的列;id 必在期望模型中,不会被 DROP) const expectedColumnSet = new Set(expectedColumnNames); for (const columnName of actualColumnNames) { if (!expectedColumnSet.has(columnName)) { clauses.push(`DROP COLUMN ${quoteIdentifier(columnName)}`); } } const previousAutoIncrement = await this.getTableAutoIncrement(tableName); if (clauses.length > 0) { await sequelize.query(`ALTER TABLE ${quotedTableName} ${clauses.join(', ')}`); } // 若 ALTER 触发表重建并把自增水位重置到历史低值,恢复原水位 const currentAutoIncrement = await this.getTableAutoIncrement(tableName); if (previousAutoIncrement !== null && currentAutoIncrement !== null && currentAutoIncrement < previousAutoIncrement) { await sequelize.query(`ALTER TABLE ${quotedTableName} AUTO_INCREMENT = ${previousAutoIncrement}`); this.app.logger.warn( `订单工厂表 ${tableName} 自增水位被 ALTER 重置(${previousAutoIncrement} → ${currentAutoIncrement}),已恢复为 ${previousAutoIncrement}` ); } // 索引同步不再使用 sync({ alter: true }):历史事故表明它会重建表并重置自增水位, // 且无法可靠检测 AUTO_INCREMENT 属性差异。改为仅补齐缺失索引,不重建、不删除已有索引。 const existingIndexNames = new Set((await queryInterface.showIndex(tableName)) .map(index => index.Key_name || index.name || '') .filter(Boolean)); for (const indexDef of this.getIndexes(warehouseId, type)) { if (existingIndexNames.has(indexDef.name)) { continue; } await queryInterface.addIndex(tableName, indexDef.fields, { name: indexDef.name, unique: Boolean(indexDef.unique), }); } } /** * 获取当前库中已存在的订单工厂目标表。 * @return {Promise>} 目标表名列表。 */ async listManagedTableNames() { const [ rows ] = await this.app.model.query(` SELECT TABLE_NAME AS tableName FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME LIKE 'wms_order_delivery_%' `); return rows .map(item => item.tableName) .filter(tableName => parseManagedTableName(tableName)); } /** * 创建物理表 * @param {number} warehouseId 仓库ID * @param {string} type 模型类型 * @return {Promise} */ async createPhysicalTable(warehouseId, type) { const modelType = this.resolveModelType(type); const tableName = this.generateTableName(warehouseId, modelType); const dynamicModel = this.buildManagedModel(warehouseId, modelType, tableName); // 统一走差异检测 + 自增水位保护的同步路径,不再使用 sync({ alter: true }) await this.ensureManagedTableSchema(tableName, modelType, warehouseId, dynamicModel); this.app.logger.info(`创建/同步物理表成功: ${tableName}`); } /** * 获取状态枚举值 */ getStatusEnumValues() { return { status: [ 'created', 'cancel', 'error' ], sync_status: [ 'padding', 'fin', 'error' ], post_status: [ 'padding', 'fin', 'timeout', 'error', 'none' ], storage_status: [ 'padding', 'fin', 'error', 'none' ], pick_status: [ 'padding', 'fin', 'error', 'none' ], pack_status: [ 'none', 'padding', 'fin', 'error' ], inspection_status: [ 'none', 'padding', 'running', 'fin', 'error' ], step: [ 0, 1 ], print_status: [ 'none', 'padding', 'fin', 'error' ], print_lock_status: [ 'none', 'warehouse' ], claim_status: [ 'none', 'padding', 'fin', 'error' ], outbound_status: [ 'none', 'padding', 'fin', 'timeout', 'error' ], lock_status: [ 'none', 'warehouse', 'store' ], intercept_status: [ 'none', 'requesting', 'requested', 'intercepting', 'intercepted_in_transit', 'intercepted_at_warehouse', 'returning', 'returned', 'delivered_by_mistake', 'timeout', 'cancelled', 'failed', 'exception', ], }; } /** * 生成表名 * @param {number} warehouseId 仓库ID * @param {string} type 模型类型 * @return {string} 表名 */ generateTableName(warehouseId, type) { const modelType = this.resolveModelType(type); return buildManagedTableName(warehouseId, modelType); } /** * 获取订单工厂管理表的注释。 * @param {number|string} warehouseId 仓库ID。 * @param {string} type 模型类型。 * @return {string} 表注释。 */ getTableComment(warehouseId, type) { return buildTableComment(warehouseId, type); } /** * 清理模型缓存 */ clearCache() { this.modelCache.clear(); this.inflightInitCache.clear(); clearShardWarehouseValidationCache(this.app); this.app.logger.info('模型缓存已清理'); } /** * 获取所有缓存的模型 */ getCachedModels() { return Array.from(this.modelCache.entries()); } } return new OrderDeliveryFactory(); };