@pisell/pisellos 2.3.30 → 2.3.32

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

@@ -103,7 +103,10 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       this.updateCreateStore();
     }
     if (Array.isArray((_a = options == null ? void 0 : options.initialState) == null ? void 0 : _a.list)) {
-      this.store.list = options.initialState.list.map((order) => this.normalizeOrderForMemoryList(order));
+      this.store.list = this.normalizeOrdersForMemoryList(
+        options.initialState.list,
+        "initialState"
+      );
       this.syncOrdersMap();
       this.emitOrdersChanged([], "initialState");
     } else {
@@ -463,17 +466,11 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     return DEFAULT_ORDER_SYNC_THROTTLE_MS;
   }
   async preload() {
-    const getData = async () => {
-      const orders = await this.loadOrdersByServer();
-      if (orders.length === 0) {
-        return;
-      }
-      this.store.list = (0, import_lodash_es.cloneDeep)(orders);
-      this.syncOrdersMap();
-      this.emitOrdersChanged([], "preload");
-      this.core.effects.emit(import_types.OrderHooks.onOrdersSyncCompleted, null);
-    };
-    getData();
+    const orders = await this.loadOrdersByServer();
+    this.store.list = (0, import_lodash_es.cloneDeep)(orders);
+    this.syncOrdersMap();
+    await this.emitOrdersChanged([], "preload");
+    await this.core.effects.emit(import_types.OrderHooks.onOrdersSyncCompleted, null);
   }
   getOrders() {
     return this.store.list;
@@ -558,7 +555,10 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       }
       return null;
     }
-    this.store.list = orders.map((order) => this.normalizeOrderForMemoryList(order));
+    this.store.list = this.normalizeOrdersForMemoryList(
+      orders,
+      "getLocalOrderByLookup.sqliteMemory"
+    );
     this.syncOrdersMap();
     const normalizedOrder = this.normalizeOrderForMemoryList(localOrder);
     if (options.operationId) {
@@ -653,12 +653,13 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     };
     this.logInfo("updateLocalPayment-支付项合并完成", paymentContext);
     const targetIndex = this.findOrderIndexByIdentity(this.store.list, found.order);
-    if (targetIndex < 0) {
+    const shouldKeepInMemory = this.shouldKeepOrderInMemory(nextOrder);
+    if (targetIndex < 0 && shouldKeepInMemory) {
       this.logError("updateLocalPayment-订单Store索引未命中", paymentContext);
       return null;
     }
     const previousList = this.store.list;
-    this.store.list = this.store.list.map((order, index) => index === targetIndex ? nextOrder : order);
+    this.store.list = shouldKeepInMemory ? this.store.list.map((order, index) => index === targetIndex ? nextOrder : order) : this.store.list.filter((_, index) => index !== targetIndex);
     this.syncOrdersMap();
     const storageOrder = this.withoutSyntheticDraftOrderId(nextOrder);
     try {
@@ -681,16 +682,25 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       });
       throw error;
     }
