@pisell/pisellos 0.0.479 → 0.0.481

package/lib/server/index.js

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/server/index.ts
@@ -23,11 +33,19 @@ __export(server_exports, {
   default: () => server_default
 });
 module.exports = __toCommonJS(server_exports);
+var import_dayjs = __toESM(require("dayjs"));
 var import_products = require("./modules/products");
 var import_menu = require("./modules/menu");
 var import_quotation = require("./modules/quotation");
 var import_schedule = require("./modules/schedule");
+var import_resource = require("./modules/resource");
 var import_schedule2 = require("./utils/schedule");
+var import_types = require("./modules/products/types");
+var import_product = require("./utils/product");
+var import_order = require("./modules/order");
+var import_types2 = require("./modules/order/types");
+var import_filterOrders = require("./modules/order/utils/filterOrders");
+var import_filterBookings = require("./modules/order/utils/filterBookings");
 __reExport(server_exports, require("./modules"), module.exports);
 var Server = class {
   constructor(core) {
@@ -38,6 +56,11 @@ var Server = class {
       put: {},
       remove: {}
     };
+    // ---- 商品查询订阅者 ----
+    this.productQuerySubscribers = /* @__PURE__ */ new Map();
+    // ---- 订单 / 预约列表查询订阅者 ----
+    this.orderQuerySubscribers = /* @__PURE__ */ new Map();
+    this.bookingQuerySubscribers = /* @__PURE__ */ new Map();
     // 模块注册表 - 定义所有可用的模块配置
     this.moduleRegistry = {
       products: {
@@ -78,71 +101,164 @@ var Server = class {
           availabilityDateList: [],
           otherProductsIds: []
         }
+      },
+      order: {
+        name: "order",
+        moduleClass: import_order.OrderModule,
+        moduleName: "server_order",
+        version: "1.0.0",
+        defaultStore: {
+          list: []
+        }
+      },
+      resource: {
+        name: "resource",
+        moduleClass: import_resource.ResourceModule,
+        moduleName: "server_resource",
+        version: "1.0.0",
+        defaultStore: {
+          list: [],
+          map: /* @__PURE__ */ new Map(),
+          bookings: []
+        }
       }
     };
     /**
-     * 处理商品查询请求（编排 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;
-      if (!this.products) {
-        console.error("[Server] Products 模块未注册");
-        return {
-          message: "Products 模块未注册",
-          data: { list: [], count: 0 }
-        };
-      }
-      if (!this.menu) {
-        console.error("[Server] Menu 模块未注册");
-        return {
-          message: "Menu 模块未注册",
-          data: { list: [], count: 0 }
-        };
+      const { callback, subscriberId } = config || {};
+      this.logInfo("handleProductQuery: 开始处理商品查询请求", {
+        menu_list_ids,
+        schedule_datetime,
+        schedule_date
+      });
+      if (subscriberId && typeof callback === "function") {
+        this.productQuerySubscribers.set(subscriberId, {
+          callback,
+          context: { menu_list_ids, schedule_date, schedule_datetime }
+        });
+        this.logInfo("handleProductQuery: 已注册订阅者", {
+          subscriberId,
+          totalSubscribers: this.productQuerySubscribers.size
+        });
       }
-      if (!this.schedule) {
-        console.error("[Server] Schedule 模块未注册");
-        return {
-          message: "Schedule 模块未注册",
-          data: { list: [], count: 0 }
-        };
+      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 };
+    };
+    /**
+     * 处理订单列表查询
+     * 存储订阅者信息，本地计算结果；数据变更时通过 callback 推送
+     */
+    this.handleOrderList = async ({ url, method, data, config }) => {
+      console.log("[Server] handleOrderList:", url, method, data, config);
+      const queryPayload = data && typeof data === "object" ? { ...data } : {};
+      const { callback, subscriberId } = config || {};
+      this.logInfo("handleOrderList: 开始处理订单列表请求", { data: queryPayload });
+      if (subscriberId && typeof callback === "function") {
+        this.orderQuerySubscribers.set(subscriberId, {
+          callback,
+          context: queryPayload
+        });
+        this.logInfo("handleOrderList: 已注册订阅者", {
+          subscriberId,
+          totalSubscribers: this.orderQuerySubscribers.size
+        });
       }
-      let activeMenuList = [];
-      if (menu_list_ids && Array.isArray(menu_list_ids) && menu_list_ids.length > 0) {
-        console.log("[Server] 获取餐牌详情，IDs:", menu_list_ids);
-        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;
+      return this.computeOrderQueryResult(queryPayload);
+    };
+    /**
+     * 取消订单列表查询订阅（HTTP 路由入口）
+     */
+    this.handleUnsubscribeOrderQuery = async ({ data }) => {
+      const { subscriberId } = data || {};
+      if (subscriberId) {
+        this.orderQuerySubscribers.delete(subscriberId);
+        this.logInfo("handleUnsubscribeOrderQuery: 已移除订阅者", {
+          subscriberId,
+          remaining: this.orderQuerySubscribers.size
         });
       }
-      console.log(activeMenuList, "activeMenuList");
-      const allProductsWithPrice = await this.products.getProductsWithPrice(data.schedule_date, {
-        scheduleModule: this.getSchedule()
+      return { code: 200, message: "ok", status: true };
+    };
+    /**
+     * 处理预约列表查询
+     * 今天：注册订阅者 + 本地数据筛选；非今天：清理订阅者 + 走真实 API
+     */
+    this.handleBookingList = async ({ url, method, data, config }) => {
+      console.log("[Server] handleBookingList:", url, method, data, config);
+      const queryPayload = data && typeof data === "object" ? { ...data } : {};
+      const { callback, subscriberId } = config || {};
+      const isToday = this.isBookingQueryForToday(queryPayload);
+      this.logInfo("handleBookingList: 开始处理预约列表请求", {
+        data: queryPayload,
+        isToday
       });
-      console.log(allProductsWithPrice, "allProductsWithPrice");
-      let filteredProducts = this.filterProductsByMenuConfig(allProductsWithPrice, activeMenuList);
-      filteredProducts = filteredProducts.sort((a, b) => {
-        const sortDiff = Number(b.sort) - Number(a.sort);
-        if (sortDiff !== 0) {
-          return sortDiff;
+      if (isToday) {
+        if (subscriberId && typeof callback === "function") {
+          this.bookingQuerySubscribers.set(subscriberId, {
+            callback,
+            context: queryPayload
+          });
+          this.logInfo("handleBookingList: 已注册订阅者（今天）", {
+            subscriberId,
+            totalSubscribers: this.bookingQuerySubscribers.size
+          });
+        }
+        return this.computeBookingQueryResult(queryPayload);
+      } else {
+        if (subscriberId) {
+          this.bookingQuerySubscribers.delete(subscriberId);
+          this.logInfo("handleBookingList: 已清理订阅者（非今天）", {
+            subscriberId,
+            remaining: this.bookingQuerySubscribers.size
+          });
         }
-        return (a.title || "").localeCompare(b.title || "");
+        return this.fetchBookingListFromAPI(queryPayload);
+      }
+    };
+    /**
+     * 处理资源列表查询
+     * 转发到资源模块去
+     */
+    this.handleResourceList = async ({ url, method, data, config }) => {
+      var _a;
+      console.log("[Server] handleResourceList:", url, method, data, config);
+      const list = (_a = this.resource) == null ? void 0 : _a.getResources({
+        skip: (data == null ? void 0 : data.skip) || 1,
+        num: (data == null ? void 0 : data.num) || 10
       });
-      console.log("[Server] 原始商品数量:", allProductsWithPrice.length);
-      console.log("[Server] 过滤后商品数量:", filteredProducts.length);
-      console.log(filteredProducts, "filteredProducts");
       return {
         code: 200,
-        data: {
-          list: filteredProducts,
-          count: filteredProducts.length
-        },
+        data: { list, count: (list == null ? void 0 : list.length) || 0 },
         message: "",
         status: true
       };
     };
+    /**
+     * 取消预约列表查询订阅（HTTP 路由入口）
+     */
+    this.handleUnsubscribeBookingQuery = async ({ data }) => {
+      const { subscriberId } = data || {};
+      if (subscriberId) {
+        this.bookingQuerySubscribers.delete(subscriberId);
+        this.logInfo("handleUnsubscribeBookingQuery: 已移除订阅者", {
+          subscriberId,
+          remaining: this.bookingQuerySubscribers.size
+        });
+      }
+      return { code: 200, message: "ok", status: true };
+    };
     /**
      * 处理获取日程时间段点的请求
      * 通过餐牌ID列表获取所有相关日程的时间段点
@@ -150,8 +266,10 @@ var Server = class {
     this.handleGetScheduleTimePoints = async ({ url, method, data, config }) => {
       console.log("[Server] handleGetScheduleTimePoints:", url, method, data, config);
       const { menu_list_ids } = data;
+      this.logInfo("handleGetScheduleTimePoints 开始处理", { menuListIdsCount: (menu_list_ids == null ? void 0 : menu_list_ids.length) ?? 0, menu_list_ids });
       if (!this.menu) {
         console.error("[Server] Menu 模块未注册");
+        this.logError("handleGetScheduleTimePoints: Menu 模块未注册");
         return {
           code: 500,
           message: "Menu 模块未注册",
@@ -161,6 +279,7 @@ var Server = class {
       }
       if (!this.schedule) {
         console.error("[Server] Schedule 模块未注册");
+        this.logError("handleGetScheduleTimePoints: Schedule 模块未注册");
         return {
           code: 500,
           message: "Schedule 模块未注册",
@@ -170,6 +289,7 @@ var Server = class {
       }
       if (!menu_list_ids || !Array.isArray(menu_list_ids) || menu_list_ids.length === 0) {
         console.error("[Server] menu_list_ids 参数无效");
+        this.logWarning("handleGetScheduleTimePoints: menu_list_ids 参数无效", { menuListIdsCount: (menu_list_ids == null ? void 0 : menu_list_ids.length) ?? 0, menu_list_ids });
         return {
           code: 400,
           message: "menu_list_ids 参数无效",
@@ -180,9 +300,19 @@ var Server = class {
       try {
         const menuList = this.menu.getMenuByIds(menu_list_ids);
         console.log(`[Server] 找到 ${menuList.length} 个餐牌`);
+        this.logInfo("handleGetScheduleTimePoints: 获取到餐牌列表", {
+          requestedCount: menu_list_ids.length,
+          foundCount: menuList.length,
+          menu_list_ids,
+          menuList
+        });
         const scheduleIds = (0, import_schedule2.extractScheduleIdsFromMenus)(menuList);
         console.log(`[Server] 提取到 ${scheduleIds.length} 个日程ID:`, scheduleIds);
+        this.logInfo("handleGetScheduleTimePoints: 提取到日程 IDs", {
+          scheduleCount: scheduleIds.length
+        });
         if (scheduleIds.length === 0) {
+          this.logInfo("handleGetScheduleTimePoints: 没有找到相关日程", { menuListIdsCount: menu_list_ids.length });
           return {
             code: 200,
             message: "没有找到相关日程",
@@ -192,8 +322,18 @@ var Server = class {
         }
         const scheduleList = this.schedule.getScheduleByIds(scheduleIds);
         console.log(`[Server] 找到 ${scheduleList.length} 个日程`);
+        this.logInfo("handleGetScheduleTimePoints: 获取到日程详情", {
+          requestedCount: scheduleIds.length,
+          foundCount: scheduleList.length
+        });
         const timePoints = (0, import_schedule2.extractTimePointsFromSchedules)(scheduleList);
         console.log(`[Server] 提取到 ${timePoints.length} 个时间点:`, timePoints);
+        this.logInfo("handleGetScheduleTimePoints 处理完成", {
+          menuListIdsCount: menu_list_ids.length,
+          menuCount: menuList.length,
+          scheduleCount: scheduleList.length,
+          timePointCount: timePoints.length
+        });
         return {
           code: 200,
           message: "获取成功",
@@ -201,17 +341,30 @@ var Server = class {
           status: true
         };
       } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "未知错误";
         console.error("[Server] 获取日程时间点失败:", error);
+        this.logError("handleGetScheduleTimePoints: 获取日程时间点失败", {
+          menuListIdsCount: menu_list_ids.length,
+          error: errorMessage
+        });
         return {
           code: 500,
-          message: `获取失败: ${error instanceof Error ? error.message : "未知错误"}`,
+          message: `获取失败: ${errorMessage}`,
           data: [],
           status: false
         };
       }
     };
+    var _a;
     this.core = core;
-    console.log("[Server] Server 初始化");
+    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 初始化", this.core);
+    this.logInfo("Server 初始化", {
+      hasApp: !!this.app,
+      hasLogger: !!this.logger
+    });
   }
   /**
    * 注册路由
@@ -222,13 +375,16 @@ var Server = class {
       const { method, path, handler } = route;
       if (!this.router[method]) {
         console.warn(`[Server] 不支持的 HTTP 方法: ${method}`);
+        this.logWarning(`不支持的 HTTP 方法`, { method, path });
         return;
       }
       if (this.router[method][path]) {
         console.warn(`[Server] 路由已存在，将被覆盖: ${method.toUpperCase()} ${path}`);
+        this.logWarning(`路由已存在，将被覆盖`, { method, path });
       }
       this.router[method][path] = handler;
       console.log(`[Server] 📝 注册路由: ${method.toUpperCase()} ${path}`);
+      this.logInfo(`注册路由`, { method: method.toUpperCase(), path });
     });
   }
   /**
@@ -238,12 +394,15 @@ var Server = class {
    * @param moduleName 模块名称（用于日志）
    */
   async registerModuleWithRoutes(module2, options, moduleName) {
+    this.logInfo(`开始注册模块: ${moduleName}`, { moduleName, options });
     await this.core.registerModule(module2, options);
     console.log(`[Server] ✅ ${moduleName} 模块已注册`);
+    this.logInfo(`模块注册成功: ${moduleName}`, { moduleName });
     if (typeof module2.getRoutes === "function") {
       const routes = module2.getRoutes();
       if (routes && routes.length > 0) {
         this.registerRoutes(routes);
+        this.logInfo(`模块路由已注册: ${moduleName}`, { moduleName, routesCount: routes.length });
       }
     }
   }
@@ -255,8 +414,14 @@ var Server = class {
     const moduleName = typeof moduleConfig === "string" ? moduleConfig : moduleConfig.name;
     const shouldPreload = typeof moduleConfig === "object" ? moduleConfig.preload !== false : true;
     const customConfig = typeof moduleConfig === "object" ? moduleConfig.config : {};
+    this.logInfo(`解析模块配置: ${moduleName}`, {
+      moduleName,
+      shouldPreload,
+      customConfig
+    });
     const registryConfig = this.moduleRegistry[moduleName];
     if (!registryConfig) {
+      this.logError(`未找到模块配置: ${moduleName}`, { moduleName });
       throw new Error(`[Server] 未找到模块配置: ${moduleName}`);
     }
     const ModuleClass = registryConfig.moduleClass;
@@ -271,6 +436,11 @@ var Server = class {
       moduleName.charAt(0).toUpperCase() + moduleName.slice(1)
     );
     this[moduleName] = moduleInstance;
+    this.logInfo(`模块注册完成: ${moduleName}`, {
+      moduleName,
+      shouldPreload,
+      version: registryConfig.version
+    });
     return { module: moduleInstance, config: registryConfig, shouldPreload };
   }
   /**
@@ -280,17 +450,34 @@ var Server = class {
   async registerModules(moduleConfigs) {
     console.log("[Server] 开始注册模块...");
     const configs = moduleConfigs || Object.keys(this.moduleRegistry);
+    this.logInfo("开始批量注册模块", {
+      moduleConfigs: configs,
+      totalCount: configs.length
+    });
     const registeredModules = [];
     for (const config of configs) {
+      const configName = typeof config === "string" ? config : config.name;
       try {
         const result = await this.registerModuleByName(config);
         registeredModules.push(result);
       } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logError(`模块注册失败: ${configName}`, {
+          moduleName: configName,
+          error: errorMessage
+        });
         console.error(`[Server] 模块注册失败:`, error);
         throw error;
       }
     }
     console.log("[Server] ✅ 所有模块注册完成");
+    this.logInfo("所有模块注册完成", {
+      registeredCount: registeredModules.length,
+      moduleNames: registeredModules.map((m) => {
+        var _a;
+        return (_a = m == null ? void 0 : m.config) == null ? void 0 : _a.name;
+      })
+    });
     return registeredModules;
   }
   /**
@@ -300,25 +487,56 @@ var Server = class {
   async preloadModulesData(registeredModules, options) {
     var _a, _b;
     console.log("[Server] 开始预加载模块数据...");
+    const modulesToPreload = registeredModules.filter((m) => m.shouldPreload);
+    this.logInfo("开始预加载模块数据", {
+      totalModules: registeredModules.length,
+      preloadCount: modulesToPreload.length,
+      modulesToPreload
+    });
+    const preloadResults = [];
     for (const { module: module2, config, shouldPreload } of registeredModules) {
       if (!shouldPreload) {
         console.log(`[Server] ⏭️ 跳过 ${config.name} 模块预加载`);
+        this.logInfo(`跳过模块预加载: ${config.name}`, { moduleName: config.name, reason: "shouldPreload=false" });
         continue;
       }
       if (typeof module2.preload === "function") {
+        const startTime = Date.now();
         try {
+          this.logInfo(`开始预加载模块: ${config.name}`, { moduleName: config.name });
           (_a = options == null ? void 0 : options.onModuleLoad) == null ? void 0 : _a.call(options, config.name);
           await module2.preload();
           (_b = options == null ? void 0 : options.onModuleLoadComplete) == null ? void 0 : _b.call(options, config.name);
+          const duration = Date.now() - startTime;
           console.log(`[Server] ✅ ${config.name} 模块数据已预加载`);
+          this.logInfo(`模块预加载成功: ${config.name}`, {
+            moduleName: config.name,
+            duration: `${duration}ms`
+          });
+          preloadResults.push({ name: config.name, success: true });
         } catch (error) {
+          const duration = Date.now() - startTime;
+          const errorMessage = error instanceof Error ? error.message : String(error);
           console.error(`[Server] ❌ ${config.name} 模块预加载失败:`, error);
+          this.logError(`模块预加载失败: ${config.name}`, {
+            moduleName: config.name,
+            duration: `${duration}ms`,
+            error: errorMessage
+          });
+          preloadResults.push({ name: config.name, success: false, error: errorMessage });
         }
       } else {
         console.log(`[Server] ⚠️ ${config.name} 模块未实现 preload() 方法`);
+        this.logWarning(`模块未实现 preload 方法: ${config.name}`, { moduleName: config.name });
       }
     }
+    const successCount = preloadResults.filter((r) => r.success).length;
+    const failCount = preloadResults.filter((r) => !r.success).length;
     console.log("[Server] ✅ 所有模块数据预加载完成");
+    this.logInfo("所有模块预加载完成", {
+      successCount,
+      failCount
+    });
   }
   /**
    * 初始化 Server（注册模块并预加载数据）
@@ -326,11 +544,33 @@ var Server = class {
    * @param autoPreload 是否自动预加载数据
    */
   async initialize(moduleConfigs, autoPreload = true, options) {
+    const startTime = Date.now();
+    this.logInfo("Server 初始化开始", {
+      moduleConfigCount: (moduleConfigs == null ? void 0 : moduleConfigs.length) ?? "all",
+      autoPreload,
+      moduleConfigs
+    });
     this.registerServerRoutes();
     const registeredModules = await this.registerModules(moduleConfigs);
     if (autoPreload) {
       await this.preloadModulesData(registeredModules, options);
+    } else {
+      this.logInfo("跳过自动预加载", { autoPreload });
     }
+    this.core.effects.on(import_types.ProductsHooks.onProductsSyncCompleted, (payload) => {
+      this.recomputeAndNotifyProductQuery({
+        changedIds: payload == null ? void 0 : payload.changedIds
+      });
+    });
+    this.core.effects.on(import_types2.OrderHooks.onOrdersChanged, () => {
+      this.recomputeAndNotifyOrderQuery();
+      this.recomputeAndNotifyBookingQuery();
+    });
+    const duration = Date.now() - startTime;
+    this.logInfo("Server 初始化完成", {
+      duration: `${duration}ms`,
+      registeredModuleCount: registeredModules.length
+    });
     return registeredModules;
   }
   /**
@@ -370,14 +610,45 @@ var Server = class {
       modules.push("quotation");
     if (this.schedule)
       modules.push("schedule");
+    if (this.resource)
+      modules.push("resource");
+    if (this.order)
+      modules.push("order");
     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>
    */
   async clearAllIndexDB() {
     console.log("[Server] 开始清空所有模块的IndexedDB缓存...");
+    this.logInfo("开始清空所有模块的 IndexedDB 缓存");
     const clearTasks = [];
     const moduleNames = [];
     if (this.products) {
@@ -396,15 +667,28 @@ var Server = class {
       clearTasks.push(this.schedule.clear());
       moduleNames.push("Schedule");
     }
+    if (this.resource) {
+      clearTasks.push(this.resource.clear());
+      moduleNames.push("Resource");
+    }
+    if (this.order) {
+      clearTasks.push(this.order.clear());
+      moduleNames.push("Order");
+    }
     if (clearTasks.length === 0) {
       console.warn("[Server] 没有找到已注册的模块，无需清空");
+      this.logWarning("没有找到已注册的模块，无需清空 IndexedDB");
       return;
     }
+    this.logInfo("准备清空模块缓存", { moduleNames });
     try {
       await Promise.all(clearTasks);
       console.log(`[Server] ✅ 已成功清空所有模块的IndexedDB缓存: ${moduleNames.join(", ")}`);
+      this.logInfo("成功清空所有模块的 IndexedDB 缓存", { moduleNames });
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       console.error("[Server] ❌ 清空IndexedDB缓存时发生错误:", error);
+      this.logError("清空 IndexedDB 缓存时发生错误", { moduleNames, error: errorMessage });
       throw error;
     }
   }
@@ -440,14 +724,39 @@ var Server = class {
    * @param params 请求参数
    */
   async handleRoute(method, path, params) {
-    console.log(method, path, params, "method, path, params");
+    const startTime = Date.now();
+    this.logInfo(`路由请求开始: ${method.toUpperCase()} ${path}`, {
+      method: method.toUpperCase(),
+      path,
+      url: params.url,
+      data: params.data
+    });
     const handler = this.getRouteHandler(method, path);
     if (!handler) {
+      this.logError(`路由未找到: ${method.toUpperCase()} ${path}`, { method, path });
       throw new Error(`Route not found: ${method.toUpperCase()} ${path}`);
     }
     try {
-      return await handler(params);
+      const result = await handler(params);
+      const duration = Date.now() - startTime;
+      this.logInfo(`路由请求完成: ${method.toUpperCase()} ${path}`, {
+        method: method.toUpperCase(),
+        path,
+        duration: `${duration}ms`,
+        resultCode: result == null ? void 0 : result.code,
+        resultStatus: result == null ? void 0 : result.status
+      });
+      return result;
     } catch (error) {
+      const duration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logError(`路由处理错误: ${method.toUpperCase()} ${path}`, {
+        method: method.toUpperCase(),
+        path,
+        duration: `${duration}ms`,
+        error: errorMessage,
+        data: params.data
+      });
       console.error(`[Server] 路由处理错误: ${method.toUpperCase()} ${path}`, error);
       throw error;
     }
@@ -477,13 +786,332 @@ 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",
         handler: this.handleGetScheduleTimePoints.bind(this)
+      },
+      {
+        method: "post",
+        path: "/shop/order/v2/list",
+        handler: this.handleOrderList.bind(this)
+      },
+      {
+        method: "post",
+        path: "/shop/order/v2/list/unsubscribe",
+        handler: this.handleUnsubscribeOrderQuery.bind(this)
+      },
+      {
+        method: "get",
+        path: "/shop/schedule/booking",
+        handler: this.handleBookingList.bind(this)
+      },
+      {
+        method: "get",
+        path: "/shop/schedule/booking/unsubscribe",
+        handler: this.handleUnsubscribeBookingQuery.bind(this)
+      },
+      {
+        method: "get",
+        path: "/shop/form/resource/page",
+        handler: this.handleResourceList.bind(this)
       }
     ]);
   }
+  /**
+   * 根据 subscriberId 移除商品查询订阅者
+   */
+  removeProductQuerySubscriber(subscriberId) {
+    if (subscriberId) {
+      this.productQuerySubscribers.delete(subscriberId);
+      this.logInfo("removeProductQuerySubscriber: 已移除订阅者", {
+        subscriberId,
+        remaining: this.productQuerySubscribers.size
+      });
+    }
+  }
+  /**
+   * 判断预约查询的 sales_time_between 起始日期是否为今天
+   */
+  isBookingQueryForToday(data) {
+    const range = data == null ? void 0 : data.sales_time_between;
+    if (!Array.isArray(range) || range.length < 1)
+      return true;
+    const startDateStr = String(range[0]).split("T")[0].split(" ")[0];
+    const todayStr = (0, import_dayjs.default)().format("YYYY-MM-DD");
+    return startDateStr === todayStr;
+  }
+  /**
+   * 非今天的预约查询：通过真实 API 获取数据，再做 flattenOrdersToBookings 拆分
+   */
+  async fetchBookingListFromAPI(data) {
+    var _a, _b;
+    if (!((_a = this.app) == null ? void 0 : _a.request)) {
+      this.logError("fetchBookingListFromAPI: app.request 不可用");
+      return {
+        code: 500,
+        message: "app.request 不可用",
+        data: { list: [], count: 0 },
+        status: false
+      };
+    }
+    try {
+      const response = await this.app.request.get("/shop/order/sales", { ...data, form_record_ids: void 0, with: ["all"] }, {
+        isShopApi: true
+      });
+      const rawList = ((_b = response == null ? void 0 : response.data) == null ? void 0 : _b.list) ?? (response == null ? void 0 : response.list) ?? [];
+      const list = (0, import_filterBookings.filterBookingsFromOrders)(rawList, data);
+      this.logInfo("fetchBookingListFromAPI: API 返回并拆分完成", {
+        rawCount: rawList.length,
+        flattenedCount: list.count
+      });
+      return {
+        code: 200,
+        data: { ...response.data, list: (list == null ? void 0 : list.list) || [] },
+        message: "",
+        status: true
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logError("fetchBookingListFromAPI: 请求失败", { error: errorMessage });
+      return {
+        code: 500,
+        message: errorMessage,
+        data: { list: [], count: 0 },
+        status: false
+      };
+    }
+  }
+  /**
+   * 订单列表本地计算（编排 Order 模块）
+   * filter 逻辑暂为 mock，仅记录参数
+   */
+  async computeOrderQueryResult(data) {
+    this.logInfo("computeOrderQueryResult: 开始过滤", { data });
+    console.log("[Server] computeOrderQueryResult", data);
+    if (!this.order) {
+      this.logError("computeOrderQueryResult: Order 模块未注册");
+      return {
+        code: 500,
+        message: "Order 模块未注册",
+        data: { list: [], count: 0 },
+        status: false
+      };
+    }
+    const rawList = this.order.getOrders();
+    this.logInfo("computeOrderQueryResult: 本地订单数量", { rawCount: rawList.length });
+    const result = (0, import_filterOrders.filterOrders)(rawList, data);
+    this.logInfo("computeOrderQueryResult: 过滤结果", {
+      rawCount: rawList.length,
+      filteredCount: result.count,
+      size: result.size,
+      skip: result.skip
+    });
+    return {
+      code: 200,
+      data: result,
+      message: "",
+      status: true
+    };
+  }
+  /**
+   * 预约列表本地计算（编排 Order 模块）
+   * 从订单中展开 bookings，再按条件筛选 + 分页
+   */
+  async computeBookingQueryResult(data) {
+    if (!this.order) {
+      this.logError("computeBookingQueryResult: Order 模块未注册");
+      return {
+        code: 500,
+        message: "Order 模块未注册",
+        data: { list: [], count: 0 },
+        status: false
+      };
+    }
+    const rawOrders = this.order.getOrders();
+    let result = (0, import_filterBookings.filterBookingsFromOrders)(rawOrders, data);
+    result = (0, import_filterBookings.sortBookings)(result, data);
+    this.logInfo("computeBookingQueryResult: 过滤结果", {
+      orderCount: rawOrders.length,
+      filteredCount: result.count,
+      size: result.size,
+      skip: result.skip
+    });
+    return {
+      code: 200,
+      data: result,
+      message: "",
+      status: true
+    };
+  }
+  /**
+   * 商品查询的核心计算逻辑（编排 Products、Menu、Schedule 模块）
+   * 供 handleProductQuery 首次返回及 pubsub 变更推送复用
+   * @param context 查询上下文
+   * @param options 可选参数
+   * @param options.changedIds 变更的商品 IDs，用于增量更新价格缓存
+   */
+  async computeProductQueryResult(context, options) {
+    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,
+      changedIds: options == null ? void 0 : options.changedIds
+    });
+    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()
+    }, {
+      changedIds: options == null ? void 0 : options.changedIds
+    });
+    (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 tStatus = performance.now();
+    const beforeStatusCount = filteredProducts.length;
+    filteredProducts = filteredProducts.filter((p) => ((p == null ? void 0 : p.status) || "published") === "published");
+    (0, import_product.perfMark)("computeQuery.filterByStatus", performance.now() - tStatus, {
+      before: beforeStatusCount,
+      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 事件触发
+   * @param options 可选参数
+   * @param options.changedIds 变更的商品 IDs，用于增量更新价格缓存
+   */
+  async recomputeAndNotifyProductQuery(options) {
+    if (this.productQuerySubscribers.size === 0)
+      return;
+    this.logInfo("recomputeAndNotifyProductQuery: 开始推送", {
+      subscriberCount: this.productQuerySubscribers.size,
+      changedIds: options == null ? void 0 : options.changedIds
+    });
+    for (const [subscriberId, subscriber] of this.productQuerySubscribers.entries()) {
+      try {
+        const result = await this.computeProductQueryResult(subscriber.context, {
+          changedIds: options == null ? void 0 : options.changedIds
+        });
+        subscriber.callback(result);
+        this.logInfo("recomputeAndNotifyProductQuery: 已推送", { subscriberId });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logError("recomputeAndNotifyProductQuery: 推送失败", {
+          subscriberId,
+          error: errorMessage
+        });
+      }
+    }
+  }
+  /**
+   * 订单数据变更后，遍历订阅者重新计算并通过 callback 推送
+   */
+  async recomputeAndNotifyOrderQuery() {
+    if (this.orderQuerySubscribers.size === 0)
+      return;
+    this.logInfo("recomputeAndNotifyOrderQuery: 开始推送", {
+      subscriberCount: this.orderQuerySubscribers.size
+    });
+    for (const [subscriberId, subscriber] of this.orderQuerySubscribers.entries()) {
+      try {
+        const result = await this.computeOrderQueryResult(subscriber.context);
+        subscriber.callback(result);
+        this.logInfo("recomputeAndNotifyOrderQuery: 已推送", { subscriberId });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logError("recomputeAndNotifyOrderQuery: 推送失败", {
+          subscriberId,
+          error: errorMessage
+        });
+      }
+    }
+  }
+  /**
+   * 预约数据变更后，遍历订阅者重新计算并通过 callback 推送
+   */
+  async recomputeAndNotifyBookingQuery() {
+    if (this.bookingQuerySubscribers.size === 0)
+      return;
+    this.logInfo("recomputeAndNotifyBookingQuery: 开始推送", {
+      subscriberCount: this.bookingQuerySubscribers.size
+    });
+    for (const [subscriberId, subscriber] of this.bookingQuerySubscribers.entries()) {
+      try {
+        const result = await this.computeBookingQueryResult(subscriber.context);
+        subscriber.callback(result);
+        this.logInfo("recomputeAndNotifyBookingQuery: 已推送", { subscriberId });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logError("recomputeAndNotifyBookingQuery: 推送失败", {
+          subscriberId,
+          error: errorMessage
+        });
+      }
+    }
+  }
   /**
    * 根据餐牌配置过滤商品
    * @param products 所有商品列表
@@ -494,6 +1122,10 @@ var Server = class {
   filterProductsByMenuConfig(products, activeMenuList) {
     if (!activeMenuList || activeMenuList.length === 0) {
       console.log("[Server] 没有生效的餐牌，返回空数组");
+      this.logInfo("filterProductsByMenuConfig: 没有生效的餐牌，返回空数组", {
+        productCount: products.length,
+        activeMenuCount: 0
+      });
       return [];
     }
     let allowedProductIds = /* @__PURE__ */ new Set();
@@ -503,10 +1135,19 @@ var Server = class {
       const config = menu.partyroom_package;
       if (!config) {
         console.warn("[Server] 餐牌缺少 partyroom_package 配置:", menu);
+        this.logWarning("filterProductsByMenuConfig: 餐牌缺少 partyroom_package 配置", {
+          menuId: menu.form_record_id,
+          menuName: menu.name
+        });
         continue;
       }
       if (config.type === "product_all") {
         console.log("[Server] 餐牌允许所有商品:", menu.name);
+        this.logInfo("filterProductsByMenuConfig: 餐牌允许所有商品", {
+          menuId: menu.form_record_id,
+          menuName: menu.name,
+          configType: config.type
+        });
         hasProductAll = true;
         break;
       }
@@ -514,22 +1155,47 @@ var Server = class {
         const productIds = config.products.map((item) => item.product_id);
         productIds.forEach((id) => id && allowedProductIds.add(id));
         console.log("[Server] 餐牌允许指定商品 (product_ids):", menu.name, productIds);
+        this.logInfo("filterProductsByMenuConfig: 餐牌允许指定商品", {
+          menuId: menu.form_record_id,
+          menuName: menu.name,
+          configType: config.type,
+          productIdsCount: productIds.length
+        });
       }
       if (config.type === "product_collection" && Array.isArray(config.products)) {
         const collectionIds = config.products.map((item) => item.product_collection_id);
         collectionIds.forEach((id) => id && allowedCollectionIds.add(id));
         console.log("[Server] 餐牌允许商品集合 (product_collection):", menu.name, collectionIds);
+        this.logInfo("filterProductsByMenuConfig: 餐牌允许商品集合", {
+          menuId: menu.form_record_id,
+          menuName: menu.name,
+          configType: config.type,
+          collectionIdsCount: collectionIds.length
+        });
       }
     }
     if (hasProductAll) {
+      this.logInfo("filterProductsByMenuConfig: 返回所有商品（product_all）", {
+        productCount: products.length
+      });
       return products;
     }
     if (allowedProductIds.size === 0 && allowedCollectionIds.size === 0) {
       console.log("[Server] 没有允许的商品和集合");
+      this.logWarning("filterProductsByMenuConfig: 没有允许的商品和集合", {
+        productCount: products.length,
+        activeMenuCount: activeMenuList.length
+      });
       return [];
     }
-    console.log("[Server] 允许的商品 IDs:", Array.from(allowedProductIds));
-    console.log("[Server] 允许的集合 IDs:", Array.from(allowedCollectionIds));
+    const allowedProductIdsArray = Array.from(allowedProductIds);
+    const allowedCollectionIdsArray = Array.from(allowedCollectionIds);
+    console.log("[Server] 允许的商品 IDs:", allowedProductIdsArray);
+    console.log("[Server] 允许的集合 IDs:", allowedCollectionIdsArray);
+    this.logInfo("filterProductsByMenuConfig: 收集到的允许规则", {
+      allowedProductCount: allowedProductIds.size,
+      allowedCollectionCount: allowedCollectionIds.size
+    });
     const filteredProducts = products.filter((product) => {
       if (allowedProductIds.has(product.id)) {
         return true;
@@ -545,8 +1211,64 @@ var Server = class {
       return false;
     });
     console.log("[Server] 过滤结果: 原始 %d 个，过滤后 %d 个", products.length, filteredProducts.length);
+    this.logInfo("filterProductsByMenuConfig: 过滤完成", {
+      originalCount: products.length,
+      filteredCount: filteredProducts.length,
+      removedCount: products.length - filteredProducts.length
+    });
     return filteredProducts;
   }
+  /**
+   * 记录信息日志
+   * @param title 日志标题
+   * @param metadata 日志元数据
+   */
+  logInfo(title, metadata) {
+    try {
+      if (this.logger) {
+        this.logger.addLog({
+          type: "info",
+          title: `[Server] ${title}`,
+          metadata: metadata || {}
+        });
+      }
+    } catch {
+    }
+  }
+  /**
+   * 记录警告日志
+   * @param title 日志标题
+   * @param metadata 日志元数据
+   */
+  logWarning(title, metadata) {
+    try {
+      if (this.logger) {
+        this.logger.addLog({
+          type: "warning",
+          title: `[Server] ${title}`,
+          metadata: metadata || {}
+        });
+      }
+    } catch {
+    }
+  }
+  /**
+   * 记录错误日志
+   * @param title 日志标题
+   * @param metadata 日志元数据
+   */
+  logError(title, metadata) {
+    try {
+      if (this.logger) {
+        this.logger.addLog({
+          type: "error",
+          title: `[Server] ${title}`,
+          metadata: metadata || {}
+        });
+      }
+    } catch {
+    }
+  }
 };
 var server_default = Server;
 // Annotate the CommonJS export names for ESM import in node: