@pisell/pisellos 2.2.78 → 2.2.80

package/lib/server/index.js

@@ -28,6 +28,8 @@ var import_menu = require("./modules/menu");
 var import_quotation = require("./modules/quotation");
 var import_schedule = require("./modules/schedule");
 var import_schedule2 = require("./utils/schedule");
+var import_types = require("./modules/products/types");
+var import_product = require("./utils/product");
 __reExport(server_exports, require("./modules"), module.exports);
 var Server = class {
   constructor(core) {
@@ -38,6 +40,8 @@ var Server = class {
       put: {},
       remove: {}
     };
+    // ---- 商品查询订阅者 ----
+    this.productQuerySubscribers = /* @__PURE__ */ new Map();
     // 模块注册表 - 定义所有可用的模块配置
     this.moduleRegistry = {
       products: {
@@ -81,109 +85,37 @@ var Server = class {
       }
     };
     /**
-     * 处理商品查询请求（编排 Products、Menu、Schedule 模块）
-     * 这是一个业务编排方法，协调多个模块完成复杂的业务需求
+     * 处理商品查询请求
+     * 存储订阅者信息，便于数据变更时推送最新结果
      */
     this.handleProductQuery = async ({ url, method, data, config }) => {
       console.log("[Server] handleProductQuery:", url, method, data, config);
       const { menu_list_ids, schedule_datetime, schedule_date } = data;
-      this.logInfo("handleProductQuery 开始处理", {
-        menuListIdsCount: (menu_list_ids == null ? void 0 : menu_list_ids.length) ?? 0,
+      const { callback, subscriberId } = config || {};
+      this.logInfo("handleProductQuery: 开始处理商品查询请求", {
+        menu_list_ids,
         schedule_datetime,
-        schedule_date,
-        menu_list_ids
+        schedule_date
       });
-      if (!this.products) {
-        console.error("[Server] Products 模块未注册");
-        this.logError("handleProductQuery: Products 模块未注册");
-        return {
-          message: "Products 模块未注册",
-          data: { list: [], count: 0 }
-        };
-      }
-      if (!this.menu) {
-        console.error("[Server] Menu 模块未注册");
-        this.logError("handleProductQuery: Menu 模块未注册");
-        return {
-          message: "Menu 模块未注册",
-          data: { list: [], count: 0 }
-        };
-      }
-      if (!this.schedule) {
-        console.error("[Server] Schedule 模块未注册");
-        this.logError("handleProductQuery: Schedule 模块未注册");
-        return {
-          message: "Schedule 模块未注册",
-          data: { list: [], count: 0 }
-        };
-      }
-      let activeMenuList = [];
-      if (menu_list_ids && Array.isArray(menu_list_ids) && menu_list_ids.length > 0) {
-        console.log("[Server] 获取餐牌详情，IDs:", menu_list_ids);
-        this.logInfo("handleProductQuery: 获取餐牌详情", { menuListIdsCount: menu_list_ids.length, menu_list_ids });
-        const menuList = this.menu.getMenuByIds(menu_list_ids);
-        this.logInfo("handleProductQuery: 获取到餐牌列表", {
-          requestedCount: menu_list_ids.length,
-          foundCount: menuList.length,
-          menu_list_ids,
-          menuList
+      if (subscriberId && typeof callback === "function") {
+        this.productQuerySubscribers.set(subscriberId, {
+          callback,
+          context: { menu_list_ids, schedule_date, schedule_datetime }
         });
-        activeMenuList = menuList.filter((menu) => {
-          var _a;
-          const isInSchedule = ((_a = this.schedule) == null ? void 0 : _a.getDateIsInSchedule(schedule_datetime, menu.schedule)) || false;
-          return isInSchedule;
+        this.logInfo("handleProductQuery: 已注册订阅者", {
+          subscriberId,
+          totalSubscribers: this.productQuerySubscribers.size
         });
-        this.logInfo("handleProductQuery: 过滤生效餐牌", {
-          totalMenuCount: menuList.length,
-          activeMenuCount: activeMenuList.length,
-          schedule_datetime,
-          menuList,
-          activeMenuList
-        });
-      } else {
-        this.logWarning("handleProductQuery: 未提供有效的 menu_list_ids", { menuListIdsCount: (menu_list_ids == null ? void 0 : menu_list_ids.length) ?? 0, menu_list_ids });
       }
-      console.log(activeMenuList, "activeMenuList");
-      this.logInfo("handleProductQuery: 开始获取商品列表", { schedule_date });
-      const allProductsWithPrice = await this.products.getProductsWithPrice(data.schedule_date, {
-        scheduleModule: this.getSchedule()
-      });
-      this.logInfo("handleProductQuery: 获取到商品列表", {
-        productCount: allProductsWithPrice.length,
-        schedule_date
-      });
-      console.log(allProductsWithPrice, "allProductsWithPrice");
-      this.logInfo("handleProductQuery: 开始按餐牌配置过滤商品", {
-        totalProducts: allProductsWithPrice.length,
-        activeMenuCount: activeMenuList.length
-      });
-      let filteredProducts = this.filterProductsByMenuConfig(allProductsWithPrice, activeMenuList);
-      filteredProducts = filteredProducts.sort((a, b) => {
-        const sortDiff = Number(b.sort) - Number(a.sort);
-        if (sortDiff !== 0) {
-          return sortDiff;
-        }
-        return (a.title || "").localeCompare(b.title || "");
-      });
-      console.log("[Server] 原始商品数量:", allProductsWithPrice.length);
-      console.log("[Server] 过滤后商品数量:", filteredProducts.length);
-      console.log(filteredProducts, "filteredProducts");
-      this.logInfo("handleProductQuery 处理完成", {
-        originalProductCount: allProductsWithPrice.length,
-        filteredProductCount: filteredProducts.length,
-        activeMenuCount: activeMenuList.length,
-        schedule_date,
-        schedule_datetime
-      });
-      return {
-        code: 200,
-        data: {
-          list: filteredProducts,
-          count: filteredProducts.length
-        },
-        message: "",
-        status: true
-      };
+      return this.computeProductQueryResult({ menu_list_ids, schedule_date, schedule_datetime });
+    };
+    /**
+     * 取消商品查询订阅（HTTP 路由入口）
+     */
+    this.handleUnsubscribeProductQuery = async ({ data }) => {
+      const { subscriberId } = data || {};
+      this.removeProductQuerySubscriber(subscriberId);
+      return { code: 200, message: "ok", status: true };
     };
     /**
      * 处理获取日程时间段点的请求
@@ -286,7 +218,7 @@ var Server = class {
     const appPlugin = core.getPlugin("app");
     this.app = (appPlugin == null ? void 0 : appPlugin.getApp()) || null;
     this.logger = ((_a = this.app) == null ? void 0 : _a.logger) || null;
-    console.log("[Server] Server 初始化");
+    console.log("[Server] Server 初始化", this.core);
     this.logInfo("Server 初始化", {
       hasApp: !!this.app,
       hasLogger: !!this.logger
@@ -483,6 +415,9 @@ var Server = class {
     } else {
       this.logInfo("跳过自动预加载", { autoPreload });
     }
+    this.core.effects.on(import_types.ProductsHooks.onProductsSyncCompleted, () => {
+      this.recomputeAndNotifyProductQuery();
+    });
     const duration = Date.now() - startTime;
     this.logInfo("Server 初始化完成", {
       duration: `${duration}ms`,
@@ -529,6 +464,32 @@ var Server = class {
       modules.push("schedule");
     return modules;
   }
+  /**
+   * 后台静默刷新商品数据
+   * 重新拉取全量 SSE 接口，更新本地数据后触发 onProductsSyncCompleted
+   * 不影响当前界面展示，适用于切回前台、定时刷新等场景
+   */
+  async refreshProductsInBackground() {
+    if (!this.products) {
+      this.logWarning("refreshProductsInBackground: Products 模块未注册");
+      return;
+    }
+    this.logInfo("refreshProductsInBackground 开始");
+    const startTime = Date.now();
+    try {
+      await this.products.silentRefresh();
+      const duration = Date.now() - startTime;
+      this.logInfo("refreshProductsInBackground 完成", { duration: `${duration}ms` });
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("[Server] refreshProductsInBackground 失败:", error);
+      this.logError("refreshProductsInBackground 失败", {
+        duration: `${duration}ms`,
+        error: errorMessage
+      });
+    }
+  }
   /**
    * 清空所有server模块的IndexedDB缓存
    * @returns Promise<void>
@@ -666,6 +627,11 @@ var Server = class {
         path: "/shop/product/query",
         handler: this.handleProductQuery.bind(this)
       },
+      {
+        method: "post",
+        path: "/shop/product/query/unsubscribe",
+        handler: this.handleUnsubscribeProductQuery.bind(this)
+      },
       {
         method: "post",
         path: "/shop/menu/schedule-time-points",
@@ -673,6 +639,117 @@ var Server = class {
       }
     ]);
   }
+  /**
+   * 根据 subscriberId 移除商品查询订阅者
+   */
+  removeProductQuerySubscriber(subscriberId) {
+    if (subscriberId) {
+      this.productQuerySubscribers.delete(subscriberId);
+      this.logInfo("removeProductQuerySubscriber: 已移除订阅者", {
+        subscriberId,
+        remaining: this.productQuerySubscribers.size
+      });
+    }
+  }
+  /**
+   * 商品查询的核心计算逻辑（编排 Products、Menu、Schedule 模块）
+   * 供 handleProductQuery 首次返回及 pubsub 变更推送复用
+   */
+  async computeProductQueryResult(context) {
+    const tTotal = performance.now();
+    const { menu_list_ids, schedule_date, schedule_datetime } = context;
+    this.logInfo("computeProductQueryResult 开始", {
+      menuListIdsCount: (menu_list_ids == null ? void 0 : menu_list_ids.length) ?? 0,
+      schedule_datetime,
+      schedule_date
+    });
+    if (!this.products) {
+      this.logError("computeProductQueryResult: Products 模块未注册");
+      return { message: "Products 模块未注册", data: { list: [], count: 0 } };
+    }
+    if (!this.menu) {
+      this.logError("computeProductQueryResult: Menu 模块未注册");
+      return { message: "Menu 模块未注册", data: { list: [], count: 0 } };
+    }
+    if (!this.schedule) {
+      this.logError("computeProductQueryResult: Schedule 模块未注册");
+      return { message: "Schedule 模块未注册", data: { list: [], count: 0 } };
+    }
+    let activeMenuList = [];
+    if (menu_list_ids && Array.isArray(menu_list_ids) && menu_list_ids.length > 0) {
+      const tMenu = performance.now();
+      const menuList = this.menu.getMenuByIds(menu_list_ids);
+      activeMenuList = menuList.filter((menu) => {
+        var _a;
+        return ((_a = this.schedule) == null ? void 0 : _a.getDateIsInSchedule(schedule_datetime, menu.schedule)) || false;
+      });
+      (0, import_product.perfMark)("computeQuery.filterActiveMenu", performance.now() - tMenu, {
+        totalMenu: menuList.length,
+        activeMenu: activeMenuList.length
+      });
+    }
+    const tPrice = performance.now();
+    const allProductsWithPrice = await this.products.getProductsWithPrice(schedule_date, {
+      scheduleModule: this.getSchedule()
+    });
+    (0, import_product.perfMark)("computeQuery.getProductsWithPrice", performance.now() - tPrice, {
+      count: allProductsWithPrice.length
+    });
+    const tFilter = performance.now();
+    let filteredProducts = this.filterProductsByMenuConfig(allProductsWithPrice, activeMenuList);
+    (0, import_product.perfMark)("computeQuery.filterByMenu", performance.now() - tFilter, {
+      before: allProductsWithPrice.length,
+      after: filteredProducts.length
+    });
+    const tSort = performance.now();
+    filteredProducts = filteredProducts.sort((a, b) => {
+      const sortDiff = Number(b.sort) - Number(a.sort);
+      if (sortDiff !== 0)
+        return sortDiff;
+      return (a.title || "").localeCompare(b.title || "");
+    });
+    (0, import_product.perfMark)("computeQuery.sort", performance.now() - tSort, { count: filteredProducts.length });
+    (0, import_product.perfMark)("computeProductQueryResult", performance.now() - tTotal, {
+      originalCount: allProductsWithPrice.length,
+      filteredCount: filteredProducts.length,
+      activeMenuCount: activeMenuList.length
+    });
+    this.logInfo("computeProductQueryResult 完成", {
+      originalCount: allProductsWithPrice.length,
+      filteredCount: filteredProducts.length,
+      activeMenuCount: activeMenuList.length
+    });
+    return {
+      code: 200,
+      data: { list: filteredProducts, count: filteredProducts.length },
+      message: "",
+      status: true
+    };
+  }
+  /**
+   * 数据变更后，遍历所有订阅者重新计算查询结果并通过 callback 推送
+   * 由 ProductsModule 的 onProductsSyncCompleted 事件触发
+   */
+  async recomputeAndNotifyProductQuery() {
+    if (this.productQuerySubscribers.size === 0)
+      return;
+    this.logInfo("recomputeAndNotifyProductQuery: 开始推送", {
+      subscriberCount: this.productQuerySubscribers.size
+    });
+    for (const [subscriberId, subscriber] of this.productQuerySubscribers.entries()) {
+      try {
+        const result = await this.computeProductQueryResult(subscriber.context);
+        subscriber.callback(result);
+        this.logInfo("recomputeAndNotifyProductQuery: 已推送", { subscriberId });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logError("recomputeAndNotifyProductQuery: 推送失败", {
+          subscriberId,
+          error: errorMessage
+        });
+      }
+    }
+  }
   /**
    * 根据餐牌配置过滤商品
    * @param products 所有商品列表

package/lib/server/modules/products/index.d.ts

@@ -19,6 +19,9 @@ export declare class ProductsModule extends BaseModule implements Module {
     private readonly CACHE_MAX_DAYS;
     private formatters;
     private isPriceFormatterRegistered;
+    private productDataSource;
+    private pendingSyncMessages;
+    private syncTimer?;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: any): Promise<void>;
     /**
@@ -107,26 +110,57 @@ export declare class ProductsModule extends BaseModule implements Module {
      * 可用于手动刷新价格数据
      */
     clearPriceCache(): void;
+    /**
+     * 通过 ProductDataSource SSE 加载完整商品列表
+     */
+    loadProductsByServer(): Promise<any>;
+    /**
+     * 纯请求方法：通过 HTTP 接口获取商品列表（无副作用，不触发事件、不写 IndexDB）
+     * @param params 查询参数
+     * @returns 商品列表
+     */
+    private fetchProductsByHttp;
     /**
      * 加载完整商品列表通过接口（包含所有详细数据）
+     * 包含副作用：保存到 IndexDB + 触发 onProductsLoaded 事件
      * @param params 查询参数
      */
-    loadProductsByServer(params?: {
+    loadProductsByServerHttp(params?: {
         category_ids?: number[];
         product_ids?: number[];
         collection?: number | string[];
         customer_id?: number;
         cacheId?: string;
-    }): Promise<any>;
+    }): Promise<ProductData[]>;
     /**
-     * 获取商品列表（从缓存）
+     * 获取商品列表（深拷贝，供外部安全使用）
      */
     getProducts(): Promise<ProductData[]>;
+    /**
+     * 内部获取商品列表的直接引用（无拷贝）
+     * 仅供内部 formatter 流程使用，因为 formatter 会创建新对象
+     */
+    private getProductsRef;
     /**
      * 根据ID获取单个商品（从内存缓存）
      * 使用 Map 快速查询，时间复杂度 O(1)
      */
     getProductById(id: number): Promise<ProductData | undefined>;
+    /**
+     * 根据 ID 列表删除商品（用于 pubsub 同步删除场景）
+     * 同时更新 store.list、store.map、IndexDB 和价格缓存
+     */
+    removeProductsByIds(ids: number[]): Promise<void>;
+    /**
+     * 重新从服务器加载全量商品列表并更新本地 store
+     * 用于 pubsub 同步 create / update / batch_update 场景
+     */
+    refreshProducts(): Promise<ProductData[]>;
+    /**
+     * 局部更新指定商品的报价单价格
+     * 遍历所有已缓存的日期，为目标商品重新获取价格并覆盖到缓存中
+     */
+    updateProductPriceByIds(ids: number[]): Promise<void>;
     /**
      * 清空缓存
      */
@@ -152,6 +186,70 @@ export declare class ProductsModule extends BaseModule implements Module {
      * 在模块注册后自动调用
      */
     preload(): Promise<void>;
+    /**
+     * 初始化 ProductDataSource 实例
+     * 与 pubsub 订阅和数据获取分开，仅负责创建实例
+     */
+    private initProductDataSource;
+    /**
+     * 初始化 pubsub 订阅，监听管理后台商品变更
+     * 仅负责订阅 product / product_quotation 频道，消息通过防抖合并后批量处理
+     * 数据获取由 loadProductsByServer 单独负责
+     */
+    private setupProductSync;
+    /**
+     * 处理防抖后的同步消息批次
+     *
+     * 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 层
+     */
+    private processProductSyncMessages;
+    /**
+     * 通过 SSE 按 ids 增量拉取商品数据
+     * 请求 GET /shop/core/stream?type=product&ids={ids}
+     */
+    private fetchProductsBySSE;
+    /**
+     * 将 body 完整数据直接覆盖到本地 store（不调用报价单接口）
+     * 已存在的 → 直接替换；不存在的 → 追加
+     * 同时更新 Map 缓存、IndexDB，清空价格缓存，触发 onProductsChanged
+     */
+    private applyBodyUpdatesToStore;
+    /**
+     * 将增量拉取的商品合并到 store
+     * 已存在的 → 替换；新的 → 追加
+     * 同时更新 store.map、IndexDB，触发 onProductsChanged
+     */
+    private mergeProductsToStore;
+    /**
+     * 增量更新价格缓存中变更的商品
+     * 对每个已缓存的日期 key：替换/追加最新商品数据，重新拉取这些 ID 的价格并应用
+     */
+    private updatePriceCacheForProducts;
+    /**
+     * 全量重新拉取报价单价格并重建价格缓存
+     * 遍历当前已缓存的所有日期 key，对每个日期重新调用 loadProductsPrice
+     */
+    private refreshAllPriceCache;
+    /**
+     * 静默全量刷新：后台重新拉取全量 SSE 数据并更新本地
+     * 拿到完整数据后一次性替换 store，清除价格缓存，触发 onProductsSyncCompleted
+     * @returns 刷新后的商品列表
+     */
+    silentRefresh(): Promise<ProductData[]>;
+    /**
+     * 销毁同步资源（取消 pubsub 订阅、清除定时器）
+     */
+    destroyProductSync(): void;
     /**
      * 获取模块的路由定义
      * Products 模块暂不提供路由，由 Server 层统一处理