@pisell/pisellos 2.2.80 → 2.2.82

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

@@ -23,11 +23,11 @@ __export(products_exports, {
 });
 module.exports = __toCommonJS(products_exports);
 var import_BaseModule = require("../../../modules/BaseModule");
+var import_lodash_es = require("lodash-es");
 var import_plugins = require("../../../plugins");
 var import_types = require("./types");
 var import_product = require("../../utils/product");
 var INDEXDB_STORE_NAME = "products";
-var PRODUCT_SYNC_DEBOUNCE_MS = 1e4;
 var ProductsModule = class extends import_BaseModule.BaseModule {
   constructor(name, version) {
     super(name, version);
@@ -44,7 +44,6 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     this.formatters = [];
     // 是否已注册内置价格格式化器
     this.isPriceFormatterRegistered = false;
-    this.pendingSyncMessages = [];
   }
   async initialize(core, options) {
     var _a;
@@ -72,8 +71,6 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
       }
     }
     this.registerBuiltinPriceFormatter();
-    this.initProductDataSource();
-    this.setupProductSync();
     this.logInfo("模块初始化完成", {
       hasDbManager: !!this.dbManager,
       hasLogger: !!this.logger,
@@ -189,32 +186,29 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    * @returns 应用了价格的商品列表
    */
   async getProductsWithPrice(schedule_date, extraContext) {
-    const t0 = performance.now();
     const cacheKey = schedule_date;
     if (this.productsPriceCache.has(cacheKey)) {
+      console.log(`[ProductsModule] 💰 商品价格缓存命中: ${cacheKey}`);
       const cachedProducts = this.productsPriceCache.get(cacheKey);
-      (0, import_product.perfMark)("getProductsWithPrice(cacheHit)", performance.now() - t0, {
-        cacheKey,
-        count: cachedProducts.length
-      });
       this.logInfo("商品价格缓存命中", {
         cacheKey,
         productCount: cachedProducts.length
       });
       return cachedProducts;
     }
+    console.log(`[ProductsModule] 🌐 获取商品并应用价格: ${cacheKey}`);
     this.logInfo("商品价格缓存未命中，准备获取", { cacheKey });
+    const startTime = Date.now();
     const result = await this.prepareProductsWithPrice(schedule_date, extraContext);
+    const duration = Date.now() - startTime;
     this.productsPriceCache.set(cacheKey, result);
+    console.log(`[ProductsModule] ✅ 商品价格已缓存: ${cacheKey}, 共 ${result.length} 个商品`);
     this.logInfo("商品价格已缓存", {
       cacheKey,
-      productCount: result.length
+      productCount: result.length,
+      duration: `${duration}ms`
     });
     this.cleanExpiredPriceCache();
-    (0, import_product.perfMark)("getProductsWithPrice(cacheMiss)", performance.now() - t0, {
-      cacheKey,
-      count: result.length
-    });
     return result;
   }
   /**
@@ -225,35 +219,27 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    * @private
    */
   async prepareProductsWithPrice(schedule_date, extraContext) {
-    const tTotal = performance.now();
     this.logInfo("prepareProductsWithPrice 开始处理", { schedule_date });
     try {
-      const allProducts = this.getProductsRef();
+      const allProducts = await this.getProducts();
       this.logInfo("获取到商品列表", { productCount: allProducts.length });
-      const tIds = performance.now();
-      const ids = new Array(allProducts.length);
-      for (let i = 0; i < allProducts.length; i++) {
-        ids[i] = allProducts[i].id;
-      }
-      (0, import_product.perfMark)("prepareProducts.extractIds", performance.now() - tIds, { count: ids.length });
-      const tPrice = performance.now();
+      console.log(`[ProductsModule] 🌐 开始获取商品报价单价格`);
       const priceData = await this.loadProductsPrice({
-        ids,
+        ids: allProducts.map((product) => product.id).sort((a, b) => a - b),
         schedule_date
       });
-      (0, import_product.perfMark)("prepareProducts.loadPrice", performance.now() - tPrice, { count: ids.length });
+      console.log(`[ProductsModule] 🌐 获取商品报价单价格成功`, priceData);
       this.logInfo("获取商品报价单价格成功", { priceDataCount: (priceData == null ? void 0 : priceData.length) ?? 0 });
       const context = {
         schedule_date,
         priceData,
         ...extraContext
+        // 合并 Server 层传入的额外数据（如 scheduleList）
       };
-      const tFormat = performance.now();
+      console.log(`[ProductsModule] 🌐 通过格式化器流程处理商品（包括价格应用、字段扩展等）`);
+      this.logInfo("开始通过格式化器流程处理商品", { formatterCount: this.formatters.length });
       const processedProducts = await this.applyFormatters(allProducts, context);
-      (0, import_product.perfMark)("prepareProducts.applyFormatters", performance.now() - tFormat, {
-        count: allProducts.length,
-        formatterCount: this.formatters.length
-      });
+      console.log(`[ProductsModule] 🌐 通过格式化器流程处理商品（包括价格应用、字段扩展等）成功`, processedProducts);
       this.logInfo("prepareProductsWithPrice 处理完成", {
         originalProductCount: allProducts.length,
         processedProductCount: processedProducts.length,
@@ -263,10 +249,6 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
         import_types.ProductsHooks.onProductsPriceApplied,
         processedProducts
       );
-      (0, import_product.perfMark)("prepareProductsWithPrice", performance.now() - tTotal, {
-        productCount: allProducts.length,
-        formatterCount: this.formatters.length
-      });
       return processedProducts;
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
@@ -299,13 +281,8 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     for (let i = 0; i < this.formatters.length; i++) {
       const formatter = this.formatters[i];
       try {
-        const tF = performance.now();
+        console.log(`[ProductsModule] 📝 应用格式化器 ${i + 1}/${this.formatters.length}`);
         result = await formatter(result, context);
-        (0, import_product.perfMark)(`applyFormatters[${i}]`, performance.now() - tF, {
-          index: i,
-          total: this.formatters.length,
-          productCount: result.length
-        });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         console.error(`[ProductsModule] ❌ 格式化器 ${i + 1} 执行失败:`, error);
@@ -316,6 +293,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
         });
       }
     }
+    console.log(`[ProductsModule] ✅ 所有格式化器已应用，共 ${this.formatters.length} 个`);
     this.logInfo("所有格式化器已应用", {
       formatterCount: this.formatters.length,
       resultProductCount: result.length
@@ -409,45 +387,10 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     console.log("[ProductsModule] 🗑️ 商品价格缓存已清空");
   }
   /**
-   * 通过 ProductDataSource SSE 加载完整商品列表
-   */
-  async loadProductsByServer() {
-    if (!this.productDataSource) {
-      this.logWarning("loadProductsByServer: ProductDataSource 不可用");
-      return [];
-    }
-    this.logInfo("开始通过 DataSource SSE 加载商品列表");
-    const t0 = performance.now();
-    try {
-      const tSSE = performance.now();
-      const productList = await this.productDataSource.run({ sse: {} });
-      const list = productList || [];
-      (0, import_product.perfMark)("loadProductsByServer.SSE", performance.now() - tSSE, { count: list.length });
-      this.logInfo("通过 DataSource SSE 加载商品列表成功", {
-        productCount: list.length,
-        duration: `${Math.round(performance.now() - t0)}ms`
-      });
-      await this.saveProductsToIndexDB(list);
-      await this.core.effects.emit(import_types.ProductsHooks.onProductsLoaded, list);
-      (0, import_product.perfMark)("loadProductsByServer", performance.now() - t0, { count: list.length });
-      return list;
-    } catch (error) {
-      const duration = Math.round(performance.now() - t0);
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error("[Products] 加载商品数据失败:", error);
-      this.logError("通过 DataSource SSE 加载商品列表失败", {
-        duration: `${duration}ms`,
-        error: errorMessage
-      });
-      return [];
-    }
-  }
-  /**
-   * 纯请求方法：通过 HTTP 接口获取商品列表（无副作用，不触发事件、不写 IndexDB）
+   * 加载完整商品列表通过接口（包含所有详细数据）
    * @param params 查询参数
-   * @returns 商品列表
    */
-  async fetchProductsByHttp(params) {
+  async loadProductsByServer(params) {
     var _a, _b;
     const {
       category_ids = [],
@@ -456,7 +399,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
       customer_id,
       cacheId
     } = params || {};
-    this.logInfo("fetchProductsByHttp: 开始请求", {
+    this.logInfo("开始从服务器加载商品列表", {
       categoryIdsCount: category_ids.length,
       productIdsCount: product_ids.length,
       collectionCount: Array.isArray(collection) ? collection.length : collection ? 1 : 0,
@@ -477,12 +420,16 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
             "event_item"
           ],
           force_ignore_cache_flag: 1,
+          // 获取所有详细信息
           with: [
             "category",
             "collection",
             "resourceRelation",
+            // 套餐
             "bundleGroup.bundleItem",
+            // 单规格
             "optionGroup.optionItem",
+            // 组合规格
             "variantGroup.variantItem"
           ],
           open_deposit: 1,
@@ -502,16 +449,21 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
       );
       const productList = ((_b = productsData == null ? void 0 : productsData.data) == null ? void 0 : _b.list) || [];
       const duration = Date.now() - startTime;
-      this.logInfo("fetchProductsByHttp: 请求成功", {
+      this.logInfo("从服务器加载商品列表成功", {
         productCount: productList.length,
         duration: `${duration}ms`
       });
-      return productList;
+      await this.saveProductsToIndexDB(productList);
+      await this.core.effects.emit(
+        import_types.ProductsHooks.onProductsLoaded,
+        productsData.data.list
+      );
+      return productsData.data.list;
     } catch (error) {
       const duration = Date.now() - startTime;
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error("[Products] fetchProductsByHttp 失败:", error);
-      this.logError("fetchProductsByHttp: 请求失败", {
+      console.error("[Products] 加载商品数据失败:", error);
+      this.logError("从服务器加载商品列表失败", {
         duration: `${duration}ms`,
         error: errorMessage
       });
@@ -519,33 +471,10 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     }
   }
   /**
-   * 加载完整商品列表通过接口（包含所有详细数据）
-   * 包含副作用：保存到 IndexDB + 触发 onProductsLoaded 事件
-   * @param params 查询参数
-   */
-  async loadProductsByServerHttp(params) {
-    const productList = await this.fetchProductsByHttp(params);
-    if (productList.length > 0) {
-      await this.saveProductsToIndexDB(productList);
-      await this.core.effects.emit(import_types.ProductsHooks.onProductsLoaded, productList);
-    }
-    return productList;
-  }
-  /**
-   * 获取商品列表（深拷贝，供外部安全使用）
+   * 获取商品列表（从缓存）
    */
   async getProducts() {
-    const t0 = performance.now();
-    const result = structuredClone(this.store.list);
-    (0, import_product.perfMark)("ProductsModule.getProducts(structuredClone)", performance.now() - t0, { count: result.length });
-    return result;
-  }
-  /**
-   * 内部获取商品列表的直接引用（无拷贝）
-   * 仅供内部 formatter 流程使用，因为 formatter 会创建新对象
-   */
-  getProductsRef() {
-    return this.store.list;
+    return (0, import_lodash_es.cloneDeep)(this.store.list);
   }
   /**
    * 根据ID获取单个商品（从内存缓存）
@@ -553,79 +482,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    */
   async getProductById(id) {
     const product = this.store.map.get(id);
-    return product ? structuredClone(product) : void 0;
-  }
-  /**
-   * 根据 ID 列表删除商品（用于 pubsub 同步删除场景）
-   * 同时更新 store.list、store.map、IndexDB 和价格缓存
-   */
-  async removeProductsByIds(ids) {
-    const idSet = new Set(ids);
-    this.logInfo("removeProductsByIds", { ids, count: ids.length });
-    this.store.list = this.store.list.filter((p) => !idSet.has(p.id));
-    for (const id of ids) {
-      this.store.map.delete(id);
-    }
-    if (this.dbManager) {
-      try {
-        for (const id of ids) {
-          await this.dbManager.delete(INDEXDB_STORE_NAME, id);
-        }
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        this.logError("removeProductsByIds: IndexDB 删除失败", { ids, error: errorMessage });
-      }
-    }
-    for (const [dateKey, cachedProducts] of this.productsPriceCache.entries()) {
-      this.productsPriceCache.set(
-        dateKey,
-        cachedProducts.filter((p) => !idSet.has(p.id))
-      );
-    }
-    this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
-    this.logInfo("removeProductsByIds 完成", { remaining: this.store.list.length });
-  }
-  /**
-   * 重新从服务器加载全量商品列表并更新本地 store
-   * 用于 pubsub 同步 create / update / batch_update 场景
-   */
-  async refreshProducts() {
-    const tTotal = performance.now();
-    this.logInfo("refreshProducts 开始");
-    const products = await this.loadProductsByServer();
-    if (products && products.length > 0) {
-      this.store.list = products;
-      this.syncProductsMap();
-      this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
-      this.logInfo("refreshProducts 完成", { productCount: products.length });
-    } else {
-      this.logWarning("refreshProducts: 服务器未返回数据");
-    }
-    (0, import_product.perfMark)("refreshProducts", performance.now() - tTotal, { count: this.store.list.length });
-    return this.store.list;
-  }
-  /**
-   * 局部更新指定商品的报价单价格
-   * 遍历所有已缓存的日期，为目标商品重新获取价格并覆盖到缓存中
-   */
-  async updateProductPriceByIds(ids) {
-    this.logInfo("updateProductPriceByIds", { ids });
-    for (const [dateKey, cachedProducts] of this.productsPriceCache.entries()) {
-      try {
-        const priceData = await this.loadProductsPrice({
-          ids,
-          schedule_date: dateKey
-        });
-        if (priceData && priceData.length > 0) {
-          const updatedProducts = (0, import_product.applyPriceDataToProducts)(cachedProducts, priceData);
-          this.productsPriceCache.set(dateKey, updatedProducts);
-          this.logInfo("updateProductPriceByIds: 缓存已更新", { dateKey, priceDataCount: priceData.length });
-        }
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        this.logError("updateProductPriceByIds: 失败", { dateKey, ids, error: errorMessage });
-      }
-    }
+    return product ? (0, import_lodash_es.cloneDeep)(product) : void 0;
   }
   /**
    * 清空缓存
@@ -661,9 +518,7 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
       return [];
     }
     try {
-      const t0 = performance.now();
       const products = await this.dbManager.getAll(INDEXDB_STORE_NAME);
-      (0, import_product.perfMark)("loadProductsFromIndexDB", performance.now() - t0, { count: (products == null ? void 0 : products.length) ?? 0 });
       this.logInfo("从 IndexDB 加载商品数据", {
         productCount: (products == null ? void 0 : products.length) ?? 0
       });
@@ -686,10 +541,11 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
     }
     this.logInfo("开始保存商品数据到 IndexDB", { productCount: products.length });
     try {
-      const t0 = performance.now();
       await this.dbManager.clear(INDEXDB_STORE_NAME);
-      await this.dbManager.bulkAdd(INDEXDB_STORE_NAME, products);
-      (0, import_product.perfMark)("saveProductsToIndexDB", performance.now() - t0, { count: products.length });
+      const savePromises = products.map(
+        (product) => this.dbManager.add(INDEXDB_STORE_NAME, product)
+      );
+      await Promise.all(savePromises);
       console.log(
         `[Products] 已将 ${products.length} 个商品平铺保存到 IndexDB`
       );
@@ -709,12 +565,11 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    * @private
    */
   syncProductsMap() {
-    const t0 = performance.now();
     this.store.map.clear();
     for (const product of this.store.list) {
       this.store.map.set(product.id, product);
     }
-    (0, import_product.perfMark)("syncProductsMap", performance.now() - t0, { count: this.store.map.size });
+    console.log(`[Products] Map 缓存已同步，共 ${this.store.map.size} 个商品`);
   }
   /**
    * 预加载模块数据（统一接口）
@@ -722,29 +577,22 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
    */
   async preload() {
     console.log("[Products] 开始预加载数据...");
-    const tTotal = performance.now();
+    const startTime = Date.now();
     this.logInfo("开始预加载数据");
     try {
-      const tIndexDB = performance.now();
       const cachedData = await this.loadProductsFromIndexDB();
-      (0, import_product.perfMark)("preload.loadFromIndexDB", performance.now() - tIndexDB, { count: (cachedData == null ? void 0 : cachedData.length) ?? 0 });
       if (cachedData && cachedData.length > 0) {
         console.log(`[Products] 从 IndexDB 加载了 ${cachedData.length} 个商品`);
-        this.store.list = cachedData;
-        const tSync = performance.now();
+        this.store.list = (0, import_lodash_es.cloneDeep)(cachedData);
         this.syncProductsMap();
-        (0, import_product.perfMark)("preload.syncProductsMap", performance.now() - tSync, { count: cachedData.length });
         this.core.effects.emit(
           import_types.ProductsHooks.onProductsChanged,
           this.store.list
         );
-        (0, import_product.perfMark)("preload(IndexDB)", performance.now() - tTotal, {
-          count: cachedData.length,
-          source: "IndexDB"
-        });
+        const duration = Date.now() - startTime;
         this.logInfo("预加载完成（从 IndexDB）", {
           productCount: cachedData.length,
-          duration: `${Math.round(performance.now() - tTotal)}ms`,
+          duration: `${duration}ms`,
           source: "IndexDB"
         });
         return;
@@ -756,416 +604,24 @@ var ProductsModule = class extends import_BaseModule.BaseModule {
       console.warn("[Products] 从 IndexDB 加载数据失败:", error);
       this.logWarning("从 IndexDB 加载数据失败，准备从服务器加载", { error: errorMessage });
     }
-    const tServer = performance.now();
     const products = await this.loadProductsByServer();
-    (0, import_product.perfMark)("preload.loadFromServer", performance.now() - tServer, { count: (products == null ? void 0 : products.length) ?? 0 });
     if (products && products.length > 0) {
-      this.store.list = products;
-      const tSync = performance.now();
+      await this.saveProductsToIndexDB(products);
+      this.store.list = (0, import_lodash_es.cloneDeep)(products);
       this.syncProductsMap();
-      (0, import_product.perfMark)("preload.syncProductsMap", performance.now() - tSync, { count: products.length });
       this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
-      (0, import_product.perfMark)("preload(Server)", performance.now() - tTotal, {
-        count: products.length,
-        source: "Server"
-      });
+      const duration = Date.now() - startTime;
       this.logInfo("预加载完成（从服务器）", {
         productCount: products.length,
-        duration: `${Math.round(performance.now() - tTotal)}ms`,
+        duration: `${duration}ms`,
         source: "Server"
       });
     } else {
-      (0, import_product.perfMark)("preload(empty)", performance.now() - tTotal, { source: "empty" });
+      const duration = Date.now() - startTime;
       this.logWarning("预加载完成但未获取到数据", {
-        duration: `${Math.round(performance.now() - tTotal)}ms`
-      });
-    }
-  }
-  // =============================================
-  // 商品数据同步（pubsub）
-  // =============================================
-  /**
-   * 初始化 ProductDataSource 实例
-   * 与 pubsub 订阅和数据获取分开，仅负责创建实例
-   */
-  initProductDataSource() {
-    var _a, _b;
-    const ProductDataSourceClass = (_b = (_a = this.core.serverOptions) == null ? void 0 : _a.All_DATA_SOURCES) == null ? void 0 : _b.ProductDataSource;
-    if (!ProductDataSourceClass) {
-      this.logWarning("initProductDataSource: ProductDataSource 不可用");
-      return;
-    }
-    this.productDataSource = new ProductDataSourceClass();
-    this.logInfo("ProductDataSource 实例已创建");
-  }
-  /**
-   * 初始化 pubsub 订阅，监听管理后台商品变更
-   * 仅负责订阅 product / product_quotation 频道，消息通过防抖合并后批量处理
-   * 数据获取由 loadProductsByServer 单独负责
-   */
-  setupProductSync() {
-    if (!this.productDataSource) {
-      this.logWarning("setupProductSync: ProductDataSource 不可用，跳过同步初始化");
-      return;
-    }
-    const createHandler = (channelKey) => (message) => {
-      const data = (message == null ? void 0 : message.data) || message;
-      if (!data)
-        return;
-      console.log(`[ProductsModule] 收到同步消息 [${channelKey}]:`, data);
-      this.logInfo("收到同步消息", {
-        channelKey,
-        action: data.action,
-        id: data.id,
-        action_filed: data.action_filed
-      });
-      this.pendingSyncMessages.push({ ...data, _channelKey: channelKey });
-      if (this.syncTimer) {
-        clearTimeout(this.syncTimer);
-      }
-      this.syncTimer = setTimeout(() => {
-        this.processProductSyncMessages();
-      }, PRODUCT_SYNC_DEBOUNCE_MS);
-    };
-    this.productDataSource.run({
-      pubsub: {
-        callback: (res) => {
-          console.log("sse_products_callback", res);
-          this.logInfo("sse_products_callback: 收到同步消息", {
-            data: res == null ? void 0 : res.data
-          });
-          if (!(res == null ? void 0 : res.data))
-            return;
-          const data = res.data;
-          const channelKey = data.module || "product";
-          createHandler(channelKey)(data);
-        }
-      }
-    }).catch((err) => {
-      this.logError("setupProductSync: DataSource run 出错", {
-        error: err instanceof Error ? err.message : String(err)
-      });
-    });
-    this.logInfo("setupProductSync: pubsub 订阅已建立");
-  }
-  /**
-   * 处理防抖后的同步消息批次
-   *
-   * product 模块：
-   *   - operation === 'delete' → 本地删除
-   *   - 有 body（无 price change_types） → body 完整数据直接覆盖本地
-   *   - change_types 包含 price → SSE 增量拉取 + 刷新报价单价格缓存
-   *   - change_types 仅 stock → 跳过（暂不响应）
-   *
-   * product_collection / product_category / product_quotation：
-   *   - 按 relation_product_ids SSE 拉取受影响商品
-   *   - product_quotation 额外刷新报价单价格缓存
-   *
-   * 处理完成后 emit onProductsSyncCompleted 通知 Server 层
-   */
-  async processProductSyncMessages() {
-    var _a, _b, _c, _d, _e;
-    const messages = [...this.pendingSyncMessages];
-    this.pendingSyncMessages = [];
-    if (messages.length === 0)
-      return;
-    this.logInfo("processProductSyncMessages: 开始处理", { count: messages.length });
-    const deleteIds = [];
-    const bodyUpdates = /* @__PURE__ */ new Map();
-    const sseRefreshIds = [];
-    const priceRefreshIds = [];
-    for (const msg of messages) {
-      const channelKey = msg._channelKey || msg.module || "product";
-      if (channelKey === "product") {
-        if (msg.operation === "delete" || msg.action === "delete") {
-          if ((_a = msg.ids) == null ? void 0 : _a.length)
-            deleteIds.push(...msg.ids);
-          else if (msg.id)
-            deleteIds.push(msg.id);
-          continue;
-        }
-        if (((_b = msg.change_types) == null ? void 0 : _b.length) && msg.change_types.every((t) => t === "stock")) {
-          this.logInfo("跳过仅库存变更", { ids: msg.ids });
-          continue;
-        }
-        if ((_c = msg.change_types) == null ? void 0 : _c.includes("price")) {
-          const ids = msg.ids || (msg.id ? [msg.id] : []);
-          sseRefreshIds.push(...ids);
-          priceRefreshIds.push(...ids);
-          continue;
-        }
-        if (msg.body) {
-          const bodyId = msg.body.id || msg.id;
-          if (bodyId)
-            bodyUpdates.set(bodyId, msg.body);
-          continue;
-        }
-        if ((_d = msg.ids) == null ? void 0 : _d.length) {
-          sseRefreshIds.push(...msg.ids);
-        } else if (msg.id) {
-          sseRefreshIds.push(msg.id);
-        }
-      } else if (["product_collection", "product_category", "product_quotation"].includes(channelKey)) {
-        if ((_e = msg.relation_product_ids) == null ? void 0 : _e.length) {
-          sseRefreshIds.push(...msg.relation_product_ids);
-          if (channelKey === "product_quotation") {
-            this.clearPriceCache();
-            priceRefreshIds.push(...msg.relation_product_ids);
-          }
-        }
-      }
-    }
-    const uniqueDeleteIds = [...new Set(deleteIds)];
-    const uniqueSSEIds = [...new Set(sseRefreshIds)];
-    const uniquePriceIds = [...new Set(priceRefreshIds)];
-    if (uniqueDeleteIds.length > 0) {
-      await this.removeProductsByIds(uniqueDeleteIds);
-    }
-    if (bodyUpdates.size > 0) {
-      await this.applyBodyUpdatesToStore(bodyUpdates);
-    }
-    if (uniqueSSEIds.length > 0) {
-      const freshProducts = await this.fetchProductsBySSE(uniqueSSEIds);
-      if (freshProducts.length > 0) {
-        await this.mergeProductsToStore(freshProducts);
-        await this.updatePriceCacheForProducts(freshProducts);
-      }
-      this.logInfo("processProductSyncMessages: SSE 增量更新完成", {
-        requestedCount: uniqueSSEIds.length,
-        receivedCount: freshProducts.length
-      });
-    }
-    const sseHandledSet = new Set(uniqueSSEIds);
-    const remainingPriceIds = uniquePriceIds.filter((id) => !sseHandledSet.has(id));
-    if (remainingPriceIds.length > 0) {
-      await this.updateProductPriceByIds(remainingPriceIds);
-    }
-    this.logInfo("processProductSyncMessages: 处理完成", {
-      deleteCount: uniqueDeleteIds.length,
-      bodyUpdateCount: bodyUpdates.size,
-      sseRefreshCount: uniqueSSEIds.length,
-      priceRefreshCount: uniquePriceIds.length
-    });
-    await this.core.effects.emit(import_types.ProductsHooks.onProductsSyncCompleted, null);
-  }
-  /**
-   * 通过 SSE 按 ids 增量拉取商品数据
-   * 请求 GET /shop/core/stream?type=product&ids={ids}
-   */
-  async fetchProductsBySSE(ids) {
-    if (!this.productDataSource) {
-      this.logWarning("fetchProductsBySSE: ProductDataSource 不可用");
-      return [];
-    }
-    this.logInfo("fetchProductsBySSE: 开始", { ids, count: ids.length });
-    const t0 = performance.now();
-    try {
-      const productList = await this.productDataSource.run({
-        sse: { query: { type: "product", ids } }
-      });
-      const list = productList || [];
-      (0, import_product.perfMark)("fetchProductsBySSE", performance.now() - t0, { count: list.length });
-      this.logInfo("fetchProductsBySSE: 成功", {
-        requestedCount: ids.length,
-        receivedCount: list.length,
-        duration: `${Math.round(performance.now() - t0)}ms`
-      });
-      return list;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logError("fetchProductsBySSE: 失败", { ids, error: errorMessage });
-      return [];
-    }
-  }
-  /**
-   * 将 body 完整数据直接覆盖到本地 store（不调用报价单接口）
-   * 已存在的 → 直接替换；不存在的 → 追加
-   * 同时更新 Map 缓存、IndexDB，清空价格缓存，触发 onProductsChanged
-   */
-  async applyBodyUpdatesToStore(bodyUpdates) {
-    this.logInfo("applyBodyUpdatesToStore: 开始", { count: bodyUpdates.size });
-    let updatedCount = 0;
-    let newCount = 0;
-    const appliedIds = /* @__PURE__ */ new Set();
-    this.store.list = this.store.list.map((p) => {
-      if (bodyUpdates.has(p.id)) {
-        updatedCount++;
-        appliedIds.add(p.id);
-        return bodyUpdates.get(p.id);
-      }
-      return p;
-    });
-    for (const [id, body] of bodyUpdates) {
-      if (!appliedIds.has(id)) {
-        this.store.list.push(body);
-        newCount++;
-      }
-    }
-    this.syncProductsMap();
-    await this.saveProductsToIndexDB(this.store.list);
-    await this.updatePriceCacheForProducts([...bodyUpdates.values()]);
-    this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
-    this.logInfo("applyBodyUpdatesToStore: 完成", {
-      updatedCount,
-      newCount,
-      totalCount: this.store.list.length
-    });
-  }
-  /**
-   * 将增量拉取的商品合并到 store
-   * 已存在的 → 替换；新的 → 追加
-   * 同时更新 store.map、IndexDB，触发 onProductsChanged
-   */
-  async mergeProductsToStore(freshProducts) {
-    const freshMap = /* @__PURE__ */ new Map();
-    for (const p of freshProducts) {
-      freshMap.set(p.id, p);
-    }
-    const updatedList = this.store.list.map((p) => {
-      if (freshMap.has(p.id)) {
-        const fresh = freshMap.get(p.id);
-        freshMap.delete(p.id);
-        return fresh;
-      }
-      return p;
-    });
-    const newCount = freshMap.size;
-    for (const p of freshMap.values()) {
-      updatedList.push(p);
-    }
-    const updatedCount = freshProducts.length - newCount;
-    this.store.list = updatedList;
-    this.syncProductsMap();
-    await this.saveProductsToIndexDB(this.store.list);
-    this.logInfo("mergeProductsToStore: 合并完成", {
-      updatedCount,
-      newCount,
-      totalCount: this.store.list.length
-    });
-    this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
-  }
-  /**
-   * 增量更新价格缓存中变更的商品
-   * 对每个已缓存的日期 key：替换/追加最新商品数据，重新拉取这些 ID 的价格并应用
-   */
-  async updatePriceCacheForProducts(freshProducts) {
-    if (this.productsPriceCache.size === 0)
-      return;
-    const freshIds = freshProducts.map((p) => p.id);
-    const freshMap = /* @__PURE__ */ new Map();
-    for (const p of freshProducts) {
-      freshMap.set(p.id, p);
-    }
-    this.logInfo("updatePriceCacheForProducts: 开始", {
-      freshIds,
-      cachedDateCount: this.productsPriceCache.size
-    });
-    for (const [dateKey, cachedProducts] of this.productsPriceCache.entries()) {
-      try {
-        const updatedList = cachedProducts.map((p) => {
-          const fresh = freshMap.get(p.id);
-          return fresh ? { ...fresh } : p;
-        });
-        const existingIds = new Set(cachedProducts.map((p) => p.id));
-        for (const p of freshProducts) {
-          if (!existingIds.has(p.id)) {
-            updatedList.push({ ...p });
-          }
-        }
-        const priceData = await this.loadProductsPrice({
-          ids: freshIds,
-          schedule_date: dateKey
-        });
-        const result = priceData && priceData.length > 0 ? (0, import_product.applyPriceDataToProducts)(updatedList, priceData) : updatedList;
-        this.productsPriceCache.set(dateKey, result);
-        this.logInfo("updatePriceCacheForProducts: 日期缓存已更新", {
-          dateKey,
-          updatedIds: freshIds
-        });
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        this.logError("updatePriceCacheForProducts: 失败", { dateKey, error: errorMessage });
-      }
-    }
-  }
-  /**
-   * 全量重新拉取报价单价格并重建价格缓存
-   * 遍历当前已缓存的所有日期 key，对每个日期重新调用 loadProductsPrice
-   */
-  async refreshAllPriceCache() {
-    const allProducts = this.getProductsRef();
-    if (allProducts.length === 0)
-      return;
-    const ids = allProducts.map((p) => p.id);
-    const dateKeys = Array.from(this.productsPriceCache.keys());
-    this.clearPriceCache();
-    if (dateKeys.length === 0) {
-      this.logInfo("refreshAllPriceCache: 无已缓存日期，跳过");
-      return;
-    }
-    this.logInfo("refreshAllPriceCache: 开始重新拉取", { dateKeys, productCount: ids.length });
-    for (const dateKey of dateKeys) {
-      try {
-        const priceData = await this.loadProductsPrice({ ids, schedule_date: dateKey });
-        if (priceData && priceData.length > 0) {
-          const updatedProducts = (0, import_product.applyPriceDataToProducts)(allProducts, priceData);
-          this.productsPriceCache.set(dateKey, updatedProducts);
-        }
-        this.logInfo("refreshAllPriceCache: 日期缓存已更新", { dateKey });
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        this.logError("refreshAllPriceCache: 失败", { dateKey, error: errorMessage });
-      }
-    }
-  }
-  /**
-   * 静默全量刷新：后台重新拉取全量 SSE 数据并更新本地
-   * 拿到完整数据后一次性替换 store，清除价格缓存，触发 onProductsSyncCompleted
-   * @returns 刷新后的商品列表
-   */
-  async silentRefresh() {
-    const t0 = performance.now();
-    this.logInfo("silentRefresh 开始");
-    try {
-      const products = await this.loadProductsByServer();
-      if (products && products.length > 0) {
-        this.store.list = products;
-        this.syncProductsMap();
-        this.clearPriceCache();
-        this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
-        await this.core.effects.emit(import_types.ProductsHooks.onProductsSyncCompleted, null);
-        this.logInfo("silentRefresh 完成", {
-          productCount: products.length,
-          duration: `${Math.round(performance.now() - t0)}ms`
-        });
-      } else {
-        this.logWarning("silentRefresh: 服务器未返回数据");
-      }
-      (0, import_product.perfMark)("silentRefresh", performance.now() - t0, { count: this.store.list.length });
-      return this.store.list;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logError("silentRefresh 失败", {
-        duration: `${Math.round(performance.now() - t0)}ms`,
-        error: errorMessage
+        duration: `${duration}ms`
       });
-      return this.store.list;
-    }
-  }
-  /**
-   * 销毁同步资源（取消 pubsub 订阅、清除定时器）
-   */
-  destroyProductSync() {
-    var _a;
-    if (this.syncTimer) {
-      clearTimeout(this.syncTimer);
-      this.syncTimer = void 0;
-    }
-    if ((_a = this.productDataSource) == null ? void 0 : _a.destroy) {
-      this.productDataSource.destroy();
     }
-    this.pendingSyncMessages = [];
-    this.logInfo("destroyProductSync: 同步资源已销毁");
   }
   /**
    * 获取模块的路由定义