@pisell/pisellos 2.2.291 → 2.2.293

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

@@ -17,6 +17,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 const INDEXDB_STORE_NAME = 'orders';
 const ORDER_STORAGE_KEY_FIELD = '__order_storage_key';
 const ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY = 'server_order_last_full_fetch_at';
+const ORDER_LAST_FULL_FETCH_SHOP_ID_STORAGE_KEY = 'server_order_last_full_fetch_shop_id';
 const ORDER_SYNC_THROTTLE_MS_STORAGE_KEY = 'order_sync_throttle_ms';
 const DEFAULT_ORDER_SYNC_THROTTLE_MS = 2_000;
 /** pubsub 回声写入去重窗口：业务 API 刚写入后，跳过同单 SQLite patch */
@@ -182,19 +183,25 @@ class OrderModule extends _BaseModule.BaseModule {
    * 仅记录计数与订单标识，不输出商品、预约、支付或客户明细。
    */
   normalizeOrderCollectionsForIngress(order, source) {
-    const sourceOrder = (0, _lodashEs.cloneDeep)(order);
-    const sourceOrderRecord = sourceOrder;
+    const sourceOrderRecord = order;
+    let sourceOrder = sourceOrderRecord;
     if (Array.isArray(sourceOrderRecord.payments)) {
-      sourceOrderRecord.payments = sourceOrderRecord.payments.map(payment => {
-        if (!(0, _paymentUtils.isPendingOrderPayment)(payment) || (0, _paymentUtils.getOrderPaymentIdentityKeys)(payment).some(key => key.startsWith('unique_payment_number:'))) {
-          return payment;
-        }
-        return {
-          ...payment,
-          [PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER]: true
-        };
-      });
+      sourceOrder = {
+        ...sourceOrderRecord,
+        payments: sourceOrderRecord.payments.map(payment => {
+          if (!(0, _paymentUtils.isPendingOrderPayment)(payment) || (0, _paymentUtils.getOrderPaymentIdentityKeys)(payment).some(key => key.startsWith('unique_payment_number:'))) {
+            return payment;
+          }
+          return {
+            ...payment,
+            [PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER]: true
+          };
+        })
+      };
     }
+
+    // normalizeOrderCollections 内部已经 cloneDeep；这里只浅复制被改写的 payments，
+    // 既不修改调用方对象，也避免对整笔订单重复深拷贝。
     const result = (0, _orderCollectionIdentity.normalizeOrderCollections)(sourceOrder);
     const normalizedOrderRecord = result.order;
     if (Array.isArray(normalizedOrderRecord.payments)) {
@@ -528,27 +535,68 @@ class OrderModule extends _BaseModule.BaseModule {
     return DEFAULT_ORDER_SYNC_THROTTLE_MS;
   }
   async preload() {
-    // const hasPulledInCurrentWindow = this.hasPulledOrdersToday()
-    // // 仅当缓存属于当前统计窗口时才直接复用，避免跨天/跨营业日窗口继续使用旧数据
-    // if (cachedOrders.length > 0 && hasPulledInCurrentWindow) {
-    //   this.store.list = cloneDeep(cachedOrders)
-    //   this.syncOrdersMap()
-    //   this.core.effects.emit(OrderHooks.onOrdersChanged, this.store.list)
-    //   return
-    // }
-
-    // if (hasPulledInCurrentWindow) {
-    //   this.logInfo('当天已完成全量订单拉取，跳过本次全量拉取', {
-    //     lastFullFetchAt: this.getStorageItem(ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY),
-    //   })
-    //   return
-    // }
+    const preloadStartedAt = Date.now();
+    let cachedOrders = null;
+    let sqliteLoadTimings;
+    if (this.dbManager) {
+      try {
+        cachedOrders = await this.loadOrdersFromSQLite({
+          throwOnError: true,
+          onTiming: timings => {
+            sqliteLoadTimings = timings;
+          }
+        });
+      } catch (error) {
+        this.logWarning('preload-SQLite读取失败，回退远端全量拉取', {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    if (cachedOrders !== null && this.hasPulledOrdersToday()) {
+      const memoryPrepareStartedAt = performance.now();
+      const memoryOrders = this.prepareNormalizedOrdersForMemoryList(cachedOrders);
+      const memoryPrepareMs = +(performance.now() - memoryPrepareStartedAt).toFixed(2);
 
-    const orders = await this.loadOrdersByServer();
+      // loadOrdersFromSQLite 已返回独立且完成集合规范化的新对象；直接进入 store，
+      // 不再进行第二轮 normalize 和没有隔离收益的最终 cloneDeep。
+      this.store.list = memoryOrders;
+      const syncMapStartedAt = performance.now();
+      this.syncOrdersMap();
+      const syncMapMs = +(performance.now() - syncMapStartedAt).toFixed(2);
+      const onOrdersLoadedStartedAt = performance.now();
+      await this.core.effects.emit(_types.OrderHooks.onOrdersLoaded, this.store.list);
+      const onOrdersLoadedMs = +(performance.now() - onOrdersLoadedStartedAt).toFixed(2);
+      const emitOrdersChangedStartedAt = performance.now();
+      await this.emitOrdersChanged([], 'preload.sqlite');
+      const emitOrdersChangedMs = +(performance.now() - emitOrdersChangedStartedAt).toFixed(2);
+      this.logInfo('预加载完成', {
+        trigger: 'preload',
+        source: 'SQLite',
+        orderCount: this.store.list.length,
+        duration: `${Date.now() - preloadStartedAt}ms`,
+        stages: {
+          ...(sqliteLoadTimings || {}),
+          memoryPrepareMs,
+          syncMapMs,
+          onOrdersLoadedMs,
+          emitOrdersChangedMs
+        }
+      });
+      return;
+    }
+    const orders = await this.loadOrdersByServer({
+      trigger: 'preload'
+    });
     this.store.list = (0, _lodashEs.cloneDeep)(orders);
     this.syncOrdersMap();
     await this.emitOrdersChanged([], 'preload');
     await this.core.effects.emit(_types.OrderHooks.onOrdersSyncCompleted, null);
+    this.logInfo('预加载完成', {
+      trigger: 'preload',
+      source: 'Server',
+      orderCount: this.store.list.length,
+      duration: `${Date.now() - preloadStartedAt}ms`
+    });
   }
   getOrders() {
     return this.store.list;
@@ -764,10 +812,13 @@ class OrderModule extends _BaseModule.BaseModule {
       previousPayment
     };
   }
-  async loadOrdersByServer() {
+  async loadOrdersByServer(options = {}) {
     let orderList = [];
+    let hasFetchedRemoteSnapshot = false;
+    const trigger = options.trigger || 'unknown';
     const protectedOrdersBeforeRemoteFetch = (await this.loadOrdersFromSQLite()).filter(order => this.shouldProtectLocalOrderFromRemoteSnapshot(order));
     this.logInfo('loadOrdersByServer-开始', {
+      trigger,
       hasOrderDataSource: !!this.orderDataSource,
       query: this.store?.createdAtQuery || null,
       protectedLocalOrderCount: protectedOrdersBeforeRemoteFetch.length,
@@ -782,18 +833,29 @@ class OrderModule extends _BaseModule.BaseModule {
         });
         orderList = data || [];
         this.logInfo('loadOrdersByServer-SSE拉取成功', {
+          trigger,
           count: orderList.length
         });
-        this.markOrderPulledAtNow();
+        hasFetchedRemoteSnapshot = true;
         this.lastServerFullFetchAtMs = Date.now();
       } catch {
         this.logInfo('loadOrdersByServer-SSE拉取失败，保持当前内存订单');
         return this.store.list;
       }
     }
-    const mergedOrders = await this.replaceOrdersSnapshotInSQLite(orderList, 'loadOrdersByServer', protectedOrdersBeforeRemoteFetch);
+    if (hasFetchedRemoteSnapshot) {
+      this.clearOrderSnapshotMarker();
+    }
+    const {
+      orders: mergedOrders,
+      persisted: isRemoteSnapshotPersisted
+    } = await this.replaceOrdersSnapshotInSQLite(orderList, 'loadOrdersByServer', protectedOrdersBeforeRemoteFetch);
+    if (hasFetchedRemoteSnapshot && isRemoteSnapshotPersisted) {
+      this.markOrderPulledAtNow();
+    }
     const memoryOrders = this.normalizeOrdersForMemoryList(mergedOrders, 'loadOrdersByServer.memory');
     this.logInfo('loadOrdersByServer-结束', {
+      trigger,
       count: memoryOrders.length,
       persistedCount: mergedOrders.length,
       sqliteOnlyDraftCount: mergedOrders.length - memoryOrders.length
@@ -807,22 +869,37 @@ class OrderModule extends _BaseModule.BaseModule {
    * 拿到完整数据后一次性替换 store，触发订单变更与同步完成事件
    * @returns 刷新后的订单列表
    */
-  async silentRefresh() {
+  async silentRefresh(options = {}) {
     const startTime = Date.now();
+    const trigger = options.trigger || 'background';
     const elapsedSinceFullFetch = Date.now() - this.lastServerFullFetchAtMs;
     if (this.lastServerFullFetchAtMs > 0 && elapsedSinceFullFetch < ORDER_SILENT_REFRESH_MIN_INTERVAL_MS) {
+      this.logInfo('silentRefresh 跳过全量 SSE', {
+        trigger,
+        reason: 'within_min_interval',
+        minIntervalMs: ORDER_SILENT_REFRESH_MIN_INTERVAL_MS,
+        elapsedSinceFullFetchMs: elapsedSinceFullFetch,
+        orderCount: this.store.list.length
+      });
       return this.store.list;
     }
-    this.logInfo('silentRefresh 开始');
+    this.logInfo('silentRefresh 开始', {
+      trigger,
+      elapsedSinceFullFetchMs: elapsedSinceFullFetch,
+      orderCount: this.store.list.length
+    });
     try {
       // 刷新前，需要更新当前营业日边界（store.createdAtQuery）
       this.updateCreateStore();
-      const orders = await this.loadOrdersByServer();
+      const orders = await this.loadOrdersByServer({
+        trigger
+      });
       this.store.list = (0, _lodashEs.cloneDeep)(orders);
       this.syncOrdersMap();
       await this.emitOrdersChanged([], 'silentRefresh');
       await this.core.effects.emit(_types.OrderHooks.onOrdersSyncCompleted, null);
       this.logInfo('silentRefresh 完成', {
+        trigger,
         orderCount: orders.length,
         duration: `${Date.now() - startTime}ms`
       });
@@ -830,6 +907,7 @@ class OrderModule extends _BaseModule.BaseModule {
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       this.logError('silentRefresh 失败', {
+        trigger,
         duration: `${Date.now() - startTime}ms`,
         error: errorMessage
       });
@@ -838,6 +916,13 @@ class OrderModule extends _BaseModule.BaseModule {
   }
   normalizeOrderForMemoryList(order, source = 'normalizeOrderForMemoryList') {
     const normalizedOrder = this.normalizeOrderCollectionsForIngress(order, source);
+    return this.prepareNormalizedOrderForMemoryList(normalizedOrder);
+  }
+
+  /**
+   * 将已经完成集合规范化的订单转换为内存身份，不重复扫描 products/bookings/payments。
+   */
+  prepareNormalizedOrderForMemoryList(normalizedOrder) {
     const externalSaleNumber = normalizedOrder?.external_sale_number;
     if (this.isDraftOrder(normalizedOrder) && !this.hasRealOrderId(normalizedOrder)) {
       return normalizedOrder;
@@ -853,6 +938,9 @@ class OrderModule extends _BaseModule.BaseModule {
       order_id: externalSaleNumber
     };
   }
+  prepareNormalizedOrdersForMemoryList(orders) {
+    return orders.map(order => this.prepareNormalizedOrderForMemoryList(order)).filter(order => this.shouldKeepOrderInMemory(order));
+  }
   normalizeOrdersForMemoryList(orders, source) {
     return orders.map(order => this.normalizeOrderForMemoryList(order, source)).filter(order => this.shouldKeepOrderInMemory(order));
   }
@@ -2021,22 +2109,29 @@ class OrderModule extends _BaseModule.BaseModule {
   }
 
   /**
-   * 当前订单拉取窗口：
-   * - 优先使用 createdAtQuery.sales_time_between（已按营业日边界初始化）
-   * - 无法解析时退化为自然日窗口
+   * 当前订单缓存可复用窗口。
+   * start_time 模式使用精确的营业日起止时间；配置缺失或异常时退化为自然日。
    */
-  getCurrentPullWindow() {
+  getCurrentOrderCacheWindow() {
     const now = (0, _dayjs.default)();
-    const range = this.store?.createdAtQuery?.sales_time_between;
-    if (Array.isArray(range) && range.length >= 2) {
-      const startAt = (0, _dayjs.default)(range[0]);
-      const endExclusiveAt = (0, _dayjs.default)(range[1]);
-      if (startAt.isValid() && endExclusiveAt.isValid() && endExclusiveAt.isAfter(startAt)) {
-        return {
-          startAt,
-          endExclusiveAt
-        };
+    try {
+      const appPlugin = this.core.getPlugin('app');
+      const app = appPlugin?.getApp();
+      const coreData = app?.data.store.getStore().getDataByModel('core');
+      const boundary = coreData?.core?.operating_day_boundary;
+      if (boundary?.type === 'start_time') {
+        const boundaryTime = String(boundary.time || '').trim();
+        const todayBoundary = (0, _dayjs.default)(`${now.format('YYYY-MM-DD')} ${boundaryTime}`);
+        if (todayBoundary.isValid()) {
+          const startAt = now.isBefore(todayBoundary) ? todayBoundary.subtract(1, 'day') : todayBoundary;
+          return {
+            startAt,
+            endExclusiveAt: startAt.add(1, 'day')
+          };
+        }
       }
+    } catch {
+      // 读取营业日配置失败时按自然日兜底，不影响启动。
     }
     const startAt = now.startOf('day');
     return {
@@ -2047,19 +2142,41 @@ class OrderModule extends _BaseModule.BaseModule {
   hasPulledOrdersToday() {
     const lastFullFetchAt = this.getStorageItem(ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY);
     if (!lastFullFetchAt) return false;
+    const currentShopId = this.getCurrentShopId();
+    const lastFullFetchShopId = this.getStorageItem(ORDER_LAST_FULL_FETCH_SHOP_ID_STORAGE_KEY);
+    if (!currentShopId || !lastFullFetchShopId || currentShopId !== lastFullFetchShopId) {
+      return false;
+    }
     const parsed = (0, _dayjs.default)(lastFullFetchAt);
     if (!parsed.isValid()) return false;
-
-    // 按当前拉取窗口判断，而不是自然日判断。
-    // 这样在营业日跨日边界（start_time）场景下也能正确判定是否需要重新拉取。
     const {
       startAt,
       endExclusiveAt
-    } = this.getCurrentPullWindow();
+    } = this.getCurrentOrderCacheWindow();
     return (parsed.isAfter(startAt) || parsed.isSame(startAt)) && parsed.isBefore(endExclusiveAt);
   }
   markOrderPulledAtNow() {
+    const currentShopId = this.getCurrentShopId();
+    if (!currentShopId) return;
     this.setStorageItem(ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY, (0, _dayjs.default)().format('YYYY-MM-DD HH:mm:ss'));
+    this.setStorageItem(ORDER_LAST_FULL_FETCH_SHOP_ID_STORAGE_KEY, currentShopId);
+  }
+  clearOrderSnapshotMarker() {
+    this.setStorageItem(ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY, '');
+    this.setStorageItem(ORDER_LAST_FULL_FETCH_SHOP_ID_STORAGE_KEY, '');
+  }
+  getCurrentShopId() {
+    try {
+      const appPlugin = this.core.getPlugin('app');
+      const app = appPlugin?.getApp();
+      if (!app) return null;
+      const coreData = app.data.store.getStore().getDataByModel('core');
+      const shopId = coreData?.core?.id;
+      if (shopId === undefined || shopId === null || shopId === '') return null;
+      return String(shopId);
+    } catch {
+      return null;
+    }
   }
   getStorageItem(key) {
     try {
@@ -2085,12 +2202,24 @@ class OrderModule extends _BaseModule.BaseModule {
       // 忽略存储异常，避免影响主流程
     }
   }
-  async loadOrdersFromSQLite() {
+  async loadOrdersFromSQLite(options = {}) {
     if (!this.dbManager) return [];
     try {
+      const loadStartedAt = performance.now();
+      const rawReadStartedAt = performance.now();
       const orders = await this.dbManager.getAll(INDEXDB_STORE_NAME);
-      return (orders || []).map(order => this.normalizeOrderCollectionsForIngress(order, 'loadOrdersFromSQLite'));
-    } catch {
+      const sqliteRawReadMs = +(performance.now() - rawReadStartedAt).toFixed(2);
+      const normalizeStartedAt = performance.now();
+      const normalizedOrders = (orders || []).map(order => this.normalizeOrderCollectionsForIngress(order, 'loadOrdersFromSQLite'));
+      const sqliteNormalizeMs = +(performance.now() - normalizeStartedAt).toFixed(2);
+      options.onTiming?.({
+        sqliteRawReadMs,
+        sqliteNormalizeMs,
+        sqliteLoadTotalMs: +(performance.now() - loadStartedAt).toFixed(2)
+      });
+      return normalizedOrders;
+    } catch (error) {
+      if (options.throwOnError) throw error;
       return [];
     }
   }
@@ -2323,14 +2452,18 @@ class OrderModule extends _BaseModule.BaseModule {
    * 用于 SSE 全量拉取与营业日窗口裁剪。
    *
    * @example
-   * await this.replaceOrdersSnapshotInSQLite(orderList)
+   * const { orders, persisted } = await this.replaceOrdersSnapshotInSQLite(orderList, 'refresh')
    */
   async replaceOrdersSnapshotInSQLite(orderList, source, protectedOrdersBeforeRemoteFetch = []) {
     if (!this.dbManager) {
-      return this.compactOrderListByIdentity(orderList.map(order => this.normalizeRemoteSyncedOrder(order)), `${source}.snapshotNoDb`).list;
+      return {
+        orders: this.compactOrderListByIdentity(orderList.map(order => this.normalizeRemoteSyncedOrder(order)), `${source}.snapshotNoDb`).list,
+        persisted: false
+      };
     }
     const remoteSnapshot = (0, _lodashEs.cloneDeep)(orderList).map(order => this.normalizeOrderCollectionsForIngress(order, `${source}.remoteIngress`));
     let mergedSnapshot = this.compactOrderListByIdentity(remoteSnapshot.map(order => this.normalizeRemoteSyncedOrder(order)), `${source}.remoteSnapshot`).list;
+    let persisted = false;
     try {
       await this.runInOrderSQLiteSaveQueue(async () => {
         const existingOrders = typeof this.dbManager.getAll === 'function' ? await this.dbManager.getAll(INDEXDB_STORE_NAME) : [];
@@ -2379,13 +2512,17 @@ class OrderModule extends _BaseModule.BaseModule {
           count: mergedSnapshot.length
         });
       });
+      persisted = true;
     } catch (error) {
       this.logError('全量保存订单到 SQLite 失败', {
         error: error instanceof Error ? error.message : String(error),
         orderList: remoteSnapshot.length
       });
     }
-    return mergedSnapshot;
+    return {
+      orders: mergedSnapshot,
+      persisted
+    };
   }
 
   /**
@@ -2402,7 +2539,7 @@ class OrderModule extends _BaseModule.BaseModule {
         await this.dbManager.clear(INDEXDB_STORE_NAME);
       });
     }
-    this.setStorageItem(ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY, '');
+    this.clearOrderSnapshotMarker();
     this.emitOrdersChanged([], 'clear');
   }
 }

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

@@ -25,6 +25,7 @@ export declare class ProductsModule extends BaseModule implements Module {
     private quotationBridgeLoadedKey?;
     private quotationBridgeRefreshPromise?;
     private quotationBridgeRefreshKey?;
+    private quotationBridgeUpdatedCallback?;
     private quotationScheduleCache;
     private quotationScheduleCacheSource;
     private quotationScheduleCacheLoaded;
@@ -72,6 +73,7 @@ export declare class ProductsModule extends BaseModule implements Module {
         scheduleModule?: any;
         channel?: string;
         customer_id?: number | string;
+        onQuotationUpdated?: () => void;
     }): Promise<void>;
     /**
      * 刷新桥接器内的报价单列表。
@@ -87,8 +89,8 @@ export declare class ProductsModule extends BaseModule implements Module {
     private buildBundleGroupPriceData;
     /**
      * 获取应用了价格的商品列表（带缓存）
-     * 使用日期作为缓存 key，同一天的商品价格会被缓存
-     * 缓存的是已经应用了价格的完整商品列表，避免重复转换
+     * 使用时间、客户、策略、商品范围和语言作为缓存 key
+     * 缓存的是已经应用了价格与多语言的完整商品列表，避免重复转换
      * @param schedule_date 日期
      * @param extraContext 额外的上下文数据（可选，由 Server 层传入）
      * @param options 可选参数
@@ -181,7 +183,9 @@ export declare class ProductsModule extends BaseModule implements Module {
     /**
      * 通过 ProductDataSource SSE 加载完整商品列表
      */
-    loadProductsByServer(): Promise<any>;
+    loadProductsByServer(options?: {
+        trigger?: string;
+    }): Promise<any>;
     /**
      * 纯请求方法：通过 HTTP 接口获取商品列表（无副作用，不触发事件、不写 IndexDB）
      * @param params 查询参数
@@ -331,7 +335,9 @@ export declare class ProductsModule extends BaseModule implements Module {
      * 拿到完整数据后一次性替换 store，清除价格缓存，触发 onProductsSyncCompleted
      * @returns 刷新后的商品列表
      */
-    silentRefresh(): Promise<ProductData[]>;
+    silentRefresh(options?: {
+        trigger?: string;
+    }): Promise<ProductData[]>;
     /**
      * 销毁同步资源（取消 pubsub 订阅、清除定时器）
      */