-    await this.emitOrdersChanged([nextOrder], "updateLocalPayment");
+    if (shouldKeepInMemory || targetIndex >= 0) {
+      await this.emitOrdersChanged(
+        shouldKeepInMemory ? [nextOrder] : [],
+        shouldKeepInMemory ? "updateLocalPayment" : "updateLocalPayment.sqliteOnlyDraft"
+      );
+    }
     this.logInfo("updateLocalPayment-变更事件完成", paymentContext);
     return { order: nextOrder, payment: nextPayment, previousPayment };
   }
   async loadOrdersByServer() {
     var _a;
     let orderList = [];
+    const protectedOrdersBeforeRemoteFetch = (await this.loadOrdersFromSQLite()).filter(
+      (order) => this.isPendingSyncOrder(order) || this.isDraftOrder(order)
+    );
     this.logInfo("loadOrdersByServer-开始", {
       hasOrderDataSource: !!this.orderDataSource,
-      query: ((_a = this.store) == null ? void 0 : _a.createdAtQuery) || null
+      query: ((_a = this.store) == null ? void 0 : _a.createdAtQuery) || null,
+      protectedLocalOrderCount: protectedOrdersBeforeRemoteFetch.length
     });
     if (this.orderDataSource) {
       try {
@@ -710,10 +720,19 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         return this.store.list;
       }
     }
-    const mergedOrders = await this.replaceOrdersSnapshotInSQLite(orderList, "loadOrdersByServer");
-    const memoryOrders = mergedOrders.map((order) => this.normalizeOrderForMemoryList(order));
+    const mergedOrders = await this.replaceOrdersSnapshotInSQLite(
+      orderList,
+      "loadOrdersByServer",
+      protectedOrdersBeforeRemoteFetch
+    );
+    const memoryOrders = this.normalizeOrdersForMemoryList(
+      mergedOrders,
+      "loadOrdersByServer.memory"
+    );
     this.logInfo("loadOrdersByServer-结束", {
-      count: memoryOrders.length
+      count: memoryOrders.length,
+      persistedCount: mergedOrders.length,
+      sqliteOnlyDraftCount: mergedOrders.length - memoryOrders.length
     });
     await this.core.effects.emit(import_types.OrderHooks.onOrdersLoaded, memoryOrders);
     return memoryOrders;
@@ -733,18 +752,14 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     try {
       this.updateCreateStore();
       const orders = await this.loadOrdersByServer();
-      if (orders.length > 0) {
-        this.store.list = (0, import_lodash_es.cloneDeep)(orders);
-        this.syncOrdersMap();
-        this.emitOrdersChanged([], "silentRefresh");
-        await this.core.effects.emit(import_types.OrderHooks.onOrdersSyncCompleted, null);
-        this.logInfo("silentRefresh 完成", {
-          orderCount: orders.length,
-          duration: `${Date.now() - startTime}ms`
-        });
-      } else {
-        this.logInfo("silentRefresh: 服务器未返回数据");
-      }
+      this.store.list = (0, import_lodash_es.cloneDeep)(orders);
+      this.syncOrdersMap();
+      await this.emitOrdersChanged([], "silentRefresh");
+      await this.core.effects.emit(import_types.OrderHooks.onOrdersSyncCompleted, null);
+      this.logInfo("silentRefresh 完成", {
+        orderCount: orders.length,
+        duration: `${Date.now() - startTime}ms`
+      });
       return this.store.list;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -758,6 +773,9 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   normalizeOrderForMemoryList(order, source = "normalizeOrderForMemoryList") {
     const normalizedOrder = this.normalizeOrderCollectionsForIngress(order, source);
     const externalSaleNumber = normalizedOrder == null ? void 0 : normalizedOrder.external_sale_number;
+    if (this.isDraftOrder(normalizedOrder) && !this.hasRealOrderId(normalizedOrder)) {
+      return normalizedOrder;
+    }
     if ((normalizedOrder == null ? void 0 : normalizedOrder.order_id) !== void 0 && (normalizedOrder == null ? void 0 : normalizedOrder.order_id) !== null && (normalizedOrder == null ? void 0 : normalizedOrder.order_id) !== "") {
       return normalizedOrder;
     }
@@ -769,6 +787,18 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       order_id: externalSaleNumber
     };
   }
+  normalizeOrdersForMemoryList(orders, source) {
+    return orders.map((order) => this.normalizeOrderForMemoryList(order, source)).filter((order) => this.shouldKeepOrderInMemory(order));
+  }
+  hasRealOrderId(order) {
+    if (!order || this.isBlankIdentityValue(order.order_id))
+      return false;
+    const externalSaleNumber = order.external_sale_number;
+    return !(this.isDraftOrder(order) && !this.isBlankIdentityValue(externalSaleNumber) && String(order.order_id) === String(externalSaleNumber));
+  }
+  shouldKeepOrderInMemory(order) {
+    return !this.isDraftOrder(order) || this.hasRealOrderId(order);
+  }
   withoutSyntheticDraftOrderId(order) {
     const externalSaleNumber = order.external_sale_number;
     if (Number(order.is_draft_order || 0) !== 1 || order.order_id === void 0 || externalSaleNumber === void 0 || String(order.order_id) !== String(externalSaleNumber)) {
@@ -984,8 +1014,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     await this.emitOrdersChanged(patchedOrders, "upsertPendingSyncOrders");
   }
   /**
-   * 将 POS 草稿订单按 SQLite storage key 合并进 store 并落库。
-   * 草稿只表示本地可恢复快照，不进入同步队列。
+   * 将 POS 草稿订单按 SQLite storage key 落库。
+   * 只有具备真实 order_id 的草稿进入 store；其余草稿仅供本地恢复查询。
    */
   async upsertLocalDraftOrders(draftOrders) {
     if (!(draftOrders == null ? void 0 : draftOrders.length)) {
@@ -1004,7 +1034,10 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       if (!storageKey)
         continue;
       draftMap.set(storageKey, draftOrder);
-      memoryDraftMap.set(storageKey, this.normalizeOrderForMemoryList(draftOrder));
+      const memoryDraftOrder = this.normalizeOrderForMemoryList(draftOrder);
+      if (this.shouldKeepOrderInMemory(memoryDraftOrder)) {
+        memoryDraftMap.set(storageKey, memoryDraftOrder);
+      }
     }
     if (draftMap.size === 0) {
       this.logError("upsertLocalDraftOrders-订单缺少可落库标识", {
@@ -1012,10 +1045,14 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       });
       return;
     }
-    this.logInfo("upsertLocalDraftOrders-开始", { count: draftMap.size });
+    this.logInfo("upsertLocalDraftOrders-开始", {
+      count: draftMap.size,
+      memoryDraftCount: memoryDraftMap.size,
+      sqliteOnlyDraftCount: draftMap.size - memoryDraftMap.size
+    });
     const patchedOrders = [...draftMap.values()];
     const mergeActions = {};
-    const updatedList = [...this.store.list];
+    const updatedList = this.store.list.filter((order) => this.shouldKeepOrderInMemory(order));
     const identityKeyToIndex = /* @__PURE__ */ new Map();
     for (let index = 0; index < updatedList.length; index += 1) {
       for (const key of this.getOrderIdentityMatchKeys(updatedList[index])) {
@@ -1045,14 +1082,34 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       this.registerOrderIdentityKeys(identityKeyToIndex, draftOrder, insertIndex);
       mergeActions[storageKey] = "insert";
     }
+    const previousList = this.store.list;
     this.store.list = this.runOrderStoreSelfCheck(updatedList, "upsertLocalDraftOrders.store");
     this.syncOrdersMap();
-    await this.patchOrdersInSQLite(patchedOrders, "upsertLocalDraftOrders", mergeActions);
+    try {
+      await this.patchOrdersInSQLite(
+        patchedOrders,
+        "upsertLocalDraftOrders",
+        mergeActions,
+        { throwOnError: true }
+      );
+    } catch (error) {
+      this.store.list = previousList;
+      this.syncOrdersMap();
+      throw error;
+    }
     this.logInfo("upsertLocalDraftOrders-结束", {
       count: patchedOrders.length,
       storeOrderCountAfter: this.store.list.length
     });
-    await this.emitOrdersChanged(patchedOrders, "upsertLocalDraftOrders");
+    const removedLegacyMemoryDraft = previousList.some(
+      (order) => !this.shouldKeepOrderInMemory(order)
+    );
+    if (memoryDraftMap.size > 0 || removedLegacyMemoryDraft) {
+      await this.emitOrdersChanged(
+        patchedOrders.filter((order) => this.shouldKeepOrderInMemory(order)),
+        "upsertLocalDraftOrders"
+      );
+    }
   }
   /**
    * 通过 SSE 按自定义 query 拉取订单（支持 select/with 精简字段）
@@ -1086,6 +1143,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     super.destroy();
   }
   syncOrdersMap() {
+    this.store.list = this.store.list.filter((order) => this.shouldKeepOrderInMemory(order));
     this.store.map.clear();
     for (const order of this.store.list) {
       const primaryIdentity = this.getOrderMapKey(order);
@@ -1924,6 +1982,26 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       is_draft_order: 0
     };
   }
+  mergeRemoteIdentityIntoDraftOrder(draftOrder, remoteOrder) {
+    const merged = {
+      ...this.withoutSyntheticDraftOrderId(draftOrder)
+    };
+    const remote = remoteOrder;
+    for (const field of [
+      "order_id",
+      "order_number",
+      "shop_order_number",
+      "shop_full_order_number"
+    ]) {
+      if (this.isBlankIdentityValue(merged[field]) && !this.isBlankIdentityValue(remote[field])) {
+        merged[field] = remote[field];
+      }
+    }
+    return this.normalizeOrderCollectionsForIngress(
+      merged,
+      "mergeRemoteIdentityIntoDraftOrder"
+    );
+  }
   mergeRemoteSnapshotWithPendingOrders(remoteOrders, existingOrders) {
     const merged = remoteOrders.map((order) => this.normalizeRemoteSyncedOrder(order));
     for (const rawOrder of existingOrders) {
@@ -1936,7 +2014,10 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       const matchIndex = this.findOrderIndexByIdentity(merged, order);
       if (matchIndex >= 0) {
         if (this.isDraftOrder(order)) {
-          merged[matchIndex] = order;
+          merged[matchIndex] = this.mergeRemoteIdentityIntoDraftOrder(
+            order,
+            merged[matchIndex]
+          );
         } else {
           merged[matchIndex] = this.mergeOrderRecords(order, merged[matchIndex]);
         }
@@ -2089,12 +2170,13 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     }
   }
   /**
-   * 全量快照替换 orders 表（clear + bulkAdd），用于 SSE 全量拉取与营业日窗口裁剪。
+   * 全量快照替换 orders 表（clear + bulkAdd），并保留本地 draft / need_sync 订单。
+   * 用于 SSE 全量拉取与营业日窗口裁剪。
    *
    * @example
    * await this.replaceOrdersSnapshotInSQLite(orderList)
    */
-  async replaceOrdersSnapshotInSQLite(orderList, source) {
+  async replaceOrdersSnapshotInSQLite(orderList, source, protectedOrdersBeforeRemoteFetch = []) {
     if (!this.dbManager) {
       return this.compactOrderListByIdentity(
         orderList.map((order) => this.normalizeRemoteSyncedOrder(order)),
@@ -2111,15 +2193,42 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     try {
       await this.runInOrderSQLiteSaveQueue(async () => {
         const existingOrders = typeof this.dbManager.getAll === "function" ? await this.dbManager.getAll(INDEXDB_STORE_NAME) : [];
+        const protectedLocalOrders = protectedOrdersBeforeRemoteFetch.map((order) => this.normalizeOrderCollectionsForIngress(
+          order,
+          `${source}.protectedBeforeRemoteFetch`
+        )).filter((order) => this.isPendingSyncOrder(order) || this.isDraftOrder(order));
+        for (const rawCurrentOrder of existingOrders || []) {
+          const currentOrder = this.normalizeOrderCollectionsForIngress(
+            rawCurrentOrder,
+            `${source}.currentSQLite`
+          );
+          const protectedIndex = this.findOrderIndexByIdentity(
+            protectedLocalOrders,
+            currentOrder
+          );
+          const currentNeedsProtection = this.isPendingSyncOrder(currentOrder) || this.isDraftOrder(currentOrder);
+          if (protectedIndex >= 0) {
+            if (currentNeedsProtection) {
+              protectedLocalOrders[protectedIndex] = currentOrder;
+            } else {
+              protectedLocalOrders.splice(protectedIndex, 1);
+            }
+            continue;
+          }
+          if (currentNeedsProtection)
+            protectedLocalOrders.push(currentOrder);
+        }
         const orderListSnapshot = this.mergeRemoteSnapshotWithPendingOrders(
           remoteSnapshot,
-          existingOrders || []
+          protectedLocalOrders
         );
         mergedSnapshot = this.compactOrderListByIdentity(orderListSnapshot, `${source}.sqliteSnapshot`).list;
         this.logInfo("replaceOrdersSnapshotInSQLite-开始", {
           source,
           count: mergedSnapshot.length,
           remoteCount: remoteSnapshot.length,
+          protectedBeforeRemoteFetchCount: protectedOrdersBeforeRemoteFetch.length,
+          protectedLocalOrderCount: protectedLocalOrders.length,
           preservedLocalUnsyncedCount: mergedSnapshot.length - remoteSnapshot.length
         });
         await this.dbManager.clear(INDEXDB_STORE_NAME);

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

@@ -18,7 +18,8 @@ export declare class ProductsModule extends BaseModule implements Module {
     private productsPriceCache;
     private readonly CACHE_MAX_DAYS;
     private formatters;
-    private isPriceFormatterRegistered;
+    private isBuiltinFormatterRegistered;
+    private isLegacyPriceFormatterEnabled;
     private quotationPriceBridge?;
     private quotationBridgeChannel?;
     private quotationBridgeLoadedKey?;
@@ -36,6 +37,8 @@ export declare class ProductsModule extends BaseModule implements Module {
     private lastPreloadCompletedAtMs;
     /** IndexDB 写入串行队列，避免快照与 patch 并发交错 */
     private productIndexDBSaveQueue;
+    /** 最近一次智能定价评估提取的 schedule 变价时间点（HH:mm），供 Server 订阅定时刷新使用 */
+    private lastScheduleTimePoints;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: any): Promise<void>;
     /**
@@ -108,6 +111,10 @@ export declare class ProductsModule extends BaseModule implements Module {
      */
     private prepareProductsWithPrice;
     private getProductsPriceCacheKey;
+    /**
+     * 稳定序列化策略上下文，避免对象 key 顺序不同导致缓存 key 抖动。
+     */
+    private stringifyStable;
     private normalizeProductIds;
     /**
      * 按轻量范围返回商品 ID，不做 structuredClone。
@@ -122,14 +129,26 @@ export declare class ProductsModule extends BaseModule implements Module {
      */
     private applyFormatters;
     /**
-     * 注册内置的价格格式化器
-     * 这个格式化器负责将价格数据应用到商品上
+     * 注册内置商品格式化器。
+     *
+     * 智能定价默认替代报价单逻辑；报价单 formatter 仅在 enableLegacyPriceFormatter=true 时启用。
      * @private
      */
-    private registerBuiltinPriceFormatter;
+    private registerBuiltinProductFormatters;
+    /**
+     * 是否启用旧报价单价格 formatter。
+     *
+     * 默认关闭，避免报价单逻辑覆盖智能定价结果。
+     */
+    private shouldEnableLegacyPriceFormatter;
+    /**
+     * 返回最近一次 prepareProductsWithPrice / DataVariant 评估提取的变价时间点（HH:mm）。
+     * 供 OS Server 商品 query 订阅定时刷新使用。
+     */
+    getLastScheduleTimePoints(): string[];
     /**
      * 注册商品格式化器
-     * 格式化器会按注册顺序依次执行（内置价格格式化器始终是第一个）
+     * 格式化器会按注册顺序依次执行；legacy 启用时先兜底报价，再由智能定价覆盖。
      * @param formatter 格式化函数
      * @param prepend 是否插入到队列开头（默认 false，追加到末尾）
      * @example
@@ -144,8 +163,8 @@ export declare class ProductsModule extends BaseModule implements Module {
      */
     registerFormatter(formatter: ProductFormatter, prepend?: boolean): void;
     /**
-     * 清空所有格式化器（包括内置价格格式化器）
-     * @param keepBuiltin 是否保留内置价格格式化器（默认 true）
+     * 清空所有格式化器（包括内置智能定价格式化器）
+     * @param keepBuiltin 是否保留内置智能定价格式化器（默认 true）
      */
     clearFormatters(keepBuiltin?: boolean): void;
     /**