@pisell/pisellos 2.3.73 → 2.3.75

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

@@ -1,129 +1,130 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";
 
-// src/server/modules/menu/index.ts
-var menu_exports = {};
-__export(menu_exports, {
-  MenuModule: () => MenuModule
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(menu_exports);
-var import_lodash_es = require("lodash-es");
-var import_BaseModule = require("../../../modules/BaseModule");
-var import_types = require("./types");
-var INDEXDB_STORE_NAME = "menu";
-var MenuModule = class extends import_BaseModule.BaseModule {
-  // LoggerManager 实例
+exports.MenuModule = void 0;
+var _lodashEs = require("lodash-es");
+var _BaseModule = require("../../../modules/BaseModule");
+var _types = require("./types");
+/**
+ * IndexDB 存储名称
+ */
+const INDEXDB_STORE_NAME = 'menu';
+
+/**
+ * 餐牌模块 - 用于管理餐牌数据和根据餐牌过滤商品
+ */
+class MenuModule extends _BaseModule.BaseModule {
+  defaultName = 'menu';
+  defaultVersion = '1.0.0';
+  request;
+  store;
+  dbManager; // IndexDBManager 实例
+  logger; // LoggerManager 实例
+
   constructor(name, version) {
     super(name, version);
-    this.defaultName = "menu";
-    this.defaultVersion = "1.0.0";
   }
   async initialize(core, options) {
-    var _a;
     this.core = core;
-    this.store = options == null ? void 0 : options.store;
-    this.request = core.getPlugin("request");
+    this.store = options?.store;
+
+    // 获取依赖的插件
+    this.request = core.getPlugin('request');
     if (!this.request) {
-      throw new Error("MenuModule 需要 request 插件支持");
+      throw new Error('MenuModule 需要 request 插件支持');
     }
-    if (Array.isArray((_a = options == null ? void 0 : options.initialState) == null ? void 0 : _a.menuList)) {
-      this.store.menuList = options == null ? void 0 : options.initialState.menuList;
+    if (Array.isArray(options?.initialState?.menuList)) {
+      this.store.menuList = options?.initialState.menuList;
+      // 同步更新 Map 缓存
       this.syncMenuMap();
-      this.core.effects.emit(import_types.MenuHooks.onMenuChanged, this.store.menuList);
+      this.core.effects.emit(_types.MenuHooks.onMenuChanged, this.store.menuList);
     } else {
       this.store.menuList = [];
-      this.store.map = /* @__PURE__ */ new Map();
+      this.store.map = new Map();
     }
-    const appPlugin = core.getPlugin("app");
+
+    // 获取并存储 dbManager
+    const appPlugin = core.getPlugin('app');
     if (appPlugin) {
       const app = appPlugin.getApp();
       this.dbManager = app.dbManager;
       this.logger = app.logger;
-      if (this.dbManager) {
-        console.log("[Menu] IndexDB Manager 已初始化");
-      } else {
-        console.warn("[Menu] IndexDB Manager 未找到");
+      if (this.dbManager) {} else {
+        console.warn('[Menu] IndexDB Manager 未找到');
       }
     }
-    this.logInfo("模块初始化完成", {
+    this.logInfo('模块初始化完成', {
       hasDbManager: !!this.dbManager,
       hasLogger: !!this.logger,
       initialMenuCount: this.store.menuList.length
     });
   }
+
   /**
    * 加载餐牌列表（从服务器）
    */
   async loadMenuList() {
-    var _a;
-    this.logInfo("开始从服务器加载餐牌列表");
+    this.logInfo('开始从服务器加载餐牌列表');
     const startTime = Date.now();
     try {
-      const response = await this.request.get(
-        `/form/data/v1`,
-        {
-          skip: 1,
-          num: 999,
-          code: "menu_list"
-        },
-        { cache: void 0 }
-      );
-      const menuList = ((_a = response == null ? void 0 : response.data) == null ? void 0 : _a.list) || [];
+      const response = await this.request.get(`/form/data/v1`, {
+        skip: 1,
+        num: 999,
+        code: 'menu_list'
+      }, {
+        cache: undefined
+      });
+      const menuList = response?.data?.list || [];
       const duration = Date.now() - startTime;
-      this.logInfo("从服务器加载餐牌列表成功", {
+      this.logInfo('从服务器加载餐牌列表成功', {
         menuCount: menuList.length,
         duration: `${duration}ms`
       });
+
+      // 保存到 IndexDB
       await this.saveMenuToIndexDB(menuList);
       await this.setMenuList(menuList);
       return menuList;
     } catch (error) {
       const duration = Date.now() - startTime;
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error("[Menu] 加载餐牌数据失败:", error);
-      this.logError("从服务器加载餐牌列表失败", {
+      console.error('[Menu] 加载餐牌数据失败:', error);
+      this.logError('从服务器加载餐牌列表失败', {
         duration: `${duration}ms`,
         error: errorMessage
       });
       return [];
     }
   }
+
   /**
    * 设置餐牌列表
    */
   async setMenuList(menuList) {
     this.store.menuList = menuList;
+    // 同步更新 Map 缓存
     this.syncMenuMap();
-    await this.core.effects.emit(import_types.MenuHooks.onMenuLoaded, menuList);
+    await this.core.effects.emit(_types.MenuHooks.onMenuLoaded, menuList);
   }
+
   /**
    * 获取餐牌列表
    */
   getMenuList() {
     return this.store.menuList;
   }
+
   /**
    * 根据 form_record_id 数组获取餐牌详情
    * 使用 Map 快速查询，时间复杂度 O(m)，m 为 ids 数量
    */
   getMenuByIds(ids) {
     if (!ids || ids.length === 0) {
-      this.logInfo("getMenuByIds: 未提供有效的 ids", { idsCount: 0 });
+      this.logInfo('getMenuByIds: 未提供有效的 ids', {
+        idsCount: 0
+      });
       return [];
     }
     const result = [];
@@ -133,13 +134,14 @@ var MenuModule = class extends import_BaseModule.BaseModule {
         result.push(menu);
       }
     }
-    this.logInfo("getMenuByIds: 查询完成", {
+    this.logInfo('getMenuByIds: 查询完成', {
       requestedCount: ids.length,
       foundCount: result.length,
       notFoundCount: ids.length - result.length
     });
     return result;
   }
+
   /**
    * 同步更新餐牌 Map 缓存
    * 将 menuList 中的餐牌同步到 map，以 form_record_id 为 key
@@ -150,151 +152,193 @@ var MenuModule = class extends import_BaseModule.BaseModule {
     for (const menu of this.store.menuList) {
       this.store.map.set(menu.form_record_id, menu);
     }
-    console.log(`[Menu] Map 缓存已同步，共 ${this.store.map.size} 个餐牌`);
   }
+
   /**
    * 清空缓存
    */
   async clear() {
-    this.logInfo("开始清空缓存", {
+    this.logInfo('开始清空缓存', {
       currentMenuCount: this.store.menuList.length
     });
     this.store.menuList = [];
     this.store.map.clear();
-    this.store.currentMenu = void 0;
+    this.store.currentMenu = undefined;
+
+    // 同时清空 IndexDB 中的数据
     if (this.dbManager) {
       try {
         await this.dbManager.clear(INDEXDB_STORE_NAME);
-        console.log("[Menu] IndexDB 缓存已清空");
-        this.logInfo("IndexDB 缓存已清空");
+        this.logInfo('IndexDB 缓存已清空');
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error("[Menu] 清空 IndexDB 缓存失败:", error);
-        this.logError("清空 IndexDB 缓存失败", { error: errorMessage });
+        console.error('[Menu] 清空 IndexDB 缓存失败:', error);
+        this.logError('清空 IndexDB 缓存失败', {
+          error: errorMessage
+        });
       }
     }
-    console.log("[Menu] 缓存已清空");
-    this.logInfo("缓存清空完成");
+    this.logInfo('缓存清空完成');
   }
+
   /**
    * 从 IndexDB 加载餐牌数据
    * @private
    */
   async loadMenuFromIndexDB() {
     if (!this.dbManager) {
-      this.logWarning("loadMenuFromIndexDB: dbManager 不可用");
+      this.logWarning('loadMenuFromIndexDB: dbManager 不可用');
       return [];
     }
+    const startedAt = performance.now();
     try {
+      // 直接获取所有餐牌记录
       const menuList = await this.dbManager.getAll(INDEXDB_STORE_NAME);
-      this.logInfo("从 IndexDB 加载餐牌数据", {
-        menuCount: (menuList == null ? void 0 : menuList.length) ?? 0
+      this.logInfo('从 IndexDB 加载餐牌数据', {
+        menuCount: menuList?.length ?? 0,
+        durationMs: +(performance.now() - startedAt).toFixed(2)
       });
       return menuList || [];
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error("[Menu] 从 IndexDB 读取数据失败:", error);
-      this.logError("从 IndexDB 读取数据失败", { error: errorMessage });
+      console.error('[Menu] 从 IndexDB 读取数据失败:', error);
+      this.logError('从 IndexDB 读取数据失败', {
+        durationMs: +(performance.now() - startedAt).toFixed(2),
+        error: errorMessage
+      });
       return [];
     }
   }
+
   /**
    * 保存餐牌数据到 IndexDB
    * @private
    */
   async saveMenuToIndexDB(menuList) {
     if (!this.dbManager) {
-      this.logWarning("saveMenuToIndexDB: dbManager 不可用");
+      this.logWarning('saveMenuToIndexDB: dbManager 不可用');
       return;
     }
-    this.logInfo("开始保存餐牌数据到 IndexDB", { menuCount: menuList.length });
+    const startedAt = performance.now();
+    let clearDurationMs = 0;
+    let writeDurationMs = 0;
+    this.logInfo('开始保存餐牌数据到 IndexDB', {
+      menuCount: menuList.length
+    });
     try {
-      await this.dbManager.clear(INDEXDB_STORE_NAME);
-      const savePromises = menuList.map(
-        (menu) => this.dbManager.add(INDEXDB_STORE_NAME, menu)
-      );
-      await Promise.all(savePromises);
-      console.log(`[Menu] 已将 ${menuList.length} 条餐牌数据保存到 IndexDB`);
-      this.logInfo("餐牌数据已保存到 IndexDB", { menuCount: menuList.length });
+      // 先清空现有的餐牌数据
+      const clearStartedAt = performance.now();
+      try {
+        await this.dbManager.clear(INDEXDB_STORE_NAME);
+      } finally {
+        clearDurationMs = +(performance.now() - clearStartedAt).toFixed(2);
+      }
+
+      // 逐个保存餐牌（每个餐牌是独立的记录）
+      const writeStartedAt = performance.now();
+      const savePromises = menuList.map(menu => this.dbManager.add(INDEXDB_STORE_NAME, menu));
+      try {
+        await Promise.all(savePromises);
+      } finally {
+        writeDurationMs = +(performance.now() - writeStartedAt).toFixed(2);
+      }
+      this.logInfo('餐牌数据已保存到 IndexDB', {
+        menuCount: menuList.length,
+        clearDurationMs,
+        writeDurationMs,
+        totalDurationMs: +(performance.now() - startedAt).toFixed(2)
+      });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error("[Menu] 保存数据到 IndexDB 失败:", error);
-      this.logError("保存数据到 IndexDB 失败", {
+      console.error('[Menu] 保存数据到 IndexDB 失败:', error);
+      this.logError('保存数据到 IndexDB 失败', {
         menuCount: menuList.length,
+        clearDurationMs,
+        writeDurationMs,
+        totalDurationMs: +(performance.now() - startedAt).toFixed(2),
         error: errorMessage
       });
     }
   }
+
   /**
    * 预加载模块数据（统一接口）
    * 在模块注册后自动调用
    */
   async preload() {
-    console.log("[Menu] 开始预加载数据...");
     const startTime = Date.now();
-    this.logInfo("开始预加载数据");
+    this.logInfo('开始预加载数据');
     try {
+      // 1. 尝试从 IndexDB 加载数据
       const cachedData = await this.loadMenuFromIndexDB();
       if (cachedData && cachedData.length > 0) {
-        console.log(`[Menu] 从 IndexDB 加载了 ${cachedData.length} 条餐牌数据`);
-        this.store.menuList = (0, import_lodash_es.cloneDeep)(cachedData);
+        // 将缓存数据放入 store
+        this.store.menuList = (0, _lodashEs.cloneDeep)(cachedData);
+        // 同步更新 Map 缓存
         this.syncMenuMap();
-        this.core.effects.emit(import_types.MenuHooks.onMenuChanged, this.store.menuList);
+        this.core.effects.emit(_types.MenuHooks.onMenuChanged, this.store.menuList);
         const duration = Date.now() - startTime;
-        this.logInfo("预加载完成（从 IndexDB）", {
+        this.logInfo('预加载完成（从 IndexDB）', {
           menuCount: cachedData.length,
           duration: `${duration}ms`,
-          source: "IndexDB"
+          source: 'IndexDB'
         });
         return;
       }
-      console.log("[Menu] IndexDB 中没有缓存数据，从服务器加载...");
-      this.logInfo("IndexDB 中没有缓存数据，准备从服务器加载");
+      this.logInfo('IndexDB 中没有缓存数据，准备从服务器加载');
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.warn("[Menu] 从 IndexDB 加载数据失败:", error);
-      this.logWarning("从 IndexDB 加载数据失败，准备从服务器加载", { error: errorMessage });
+      console.warn('[Menu] 从 IndexDB 加载数据失败:', error);
+      this.logWarning('从 IndexDB 加载数据失败，准备从服务器加载', {
+        error: errorMessage
+      });
     }
+
+    // 2. 如果 IndexDB 中没有数据，从服务器加载
     const menuList = await this.loadMenuList();
+
+    // 3. 将服务器数据保存到 IndexDB 和 store
     if (menuList && menuList.length > 0) {
       await this.saveMenuToIndexDB(menuList);
-      this.store.menuList = (0, import_lodash_es.cloneDeep)(menuList);
+      this.store.menuList = (0, _lodashEs.cloneDeep)(menuList);
+      // 同步更新 Map 缓存
       this.syncMenuMap();
-      this.core.effects.emit(import_types.MenuHooks.onMenuChanged, this.store.menuList);
+      this.core.effects.emit(_types.MenuHooks.onMenuChanged, this.store.menuList);
       const duration = Date.now() - startTime;
-      this.logInfo("预加载完成（从服务器）", {
+      this.logInfo('预加载完成（从服务器）', {
         menuCount: menuList.length,
         duration: `${duration}ms`,
-        source: "Server"
+        source: 'Server'
       });
     } else {
       const duration = Date.now() - startTime;
-      this.logWarning("预加载完成但未获取到数据", {
+      this.logWarning('预加载完成但未获取到数据', {
         duration: `${duration}ms`
       });
     }
   }
+
   /**
    * 获取模块的路由定义
    * 返回该模块需要注册的 API 路由
    */
   getRoutes() {
     return [
-      // GET /api/menu - 获取所有餐牌
-      {
-        method: "get",
-        path: "/api/menu",
-        handler: async () => {
-          const menuList = this.getMenuList();
-          return {
-            success: true,
-            data: menuList,
-            total: menuList.length
-          };
-        }
+    // GET /api/menu - 获取所有餐牌
+    {
+      method: 'get',
+      path: '/api/menu',
+      handler: async () => {
+        const menuList = this.getMenuList();
+        return {
+          success: true,
+          data: menuList,
+          total: menuList.length
+        };
       }
-    ];
+    }];
   }
+
   /**
    * 记录信息日志
    * @param title 日志标题
@@ -304,14 +348,16 @@ var MenuModule = class extends import_BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: "info",
+          type: 'info',
           title: `[MenuModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
+      // 日志记录失败不影响主流程
     }
   }
+
   /**
    * 记录警告日志
    * @param title 日志标题
@@ -321,14 +367,16 @@ var MenuModule = class extends import_BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: "warning",
+          type: 'warning',
           title: `[MenuModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
+      // 日志记录失败不影响主流程
     }
   }
+
   /**
    * 记录错误日志
    * @param title 日志标题
@@ -338,16 +386,14 @@ var MenuModule = class extends import_BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: "error",
+          type: 'error',
           title: `[MenuModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
+      // 日志记录失败不影响主流程
     }
   }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  MenuModule
-});
+}
+exports.MenuModule = MenuModule;

package/lib/server/modules/menu/types.js

@@ -1,33 +1,20 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";
 
-// src/server/modules/menu/types.ts
-var types_exports = {};
-__export(types_exports, {
-  MenuHooks: () => MenuHooks
-});
-module.exports = __toCommonJS(types_exports);
-var MenuHooks = /* @__PURE__ */ ((MenuHooks2) => {
-  MenuHooks2["onMenuLoaded"] = "menu:onMenuLoaded";
-  MenuHooks2["onMenuChanged"] = "menu:onMenuChanged";
-  return MenuHooks2;
-})(MenuHooks || {});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  MenuHooks
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
+exports.MenuHooks = void 0;
+/**
+ * 餐牌模块状态
+ */
+/**
+ * 餐牌数据结构
+ */
+/**
+ * 餐牌模块钩子
+ */
+let MenuHooks = exports.MenuHooks = /*#__PURE__*/function (MenuHooks) {
+  MenuHooks["onMenuLoaded"] = "menu:onMenuLoaded";
+  MenuHooks["onMenuChanged"] = "menu:onMenuChanged";
+  return MenuHooks;
+}({});

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

@@ -119,14 +119,23 @@ export declare class OrderModule extends BaseModule implements Module {
         payment: Record<string, any>;
         previousPayment: Record<string, any>;
     } | null>;
-    loadOrdersByServer(): Promise<OrderData[]>;
+    loadOrdersByServer(options?: {
+        trigger?: string;
+    }): Promise<OrderData[]>;
     /**
      * 静默全量刷新：后台重新拉取全量 SSE 订单数据并更新本地
      * 拿到完整数据后一次性替换 store，触发订单变更与同步完成事件
      * @returns 刷新后的订单列表
      */
-    silentRefresh(): Promise<OrderData[]>;
+    silentRefresh(options?: {
+        trigger?: string;
+    }): Promise<OrderData[]>;
     private normalizeOrderForMemoryList;
+    /**
+     * 将已经完成集合规范化的订单转换为内存身份，不重复扫描 products/bookings/payments。
+     */
+    private prepareNormalizedOrderForMemoryList;
+    private prepareNormalizedOrdersForMemoryList;
     private normalizeOrdersForMemoryList;
     private hasRealOrderId;
     private shouldKeepOrderInMemory;
@@ -291,13 +300,14 @@ export declare class OrderModule extends BaseModule implements Module {
     private logDuplicateOrders;
     private compactOrderListByIdentity;
     /**
-     * 当前订单拉取窗口：
-     * - 优先使用 createdAtQuery.sales_time_between（已按营业日边界初始化）
-     * - 无法解析时退化为自然日窗口
+     * 当前订单缓存可复用窗口。
+     * start_time 模式使用精确的营业日起止时间；配置缺失或异常时退化为自然日。
      */
-    private getCurrentPullWindow;
+    private getCurrentOrderCacheWindow;
     private hasPulledOrdersToday;
     private markOrderPulledAtNow;
+    private clearOrderSnapshotMarker;
+    private getCurrentShopId;
     private getStorageItem;
     private setStorageItem;
     private loadOrdersFromSQLite;
@@ -335,7 +345,7 @@ export declare class OrderModule extends BaseModule implements Module {
      * 用于 SSE 全量拉取与营业日窗口裁剪。
      *
      * @example
-     * await this.replaceOrdersSnapshotInSQLite(orderList)
+     * const { orders, persisted } = await this.replaceOrdersSnapshotInSQLite(orderList, 'refresh')
      */
     private replaceOrdersSnapshotInSQLite;
     /**