@pisell/pisellos 0.0.568 → 0.0.569

package/lib/server/modules/products/index.js

@@ -5,16 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ProductsModule = void 0;
 var _BaseModule = require("../../../modules/BaseModule");
-var _plugins = require("../../../plugins");
+var _Quotation = require("../../../modules/Quotation");
 var _types = require("./types");
 var _product = require("../../utils/product");
 /**
  * IndexDB 存储名称
  */
 const INDEXDB_STORE_NAME = 'products';
-
 /** 商品同步防抖时间（毫秒） */
 const PRODUCT_SYNC_DEBOUNCE_MS = 10_000;
+/** silentRefresh 最小间隔，避免 preload 后立即全量重拉 */
+const PRODUCT_SILENT_REFRESH_MIN_INTERVAL_MS = 30_000;
 
 /**
  * Products 模块 - 用于获取和管理完整的商品详细数据
@@ -38,13 +39,34 @@ class ProductsModule extends _BaseModule.BaseModule {
   // 商品格式化器列表
   formatters = [];
 
-  // 是否已注册内置价格格式化器
-  isPriceFormatterRegistered = false;
+  // 是否已注册内置商品格式化器
+  isBuiltinFormatterRegistered = false;
+  // 旧报价单格式化器默认关闭，仅显式开启时作为兼容兜底注册
+  isLegacyPriceFormatterEnabled = false;
+
+  // 普通层 QuotationModule 桥接器：本地计算报价单价格，替代 /product/query/price
+  quotationPriceBridge;
+  quotationBridgeChannel;
+  quotationBridgeLoadedKey = '';
+  quotationBridgeRefreshPromise;
+  quotationBridgeRefreshKey;
+  quotationScheduleCache = new Map();
+  quotationScheduleCacheSource = null;
+  quotationScheduleCacheLoaded = false;
 
   // ---- 商品数据同步相关 ----
   productDataSource;
   pendingSyncMessages = [];
   syncTimer;
+  /** 最近一次 SSE 全量拉取完成时间 */
+  lastServerFullFetchAtMs = 0;
+  /** 最近一次 preload 完成时间（含 IndexDB 命中） */
+  lastPreloadCompletedAtMs = 0;
+  /** IndexDB 写入串行队列，避免快照与 patch 并发交错 */
+  productIndexDBSaveQueue = Promise.resolve();
+
+  /** 最近一次智能定价评估提取的 schedule 变价时间点（HH:mm），供 Server 订阅定时刷新使用 */
+  lastScheduleTimePoints = [];
   constructor(name, version) {
     super(name, version);
   }
@@ -74,8 +96,8 @@ class ProductsModule extends _BaseModule.BaseModule {
       }
     }
 
-    // 注册内置的价格格式化器（作为第一个格式化器）
-    this.registerBuiltinPriceFormatter();
+    // 注册内置商品格式化器；智能定价默认替代报价单价格逻辑
+    this.registerBuiltinProductFormatters();
 
     // 初始化 ProductDataSource 实例
     this.initProductDataSource();
