@pisell/pisellos 0.0.567 → 0.0.568

package/lib/server/index.js

@@ -1,462 +1,283 @@
-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)
-    __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 __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
-var server_exports = {};
-__export(server_exports, {
-  default: () => server_default
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-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) {
-    // 路由注册表
-    this.router = {
-      get: {},
-      post: {},
-      put: {},
-      remove: {}
-    };
-    // ---- 商品查询订阅者 ----
-    this.productQuerySubscribers = /* @__PURE__ */ new Map();
-    // ---- 订单 / 预约列表查询订阅者 ----
-    this.orderQuerySubscribers = /* @__PURE__ */ new Map();
-    this.bookingQuerySubscribers = /* @__PURE__ */ new Map();
-    // 模块注册表 - 定义所有可用的模块配置
-    this.moduleRegistry = {
-      products: {
-        name: "products",
-        moduleClass: import_products.ProductsModule,
-        moduleName: "server_products",
-        version: "1.0.0",
-        defaultStore: {
-          list: [],
-          selectProducts: []
-        }
-      },
-      menu: {
-        name: "menu",
-        moduleClass: import_menu.MenuModule,
-        moduleName: "server_menu",
-        version: "1.0.0",
-        defaultStore: {
-          menuList: []
-        }
-      },
-      quotation: {
-        name: "quotation",
-        moduleClass: import_quotation.QuotationModule,
-        moduleName: "server_quotation",
-        version: "1.0.0",
-        defaultStore: {
-          quotationList: []
-        }
-      },
-      schedule: {
-        name: "schedule",
-        moduleClass: import_schedule.ScheduleModuleEx,
-        moduleName: "server_schedule",
-        version: "1.1.0",
-        defaultStore: {
-          scheduleList: [],
-          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: []
-        }
-      }
-    };
-    /**
-     * 处理商品查询请求
-     * 存储订阅者信息，便于数据变更时推送最新结果
-     */
-    this.handleProductQuery = async ({ url, method, data, config }) => {
-      console.log("[Server] handleProductQuery:", url, method, data, config);
-      const { menu_list_ids, schedule_datetime, schedule_date } = data;
-      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
-        });
-      }
-      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
-        });
-      }
-      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
-        });
-      }
-      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
-      });
-      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 this.fetchBookingListFromAPI(queryPayload);
+var _exportNames = {};
+exports.default = void 0;
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _products = require("./modules/products");
+var _menu = require("./modules/menu");
+var _quotation = require("./modules/quotation");
+var _schedule = require("./modules/schedule");
+var _resource = require("./modules/resource");
+var _schedule2 = require("./utils/schedule");
+var _types = require("./modules/products/types");
+var _product = require("./utils/product");
+var _order = require("./modules/order");
+var _types2 = require("./modules/order/types");
+var _filterOrders = require("./modules/order/utils/filterOrders");
+var _filterBookings = require("./modules/order/utils/filterBookings");
+var _modules = require("./modules");
+Object.keys(_modules).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _modules[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _modules[key];
+    }
+  });
+});
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// 重新导出类型供外部使用
+
+/** 商品查询订阅者 */
+
+/** 订单列表查询订阅者 */
+
+/** 预约列表查询订阅者 */
+
+/**
+ * Server 类
+ * 用于注册和管理服务端模块
+ */
+class Server {
+  core;
+  app; // App instance
+  logger; // LoggerManager instance
+
+  // 模块实例
+  products;
+  menu;
+  quotation;
+  schedule;
+  resource;
+  order;
+
+  // 路由注册表
+  router = {
+    get: {},
+    post: {},
+    put: {},
+    remove: {}
+  };
+
+  // ---- 商品查询订阅者 ----
+  productQuerySubscribers = new Map();
+
+  // ---- 订单 / 预约列表查询订阅者 ----
+  orderQuerySubscribers = new Map();
+  bookingQuerySubscribers = new Map();
+
+  // 模块注册表 - 定义所有可用的模块配置
+  moduleRegistry = {
+    products: {
+      name: 'products',
+      moduleClass: _products.ProductsModule,
+      moduleName: 'server_products',
+      version: '1.0.0',
+      defaultStore: {
+        list: [],
+        selectProducts: []
       }
-    };
-    /**
-     * 处理资源列表查询
-     * 转发到资源模块去
-     */
-    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
-      });
-      return {
-        code: 200,
-        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
-        });
+    },
+    menu: {
+      name: 'menu',
+      moduleClass: _menu.MenuModule,
+      moduleName: 'server_menu',
+      version: '1.0.0',
+      defaultStore: {
+        menuList: []
       }
-      return { code: 200, message: "ok", status: true };
-    };
-    /**
-     * 处理获取日程时间段点的请求
-     * 通过餐牌ID列表获取所有相关日程的时间段点
-     */
-    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 模块未注册",
-          data: [],
-          status: false
-        };
+    },
+    quotation: {
+      name: 'quotation',
+      moduleClass: _quotation.QuotationModule,
+      moduleName: 'server_quotation',
+      version: '1.0.0',
+      defaultStore: {
+        quotationList: []
       }
-      if (!this.schedule) {
-        console.error("[Server] Schedule 模块未注册");
-        this.logError("handleGetScheduleTimePoints: Schedule 模块未注册");
-        return {
-          code: 500,
-          message: "Schedule 模块未注册",
-          data: [],
-          status: false
-        };
+    },
+    schedule: {
+      name: 'schedule',
+      moduleClass: _schedule.ScheduleModuleEx,
+      moduleName: 'server_schedule',
+      version: '1.1.0',
+      defaultStore: {
+        scheduleList: [],
+        availabilityDateList: [],
+        otherProductsIds: []
       }
-      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 参数无效",
-          data: [],
-          status: false
-        };
+    },
+    order: {
+      name: 'order',
+      moduleClass: _order.OrderModule,
+      moduleName: 'server_order',
+      version: '1.0.0',
+      defaultStore: {
+        list: []
       }
-      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: "没有找到相关日程",
-            data: [],
-            status: true
-          };
-        }
-        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: "获取成功",
-          data: timePoints,
-          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: `获取失败: ${errorMessage}`,
-          data: [],
-          status: false
-        };
+    },
+    resource: {
+      name: 'resource',
+      moduleClass: _resource.ResourceModule,
+      moduleName: 'server_resource',
+      version: '1.0.0',
+      defaultStore: {
+        list: [],
+        map: new Map(),
+        bookings: []
       }
-    };
-    var _a;
+    }
+  };
+  constructor(core) {
     this.core = core;
-    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 初始化", {
+    const appPlugin = core.getPlugin('app');
+    this.app = appPlugin?.getApp() || null;
+    this.logger = this.app?.logger || null;
+    this.logInfo('Server 初始化', {
       hasApp: !!this.app,
       hasLogger: !!this.logger
     });
   }
