@pisell/pisellos 2.2.315 → 2.2.316

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

@@ -289,6 +289,7 @@ class OrderModule extends _BaseModule.BaseModule {
     const existingRecord = existing;
     const incomingRecord = incoming;
     const uidRemaps = [];
+    this.applyHolderRelationsSnapshot(reconciled, existing, incoming);
     for (const field of ORDER_AUTHORITATIVE_COLLECTION_FIELDS) {
       if (!Array.isArray(incomingRecord[field])) continue;
       reconciled[field] = this.mergeAuthoritativeOrderCollection(field, existingRecord[field], incomingRecord[field], uidRemaps);
@@ -365,7 +366,7 @@ class OrderModule extends _BaseModule.BaseModule {
         continue;
       }
 
-      // 远端商品成员确实发生增删时必须落库，避免内存已更新但 SQLite 仍被回声窗口跳过。
+      // 远端商品成员或 Holder 关系确实变化时必须落库，避免被回声窗口跳过。
       if (forceWriteStorageKeys.has(storageKey)) {
         toWrite.push(order);
         continue;
@@ -1339,6 +1340,7 @@ class OrderModule extends _BaseModule.BaseModule {
       if (matchIndex >= 0) {
         const existingOrder = updatedList[matchIndex];
         const reconciledDraftOrder = this.preserveExistingBusinessCodeForDraft(existingOrder, draftOrder);
+        this.applyHolderRelationsSnapshot(reconciledDraftOrder, existingOrder, draftOrder);
         const mergedOrder = this.mergeOrderRecords(existingOrder, reconciledDraftOrder);
         const nextOrder = {
           ...mergedOrder,
@@ -1617,7 +1619,10 @@ class OrderModule extends _BaseModule.BaseModule {
       const hasSingleId = routeInfo.hasSingleId;
       const normalizedBody = this.normalizeOrderSyncPayload(msg.body || msg.data);
       if (routeInfo.route === 'bodyUpsert' && normalizedBody) {
-        upsertOrders.set(this.getIdKey(normalizedBody.order_id), normalizedBody);
+        const orderKey = this.getIdKey(normalizedBody.order_id);
+        const previousBody = upsertOrders.get(orderKey);
+        if (previousBody) this.applyHolderRelationsSnapshot(normalizedBody, previousBody, normalizedBody);
+        upsertOrders.set(orderKey, normalizedBody);
         return;
       }
       if (hasBatchIds) refreshIds.push(...routeInfo.batchIds);else if (routeInfo.route === 'httpRefresh.singleId' && singleId !== null) refreshIds.push(singleId);else if (routeInfo.route === 'httpRefresh.relationIds') refreshIds.push(...routeInfo.batchIds);
@@ -1810,6 +1815,9 @@ class OrderModule extends _BaseModule.BaseModule {
           const mergedStorageKey = this.getOrderStorageKey(mergedOrder);
           if (mergedStorageKey) forceWriteStorageKeys.add(mergedStorageKey);
         }
+        if (nextStorageKey && !(0, _lodashEs.isEqual)(existingOrder.holder_relations, mergedOrder.holder_relations)) {
+          forceWriteStorageKeys.add(nextStorageKey);
+        }
         // 合并后身份字段可能新增（如挂单拿到 order_id），同步登记到索引，
         // 供同批后续 fresh 命中同一槽位，避免重复插入
         this.registerOrderIdentityKeys(identityKeyToIndex, mergedOrder, adjustedMatchIndex);
@@ -2110,6 +2118,38 @@ class OrderModule extends _BaseModule.BaseModule {
     const incomingIdentityKeys = new Set(incomingPayments.flatMap(payment => (0, _paymentUtils.getOrderPaymentIdentityKeys)(payment)));
     return existingPayments.filter(payment => (0, _paymentUtils.isIdentifiedPendingOrderPayment)(payment) && !(0, _paymentUtils.getOrderPaymentIdentityKeys)(payment).some(key => incomingIdentityKeys.has(key)));
   }
+
+  /** 关系数组是完整快照，不能拼接或按商品子项生成 UID；扩展字段整体保留。 */
+  applyHolderRelationsSnapshot(target, existing, incoming) {
+    if (Array.isArray(incoming.holder_relations)) {
+      target.holder_relations = (0, _lodashEs.cloneDeep)(incoming.holder_relations);
+    } else if (Array.isArray(existing.holder_relations)) {
+      target.holder_relations = (0, _lodashEs.cloneDeep)(existing.holder_relations);
+    } else {
+      delete target.holder_relations;
+    }
+  }
+
+  /** 全量拉取缺少关系字段时，仍保留同一订单已有的关系快照。 */
+  preserveOmittedHolderRelations(incomingOrders, existingOrders) {
+    const existingByIdentity = new Map();
+    for (const order of existingOrders) {
+      if (!Array.isArray(order.holder_relations)) continue;
+      for (const key of this.getOrderIdentityMatchKeys(order)) {
+        existingByIdentity.set(key, order);
+      }
+    }
+    return incomingOrders.map(order => {
+      if (Array.isArray(order.holder_relations)) return order;
+      const existingOrder = this.getOrderIdentityMatchKeys(order).map(key => existingByIdentity.get(key)).find(Boolean);
+      if (!existingOrder) return order;
+      const nextOrder = {
+        ...order
+      };
+      this.applyHolderRelationsSnapshot(nextOrder, existingOrder, order);
+      return nextOrder;
+    });
+  }
   mergeOrderRecords(existing, incoming) {
     const preferred = this.pickPreferredOrder(existing, incoming);
     const secondary = preferred === existing ? incoming : existing;
@@ -2152,6 +2192,7 @@ class OrderModule extends _BaseModule.BaseModule {
     if (Object.prototype.hasOwnProperty.call(incomingRecord, 'order_meta_list')) {
       mergedRecord.order_meta_list = (0, _lodashEs.cloneDeep)(incomingRecord.order_meta_list);
     }
+    this.applyHolderRelationsSnapshot(merged, existing, incoming);
 
     // 子项数组遵循完整快照语义：incoming 自有且为数组（包括 []）时权威替换；
     // 字段缺席或不是数组时视为稀疏 patch，继续保留 existing。
@@ -2593,7 +2634,7 @@ class OrderModule extends _BaseModule.BaseModule {
   async replaceOrdersSnapshotInSQLite(orderList, source, protectedOrdersBeforeRemoteFetch = []) {
     if (!this.dbManager) {
       return {
-        orders: this.compactOrderListByIdentity(orderList.map(order => this.normalizeRemoteSyncedOrder(order)), `${source}.snapshotNoDb`).list,
+        orders: this.compactOrderListByIdentity(this.preserveOmittedHolderRelations(orderList, this.store.list).map(order => this.normalizeRemoteSyncedOrder(order)), `${source}.snapshotNoDb`).list,
         persisted: false
       };
     }
@@ -2603,6 +2644,7 @@ class OrderModule extends _BaseModule.BaseModule {
     try {
       await this.runInOrderSQLiteSaveQueue(async () => {
         const existingOrders = typeof this.dbManager.getAll === 'function' ? await this.dbManager.getAll(INDEXDB_STORE_NAME) : [];
+        const remoteSnapshotWithHolderRelations = this.preserveOmittedHolderRelations(remoteSnapshot, [...protectedOrdersBeforeRemoteFetch, ...(existingOrders || [])]);
         const protectedLocalOrders = protectedOrdersBeforeRemoteFetch.map(order => this.normalizeOrderCollectionsForIngress(order, `${source}.protectedBeforeRemoteFetch`)).filter(order => this.shouldProtectLocalOrderFromRemoteSnapshot(order));
         for (const rawCurrentOrder of existingOrders || []) {
           const currentOrder = this.normalizeOrderCollectionsForIngress(rawCurrentOrder, `${source}.currentSQLite`);
@@ -2618,7 +2660,7 @@ class OrderModule extends _BaseModule.BaseModule {
           }
           if (currentNeedsProtection) protectedLocalOrders.push(currentOrder);
         }
-        const orderListSnapshot = this.mergeRemoteSnapshotWithPendingOrders(remoteSnapshot, protectedLocalOrders);
+        const orderListSnapshot = this.mergeRemoteSnapshotWithPendingOrders(remoteSnapshotWithHolderRelations, protectedLocalOrders);
         mergedSnapshot = this.compactOrderListByIdentity(orderListSnapshot, `${source}.sqliteSnapshot`).list;
         this.logInfo('replaceOrdersSnapshotInSQLite-开始', {
           source,

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

@@ -1,4 +1,5 @@
 import type { ScheduleEventResource } from '../resource/types';
+import type { OrderHolderRelation } from '../../../modules/Order/types';
 /**
  * Order 模块主键类型（对齐标准 Sales 协议的 order_id）
  */
@@ -448,6 +449,8 @@ export interface OrderData {
     contacts_info?: unknown[];
     /** 订单级主体参数 */
     holder?: Record<string, unknown> | null;
+    /** 非预约商品 Holder 关系完整快照；缺席表示本次回包未提供 */
+    holder_relations?: OrderHolderRelation[];
     /** 订单前端扩展快照 */
     order_meta_list?: {
         point_cards_snapshot?: Array<{

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

@@ -3,6 +3,7 @@ import { BaseModule } from '../../../modules/BaseModule';
 import { ProductData } from '../../../modules/Product/types';
 import type { RouteDefinition } from '../../types';
 import { ProductIdScope, type ProductSnapshot, ProductFormatter, ProductFormatterContext } from './types';
+import type { CommittedProducts, ReplicatedProducts } from './types';
 /**
  * Products 模块 - 用于获取和管理完整的商品详细数据
  * 相比 ProductList 模块，Products 会获取所有详细信息并缓存
@@ -40,6 +41,26 @@ export declare class ProductsModule extends BaseModule implements Module {
     private productIndexDBSaveQueue;
     /** 最近一次智能定价评估提取的 schedule 变价时间点（HH:mm），供 Server 订阅定时刷新使用 */
     private lastScheduleTimePoints;
+    private committedProductState?;
+    private productReplicationSourceGeneration;
+    private productPersistenceFailed;
+    private runtimeSyncMode;
+    private runtimeSyncGeneration;
+    private requestReplicaRefresh?;
+    private replicaApplyQueue;
+    private productSyncQueue;
+    private replicaPriceDirtyIds;
+    /** Installed after initial preload; initial cache/network loading stays unchanged. */
+    setRuntimeSyncMode(mode: 'normal' | 'memoryReplica', requestRefresh?: (trigger: string) => Promise<void>): Promise<void>;
+    isMemoryReplica(): boolean;
+    /** Read persisted data once on the main screen to establish a committed baseline. */
+    enableProductReplicationSource(): Promise<void>;
+    /** Release the extra catalog without changing the normal product store or persistence. */
+    disableProductReplicationSource(): void;
+    getCommittedProductSnapshot(): CommittedProducts | null;
+    private recordProductCommit;
+    applyReplicatedProducts(change: ReplicatedProducts): Promise<void>;
+    private refreshFromReplica;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: any): Promise<void>;
     /**
@@ -230,7 +251,10 @@ export declare class ProductsModule extends BaseModule implements Module {
      * 根据 ID 列表删除商品（用于 pubsub 同步删除场景）
      * 同时更新 store.list、store.map、IndexDB 和价格缓存
      */
-    removeProductsByIds(ids: number[]): Promise<void>;
+    removeProductsByIds(ids: number[], options?: {
+        skipIndexDB?: boolean;
+        skipEmit?: boolean;
+    }): Promise<void>;
     /**
      * 重新从服务器加载全量商品列表并更新本地 store
      * 用于 pubsub 同步 create / update / batch_update 场景
@@ -261,13 +285,8 @@ export declare class ProductsModule extends BaseModule implements Module {
      * await this.replaceProductsSnapshotInIndexDB(list, 'loadProductsByServer')
      */
     private replaceProductsSnapshotInIndexDB;
-    /**
-     * 增量 upsert 商品到 IndexDB，不清空表；用于 pubsub 批次合并后的变更商品。
-     *
-     * @example
-     * await this.patchProductsInIndexDB(changedProducts, 'pubsub.processProductSyncMessages', mergeActions)
-     */
     private patchProductsInIndexDB;
+    private persistProductDelta;
     /**
      * 同步更新商品 Map 缓存
      * 将 list 中的商品同步到 map，以 id 为 key
@@ -309,6 +328,7 @@ export declare class ProductsModule extends BaseModule implements Module {
      * Server 层监听该事件后对变更商品增量执行 prepareProductsWithPrice 并更新缓存
      */
     private processProductSyncMessages;
+    private processProductSyncBatch;
     /**
      * 通过 SSE 按 ids 增量拉取商品数据
      * 请求 GET /shop/core/stream?type=product&ids={ids}
@@ -342,6 +362,7 @@ export declare class ProductsModule extends BaseModule implements Module {
      * 销毁同步资源（取消 pubsub 订阅、清除定时器）
      */
     destroyProductSync(): void;
+    destroy(): void;
     /**
      * 获取模块的路由定义
      * Products 模块暂不提供路由，由 Server 层统一处理