@@ -152,33 +174,30 @@ class ProductsModule extends _BaseModule.BaseModule {
    */
   async loadProductsPrice({
     ids = [],
-    customer_id,
-    schedule_date
+    schedule_date,
+    schedule_datetime,
+    customer_id
   }) {
     this.logInfo('开始加载商品价格', {
       productCount: ids.length,
       schedule_date,
+      schedule_datetime,
       customer_id
     });
     const startTime = Date.now();
+    const datetime = schedule_datetime || schedule_date;
     try {
-      const productsData = await this.request.post(`/product/query/price`, {
-        ids,
-        customer_id,
-        schedule_date
-      }, {
-        cache: {
-          mode: _plugins.RequestModeENUM.REMOTE_LOCAL,
-          type: "memory"
-        }
-      });
+      await this.ensureQuotationBridgeReady(customer_id);
+      const idSet = new Set(ids);
+      const products = this.getProductsRef().filter(product => idSet.has(product.id));
+      const priceData = products.map(product => this.buildPriceDataFromQuotation(product, datetime, customer_id));
       const duration = Date.now() - startTime;
       this.logInfo('加载商品价格成功', {
         productCount: ids.length,
-        priceDataCount: productsData.data?.length ?? 0,
+        priceDataCount: priceData.length,
         duration: `${duration}ms`
       });
-      return productsData.data;
+      return priceData;
     } catch (error) {
       const duration = Date.now() - startTime;
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -191,6 +210,179 @@ class ProductsModule extends _BaseModule.BaseModule {
     }
   }
 
+  /**
+   * 设置报价单价格桥接器。
+   * Server 层负责传入完整 schedule 模块，Products 只负责把报价单计算结果转成价格响应形状。
+   */
+  async setupQuotationPriceBridge(params) {
+    if (!this.core) {
+      this.logWarning('setupQuotationPriceBridge: core 尚未初始化');
+      return;
+    }
+    const channel = params.channel || this.otherParams?.channel;
+    this.quotationBridgeChannel = channel;
+    if (!this.quotationPriceBridge) {
+      const quotation = new _Quotation.QuotationModule(`${this.name}_quotation_price_bridge`);
+      await quotation.initialize(this.core, {});
+      this.quotationPriceBridge = quotation;
+    }
+    if (params.scheduleModule) {
+      if (this.quotationScheduleCacheSource !== params.scheduleModule) {
+        this.quotationScheduleCache.clear();
+        this.quotationScheduleCacheLoaded = false;
+        this.quotationScheduleCacheSource = params.scheduleModule;
+      }
+      this.quotationPriceBridge.setScheduleResolver(id => {
+        const scheduleId = String(id);
+        if (this.quotationScheduleCache.has(scheduleId)) {
+          return this.quotationScheduleCache.get(scheduleId);
+        }
+        if (!this.quotationScheduleCacheLoaded) {
+          const scheduleList = params.scheduleModule.getScheduleList?.() || [];
+          for (const schedule of scheduleList) {
+            this.quotationScheduleCache.set(String(schedule.id), schedule);
+          }
+          this.quotationScheduleCacheLoaded = true;
+        }
+        if (this.quotationScheduleCache.has(scheduleId)) {
+          return this.quotationScheduleCache.get(scheduleId);
+        }
+        const schedules = params.scheduleModule.getScheduleListByIds?.([id]) || params.scheduleModule.getScheduleByIds?.([id]) || [];
+        if (schedules[0]) this.quotationScheduleCache.set(scheduleId, schedules[0]);
+        return schedules[0];
+      });
+    }
+    await this.refreshQuotationPriceBridge({
+      customer_id: params.customer_id
+    });
+  }
+
+  /**
+   * 刷新桥接器内的报价单列表。
+   */
+  async refreshQuotationPriceBridge(params) {
+    if (!this.quotationPriceBridge) return;
+    const refreshKey = this.getQuotationBridgeScopeKey();
+    if (this.quotationBridgeRefreshPromise && this.quotationBridgeRefreshKey === refreshKey) {
+      await this.quotationBridgeRefreshPromise;
+      return;
+    }
+    if (this.quotationBridgeRefreshPromise) {
+      await this.quotationBridgeRefreshPromise;
+    }
+    this.quotationBridgeRefreshKey = refreshKey;
+    this.quotationBridgeRefreshPromise = this.quotationPriceBridge.loadQuotations({
+      channel: this.quotationBridgeChannel
+    }).then(() => {
+      this.quotationBridgeLoadedKey = refreshKey;
+    }).finally(() => {
+      this.quotationBridgeRefreshPromise = undefined;
+      this.quotationBridgeRefreshKey = undefined;
+    });
+    await this.quotationBridgeRefreshPromise;
+  }
+  async ensureQuotationBridgeReady(customerId) {
+    if (!this.quotationPriceBridge) {
+      await this.setupQuotationPriceBridge({
+        channel: this.otherParams?.channel,
+        customer_id: customerId
+      });
+      return;
+    }
+    if (this.quotationBridgeRefreshPromise) {
+      await this.quotationBridgeRefreshPromise;
+    }
+    if (this.getQuotationBridgeScopeKey() !== this.quotationBridgeLoadedKey) {
+      await this.refreshQuotationPriceBridge({
+        customer_id: customerId
+      });
+    }
+  }
+  getQuotationBridgeScopeKey() {
+    return this.quotationBridgeChannel || '';
+  }
+  getQuotedPrice(params) {
+    const quotation = this.quotationPriceBridge;
+    if (!quotation) return null;
+    const query = {
+      productId: params.productId,
+      variantId: params.variantId,
+      datetime: params.datetime,
+      customer_id: params.customerId
+    };
+    if (typeof quotation.getQuotationMatchForProduct === 'function') {
+      return quotation.getQuotationMatchForProduct(query)?.price ?? null;
+    }
+    if (typeof quotation.getPriceForProduct === 'function') {
+      return quotation.getPriceForProduct(query);
+    }
+    return null;
+  }
+  buildPriceDataFromQuotation(product, datetime, customerId) {
+    const quotedPrice = this.getQuotedPrice({
+      productId: product.id,
+      datetime,
+      customerId
+    });
+    const productPrice = quotedPrice ?? product.price;
+    const productBasePrice = quotedPrice ?? product.base_price ?? product.price ?? 0;
+    return {
+      id: product.id,
+      price: String(productPrice ?? 0),
+      base_price: String(productBasePrice),
+      variant: this.buildVariantPriceData(product, datetime, customerId),
+      bundle_group: this.buildBundleGroupPriceData(product, datetime, customerId)
+    };
+  }
+  buildVariantPriceData(product, datetime, customerId) {
+    if (!Array.isArray(product.variant)) return [];
+    return product.variant.map(variant => {
+      const quotedPrice = this.getQuotedPrice({
+        productId: product.id,
+        variantId: Number(variant.id),
+        datetime,
+        customerId
+      });
+      const price = quotedPrice ?? variant.price ?? product.price ?? 0;
+      const basePrice = quotedPrice ?? variant.base_price ?? variant.price ?? product.base_price ?? product.price ?? 0;
+      return {
+        id: Number(variant.id),
+        product_id: Number(variant.product_id ?? product.id),
+        base_price: Number(basePrice),
+        price: Number(price)
+      };
+    });
+  }
+  buildBundleGroupPriceData(product, datetime, customerId) {
+    if (!Array.isArray(product.bundle_group)) return [];
+    return product.bundle_group.map(group => ({
+      id: Number(group.id),
+      bundle_item: (group.bundle_item || []).map(item => {
+        const bundleProductId = Number(item.bundle_product_id);
+        const bundleVariantId = Number(item.bundle_variant_id || 0);
+        const quotedPrice = this.getQuotedPrice({
+          productId: bundleProductId,
+          variantId: bundleVariantId,
+          datetime,
+          customerId
+        });
+        const price = quotedPrice ?? item.price ?? 0;
+        const basePrice = quotedPrice ?? item.base_price ?? item.price ?? 0;
+        return {
+          id: Number(item.id),
+          product_id: Number(item.product_id ?? product.id),
+          group_id: Number(item.group_id ?? group.id),
+          bundle_product_id: bundleProductId,
+          bundle_variant_id: bundleVariantId,
+          price: Number(price),
+          base_price: basePrice,
+          price_type: item.price_type,
+          price_type_ext: item.price_type_ext
+        };
+      })
+    }));
+  }
+
   /**
    * 获取应用了价格的商品列表（带缓存）
    * 使用日期作为缓存 key，同一天的商品价格会被缓存
@@ -199,12 +391,15 @@ class ProductsModule extends _BaseModule.BaseModule {
    * @param extraContext 额外的上下文数据（可选，由 Server 层传入）
    * @param options 可选参数
    * @param options.changedIds 变更的商品 IDs，非空时仅对这些商品增量执行 prepare 并更新缓存
+   * @param options.productIds 指定商品 IDs，仅对这些商品执行价格计算；不传则处理全量
    * @returns 应用了价格的商品列表
    */
   async getProductsWithPrice(schedule_date, extraContext, options) {
     const t0 = performance.now();
-    const cacheKey = schedule_date;
-    const changedIds = options?.changedIds;
+    const scopedProductIds = this.normalizeProductIds(options?.productIds);
+    const cacheKey = this.getProductsPriceCacheKey(schedule_date, extraContext, scopedProductIds);
+    const scopedProductIdSet = scopedProductIds ? new Set(scopedProductIds) : undefined;
+    const changedIds = scopedProductIdSet ? options?.changedIds?.filter(id => scopedProductIdSet.has(id)) : options?.changedIds;
     if (this.productsPriceCache.has(cacheKey)) {
       const cachedProducts = this.productsPriceCache.get(cacheKey);
 
@@ -274,9 +469,12 @@ class ProductsModule extends _BaseModule.BaseModule {
       return cachedProducts;
     }
     this.logInfo('商品价格缓存未命中，准备获取', {
-      cacheKey
+      cacheKey,
+      scopedProductCount: scopedProductIds?.length
     });
-    const result = await this.prepareProductsWithPrice(schedule_date, extraContext);
+    const result = await this.prepareProductsWithPrice(schedule_date, extraContext, scopedProductIds ? {
+      productIds: scopedProductIds
+    } : undefined);
     this.productsPriceCache.set(cacheKey, result);
     this.logInfo('商品价格已缓存', {
       cacheKey,
@@ -302,7 +500,7 @@ class ProductsModule extends _BaseModule.BaseModule {
   async prepareProductsWithPrice(schedule_date, extraContext, options) {
     const tTotal = performance.now();
     const targetIds = options?.productIds;
-    const isIncremental = targetIds && targetIds.length > 0;
+    const isIncremental = Array.isArray(targetIds);
     this.logInfo('prepareProductsWithPrice 开始处理', {
       schedule_date,
       mode: isIncremental ? 'incremental' : 'full',
@@ -313,8 +511,7 @@ class ProductsModule extends _BaseModule.BaseModule {
       let products;
       let ids;
       if (isIncremental) {
-        const idSet = new Set(targetIds);
-        products = this.getProductsRef().filter(p => idSet.has(p.id));
+        products = this.getProductsRefByIds(targetIds);
         ids = products.map(p => p.id);
       } else {
         products = this.getProductsRef();
@@ -331,22 +528,33 @@ class ProductsModule extends _BaseModule.BaseModule {
         productCount: products.length
       });
 
-      // 2. 获取价格数据（网络请求）
-      const tPrice = performance.now();
-      const priceData = await this.loadProductsPrice({
-        ids,
-        schedule_date
-      });
-      (0, _product.perfMark)('prepareProducts.loadPrice', performance.now() - tPrice, {
-        count: ids.length
-      });
-      this.logInfo('获取商品报价单价格成功', {
-        priceDataCount: priceData?.length ?? 0
-      });
+      // 2. 仅在 legacy 报价单 formatter 启用时加载报价单价格；默认由智能定价覆盖商品价格。
+      let priceData = [];
+      if (this.isLegacyPriceFormatterEnabled) {
+        const tPrice = performance.now();
+        priceData = await this.loadProductsPrice({
+          ids,
+          schedule_date,
+          schedule_datetime: extraContext?.schedule_datetime,
+          customer_id: extraContext?.customer_id
+        });
+        (0, _product.perfMark)('prepareProducts.loadPrice', performance.now() - tPrice, {
+          count: ids.length
+        });
+        this.logInfo('获取商品报价单价格成功', {
+          priceDataCount: priceData?.length ?? 0
+        });
+      }
       const context = {
         schedule_date,
+        schedule_datetime: extraContext?.schedule_datetime,
+        customer_id: extraContext?.customer_id,
         priceData,
         locale: this.core?.context?.locale,
+        dataVariantEvaluator: extraContext?.dataVariantEvaluator || this.core?.context?.dataVariantEvaluator,
+        menuList: extraContext?.menuList || [],
+        scheduleList: extraContext?.scheduleList || [],
+        strategy_context: extraContext?.strategy_context,
         ...extraContext
       };
 
@@ -381,6 +589,53 @@ class ProductsModule extends _BaseModule.BaseModule {
     }
     return [];
   }
+  getProductsPriceCacheKey(schedule_date, extraContext, productIds) {
+    const datetime = extraContext?.schedule_datetime || schedule_date;
+    const productScope = productIds ? `:products:${productIds.join(',')}` : '';
+    const strategyScope = this.stringifyStable(extraContext?.strategy_context || {});
+    return `${datetime}:customer:${extraContext?.customer_id ?? ''}:strategy:${strategyScope}${productScope}`;
+  }
+
+  /**
+   * 稳定序列化策略上下文，避免对象 key 顺序不同导致缓存 key 抖动。
+   */
+  stringifyStable(value) {
+    if (value == null) return '';
+    if (Array.isArray(value)) return `[${value.map(item => this.stringifyStable(item)).join(',')}]`;
+    if (typeof value === 'object') {
+      return `{${Object.keys(value).sort().map(key => `${key}:${this.stringifyStable(value[key])}`).join(',')}}`;
+    }
+    return String(value);
+  }
+  normalizeProductIds(productIds) {
+    if (!Array.isArray(productIds)) return undefined;
+    return Array.from(new Set(productIds.map(id => Number(id)).filter(id => Number.isFinite(id)))).sort((a, b) => a - b);
+  }
+
+  /**
+   * 按轻量范围返回商品 ID，不做 structuredClone。
+   */
+  getProductIdsByScope(scope) {
+    const productIds = this.normalizeProductIds(scope.productIds) || [];
+    const collectionIds = this.normalizeProductIds(scope.collectionIds) || [];
+    if (scope.isAllProducts) {
+      return this.getProductsRef().map(product => product.id);
+    }
+    if (productIds.length === 0 && collectionIds.length === 0) return [];
+    const result = new Set();
+    for (const id of productIds) {
+      if (this.store.map.has(id)) result.add(id);
+    }
+    if (collectionIds.length === 0) return Array.from(result);
+    const collectionIdSet = new Set(collectionIds);
+    for (const product of this.getProductsRef()) {
+      if (result.has(product.id)) continue;
+      if (!Array.isArray(product.collection)) continue;
+      const isInCollection = product.collection.some(collection => collectionIdSet.has(collection.id));
+      if (isInCollection) result.add(product.id);
+    }
+    return Array.from(result);
+  }
 
   /**
    * 应用所有已注册的格式化器
@@ -430,18 +685,46 @@ class ProductsModule extends _BaseModule.BaseModule {
   }
 
   /**
-   * 注册内置的价格格式化器
-   * 这个格式化器负责将价格数据应用到商品上
+   * 注册内置商品格式化器。
+   *
+   * 智能定价默认替代报价单逻辑；报价单 formatter 仅在 enableLegacyPriceFormatter=true 时启用。
    * @private
    */
-  registerBuiltinPriceFormatter() {
-    if (this.isPriceFormatterRegistered) {
-      console.warn('[ProductsModule] 内置价格格式化器已注册，跳过');
+  registerBuiltinProductFormatters() {
+    if (this.isBuiltinFormatterRegistered) {
+      console.warn('[ProductsModule] 内置商品格式化器已注册，跳过');
       return;
     }
+    this.isLegacyPriceFormatterEnabled = this.shouldEnableLegacyPriceFormatter();
+    const dataVariantFormatter = (products, context) => {
+      const evaluator = context.dataVariantEvaluator || this.core?.context?.dataVariantEvaluator;
+      if (!evaluator || typeof evaluator.resolveProducts !== 'function') {
+        this.lastScheduleTimePoints = [];
+        this.logWarning('智能定价评估器未注入，跳过 DataVariant 格式化', {
+          productCount: products.length
+        });
+        return products;
+      }
+      const strategyContext = context.strategy_context || {};
+      const businessData = {
+        products,
+        scheduleDateTime: context.schedule_datetime || context.schedule_date,
+        scheduleList: context.scheduleList || [],
+        menuList: context.menuList || [],
+        customerId: context.customer_id,
+        channel: strategyContext.channel,
+        orderType: strategyContext.orderType || strategyContext.order_type,
+        businessCode: strategyContext.business_code ?? strategyContext.businessCode,
+        availableWalletIds: strategyContext.available_wallet_ids,
+        custom: strategyContext
+      };
+      const result = evaluator.resolveProducts(businessData);
+      this.lastScheduleTimePoints = Array.isArray(result?.scheduleTimePoints) ? [...result.scheduleTimePoints] : [];
+      return Array.isArray(result?.products) ? result.products : products;
+    };
 
-    // 创建价格格式化器
-    const priceFormatter = (products, context) => {
+    // 创建 legacy 报价单格式化器
+    const legacyPriceFormatter = (products, context) => {
       if (!context.priceData || context.priceData.length === 0) {
         return products;
       }
@@ -453,17 +736,35 @@ class ProductsModule extends _BaseModule.BaseModule {
     const detailValueFormatter = (products, context) => {
       return (0, _product.applyDetailValueToProducts)(products, context);
     };
-
-    // 将价格格式化器注册为第一个格式化器
-    this.formatters.unshift(priceFormatter);
+    if (this.isLegacyPriceFormatterEnabled) {
+      this.formatters.push(legacyPriceFormatter);
+    }
+    this.formatters.push(dataVariantFormatter);
     this.formatters.push(i18nFormatter);
     this.formatters.push(detailValueFormatter);
-    this.isPriceFormatterRegistered = true;
+    this.isBuiltinFormatterRegistered = true;
+  }
+
+  /**
+   * 是否启用旧报价单价格 formatter。
+   *
+   * 默认关闭，避免报价单逻辑覆盖智能定价结果。
+   */
+  shouldEnableLegacyPriceFormatter() {
+    return this.otherParams?.enableLegacyPriceFormatter === true || this.core?.context?.enableLegacyPriceFormatter === true;
+  }
+
+  /**
+   * 返回最近一次 prepareProductsWithPrice / DataVariant 评估提取的变价时间点（HH:mm）。
+   * 供 OS Server 商品 query 订阅定时刷新使用。
+   */
+  getLastScheduleTimePoints() {
+    return [...this.lastScheduleTimePoints];
   }
 
   /**
    * 注册商品格式化器
-   * 格式化器会按注册顺序依次执行（内置价格格式化器始终是第一个）
+   * 格式化器会按注册顺序依次执行；legacy 启用时先兜底报价，再由智能定价覆盖。
    * @param formatter 格式化函数
    * @param prepend 是否插入到队列开头（默认 false，追加到末尾）
    * @example
@@ -478,8 +779,8 @@ class ProductsModule extends _BaseModule.BaseModule {
    */
   registerFormatter(formatter, prepend = false) {
     if (prepend) {
-      // 插入到价格格式化器之后（索引 1 的位置）
-      const insertIndex = this.isPriceFormatterRegistered ? 1 : 0;
+      // 插入到内置智能定价格式化器之后；legacy 报价单启用时需跳过它。
+      const insertIndex = this.isBuiltinFormatterRegistered ? this.isLegacyPriceFormatterEnabled ? 2 : 1 : 0;
       this.formatters.splice(insertIndex, 0, formatter);
     } else {
       // 追加到末尾
@@ -488,16 +789,17 @@ class ProductsModule extends _BaseModule.BaseModule {
   }
 
   /**
-   * 清空所有格式化器（包括内置价格格式化器）
-   * @param keepBuiltin 是否保留内置价格格式化器（默认 true）
+   * 清空所有格式化器（包括内置智能定价格式化器）
+   * @param keepBuiltin 是否保留内置智能定价格式化器（默认 true）
    */
   clearFormatters(keepBuiltin = true) {
-    if (keepBuiltin && this.isPriceFormatterRegistered) {
-      // 只保留第一个格式化器（内置价格格式化器）
-      this.formatters = [this.formatters[0]];
+    if (keepBuiltin && this.isBuiltinFormatterRegistered) {
+      // 保留 legacy 兜底（如果启用）和智能定价格式化器。
+      const builtinCount = this.isLegacyPriceFormatterEnabled ? 2 : 1;
+      this.formatters = this.formatters.slice(0, builtinCount);
     } else {
       this.formatters = [];
-      this.isPriceFormatterRegistered = false;
+      this.isBuiltinFormatterRegistered = false;
     }
   }
 
@@ -545,7 +847,8 @@ class ProductsModule extends _BaseModule.BaseModule {
         productCount: list.length,
         duration: `${Math.round(performance.now() - t0)}ms`
       });
-      await this.saveProductsToIndexDB(list);
+      await this.replaceProductsSnapshotInIndexDB(list, 'loadProductsByServer');
+      this.lastServerFullFetchAtMs = Date.now();
       await this.core.effects.emit(_types.ProductsHooks.onProductsLoaded, list);
       (0, _product.perfMark)('loadProductsByServer', performance.now() - t0, {
         count: list.length
@@ -588,7 +891,7 @@ class ProductsModule extends _BaseModule.BaseModule {
         open_bundle: 1,
         exclude_extension_type: ['product_party', 'product_event', 'product_series_event', 'product_package_ticket', 'ticket', 'event_item'],
         force_ignore_cache_flag: 1,
-        with: ['category', 'collection', 'resourceRelation', 'bundleGroup.bundleItem', 'optionGroup.optionItem', 'variantGroup.variantItem'],
+        with: ['category', 'collection', 'resourceRelation', 'bundleGroup.bundleItem', 'optionGroup.optionItem', 'variantGroup.variantItem', 'dataVariants'],
         open_deposit: 1,
         is_append_product_description: 1,
         with_count: ['bundleGroup', 'optionGroup'],
@@ -631,7 +934,8 @@ class ProductsModule extends _BaseModule.BaseModule {
   async loadProductsByServerHttp(params) {
     const productList = await this.fetchProductsByHttp(params);
     if (productList.length > 0) {
-      await this.saveProductsToIndexDB(productList);
+      await this.replaceProductsSnapshotInIndexDB(productList, 'loadProductsByServerHttp');
+      this.lastServerFullFetchAtMs = Date.now();
       await this.core.effects.emit(_types.ProductsHooks.onProductsLoaded, productList);
     }
     return productList;
@@ -649,6 +953,25 @@ class ProductsModule extends _BaseModule.BaseModule {
     return result;
   }
 
+  /**
+   * 批量获取商品轻量快照，供订单详情等响应补齐展示协议字段。
+   */
+  async getProductSnapshotsByIds(ids) {
+    const snapshots = {};
+    const seen = new Set();
+    for (const id of ids) {
+      if (!Number.isFinite(id) || seen.has(id)) continue;
+      seen.add(id);
+      const product = this.store.map.get(id);
+      if (!product) continue;
+      snapshots[String(id)] = {
+        cover: product.cover,
+        holder_config: product.holder_config
+      };
+    }
+    return snapshots;
+  }
+
   /**
    * 内部获取商品列表的直接引用（无拷贝）
    * 仅供内部 formatter 流程使用，因为 formatter 会创建新对象
@@ -657,6 +980,18 @@ class ProductsModule extends _BaseModule.BaseModule {
     return this.store.list;
   }
 
+  /**
+   * 按 ID 从 Map 取商品引用，供内部 formatter 流程使用。
+   */
+  getProductsRefByIds(ids) {
+    const products = [];
+    for (const id of ids) {
+      const product = this.store.map.get(id);
+      if (product) products.push(product);
+    }
+    return products;
+  }
+
   /**
    * 根据ID获取单个商品（从内存缓存）
    * 使用 Map 快速查询，时间复杂度 O(1)
@@ -784,37 +1119,105 @@ class ProductsModule extends _BaseModule.BaseModule {
   }
 
   /**
-   * 保存商品数据到 IndexDB（平铺存储）
-   * @private
+   * 串行执行商品 IndexDB 写入，避免快照替换与增量 patch 并发交错。
+   *
+   * @example
+   * await this.runInProductIndexDBSaveQueue(async () => {
+   *   await this.dbManager.bulkUpdate(INDEXDB_STORE_NAME, products)
+   * })
    */
-  async saveProductsToIndexDB(products) {
+  async runInProductIndexDBSaveQueue(task) {
+    const queuedTask = this.productIndexDBSaveQueue.then(task, task);
+    this.productIndexDBSaveQueue = queuedTask.then(() => undefined, () => undefined);
+    return queuedTask;
+  }
+
+  /**
+   * 全量快照写入 IndexDB：clear + bulkUpdate，仅用于 SSE/HTTP 全量拉取。
+   *
+   * @example
+   * await this.replaceProductsSnapshotInIndexDB(list, 'loadProductsByServer')
+   */
+  async replaceProductsSnapshotInIndexDB(products, source) {
     if (!this.dbManager) {
-      this.logWarning('saveProductsToIndexDB: dbManager 不可用');
+      this.logWarning('replaceProductsSnapshotInIndexDB: dbManager 不可用');
       return;
     }
-    this.logInfo('开始保存商品数据到 IndexDB', {
-      productCount: products.length
-    });
     try {
-      const t0 = performance.now();
-      await this.dbManager.clear(INDEXDB_STORE_NAME);
-      await this.dbManager.bulkUpdate(INDEXDB_STORE_NAME, products);
-      (0, _product.perfMark)('saveProductsToIndexDB', performance.now() - t0, {
-        count: products.length
-      });
-      this.logInfo('商品数据已保存到 IndexDB', {
-        productCount: products.length
+      await this.runInProductIndexDBSaveQueue(async () => {
+        this.logInfo('replaceProductsSnapshotInIndexDB 开始', {
+          source,
+          productCount: products.length
+        });
+        const t0 = performance.now();
+        await this.dbManager.clear(INDEXDB_STORE_NAME);
+        if (products.length > 0) {
+          await this.dbManager.bulkUpdate(INDEXDB_STORE_NAME, products);
+        }
+        (0, _product.perfMark)('replaceProductsSnapshotInIndexDB', performance.now() - t0, {
+          count: products.length
+        });
+        this.logInfo('replaceProductsSnapshotInIndexDB 完成', {
+          source,
+          productCount: products.length
+        });
       });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error('[Products] 保存数据到 IndexDB 失败:', error);
-      this.logError('保存数据到 IndexDB 失败', {
+      this.logError('全量保存商品到 IndexDB 失败', {
+        source,
         productCount: products.length,
         error: errorMessage
       });
     }
   }
 
+  /**
+   * 增量 upsert 商品到 IndexDB，不清空表；用于 pubsub 批次合并后的变更商品。
+   *
+   * @example
+   * await this.patchProductsInIndexDB(changedProducts, 'pubsub.processProductSyncMessages', mergeActions)
+   */
+  async patchProductsInIndexDB(products, source, mergeActions = {}) {
+    if (!this.dbManager || products.length === 0) {
+      return;
+    }
+    const validProducts = products.filter(p => p?.id !== undefined && p?.id !== null);
+    if (validProducts.length === 0) {
+      return;
+    }
+    try {
+      await this.runInProductIndexDBSaveQueue(async () => {
+        this.logInfo('patchProductsInIndexDB 开始', {
+          source,
+          count: validProducts.length
+        });
+        const t0 = performance.now();
+        if (typeof this.dbManager.bulkUpdate === 'function') {
+          await this.dbManager.bulkUpdate(INDEXDB_STORE_NAME, validProducts);
+        } else if (typeof this.dbManager.update === 'function') {
+          for (const product of validProducts) {
+            await this.dbManager.update(INDEXDB_STORE_NAME, product);
+          }
+        }
+        (0, _product.perfMark)('patchProductsInIndexDB', performance.now() - t0, {
+          count: validProducts.length
+        });
+        this.logInfo('patchProductsInIndexDB 完成', {
+          source,
+          count: validProducts.length
+        });
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logError('增量保存商品到 IndexDB 失败', {
+        source,
+        error: errorMessage,
+        productCount: validProducts.length
+      });
+    }
+  }
+
   /**
    * 同步更新商品 Map 缓存
    * 将 list 中的商品同步到 map，以 id 为 key
@@ -862,6 +1265,7 @@ class ProductsModule extends _BaseModule.BaseModule {
           duration: `${Math.round(performance.now() - tTotal)}ms`,
           source: 'IndexDB'
         });
+        this.lastPreloadCompletedAtMs = Date.now();
         return;
       }
       this.logInfo('IndexDB 中没有缓存数据，准备从服务器加载');
@@ -895,6 +1299,7 @@ class ProductsModule extends _BaseModule.BaseModule {
         duration: `${Math.round(performance.now() - tTotal)}ms`,
         source: 'Server'
       });
+      this.lastPreloadCompletedAtMs = Date.now();
     } else {
       (0, _product.perfMark)('preload(empty)', performance.now() - tTotal, {
         source: 'empty'
@@ -956,9 +1361,10 @@ class ProductsModule extends _BaseModule.BaseModule {
     this.productDataSource.run({
       pubsub: {
         callback: res => {
-          this.logInfo('sse_products_callback: 收到同步消息', {
-            data: res?.data
-          });
+          // console.log('sse_products_callback', res)
+          // this.logInfo('sse_products_callback: 收到同步消息', {
+          //   data: res?.data,
+          // });
           if (!res?.data) return;
           const data = res.data;
           const channelKey = data.module || 'product';
@@ -1049,6 +1455,10 @@ class ProductsModule extends _BaseModule.BaseModule {
         if (msg.relation_product_ids?.length) {
           sseRefreshIds.push(...msg.relation_product_ids);
         }
+      } else if (['product_data_variant'].includes(channelKey)) {
+        if (msg.product_ids?.length) {
+          sseRefreshIds.push(...msg.product_ids);
+        }
       }
     }
     const uniqueDeleteIds = [...new Set(deleteIds)];
@@ -1060,22 +1470,51 @@ class ProductsModule extends _BaseModule.BaseModule {
       await this.removeProductsByIds(uniqueDeleteIds);
     }
 
-    // 2. 处理 body 直接覆盖（store.list 更新，价格缓存不清除）
+    /** 本批次待 patch 的商品（按 id 去重，SSE 覆盖 body） */
+    const patchProductMap = new Map();
+    const patchMergeActions = {};
+    let storeMutated = uniqueDeleteIds.length > 0;
+
+    // 2. 处理 body 直接覆盖（仅内存，IndexDB 批次末统一 patch）
     if (bodyUpdates.size > 0) {
-      await this.applyBodyUpdatesToStore(bodyUpdates);
+      const bodyResult = await this.applyBodyUpdatesToStore(bodyUpdates, {
+        skipIndexDB: true,
+        skipEmit: true
+      });
+      for (const product of bodyResult.changedProducts) {
+        patchProductMap.set(product.id, product);
+        patchMergeActions[product.id] = bodyResult.mergeActions[product.id];
+      }
+      storeMutated = true;
     }
 
-    // 3. 处理 SSE 增量拉取（store.list 更新，价格缓存不清除）
+    // 3. 处理 SSE 增量拉取（仅内存，IndexDB 批次末统一 patch）
+    let freshProducts = [];
     if (uniqueSSEIds.length > 0) {
-      const freshProducts = await this.fetchProductsBySSE(uniqueSSEIds);
+      freshProducts = await this.fetchProductsBySSE(uniqueSSEIds);
       if (freshProducts.length > 0) {
-        await this.mergeProductsToStore(freshProducts);
+        const mergeResult = await this.mergeProductsToStore(freshProducts, {
+          skipIndexDB: true,
+          skipEmit: true
+        });
+        for (const product of mergeResult.changedProducts) {
+          patchProductMap.set(product.id, product);
+          patchMergeActions[product.id] = mergeResult.mergeActions[product.id];
+        }
+        storeMutated = true;
       }
       this.logInfo('processProductSyncMessages: SSE 增量更新完成123', {
         requestedCount: uniqueSSEIds.length,
         receivedCount: freshProducts.length
       });
     }
+    const patchProducts = [...patchProductMap.values()];
+    if (patchProducts.length > 0) {
+      await this.patchProductsInIndexDB(patchProducts, 'pubsub.processProductSyncMessages', patchMergeActions);
+    }
+    if (storeMutated) {
+      this.core.effects.emit(_types.ProductsHooks.onProductsChanged, this.store.list);
+    }
 
     // 收集所有非 delete 的变更 IDs（body + SSE + price），用于增量更新价格缓存
     const allChangedIds = [...new Set([...Array.from(bodyUpdates.keys()), ...uniqueSSEIds, ...uniquePriceIds])];
@@ -1095,6 +1534,14 @@ class ProductsModule extends _BaseModule.BaseModule {
 
     // 报价单变更 → 清除全量价格缓存，后续走全量重建
     if (shouldClearPriceCache) {
+      try {
+        await this.refreshQuotationPriceBridge();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logError('报价单桥接刷新失败，将继续清理价格缓存', {
+          error: errorMessage
+        });
+      }
       this.clearPriceCache();
     }
     await this.core.effects.emit(_types.ProductsHooks.onProductsSyncCompleted, {
@@ -1148,21 +1595,28 @@ class ProductsModule extends _BaseModule.BaseModule {
   /**
    * 将 body 完整数据直接覆盖到本地 store（不调用报价单接口）
    * 已存在的 → 直接替换；不存在的 → 追加
-   * 同时更新 Map 缓存、IndexDB，触发 onProductsChanged
-   * 价格缓存由 processProductSyncMessages 末尾统一清除
+   *
+   * @example
+   * await this.applyBodyUpdatesToStore(bodyUpdates, { skipIndexDB: true })
    */
-  async applyBodyUpdatesToStore(bodyUpdates) {
+  async applyBodyUpdatesToStore(bodyUpdates, options) {
+    const changedProductIds = [...bodyUpdates.keys()];
     this.logInfo('applyBodyUpdatesToStore: 开始', {
       count: bodyUpdates.size
     });
     let updatedCount = 0;
     let newCount = 0;
     const appliedIds = new Set();
+    const mergeActions = {};
+    const changedProducts = [];
     this.store.list = this.store.list.map(p => {
       if (bodyUpdates.has(p.id)) {
         updatedCount++;
         appliedIds.add(p.id);
-        return bodyUpdates.get(p.id);
+        mergeActions[p.id] = 'update';
+        const next = bodyUpdates.get(p.id);
+        changedProducts.push(next);
+        return next;
       }
       return p;
     });
@@ -1170,32 +1624,50 @@ class ProductsModule extends _BaseModule.BaseModule {
       if (!appliedIds.has(id)) {
         this.store.list.push(body);
         newCount++;
+        mergeActions[id] = 'insert';
+        changedProducts.push(body);
       }
     }
     this.syncProductsMap();
-    await this.saveProductsToIndexDB(this.store.list);
-    this.core.effects.emit(_types.ProductsHooks.onProductsChanged, this.store.list);
+    if (!options?.skipIndexDB) {
+      await this.patchProductsInIndexDB(changedProducts, 'pubsub.bodyUpdate', mergeActions);
+    }
+    if (!options?.skipEmit) {
+      this.core.effects.emit(_types.ProductsHooks.onProductsChanged, this.store.list);
+    }
     this.logInfo('applyBodyUpdatesToStore: 完成', {
       updatedCount,
       newCount,
       totalCount: this.store.list.length
     });
+    return {
+      changedProducts,
+      mergeActions,
+      updatedCount,
+      newCount
+    };
   }
 
   /**
    * 将增量拉取的商品合并到 store
    * 已存在的 → 替换；新的 → 追加
-   * 同时更新 store.map、IndexDB，触发 onProductsChanged
+   *
+   * @example
+   * await this.mergeProductsToStore(freshProducts, { skipIndexDB: true })
    */
-  async mergeProductsToStore(freshProducts) {
+  async mergeProductsToStore(freshProducts, options) {
     const freshMap = new Map();
     for (const p of freshProducts) {
       freshMap.set(p.id, p);
     }
+    const mergeActions = {};
+    const changedProducts = [];
     const updatedList = this.store.list.map(p => {
       if (freshMap.has(p.id)) {
         const fresh = freshMap.get(p.id);
         freshMap.delete(p.id);
+        mergeActions[p.id] = 'update';
+        changedProducts.push(fresh);
         return fresh;
       }
       return p;
@@ -1205,17 +1677,30 @@ class ProductsModule extends _BaseModule.BaseModule {
     const newCount = freshMap.size;
     for (const p of freshMap.values()) {
       updatedList.push(p);
+      mergeActions[p.id] = 'insert';
+      changedProducts.push(p);
     }
     const updatedCount = freshProducts.length - newCount;
+    const changedProductIds = freshProducts.map(p => p.id);
     this.store.list = updatedList;
     this.syncProductsMap();
-    await this.saveProductsToIndexDB(this.store.list);
+    if (!options?.skipIndexDB) {
+      await this.patchProductsInIndexDB(changedProducts, 'pubsub.mergeProductsToStore', mergeActions);
+    }
+    if (!options?.skipEmit) {
+      this.core.effects.emit(_types.ProductsHooks.onProductsChanged, this.store.list);
+    }
     this.logInfo('mergeProductsToStore: 合并完成', {
       updatedCount,
       newCount,
       totalCount: this.store.list.length
     });
-    this.core.effects.emit(_types.ProductsHooks.onProductsChanged, this.store.list);
+    return {
+      changedProducts,
+      mergeActions,
+      updatedCount,
+      newCount
+    };
   }
 
   /**
@@ -1225,6 +1710,12 @@ class ProductsModule extends _BaseModule.BaseModule {
    */
   async silentRefresh() {
     const t0 = performance.now();
+    const now = Date.now();
+    const elapsedSincePreload = now - this.lastPreloadCompletedAtMs;
+    const elapsedSinceFullFetch = now - this.lastServerFullFetchAtMs;
+    if (this.lastPreloadCompletedAtMs > 0 && elapsedSincePreload < PRODUCT_SILENT_REFRESH_MIN_INTERVAL_MS || this.lastServerFullFetchAtMs > 0 && elapsedSinceFullFetch < PRODUCT_SILENT_REFRESH_MIN_INTERVAL_MS) {
+      return this.store.list;
+    }
     this.logInfo('silentRefresh 开始');
     try {
       const products = await this.loadProductsByServer();