diff --git a/backend/src/config/cloudDatabase.js b/backend/src/config/cloudDatabase.js index f9aa901..0427f50 100644 --- a/backend/src/config/cloudDatabase.js +++ b/backend/src/config/cloudDatabase.js @@ -1055,6 +1055,15 @@ const resetPool = async () => { */ const query = async (sqlText, params = {}, options = {}) => { warnLegacyTimeoutOption(options, 'query()'); + // 🔥 2026-11-17:`requestTimeout` 只写 request.timeout(**请求级**),mssql 12.x 上不生效, + // 实际仍按共享池创建时定死的池级 requestTimeout(默认 60s)掐断 —— MKH-BOM 的订单大表 + // 查询就是因此「代码里写 180s、实际 60s 必超时并降级」,页面待发订单量长期为 0。 + // 需要真正放宽超时的调用方,显式传 `freshConnection: true` 走临时独立连接 + // (池级超时随 connectRequestTimeoutMs 任意放大),比让调用方各自调用 querySlow 更好维护, + // 也让单测只需 mock query() 一个入口。 + if (options && options.freshConnection === true) { + return queryWithFreshConnection(sqlText, params, options); + } const maxAttempts = parsePositiveInt(options.maxAttempts, 2); for (let attempt = 1; attempt <= maxAttempts; attempt += 1) { diff --git a/backend/src/index.js b/backend/src/index.js index 56a8587..2669b89 100644 --- a/backend/src/index.js +++ b/backend/src/index.js @@ -69,6 +69,9 @@ const { const { startMkhReplenishAlertScheduler, } = require('./jobs/mkhReplenishAlertJob'); +const { + startMkhBomPrewarmScheduler, +} = require('./jobs/mkhBomPrewarmJob'); const { startWarehouseLogisticsExceptionNotifyScheduler, } = require('./jobs/warehouseLogisticsExceptionNotifyJob'); @@ -800,6 +803,9 @@ async function startServer(options = {}) { startGoodsFirstSeenScheduler(); startAlibaba1688ImageSearchExpiryScheduler(); startMkhReplenishAlertScheduler(); + // MKH-BOM 页面索引预热:订单两表全表扫很贵(冷查分钟级),必须由后台保持热态, + // 不能让「打开页面 / F5」的用户去等(见 jobs/mkhBomPrewarmJob.js 文件头) + startMkhBomPrewarmScheduler(); startWarehouseLogisticsExceptionNotifyScheduler(); startShipTimelinessNotifyScheduler(); startDailyInventorySnapshotScheduler(); diff --git a/backend/src/jobs/mkhBomPrewarmJob.js b/backend/src/jobs/mkhBomPrewarmJob.js new file mode 100644 index 0000000..f498c9a --- /dev/null +++ b/backend/src/jobs/mkhBomPrewarmJob.js @@ -0,0 +1,90 @@ +'use strict'; + +/** + * MKH-BOM 页面索引后台预热。 + * + * 背景(2026-11-17 排查结论): + * 这个页面除了「订单两表」之外,全部数据都在内存里算。而订单查询是 + * `skus LIKE '%MKH%'` 前导通配 → 必然全表扫;副本库又慢到 + * `rpt.jst_Orders` 158 万行**光 COUNT(*)** 要 152.8s(≈1 万行/秒)。 + * 于是「谁把缓存打穿,谁就等 2~8 分钟」。 + * + * 旧行为之所以每次打开都慢: + * 前端「首屏 + 每 2 分钟」都带 `fresh=1` → 后端清运营缓存 → 必冷查。 + * + * 现在的分工: + * · 请求路径只读缓存(过期了也先返回旧值,见 loadOrderIndex 的 stale-while-revalidate); + * · 只有「同步最新数据」按钮会清缓存强制重读; + * · **索引新鲜度由这个任务负责**:启动 20 秒后跑一次,之后每 20 分钟跑一次, + * 始终赶在 30 分钟 TTL 到期之前把订单索引换掉。 + * + * 配置(都不用发版): + * · MKH_BOM_PREWARM_INTERVAL_MINUTES 预热间隔,默认 20 + * · MKH_BOM_PREWARM_DISABLED=true 关闭(排查 / 本地开发时用) + */ + +const cron = require('node-cron'); +const { prewarmMkhBomIndex } = require('../services/mkhBomService'); + +const TIMEZONE = 'Asia/Shanghai'; +const DEFAULT_INTERVAL_MINUTES = 20; +// 启动后等一会儿再跑:别和数据库连接自检、其它启动预热抢业务库 +const STARTUP_DELAY_MS = 20 * 1000; + +// 单飞:上一轮没跑完(冷查可能好几分钟)就不叠加下一轮 +let running = false; + +async function runMkhBomPrewarm(source = 'scheduled') { + if (running) return { skipped: true, reason: 'running' }; + running = true; + try { + const result = await prewarmMkhBomIndex(); + console.log( + `[MkhBomPrewarm] ${source} 完成,耗时 ${Math.round(result.elapsedMs / 1000)}s (${result.steps.join(', ')})` + ); + return result; + } catch (error) { + // 预热失败不影响功能:下一次请求会自己撞冷查(只是慢一点) + console.warn(`[MkhBomPrewarm] ${source} 失败:`, error.message || error); + return { error: error.message || String(error) }; + } finally { + running = false; + } +} + +function resolveIntervalMinutes() { + const raw = Number.parseInt(process.env.MKH_BOM_PREWARM_INTERVAL_MINUTES, 10); + if (!Number.isFinite(raw) || raw < 5 || raw > 59) return DEFAULT_INTERVAL_MINUTES; + return raw; +} + +function startMkhBomPrewarmScheduler() { + const disabled = String(process.env.MKH_BOM_PREWARM_DISABLED || '').trim().toLowerCase() === 'true'; + if (disabled) { + console.log('[Scheduler] MKH-BOM 索引预热已禁用'); + return; + } + + const minutes = resolveIntervalMinutes(); + // node-cron 的 */n 在 n 不整除 60 时会在跨小时处多跑一次,20 分钟整除,没问题 + const expression = `*/${minutes} * * * *`; + cron.schedule(expression, () => { + runMkhBomPrewarm('interval').catch(() => {}); + }, { timezone: TIMEZONE }); + + const startupTimer = setTimeout(() => { + runMkhBomPrewarm('startup').catch(() => {}); + }, STARTUP_DELAY_MS); + if (typeof startupTimer.unref === 'function') startupTimer.unref(); + + console.log(`[Scheduler] MKH-BOM 索引预热已注册: 启动后 ${STARTUP_DELAY_MS / 1000}s 跑一次,之后 ${expression} (${TIMEZONE})`); +} + +module.exports = { + DEFAULT_INTERVAL_MINUTES, + STARTUP_DELAY_MS, + TIMEZONE, + resolveIntervalMinutes, + runMkhBomPrewarm, + startMkhBomPrewarmScheduler, +}; diff --git a/backend/src/services/mkhBomService.js b/backend/src/services/mkhBomService.js index 0287648..1e7e762 100644 --- a/backend/src/services/mkhBomService.js +++ b/backend/src/services/mkhBomService.js @@ -501,10 +501,40 @@ const ORDER_TABLES = Object.freeze([ ]); // 不计入需求的订单状态:Cancelled 已取消 / Merged 已合并进别的单 const PENDING_ORDER_EXCLUDED_STATUS = Object.freeze(['Cancelled', 'Merged']); -// 只捞含 MKH 的订单,避免全表扫描(实测 1.18M 行 + 4.91M 行,合并查询约 1.25s) +// 只捞含 MKH 的订单,避免把结果集全拉回来。 +// ⚠️ 注意:这是**前导通配**(`LIKE '%MKH%'`),索引完全用不上 → SQL Server 必然全表扫。 +// 2026-11-17 实测副本库 `rpt.jst_Orders` 158 万行光 COUNT(*) 就要 152.8s(≈1 万行/秒), +// 所以这条查询必须走独立连接 + 长超时,并且不能放在用户请求路径上(见 loadOrderIndex)。 const PENDING_ORDER_SKU_LIKE = '%MKH%'; -// 订单数据源异常时的降级缓存时长 -const PENDING_ORDER_DEGRADED_TTL_MS = 60 * 1000; +// 订单数据源异常时的降级缓存时长。 +// 🔥 2026-11-17:60 秒 → 5 分钟。降级态下每次重试都是一次**全表扫描**(实测单次 60~130s, +// 慢的时候 400s+),60 秒 TTL 等于「刚失败就重打」,库越慢越打、越打越慢 —— 自残循环。 +// 5 分钟仍然够快恢复,但不会把本来就慢的副本库打穿。 +const PENDING_ORDER_DEGRADED_TTL_MS = 5 * 60 * 1000; +// 订单查询超时(毫秒)。**必须走独立连接**(`freshConnection: true`): +// 共享池的池级超时在 pool 创建时就定死了(默认 60s),`requestTimeout` 只是请求级设置、 +// 在 mssql 12.x 上不生效。2026-11-17 实测:rpt.jst_Orders 158 万行**光 COUNT(*)** 就要 +// 152.8s(≈1 万行/秒),而 `skus LIKE '%MKH%'` 前导通配必然全表扫 → 60s 无解。 +// 可用 CANGKU_MKH_ORDER_QUERY_TIMEOUT_MS 覆盖(默认 5 分钟)。 +const ORDER_QUERY_TIMEOUT_MS = Number(process.env.CANGKU_MKH_ORDER_QUERY_TIMEOUT_MS) || 300000; +// 不重连重试:这类失败是「库慢」而不是瞬时抖动,重试只会把等待翻倍(60s → 120s → …)。 +const ORDER_QUERY_MAX_ATTEMPTS = 1; +// 待发货分支的订单日期下界(天)。原 SQL 只有 `send_date IS NULL`、**没有任何时间下界**, +// 历史僵尸单全部参与扫描与累计。180 天足够覆盖真实待发(聚水潭超过半年的未发单 +// 基本已人工作废),同时把扫描量从「全表」压到「近半年」。 +// order_date 为空的单照旧纳入(宁可多算,不可漏算真实待发)。 +const PENDING_ORDER_MAX_AGE_DAYS = 180; +// 订单索引缓存时长。10 分钟 → 30 分钟:订单索引是这个页面唯一的重查询,而它承载的 +// 待发货 / 近 15 天已发货都是「分钟级变化」的数据,30 分钟对补货预警完全够用。 +// 配合 jobs/mkhBomPrewarmJob(每 20 分钟后台预热)→ 请求路径基本不会撞上冷查。 +// 注意:其它 10 分钟缓存(商品主数据 / 库存合并索引)仍用 MKH_CACHE_TTL_MS,别一起放大, +// 库存是业务要看的实时口径,30 分钟太旧了。 +const ORDER_INDEX_CACHE_TTL_MS = 30 * 60 * 1000; +// 后台刷新失败后,至少隔这么久才允许下一次尝试 —— 否则每个请求都会去撞一次全表扫描。 +const ORDER_INDEX_RETRY_AFTER_FAILURE_MS = 60 * 1000; +// 出库校验查询超时:**故意比订单主查询短**。出库校验失败是安全降级 +// (宁可漏杀不可错杀,见 ⑦-c),不值得为它多等 5 分钟。 +const OUTBOUND_QUERY_TIMEOUT_MS = 180000; // 日销兜底(⑦-a):这些店铺的单上游不计入日销,兜底也必须排除,否则会误拉进预警 const SALE_EXCLUDED_SHOP_KEYWORDS = Object.freeze(['样品', '测试']); // 日销兜底(⑦-a):**异常单**同样不能计入「已发货」—— @@ -1584,7 +1614,13 @@ async function loadOutboundOrderIds(orderIds) { ${union} ) outbound_rows`, params, - { requestTimeout: 180000 } + { + // 同订单主查询:必须独立连接,否则按共享池 60s 掐断(`requestTimeout` 不生效)。 + // 但超时故意更短,见 OUTBOUND_QUERY_TIMEOUT_MS。 + freshConnection: true, + connectRequestTimeoutMs: OUTBOUND_QUERY_TIMEOUT_MS, + maxAttempts: 1, + } ); })); @@ -1614,11 +1650,32 @@ async function loadOutboundOrderIds(orderIds) { * · 两者商品都取自主表 `skus` 文本列,`MKH-` 打头的组合装不计 * · 三条过滤只作用于**已发货**分支:待发货(⑩)本来就是没出货的订单,不做出库校验 * ⚠️ 不降级为「抛错」:取不到时按空索引处理(补货预警退化成旧口径),并缩短缓存以便重试。 + * + * 🔥 2026-11-17 性能重构(「每次打开/刷新都慢、导出也卡」的根因): + * ① 走独立连接(`freshConnection`)+ ORDER_QUERY_TIMEOUT_MS。原来传的 + * `{ requestTimeout: 180000 }` 在共享池上**不生效**(请求级 request.timeout 在 mssql 12.x + * 无效),实际一律 60s 被掐断 → 每次加载都降级成「待发SKU=0 / 订单驱动=0」。 + * ② 待发货分支补 order_date 下界(见 PENDING_ORDER_MAX_AGE_DAYS),不再扫历史僵尸单。 + * ③ 缓存改为 stale-while-revalidate:过期后**先返回旧值**、后台补新值, + * 请求路径不再为冷查买单(实测首屏冷查 126.9s vs 缓存命中 4~5s)。 + * ④ TTL 10 → 30 分钟(ORDER_INDEX_CACHE_TTL_MS),配合 jobs/mkhBomPrewarmJob + * 每 20 分钟后台预热 → 正常使用期间请求路径根本撞不上冷查。 */ -async function loadOrderIndex() { +async function loadOrderIndex(queryOptions = {}) { const now = Date.now(); - if (orderIndexCache?.value && orderIndexCache.expiresAt > now) { - return orderIndexCache.value; + const force = queryOptions.force === true; + const cached = orderIndexCache?.value || null; + + if (!force && cached && orderIndexCache.expiresAt > now) { + return cached; + } + // 过期但有旧值:先给旧值,后台刷新(不阻塞请求)。 + // 只有「确实没有旧值」(进程刚起 / 缓存被清)才让调用方等冷查。 + if (cached && !force) { + if (!orderIndexCache.pending) { + loadOrderIndex({ force: true }).catch(() => {}); + } + return cached; } if (orderIndexCache?.pending) return orderIndexCache.pending; @@ -1645,14 +1702,26 @@ async function loadOrderIndex() { WHERE o.skus LIKE @pendingOrderSkuLike AND o.status NOT IN (${statusPlaceholders}) AND ( - o.send_date IS NULL + ( + -- 待发货:只认近 N 天的单(见 PENDING_ORDER_MAX_AGE_DAYS), + -- 原写法没有时间下界,半年以前的僵尸单也会全表参与扫描与累计。 + -- order_date 为空视为「新单」照旧纳入:宁可多算,不可漏算真实待发。 + o.send_date IS NULL + AND ISNULL(o.order_date, CAST(GETDATE() AS date)) + >= DATEADD(DAY, -${PENDING_ORDER_MAX_AGE_DAYS}, CAST(GETDATE() AS date)) + ) OR ( o.send_date >= DATEADD(DAY, -${SALE_WINDOW_DAYS - 1}, CAST(GETDATE() AS date)) AND o.send_date < DATEADD(DAY, 1, CAST(GETDATE() AS date)) ) )`, { pendingOrderSkuLike: PENDING_ORDER_SKU_LIKE, ...statusParams }, - { requestTimeout: 180000 } + { + // 必须走独立连接:共享池的池级 60s 超时改不动(见 ORDER_QUERY_TIMEOUT_MS) + freshConnection: true, + connectRequestTimeoutMs: ORDER_QUERY_TIMEOUT_MS, + maxAttempts: ORDER_QUERY_MAX_ATTEMPTS, + } ))).then(async (results) => { const pendingBySku = new Map(); const shippedBySku = new Map(); @@ -1751,12 +1820,15 @@ async function loadOrderIndex() { ttl: PENDING_ORDER_DEGRADED_TTL_MS, }; } - return { pendingBySku, shippedBySku, degraded: false, error: null, ttl: MKH_CACHE_TTL_MS }; + return { pendingBySku, shippedBySku, degraded: false, error: null, ttl: ORDER_INDEX_CACHE_TTL_MS }; }); const epoch = cacheEpoch; const operationalEpoch = operationalCacheEpoch; - orderIndexCache = { pending, value: null, expiresAt: 0 }; + // 刷新期间保留旧值:并发请求照旧拿到旧快照,不必陪着这次(可能几分钟的)全表扫描一起等。 + const staleValue = orderIndexCache?.value || null; + const staleExpiresAt = orderIndexCache?.expiresAt || 0; + orderIndexCache = { pending, value: staleValue, expiresAt: staleExpiresAt }; try { const value = await pending; if (epoch === cacheEpoch && operationalEpoch === operationalCacheEpoch) { @@ -1764,7 +1836,13 @@ async function loadOrderIndex() { } return value; } catch (error) { - if (epoch === cacheEpoch && operationalEpoch === operationalCacheEpoch) orderIndexCache = null; + if (epoch === cacheEpoch && operationalEpoch === operationalCacheEpoch) { + // 刷新失败:有旧值就继续用(比空索引好得多,空索引会让待发货量显示 0), + // 并把「下次再试」压到 1 分钟后 —— 否则每个请求都会去撞一次全表扫描。 + orderIndexCache = staleValue + ? { pending: null, value: staleValue, expiresAt: Date.now() + ORDER_INDEX_RETRY_AFTER_FAILURE_MS } + : null; + } throw error; } } @@ -2634,6 +2712,40 @@ async function refreshMkhOperationalData() { } } +/** + * 后台预热:把「订单两表全表扫」这个重查询挪出用户请求路径。 + * 由 jobs/mkhBomPrewarmJob 在启动后、以及每 20 分钟调用一次(可用环境变量调整)。 + * + * 为什么需要它:订单索引是整页唯一的重查询(冷查实测 126.9s 首屏、`loadOrderIndex` 单跑 408.5s), + * 而页面其它数据全在内存里算。只要索引一直是热的,打开页面就稳定在 4~5 秒; + * 一旦让它自然过期,下一位用户就得为冷查买单。 + * + * 失败不影响功能(下一次请求会自己撞冷查),所以调用方只记日志、不重试。 + * @returns {Promise<{elapsedMs: number, steps: string[]}>} + */ +async function prewarmMkhBomIndex() { + const startedAt = Date.now(); + const steps = []; + + // ① 订单索引:剩余有效期不足一半就强制刷一次。 + // 预热 20 分钟一轮 + TTL 30 分钟 → 实际每轮都会刷(剩余 ≈10 分钟 < 15 分钟)。 + const remaining = orderIndexCache?.expiresAt ? orderIndexCache.expiresAt - Date.now() : 0; + if (!orderIndexCache?.value || remaining < ORDER_INDEX_CACHE_TTL_MS / 2) { + const orderStartedAt = Date.now(); + await loadOrderIndex({ force: true }); + steps.push(`orderIndex=${Date.now() - orderStartedAt}ms`); + } else { + steps.push('orderIndex=fresh'); + } + + // ② 库存/箱表/加工单/待发货合并索引(内部会复用上一步刚刷好的订单索引) + const replenishStartedAt = Date.now(); + await loadReplenishIndex(); + steps.push(`replenishIndex=${Date.now() - replenishStartedAt}ms`); + + return { elapsedMs: Date.now() - startedAt, steps }; +} + function clearMkhBomCache() { // 🔥 先自增代际,再清各缓存:这样「本次清缓存之前已经发起、还没返回」的查询, // 回来时 epoch 对不上,就不会把旧快照写回缓存(否则会覆盖掉清缓存后新查到的值, @@ -2668,10 +2780,21 @@ function clearMkhBomCache() { }; } +// ── 仅供单测:观察 / 催熟订单索引缓存状态 ───────────────────────── +// stale-while-revalidate 的行为依赖「缓存过期」这个时刻,用真实时钟没法稳定构造, +// 所以给测试两个只读/催熟钩子(挂在 _private 下,不参与业务逻辑)。 +const getOrderIndexCacheState = () => (orderIndexCache + ? { hasValue: Boolean(orderIndexCache.value), expiresAt: orderIndexCache.expiresAt, pending: Boolean(orderIndexCache.pending) } + : null); +const expireOrderIndexCacheForTest = () => { + if (orderIndexCache?.value) orderIndexCache = { ...orderIndexCache, expiresAt: 0 }; +}; + module.exports = { getMkhBomList, clearMkhBomCache, refreshMkhOperationalData, + prewarmMkhBomIndex, getMkhBomDetail, listReplenishAlertRows, listMkhBomExportRows, @@ -2741,6 +2864,17 @@ module.exports = { buildComponentExportRows, clearMkhOperationalCache, refreshMkhOperationalData, + prewarmMkhBomIndex, OPERATIONAL_REFRESH_DEDUPE_MS, + // 订单链路性能参数(2026-11-17) + ORDER_QUERY_TIMEOUT_MS, + ORDER_QUERY_MAX_ATTEMPTS, + ORDER_INDEX_CACHE_TTL_MS, + ORDER_INDEX_RETRY_AFTER_FAILURE_MS, + PENDING_ORDER_MAX_AGE_DAYS, + PENDING_ORDER_DEGRADED_TTL_MS, + OUTBOUND_QUERY_TIMEOUT_MS, + getOrderIndexCacheState, + expireOrderIndexCacheForTest, }, }; diff --git a/backend/test/mkhBomService.test.js b/backend/test/mkhBomService.test.js index 26fa87b..f674fcd 100644 --- a/backend/test/mkhBomService.test.js +++ b/backend/test/mkhBomService.test.js @@ -1518,3 +1518,190 @@ test('operational refresh: 并发刷新只查一次运营数据,短时重试 svc.clearMkhBomCache(); } }); + +// ── 2026-11-17 订单链路性能(「每次打开 / 刷新都慢、导出也卡」)────────── +// 实测背景:rpt.jst_Orders 158 万行光 COUNT(*) 要 152.8s(≈1 万行/秒), +// `skus LIKE '%MKH%'` 前导通配必然全表扫;而旧代码传的 `requestTimeout: 180000` +// 在共享池上不生效(请求级 request.timeout 在 mssql 12.x 无效)→ 60s 必超时降级。 + +test('order index: 订单查询走独立连接并放大超时(否则共享池 60s 必超时降级)', async () => { + const cloudDatabase = require('../src/config/cloudDatabase'); + const svc = require('../src/services/mkhBomService'); + const originalQuery = cloudDatabase.query; + const calls = []; + + cloudDatabase.query = async (sql, params, options) => { + calls.push({ sql: String(sql), params: params || {}, options: options || {} }); + return []; + }; + + try { + svc.clearMkhBomCache(); + await svc._private.loadOrderIndex(); + + const orderCalls = calls.filter((call) => call.sql.includes('o.skus LIKE')); + assert.equal(orderCalls.length, 2, '两张渠道订单表都要读(只读一张会漏需求)'); + orderCalls.forEach((call) => { + assert.equal(call.options.freshConnection, true, '必须显式要一条独立连接'); + assert.equal( + call.options.connectRequestTimeoutMs, + svc._private.ORDER_QUERY_TIMEOUT_MS, + '超时必须走连接级参数' + ); + assert.ok(call.options.connectRequestTimeoutMs >= 300000, '超时下限 5 分钟(实测单表 COUNT 就要 152.8s)'); + assert.equal(call.options.maxAttempts, 1, '慢库重连重试只会把等待翻倍'); + assert.equal(call.options.requestTimeout, undefined, '不要再传那个名义上生效的 requestTimeout'); + }); + } finally { + cloudDatabase.query = originalQuery; + svc.clearMkhBomCache(); + } +}); + +test('order index: 待发货分支带近 180 天下界,不再扫历史僵尸单', async () => { + const cloudDatabase = require('../src/config/cloudDatabase'); + const svc = require('../src/services/mkhBomService'); + const originalQuery = cloudDatabase.query; + const sqls = []; + + cloudDatabase.query = async (sql) => { + sqls.push(String(sql)); + return []; + }; + + try { + svc.clearMkhBomCache(); + await svc._private.loadOrderIndex(); + const orderSql = sqls.find((sql) => sql.includes('o.skus LIKE')) || ''; + assert.match( + orderSql, + /o\.send_date IS NULL\s+AND ISNULL\(o\.order_date/, + '待发货必须把 order_date 下界和 send_date IS NULL 绑在一起' + ); + assert.ok( + orderSql.includes(`DATEADD(DAY, -${svc._private.PENDING_ORDER_MAX_AGE_DAYS}`), + '下界天数必须来自常量(默认 180 天)' + ); + assert.equal(svc._private.PENDING_ORDER_MAX_AGE_DAYS, 180); + } finally { + cloudDatabase.query = originalQuery; + svc.clearMkhBomCache(); + } +}); + +test('order index: 源失败时降级缓存 5 分钟,避免每分钟重打慢库', async () => { + const cloudDatabase = require('../src/config/cloudDatabase'); + const svc = require('../src/services/mkhBomService'); + const originalQuery = cloudDatabase.query; + let queryCount = 0; + + cloudDatabase.query = async (sql) => { + queryCount += 1; + if (String(sql).includes('jst_qmcust_orderlist')) { + throw new Error('Timeout: Request failed to complete in 60000ms'); + } + return []; + }; + + try { + svc.clearMkhBomCache(); + const index = await svc._private.loadOrderIndex(); + assert.equal(index.degraded, true, '一张表失败要标降级'); + assert.equal(svc._private.PENDING_ORDER_DEGRADED_TTL_MS, 5 * 60 * 1000, '降级缓存必须是 5 分钟'); + assert.equal(index.ttl, 5 * 60 * 1000); + + const state = svc._private.getOrderIndexCacheState(); + const remaining = state.expiresAt - Date.now(); + assert.ok(remaining > 4 * 60 * 1000, `降级态有效期应接近 5 分钟,实际 ${remaining}ms`); + + const before = queryCount; + await svc._private.loadOrderIndex(); + assert.equal(queryCount, before, '降级缓存有效期内不得重复扫表'); + } finally { + cloudDatabase.query = originalQuery; + svc.clearMkhBomCache(); + } +}); + +test('order index: 缓存过期后先返回旧值、后台刷新(用户不再为冷查买单)', async () => { + const cloudDatabase = require('../src/config/cloudDatabase'); + const svc = require('../src/services/mkhBomService'); + const originalQuery = cloudDatabase.query; + let phase = 'cold'; + let orderQueries = 0; + // 模拟「后台刷新卡在 300s 大表扫描上」:永不 resolve,但绝不能拖住请求路径 + const pendingForever = new Promise(() => {}); + + cloudDatabase.query = async (sql) => { + if (!String(sql).includes('o.skus LIKE')) return []; + orderQueries += 1; + if (phase === 'cold') { + return [{ + oId: 1, + orderDate: new Date('2026-11-10T00:00:00Z'), + sendDate: null, + skus: '1.MKHDNZ0409260700059', + }]; + } + return pendingForever; + }; + + try { + svc.clearMkhBomCache(); + const first = await svc._private.loadOrderIndex(); + assert.equal(first.pendingBySku.get('MKHDNZ0409260700059').pendingOrderQty, 1); + + phase = 'stale'; + svc._private.expireOrderIndexCacheForTest(); + const startedAt = Date.now(); + const second = await svc._private.loadOrderIndex(); + const elapsed = Date.now() - startedAt; + + assert.equal(second, first, '过期后必须立刻返回旧快照,而不是等后台刷新'); + assert.ok(elapsed < 1000, `必须立刻返回(旧写法要等 126.9s 冷查),实际 ${elapsed}ms`); + + await new Promise((resolve) => { setTimeout(resolve, 20); }); + const state = svc._private.getOrderIndexCacheState(); + assert.equal(state.pending, true, '必须真的发起了一次后台刷新'); + assert.equal(orderQueries, 4, '前台 2 次(两张表)+ 后台刷新 2 次'); + } finally { + cloudDatabase.query = originalQuery; + svc.clearMkhBomCache(); + } +}); + +test('prewarm: 有效期过半不重查,过期则强制刷新订单索引', async () => { + const cloudDatabase = require('../src/config/cloudDatabase'); + const svc = require('../src/services/mkhBomService'); + const originalQuery = cloudDatabase.query; + let orderQueries = 0; + + cloudDatabase.query = async (sql) => { + if (String(sql).includes('o.skus LIKE')) orderQueries += 1; + return []; + }; + + try { + svc.clearMkhBomCache(); + await svc.prewarmMkhBomIndex(); + const afterCold = orderQueries; + assert.equal(afterCold, 2, '冷启动预热要把两张订单表都查一遍'); + + // 刚刷完,剩余 30 分钟 > 一半 → 不该再查(预热 20 分钟一轮,不会白扫) + const fresh = await svc.prewarmMkhBomIndex(); + assert.ok(fresh.steps.includes('orderIndex=fresh'), `实际步骤: ${fresh.steps.join(', ')}`); + assert.equal(orderQueries, afterCold, '有效期充足时不得重查订单表'); + + // 过期 → 下一轮预热必须强制刷新 + svc._private.expireOrderIndexCacheForTest(); + const refreshed = await svc.prewarmMkhBomIndex(); + assert.ok( + refreshed.steps.some((step) => /^orderIndex=\d+ms$/.test(step)), + `过期后必须强制刷新,实际步骤: ${refreshed.steps.join(', ')}` + ); + assert.equal(orderQueries, afterCold + 2); + } finally { + cloudDatabase.query = originalQuery; + svc.clearMkhBomCache(); + } +}); diff --git a/frontend/src/pages/MkhBomData/index.jsx b/frontend/src/pages/MkhBomData/index.jsx index ab486a9..30ef5ad 100644 --- a/frontend/src/pages/MkhBomData/index.jsx +++ b/frontend/src/pages/MkhBomData/index.jsx @@ -360,24 +360,17 @@ const MkhBomData = () => { const load = useCallback(async ({ background = false } = {}) => { const requestGeneration = listRequestGateRef.current.begin(); - let showProgress = false; - let progressGeneration = null; if (!background) setLoading(true); if (!background) setError(''); try { const now = Date.now(); - const forceFresh = !lastListRefreshAtRef.current - || now - lastListRefreshAtRef.current >= AUTO_REFRESH_MS; - showProgress = forceFresh && !background; - if (showProgress) progressGeneration = beginRefreshProgress('正在更新最新业务数据'); - // 首次打开/F5 和定时轮询才重读云库;筛选、分页只复用刚刷新的内存索引。 - // 后端仍会合并多用户的并发刷新,不会对业务云库造成重复全量查询。 - const result = await getMkhBomList({ - ...query, - live: 1, - ...(forceFresh ? { fresh: 1 } : null), - _refresh: now, - }); + // 🔥 2026-11-17:首屏 / F5 / 每 2 分钟轮询**不再带 fresh=1**。 + // 旧逻辑「首屏 || 距上次 ≥ 2 分钟」就发 fresh=1 → 后端清空运营缓存 → + // 订单两表必然全表扫(冷查实测首屏 126.9s,而命中缓存只要 4~5 秒)。 + // 于是「每次打开、每次刷新、每 2 分钟」都在等两分钟以上。 + // 现在新鲜度由后端后台预热维持(每 20 分钟一轮,见 jobs/mkhBomPrewarmJob), + // 页面走缓存;要强制重读只有一个入口 ——「同步最新数据 / 刷新数据」按钮(handleSync)。 + const result = await getMkhBomList({ ...query, live: 1, _refresh: now }); if (!listRequestGateRef.current.isCurrent(requestGeneration)) return; if (!result || result.success === false) { setError(result?.error || '加载 MKH-BOM 资料失败'); @@ -385,22 +378,21 @@ const MkhBomData = () => { } const snapshot = result?.data || null; try { - requireMkhFreshContract(snapshot, { requireApplied: forceFresh }); + requireMkhFreshContract(snapshot); } catch (contractError) { setData({ rows: [], total: 0, page: 1, pageSize: 50, bomReady: false }); throw contractError; } setData(snapshot); - if (forceFresh) lastListRefreshAtRef.current = Date.now(); + lastListRefreshAtRef.current = Date.now(); setError(''); } catch (requestError) { if (!listRequestGateRef.current.isCurrent(requestGeneration)) return; setError(requestError?.response?.data?.error || requestError?.message || '加载 MKH-BOM 资料失败'); } finally { if (!background && listRequestGateRef.current.isCurrent(requestGeneration)) setLoading(false); - if (showProgress) endRefreshProgress(progressGeneration); } - }, [beginRefreshProgress, endRefreshProgress, query]); + }, [query]); useEffect(() => { load(); }, [load]);