+
   /**
    * 注册路由
    * @param routes 路由定义数组
    */
   registerRoutes(routes) {
-    routes.forEach((route) => {
-      const { method, path, handler } = route;
+    routes.forEach(route => {
+      const {
+        method,
+        path,
+        handler
+      } = route;
       if (!this.router[method]) {
         console.warn(`[Server] 不支持的 HTTP 方法: ${method}`);
-        this.logWarning(`不支持的 HTTP 方法`, { method, path });
+        this.logWarning(`不支持的 HTTP 方法`, {
+          method,
+          path
+        });
         return;
       }
+
+      // 检查路由是否已存在
       if (this.router[method][path]) {
         console.warn(`[Server] 路由已存在，将被覆盖: ${method.toUpperCase()} ${path}`);
-        this.logWarning(`路由已存在，将被覆盖`, { method, path });
+        this.logWarning(`路由已存在，将被覆盖`, {
+          method,
+          path
+        });
       }
       this.router[method][path] = handler;
-      console.log(`[Server] 📝 注册路由: ${method.toUpperCase()} ${path}`);
-      this.logInfo(`注册路由`, { method: method.toUpperCase(), path });
+      this.logInfo(`注册路由`, {
+        method: method.toUpperCase(),
+        path
+      });
     });
   }
+
   /**
    * 注册单个模块并自动注册其路由
    * @param module 模块实例
    * @param options 模块配置
    * @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();
+  async registerModuleWithRoutes(module, options, moduleName) {
+    this.logInfo(`开始注册模块: ${moduleName}`, {
+      moduleName,
+      options
+    });
+
+    // 注册模块到 Core
+    await this.core.registerModule(module, options);
+    this.logInfo(`模块注册成功: ${moduleName}`, {
+      moduleName
+    });
+
+    // 自动注册模块的路由
+    if (typeof module.getRoutes === 'function') {
+      const routes = module.getRoutes();
       if (routes && routes.length > 0) {
         this.registerRoutes(routes);
-        this.logInfo(`模块路由已注册: ${moduleName}`, { moduleName, routesCount: routes.length });
+        this.logInfo(`模块路由已注册: ${moduleName}`, {
+          moduleName,
+          routesCount: routes.length
+        });
       }
     }
   }
+
   /**
    * 根据模块名称注册单个模块
    * @param moduleConfig 模块配置（可以是字符串或配置对象）
    */
   async registerModuleByName(moduleConfig) {
-    const moduleName = typeof moduleConfig === "string" ? moduleConfig : moduleConfig.name;
-    const shouldPreload = typeof moduleConfig === "object" ? moduleConfig.preload !== false : true;
-    const customConfig = typeof moduleConfig === "object" ? moduleConfig.config : {};
+    // 解析配置
+    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 });
+      this.logError(`未找到模块配置: ${moduleName}`, {
+        moduleName
+      });
       throw new Error(`[Server] 未找到模块配置: ${moduleName}`);
     }
+
+    // 创建模块实例
     const ModuleClass = registryConfig.moduleClass;
     const moduleInstance = new ModuleClass(registryConfig.moduleName, registryConfig.version);
+
+    // 合并配置
     const moduleOptions = {
-      store: { ...registryConfig.defaultStore },
+      store: {
+        ...registryConfig.defaultStore
+      },
       ...customConfig
     };
-    await this.registerModuleWithRoutes(
-      moduleInstance,
-      moduleOptions,
-      moduleName.charAt(0).toUpperCase() + moduleName.slice(1)
-    );
+
+    // 注册模块和路由
+    await this.registerModuleWithRoutes(moduleInstance, moduleOptions, moduleName.charAt(0).toUpperCase() + moduleName.slice(1));
+
+    // 保存模块实例
     this[moduleName] = moduleInstance;
     this.logInfo(`模块注册完成: ${moduleName}`, {
       moduleName,
       shouldPreload,
       version: registryConfig.version
     });
-    return { module: moduleInstance, config: registryConfig, shouldPreload };
+    return {
+      module: moduleInstance,
+      config: registryConfig,
+      shouldPreload
+    };
   }
+
   /**
    * 注册指定的服务端模块
    * @param moduleConfigs 要注册的模块配置数组（模块名称或配置对象）
    */
   async registerModules(moduleConfigs) {
-    console.log("[Server] 开始注册模块...");
+    // 如果没有指定模块，则注册所有模块
     const configs = moduleConfigs || Object.keys(this.moduleRegistry);
-    this.logInfo("开始批量注册模块", {
+    this.logInfo('开始批量注册模块', {
       moduleConfigs: configs,
       totalCount: configs.length
     });
     const registeredModules = [];
     for (const config of configs) {
-      const configName = typeof config === "string" ? config : config.name;
+      const configName = typeof config === 'string' ? config : config.name;
       try {
         const result = await this.registerModuleByName(config);
         registeredModules.push(result);
@@ -470,50 +291,57 @@ var Server = class {
         throw error;
       }
     }
-    console.log("[Server] ✅ 所有模块注册完成");
-    this.logInfo("所有模块注册完成", {
+    this.logInfo('所有模块注册完成', {
       registeredCount: registeredModules.length,
-      moduleNames: registeredModules.map((m) => {
-        var _a;
-        return (_a = m == null ? void 0 : m.config) == null ? void 0 : _a.name;
-      })
+      moduleNames: registeredModules.map(m => m?.config?.name)
     });
     return registeredModules;
   }
+
   /**
    * 预加载指定模块的数据
    * @param registeredModules 已注册的模块信息
    */
   async preloadModulesData(registeredModules, options) {
-    var _a, _b;
-    console.log("[Server] 开始预加载模块数据...");
-    const modulesToPreload = registeredModules.filter((m) => m.shouldPreload);
-    this.logInfo("开始预加载模块数据", {
+    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) {
+    for (const {
+      module,
+      config,
+      shouldPreload
+    } of registeredModules) {
       if (!shouldPreload) {
-        console.log(`[Server] ⏭️ 跳过 ${config.name} 模块预加载`);
-        this.logInfo(`跳过模块预加载: ${config.name}`, { moduleName: config.name, reason: "shouldPreload=false" });
+        this.logInfo(`跳过模块预加载: ${config.name}`, {
+          moduleName: config.name,
+          reason: 'shouldPreload=false'
+        });
         continue;
       }
-      if (typeof module2.preload === "function") {
+
+      // 统一调用模块的 preload() 方法
+      if (typeof module.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);
+          this.logInfo(`开始预加载模块: ${config.name}`, {
+            moduleName: config.name
+          });
+          options?.onModuleLoad?.(config.name);
+          await module.preload();
+          options?.onModuleLoadComplete?.(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 });
+          preloadResults.push({
+            name: config.name,
+            success: true
+          });
         } catch (error) {
           const duration = Date.now() - startTime;
           const errorMessage = error instanceof Error ? error.message : String(error);
@@ -523,21 +351,26 @@ var Server = class {
             duration: `${duration}ms`,
             error: errorMessage
           });
-          preloadResults.push({ name: config.name, success: false, 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 });
+        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("所有模块预加载完成", {
+    const successCount = preloadResults.filter(r => r.success).length;
+    const failCount = preloadResults.filter(r => !r.success).length;
+    this.logInfo('所有模块预加载完成', {
       successCount,
       failCount
     });
   }
+
   /**
    * 初始化 Server（注册模块并预加载数据）
    * @param moduleConfigs 要注册的模块配置
@@ -545,77 +378,89 @@ var Server = class {
    */
   async initialize(moduleConfigs, autoPreload = true, options) {
     const startTime = Date.now();
-    this.logInfo("Server 初始化开始", {
-      moduleConfigCount: (moduleConfigs == null ? void 0 : moduleConfigs.length) ?? "all",
+    this.logInfo('Server 初始化开始', {
+      moduleConfigCount: moduleConfigs?.length ?? 'all',
       autoPreload,
       moduleConfigs
     });
+
+    // 注册 Server 层的业务路由
     this.registerServerRoutes();
+
+    // 注册模块
     const registeredModules = await this.registerModules(moduleConfigs);
+
+    // 自动预加载数据
     if (autoPreload) {
       await this.preloadModulesData(registeredModules, options);
     } else {
-      this.logInfo("跳过自动预加载", { autoPreload });
+      this.logInfo('跳过自动预加载', {
+        autoPreload
+      });
     }
-    this.core.effects.on(import_types.ProductsHooks.onProductsSyncCompleted, (payload) => {
+
+    // 监听 ProductsModule 同步完成事件，重新计算并推送查询结果
+    this.core.effects.on(_types.ProductsHooks.onProductsSyncCompleted, payload => {
       this.recomputeAndNotifyProductQuery({
-        changedIds: payload == null ? void 0 : payload.changedIds
+        changedIds: payload?.changedIds
       });
     });
-    this.core.effects.on(import_types2.OrderHooks.onOrdersChanged, () => {
+
+    // 订单 / 预约本地数据变更时，向订阅者推送最新列表
+    this.core.effects.on(_types2.OrderHooks.onOrdersChanged, () => {
       this.recomputeAndNotifyOrderQuery();
       this.recomputeAndNotifyBookingQuery();
     });
     const duration = Date.now() - startTime;
-    this.logInfo("Server 初始化完成", {
+    this.logInfo('Server 初始化完成', {
       duration: `${duration}ms`,
       registeredModuleCount: registeredModules.length
     });
     return registeredModules;
   }
+
   /**
    * 获取 Products 模块实例
    */
   getProducts() {
     return this.products;
   }
+
   /**
    * 获取 Menu 模块实例
    */
   getMenu() {
     return this.menu;
   }
+
   /**
    * 获取 Quotation 模块实例
    */
   getQuotation() {
     return this.quotation;
   }
+
   /**
    * 获取 Schedule 模块实例
    */
   getSchedule() {
     return this.schedule;
   }
+
   /**
    * 获取所有已注册的模块列表
    */
   getRegisteredModules() {
     const modules = [];
-    if (this.products)
-      modules.push("products");
-    if (this.menu)
-      modules.push("menu");
-    if (this.quotation)
-      modules.push("quotation");
-    if (this.schedule)
-      modules.push("schedule");
-    if (this.resource)
-      modules.push("resource");
-    if (this.order)
-      modules.push("order");
+    if (this.products) modules.push('products');
+    if (this.menu) modules.push('menu');
+    if (this.quotation) 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
@@ -623,100 +468,112 @@ var Server = class {
    */
   async refreshProductsInBackground() {
     if (!this.products) {
-      this.logWarning("refreshProductsInBackground: Products 模块未注册");
+      this.logWarning('refreshProductsInBackground: Products 模块未注册');
       return;
     }
-    this.logInfo("refreshProductsInBackground 开始");
+    this.logInfo('refreshProductsInBackground 开始');
     const startTime = Date.now();
     try {
       await this.products.silentRefresh();
       const duration = Date.now() - startTime;
-      this.logInfo("refreshProductsInBackground 完成", { duration: `${duration}ms` });
+      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 失败", {
+      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 缓存");
+    this.logInfo('开始清空所有模块的 IndexedDB 缓存');
     const clearTasks = [];
     const moduleNames = [];
+
+    // 收集所有模块的清空任务
     if (this.products) {
       clearTasks.push(this.products.clear());
-      moduleNames.push("Products");
+      moduleNames.push('Products');
     }
     if (this.menu) {
       clearTasks.push(this.menu.clear());
-      moduleNames.push("Menu");
+      moduleNames.push('Menu');
     }
     if (this.quotation) {
       clearTasks.push(this.quotation.clear());
-      moduleNames.push("Quotation");
+      moduleNames.push('Quotation');
     }
     if (this.schedule) {
       clearTasks.push(this.schedule.clear());
-      moduleNames.push("Schedule");
+      moduleNames.push('Schedule');
     }
     if (this.resource) {
       clearTasks.push(this.resource.clear());
-      moduleNames.push("Resource");
+      moduleNames.push('Resource');
     }
     if (this.order) {
       clearTasks.push(this.order.clear());
-      moduleNames.push("Order");
+      moduleNames.push('Order');
     }
     if (clearTasks.length === 0) {
-      console.warn("[Server] 没有找到已注册的模块，无需清空");
-      this.logWarning("没有找到已注册的模块，无需清空 IndexedDB");
+      console.warn('[Server] 没有找到已注册的模块，无需清空');
+      this.logWarning('没有找到已注册的模块，无需清空 IndexedDB');
       return;
     }
-    this.logInfo("准备清空模块缓存", { moduleNames });
+    this.logInfo('准备清空模块缓存', {
+      moduleNames
+    });
     try {
+      // 并行执行所有清空操作
       await Promise.all(clearTasks);
-      console.log(`[Server] ✅ 已成功清空所有模块的IndexedDB缓存: ${moduleNames.join(", ")}`);
-      this.logInfo("成功清空所有模块的 IndexedDB 缓存", { moduleNames });
+      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 });
+      console.error('[Server] ❌ 清空IndexedDB缓存时发生错误:', error);
+      this.logError('清空 IndexedDB 缓存时发生错误', {
+        moduleNames,
+        error: errorMessage
+      });
       throw error;
     }
   }
+
   /**
    * 获取所有注册的路由
    */
   getRoutes() {
     return this.router;
   }
+
   /**
    * 根据方法和路径获取路由处理函数
    * @param method HTTP 方法
    * @param path 路径
    */
   getRouteHandler(method, path) {
-    var _a;
-    return (_a = this.router[method]) == null ? void 0 : _a[path];
+    return this.router[method]?.[path];
   }
+
   /**
    * 检查路由是否存在
    * @param method HTTP 方法
    * @param path 路径
    */
   hasRoute(method, path) {
-    var _a;
-    console.log(method, path, "method, path");
-    return !!((_a = this.router[method]) == null ? void 0 : _a[path]);
+    return !!this.router[method]?.[path];
   }
+
   /**
    * 执行路由处理函数
    * @param method HTTP 方法
@@ -733,7 +590,10 @@ var Server = class {
     });
     const handler = this.getRouteHandler(method, path);
     if (!handler) {
-      this.logError(`路由未找到: ${method.toUpperCase()} ${path}`, { method, path });
+      this.logError(`路由未找到: ${method.toUpperCase()} ${path}`, {
+        method,
+        path
+      });
       throw new Error(`Route not found: ${method.toUpperCase()} ${path}`);
     }
     try {
@@ -743,8 +603,8 @@ var Server = class {
         method: method.toUpperCase(),
         path,
         duration: `${duration}ms`,
-        resultCode: result == null ? void 0 : result.code,
-        resultStatus: result == null ? void 0 : result.status
+        resultCode: result?.code,
+        resultStatus: result?.status
       });
       return result;
     } catch (error) {
@@ -761,152 +621,386 @@ var Server = class {
       throw error;
     }
   }
+
   /**
    * 获取所有路由列表（用于调试和文档）
    */
   getAllRoutes() {
     const routes = [];
-    ["get", "post", "put", "remove"].forEach((method) => {
-      Object.keys(this.router[method]).forEach((path) => {
-        routes.push({ method, path });
+    ['get', 'post', 'put', 'remove'].forEach(method => {
+      Object.keys(this.router[method]).forEach(path => {
+        routes.push({
+          method,
+          path
+        });
       });
     });
     return routes;
   }
+
   /**
    * 注册 Server 层的业务路由
    * 这些路由需要编排多个模块的数据
    * @private
    */
   registerServerRoutes() {
-    console.log("[Server] 注册 Server 层业务路由...");
-    this.registerRoutes([
-      {
-        method: "post",
-        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)
-      }
-    ]);
+    this.registerRoutes([{
+      method: 'post',
+      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: 已移除订阅者", {
+      this.logInfo('removeProductQuerySubscriber: 已移除订阅者', {
         subscriberId,
         remaining: this.productQuerySubscribers.size
       });
     }
   }
+
+  /**
+   * 处理商品查询请求
+   * 存储订阅者信息，便于数据变更时推送最新结果
+   */
+  handleProductQuery = async ({
+    url,
+    method,
+    data,
+    config
+  }) => {
+    const {
+      menu_list_ids,
+      schedule_datetime,
+      schedule_date
+    } = data;
+    const {
+      callback,
+      subscriberId
+    } = config || {};
+    this.logInfo('handleProductQuery: 开始处理商品查询请求', {
+      menu_list_ids,
+      schedule_datetime,
+      schedule_date
+    });
+
+    // 存储订阅者：后续 pubsub 数据变更时可通过 callback 推送最新结果
+    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
+      });
+    }
+    return this.computeProductQueryResult({
+      menu_list_ids,
+      schedule_date,
+      schedule_datetime
+    });
+  };
+
+  /**
+   * 取消商品查询订阅（HTTP 路由入口）
+   */
+  handleUnsubscribeProductQuery = async ({
+    data
+  }) => {
+    const {
+      subscriberId
+    } = data || {};
+    this.removeProductQuerySubscriber(subscriberId);
+    return {
+      code: 200,
+      message: 'ok',
+      status: true
+    };
+  };
+
+  /**
+   * 处理订单列表查询
+   * 存储订阅者信息，本地计算结果；数据变更时通过 callback 推送
+   */
+  handleOrderList = async ({
+    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
+      });
+    }
+    return this.computeOrderQueryResult(queryPayload);
+  };
+
+  /**
+   * 取消订单列表查询订阅（HTTP 路由入口）
+   */
+  handleUnsubscribeOrderQuery = async ({
+    data
+  }) => {
+    const {
+      subscriberId
+    } = data || {};
+    if (subscriberId) {
+      this.orderQuerySubscribers.delete(subscriberId);
+      this.logInfo('handleUnsubscribeOrderQuery: 已移除订阅者', {
+        subscriberId,
+        remaining: this.orderQuerySubscribers.size
+      });
+    }
+    return {
+      code: 200,
+      message: 'ok',
+      status: true
+    };
+  };
+
   /**
    * 判断预约查询的 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");
+    const range = 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, _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 不可用");
+    if (!this.app?.request) {
+      this.logError('fetchBookingListFromAPI: app.request 不可用');
       return {
         code: 500,
-        message: "app.request 不可用",
-        data: { list: [], count: 0 },
+        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"] }, {
+      const response = await this.app.request.get('/shop/order/sales', {
+        ...data,
+        form_record_ids: undefined,
+        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 返回并拆分完成", {
+      const rawList = response?.data?.list ?? response?.list ?? [];
+      const list = (0, _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: "",
+        data: {
+          ...response.data,
+          list: list?.list || []
+        },
+        message: '',
         status: true
       };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logError("fetchBookingListFromAPI: 请求失败", { error: errorMessage });
+      this.logError('fetchBookingListFromAPI: 请求失败', {
+        error: errorMessage
+      });
       return {
         code: 500,
         message: errorMessage,
-        data: { list: [], count: 0 },
+        data: {
+          list: [],
+          count: 0
+        },
         status: false
       };
     }
   }
+
+  /**
+   * 处理预约列表查询
+   * 今天：注册订阅者 + 本地数据筛选；非今天：清理订阅者 + 走真实 API
+   */
+  handleBookingList = async ({
+    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
+    });
+    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 this.fetchBookingListFromAPI(queryPayload);
+    }
+  };
+
+  /**
+   * 处理资源列表查询
+   * 转发到资源模块去
+   */
+  handleResourceList = async ({
+    url,
+    method,
+    data,
+    config
+  }) => {
+    const list = this.resource?.getResources({
+      skip: data?.skip || 1,
+      num: data?.num || 10
+    });
+    return {
+      code: 200,
+      data: {
+        list,
+        count: list?.length || 0
+      },
+      message: '',
+      status: true
+    };
+  };
+
+  /**
+   * 取消预约列表查询订阅（HTTP 路由入口）
+   */
+  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
+    };
+  };
+
   /**
    * 订单列表本地计算（编排 Order 模块）
    * filter 逻辑暂为 mock，仅记录参数
    */
   async computeOrderQueryResult(data) {
-    this.logInfo("computeOrderQueryResult: 开始过滤", { data });
-    console.log("[Server] computeOrderQueryResult", data);
+    this.logInfo('computeOrderQueryResult: 开始过滤', {
+      data
+    });
     if (!this.order) {
-      this.logError("computeOrderQueryResult: Order 模块未注册");
+      this.logError('computeOrderQueryResult: Order 模块未注册');
       return {
         code: 500,
-        message: "Order 模块未注册",
-        data: { list: [], count: 0 },
+        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: 过滤结果", {
+    this.logInfo('computeOrderQueryResult: 本地订单数量', {
+      rawCount: rawList.length
+    });
+
+    // 使用 filterOrders 进行过滤、排序、分页
+    const result = (0, _filterOrders.filterOrders)(rawList, data);
+    this.logInfo('computeOrderQueryResult: 过滤结果', {
       rawCount: rawList.length,
       filteredCount: result.count,
       size: result.size,
@@ -915,28 +1009,32 @@ var Server = class {
     return {
       code: 200,
       data: result,
-      message: "",
+      message: '',
       status: true
     };
   }
+
   /**
    * 预约列表本地计算（编排 Order 模块）
    * 从订单中展开 bookings，再按条件筛选 + 分页
    */
   async computeBookingQueryResult(data) {
     if (!this.order) {
-      this.logError("computeBookingQueryResult: Order 模块未注册");
+      this.logError('computeBookingQueryResult: Order 模块未注册');
       return {
         code: 500,
-        message: "Order 模块未注册",
-        data: { list: [], count: 0 },
+        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: 过滤结果", {
+    let result = (0, _filterBookings.filterBookingsFromOrders)(rawOrders, data);
+    result = (0, _filterBookings.sortBookings)(result, data);
+    this.logInfo('computeBookingQueryResult: 过滤结果', {
       orderCount: rawOrders.length,
       filteredCount: result.count,
       size: result.size,
@@ -945,10 +1043,11 @@ var Server = class {
     return {
       code: 200,
       data: result,
-      message: "",
+      message: '',
       status: true
     };
   }
+
   /**
    * 商品查询的核心计算逻辑（编排 Products、Menu、Schedule 模块）
    * 供 handleProductQuery 首次返回及 pubsub 变更推送复用
@@ -958,34 +1057,55 @@ var Server = class {
    */
   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,
+    const {
+      menu_list_ids,
+      schedule_date,
+      schedule_datetime
+    } = context;
+    this.logInfo('computeProductQueryResult 开始', {
+      menuListIdsCount: menu_list_ids?.length ?? 0,
       schedule_datetime,
       schedule_date,
-      changedIds: options == null ? void 0 : options.changedIds
+      changedIds: options?.changedIds
     });
     if (!this.products) {
-      this.logError("computeProductQueryResult: Products 模块未注册");
-      return { message: "Products 模块未注册", data: { list: [], count: 0 } };
+      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 } };
+      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 } };
+      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;
+      activeMenuList = menuList.filter(menu => {
+        return this.schedule?.getDateIsInSchedule(schedule_datetime, menu.schedule) || false;
       });
-      (0, import_product.perfMark)("computeQuery.filterActiveMenu", performance.now() - tMenu, {
+      (0, _product.perfMark)('computeQuery.filterActiveMenu', performance.now() - tMenu, {
         totalMenu: menuList.length,
         activeMenu: activeMenuList.length
       });
@@ -994,49 +1114,54 @@ var Server = class {
     const allProductsWithPrice = await this.products.getProductsWithPrice(schedule_date, {
       scheduleModule: this.getSchedule()
     }, {
-      changedIds: options == null ? void 0 : options.changedIds
+      changedIds: options?.changedIds
     });
-    (0, import_product.perfMark)("computeQuery.getProductsWithPrice", performance.now() - tPrice, {
+    (0, _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, {
+    (0, _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, {
+    filteredProducts = filteredProducts.filter(p => (p?.status || "published") === 'published');
+    (0, _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 || "");
+      if (sortDiff !== 0) return sortDiff;
+      return (a.title || '').localeCompare(b.title || '');
+    });
+    (0, _product.perfMark)('computeQuery.sort', performance.now() - tSort, {
+      count: filteredProducts.length
     });
-    (0, import_product.perfMark)("computeQuery.sort", performance.now() - tSort, { count: filteredProducts.length });
-    (0, import_product.perfMark)("computeProductQueryResult", performance.now() - tTotal, {
+    (0, _product.perfMark)('computeProductQueryResult', performance.now() - tTotal, {
       originalCount: allProductsWithPrice.length,
       filteredCount: filteredProducts.length,
       activeMenuCount: activeMenuList.length
     });
-    this.logInfo("computeProductQueryResult 完成", {
+    this.logInfo('computeProductQueryResult 完成', {
       originalCount: allProductsWithPrice.length,
       filteredCount: filteredProducts.length,
       activeMenuCount: activeMenuList.length
     });
     return {
       code: 200,
-      data: { list: filteredProducts, count: filteredProducts.length },
-      message: "",
+      data: {
+        list: filteredProducts,
+        count: filteredProducts.length
+      },
+      message: '',
       status: true
     };
   }
+
   /**
    * 数据变更后，遍历所有订阅者重新计算查询结果并通过 callback 推送
    * 由 ProductsModule 的 onProductsSyncCompleted 事件触发
@@ -1044,74 +1169,80 @@ var Server = class {
    * @param options.changedIds 变更的商品 IDs，用于增量更新价格缓存
    */
   async recomputeAndNotifyProductQuery(options) {
-    if (this.productQuerySubscribers.size === 0)
-      return;
-    this.logInfo("recomputeAndNotifyProductQuery: 开始推送", {
+    if (this.productQuerySubscribers.size === 0) return;
+    this.logInfo('recomputeAndNotifyProductQuery: 开始推送', {
       subscriberCount: this.productQuerySubscribers.size,
-      changedIds: options == null ? void 0 : options.changedIds
+      changedIds: 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
+          changedIds: options?.changedIds
         });
         subscriber.callback(result);
-        this.logInfo("recomputeAndNotifyProductQuery: 已推送", { subscriberId });
+        this.logInfo('recomputeAndNotifyProductQuery: 已推送', {
+          subscriberId
+        });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        this.logError("recomputeAndNotifyProductQuery: 推送失败", {
+        this.logError('recomputeAndNotifyProductQuery: 推送失败', {
           subscriberId,
           error: errorMessage
         });
       }
     }
   }
+
   /**
    * 订单数据变更后，遍历订阅者重新计算并通过 callback 推送
    */
   async recomputeAndNotifyOrderQuery() {
-    if (this.orderQuerySubscribers.size === 0)
-      return;
-    this.logInfo("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 });
+        this.logInfo('recomputeAndNotifyOrderQuery: 已推送', {
+          subscriberId
+        });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        this.logError("recomputeAndNotifyOrderQuery: 推送失败", {
+        this.logError('recomputeAndNotifyOrderQuery: 推送失败', {
           subscriberId,
           error: errorMessage
         });
       }
     }
   }
+
   /**
    * 预约数据变更后，遍历订阅者重新计算并通过 callback 推送
    */
   async recomputeAndNotifyBookingQuery() {
-    if (this.bookingQuerySubscribers.size === 0)
-      return;
-    this.logInfo("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 });
+        this.logInfo('recomputeAndNotifyBookingQuery: 已推送', {
+          subscriberId
+        });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        this.logError("recomputeAndNotifyBookingQuery: 推送失败", {
+        this.logError('recomputeAndNotifyBookingQuery: 推送失败', {
           subscriberId,
           error: errorMessage
         });
       }
     }
   }
+
   /**
    * 根据餐牌配置过滤商品
    * @param products 所有商品列表
@@ -1120,30 +1251,33 @@ var Server = class {
    * @private
    */
   filterProductsByMenuConfig(products, activeMenuList) {
+    // 如果没有生效的餐牌，返回空数组
     if (!activeMenuList || activeMenuList.length === 0) {
-      console.log("[Server] 没有生效的餐牌，返回空数组");
-      this.logInfo("filterProductsByMenuConfig: 没有生效的餐牌，返回空数组", {
+      this.logInfo('filterProductsByMenuConfig: 没有生效的餐牌，返回空数组', {
         productCount: products.length,
         activeMenuCount: 0
       });
       return [];
     }
-    let allowedProductIds = /* @__PURE__ */ new Set();
-    let allowedCollectionIds = /* @__PURE__ */ new Set();
+
+    // 收集允许的商品 IDs 和集合 IDs
+    let allowedProductIds = new Set();
+    let allowedCollectionIds = new Set();
     let hasProductAll = false;
     for (const menu of activeMenuList) {
       const config = menu.partyroom_package;
       if (!config) {
-        console.warn("[Server] 餐牌缺少 partyroom_package 配置:", menu);
-        this.logWarning("filterProductsByMenuConfig: 餐牌缺少 partyroom_package 配置", {
+        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: 餐牌允许所有商品", {
+
+      // 如果有任何一个餐牌是 product_all，则返回所有商品
+      if (config.type === 'product_all') {
+        this.logInfo('filterProductsByMenuConfig: 餐牌允许所有商品', {
           menuId: menu.form_record_id,
           menuName: menu.name,
           configType: config.type
@@ -1151,22 +1285,24 @@ var Server = class {
         hasProductAll = true;
         break;
       }
-      if (config.type === "products" && Array.isArray(config.products)) {
-        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: 餐牌允许指定商品", {
+
+      // 如果是 product_ids 类型，从 ProductItemType 中提取 product_id
+      if (config.type === 'products' && Array.isArray(config.products)) {
+        const productIds = config.products.map(item => item.product_id);
+        productIds.forEach(id => id && allowedProductIds.add(id));
+        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: 餐牌允许商品集合", {
+
+      // 如果是 product_collection 类型，从 ProductItemType 中提取 product_collection_id
+      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));
+        this.logInfo('filterProductsByMenuConfig: 餐牌允许商品集合', {
           menuId: menu.form_record_id,
           menuName: menu.name,
           configType: config.type,
@@ -1174,15 +1310,18 @@ var Server = class {
         });
       }
     }
+
+    // 如果有餐牌允许所有商品，返回所有商品
     if (hasProductAll) {
-      this.logInfo("filterProductsByMenuConfig: 返回所有商品（product_all）", {
+      this.logInfo('filterProductsByMenuConfig: 返回所有商品（product_all）', {
         productCount: products.length
       });
       return products;
     }
+
+    // 如果没有收集到任何商品 ID 和集合 ID，返回空数组
     if (allowedProductIds.size === 0 && allowedCollectionIds.size === 0) {
-      console.log("[Server] 没有允许的商品和集合");
-      this.logWarning("filterProductsByMenuConfig: 没有允许的商品和集合", {
+      this.logWarning('filterProductsByMenuConfig: 没有允许的商品和集合', {
         productCount: products.length,
         activeMenuCount: activeMenuList.length
       });
@@ -1190,34 +1329,35 @@ var Server = class {
     }
     const allowedProductIdsArray = Array.from(allowedProductIds);
     const allowedCollectionIdsArray = Array.from(allowedCollectionIds);
-    console.log("[Server] 允许的商品 IDs:", allowedProductIdsArray);
-    console.log("[Server] 允许的集合 IDs:", allowedCollectionIdsArray);
-    this.logInfo("filterProductsByMenuConfig: 收集到的允许规则", {
+    this.logInfo('filterProductsByMenuConfig: 收集到的允许规则', {
       allowedProductCount: allowedProductIds.size,
       allowedCollectionCount: allowedCollectionIds.size
     });
-    const filteredProducts = products.filter((product) => {
+
+    // 过滤商品
+    const filteredProducts = products.filter(product => {
+      // 1. 检查商品 ID 是否在允许列表中
       if (allowedProductIds.has(product.id)) {
         return true;
       }
+
+      // 2. 检查商品是否属于允许的集合
       if (allowedCollectionIds.size > 0 && Array.isArray(product.collection)) {
-        const hasMatchingCollection = product.collection.some(
-          (col) => allowedCollectionIds.has(col.id)
-        );
+        const hasMatchingCollection = product.collection.some(col => allowedCollectionIds.has(col.id));
         if (hasMatchingCollection) {
           return true;
         }
       }
       return false;
     });
-    console.log("[Server] 过滤结果: 原始 %d 个，过滤后 %d 个", products.length, filteredProducts.length);
-    this.logInfo("filterProductsByMenuConfig: 过滤完成", {
+    this.logInfo('filterProductsByMenuConfig: 过滤完成', {
       originalCount: products.length,
       filteredCount: filteredProducts.length,
       removedCount: products.length - filteredProducts.length
     });
     return filteredProducts;
   }
+
   /**
    * 记录信息日志
    * @param title 日志标题
@@ -1227,14 +1367,16 @@ var Server = class {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: "info",
+          type: 'info',
           title: `[Server] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
+      // 日志记录失败不影响主流程
     }
   }
+
   /**
    * 记录警告日志
    * @param title 日志标题
@@ -1244,14 +1386,16 @@ var Server = class {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: "warning",
+          type: 'warning',
           title: `[Server] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
+      // 日志记录失败不影响主流程
     }
   }
+
   /**
    * 记录错误日志
    * @param title 日志标题
@@ -1261,17 +1405,132 @@ var Server = class {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: "error",
+          type: 'error',
           title: `[Server] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
+      // 日志记录失败不影响主流程
     }
   }
-};
-var server_default = Server;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require("./modules")
-});
+
+  /**
+   * 处理获取日程时间段点的请求
+   * 通过餐牌ID列表获取所有相关日程的时间段点
+   */
+  handleGetScheduleTimePoints = async ({
+    url,
+    method,
+    data,
+    config
+  }) => {
+    const {
+      menu_list_ids
+    } = data;
+    this.logInfo('handleGetScheduleTimePoints 开始处理', {
+      menuListIdsCount: menu_list_ids?.length ?? 0,
+      menu_list_ids
+    });
+
+    // 检查必要的模块是否已注册
+    if (!this.menu) {
+      console.error('[Server] Menu 模块未注册');
+      this.logError('handleGetScheduleTimePoints: Menu 模块未注册');
+      return {
+        code: 500,
+        message: 'Menu 模块未注册',
+        data: [],
+        status: false
+      };
+    }
+    if (!this.schedule) {
+      console.error('[Server] Schedule 模块未注册');
+      this.logError('handleGetScheduleTimePoints: Schedule 模块未注册');
+      return {
+        code: 500,
+        message: 'Schedule 模块未注册',
+        data: [],
+        status: false
+      };
+    }
+
+    // 检查参数
+    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?.length ?? 0,
+        menu_list_ids
+      });
+      return {
+        code: 400,
+        message: 'menu_list_ids 参数无效',
+        data: [],
+        status: false
+      };
+    }
+    try {
+      // 1. 获取餐牌列表
+      const menuList = this.menu.getMenuByIds(menu_list_ids);
+      this.logInfo('handleGetScheduleTimePoints: 获取到餐牌列表', {
+        requestedCount: menu_list_ids.length,
+        foundCount: menuList.length,
+        menu_list_ids,
+        menuList
+      });
+
+      // 2. 提取所有的 schedule IDs
+      const scheduleIds = (0, _schedule2.extractScheduleIdsFromMenus)(menuList);
+      this.logInfo('handleGetScheduleTimePoints: 提取到日程 IDs', {
+        scheduleCount: scheduleIds.length
+      });
+      if (scheduleIds.length === 0) {
+        this.logInfo('handleGetScheduleTimePoints: 没有找到相关日程', {
+          menuListIdsCount: menu_list_ids.length
+        });
+        return {
+          code: 200,
+          message: '没有找到相关日程',
+          data: [],
+          status: true
+        };
+      }
+
+      // 3. 获取日程详情
+      const scheduleList = this.schedule.getScheduleByIds(scheduleIds);
+      this.logInfo('handleGetScheduleTimePoints: 获取到日程详情', {
+        requestedCount: scheduleIds.length,
+        foundCount: scheduleList.length
+      });
+
+      // 4. 提取时间点
+      const timePoints = (0, _schedule2.extractTimePointsFromSchedules)(scheduleList);
+      this.logInfo('handleGetScheduleTimePoints 处理完成', {
+        menuListIdsCount: menu_list_ids.length,
+        menuCount: menuList.length,
+        scheduleCount: scheduleList.length,
+        timePointCount: timePoints.length
+      });
+      return {
+        code: 200,
+        message: '获取成功',
+        data: timePoints,
+        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: `获取失败: ${errorMessage}`,
+        data: [],
+        status: false
+      };
+    }
+  };
+}
+var _default = exports.default = Server; // 导出模块类型