@pisell/pisellos 2.2.263 → 2.2.265

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

@@ -37,6 +37,7 @@ var import_dayjs = __toESM(require("dayjs"));
 var import_BaseModule = require("../../../modules/BaseModule");
 var import_orderCollectionIdentity = require("../../../modules/Order/utils/orderCollectionIdentity");
 var import_types = require("./types");
+var import_payment_utils = require("../../../modules/Order/payment-utils");
 var INDEXDB_STORE_NAME = "orders";
 var ORDER_LAST_FULL_FETCH_AT_STORAGE_KEY = "server_order_last_full_fetch_at";
 var ORDER_SYNC_THROTTLE_MS_STORAGE_KEY = "order_sync_throttle_ms";
@@ -46,10 +47,13 @@ var ORDER_SILENT_REFRESH_MIN_INTERVAL_MS = 3e4;
 var ORDER_BUSINESS_WRITE_SOURCES = /* @__PURE__ */ new Set([
   "upsertOrdersFromRemote",
   "upsertPendingSyncOrders",
+  "upsertLocalDraftOrders",
   "overwriteExistingOrder",
-  "markOrderSyncedByExternalSaleNumber"
+  "markOrderSyncedByExternalSaleNumber",
+  "updateLocalPayment"
 ]);
 var ORDER_MERGE_SELF_CHECK = false;
+var PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER = "__pisell_os_pending_payment_without_unique_number__";
 var ORDER_AUTHORITATIVE_COLLECTION_FIELDS = ["products", "bookings", "payments"];
 var ORDER_COLLECTION_KIND_BY_FIELD = {
   products: "product",
@@ -100,7 +104,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 {
@@ -166,7 +173,35 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    * 仅记录计数与订单标识，不输出商品、预约、支付或客户明细。
    */
   normalizeOrderCollectionsForIngress(order, source) {
-    const result = (0, import_orderCollectionIdentity.normalizeOrderCollections)(order);
+    const sourceOrder = (0, import_lodash_es.cloneDeep)(order);
+    const sourceOrderRecord = sourceOrder;
+    if (Array.isArray(sourceOrderRecord.payments)) {
+      sourceOrderRecord.payments = sourceOrderRecord.payments.map((payment) => {
+        if (!(0, import_payment_utils.isPendingOrderPayment)(payment) || (0, import_payment_utils.getOrderPaymentIdentityKeys)(payment).some((key) => key.startsWith("unique_payment_number:"))) {
+          return payment;
+        }
+        return {
+          ...payment,
+          [PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER]: true
+        };
+      });
+    }
+    const result = (0, import_orderCollectionIdentity.normalizeOrderCollections)(sourceOrder);
+    const normalizedOrderRecord = result.order;
+    if (Array.isArray(normalizedOrderRecord.payments)) {
+      normalizedOrderRecord.payments = normalizedOrderRecord.payments.map(
+        (payment) => {
+          if (!(payment == null ? void 0 : payment[PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER]))
+            return payment;
+          const nextPayment = { ...payment };
+          const metadata = { ...nextPayment.metadata || {} };
+          delete metadata.unique_payment_number;
+          delete nextPayment[PENDING_PAYMENT_WITHOUT_UNIQUE_MARKER];
+          nextPayment.metadata = metadata;
+          return nextPayment;
+        }
+      );
+    }
     const kinds = ["product", "booking", "payment"];
     const hasChanges = kinds.some((kind) => {
       const stats = result.stats[kind];
@@ -202,9 +237,16 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   /**
    * incoming 决定权威成员集合；同一持久化行仍从 existing 补齐 incoming 省略的本地展示字段。
    */
-  mergeAuthoritativeOrderCollection(field, existing, incoming, uidRemaps = []) {
+  mergeAuthoritativeOrderCollection(field, existing, incoming, uidRemaps = [], options = {}) {
     const kind = ORDER_COLLECTION_KIND_BY_FIELD[field];
     const existingItems = Array.isArray(existing) ? existing : [];
+    if (field === "payments" && options.preserveIdentifiedPendingPayments) {
+      return (0, import_payment_utils.mergeOrderPaymentListsByIdentity)(
+        existingItems,
+        incoming,
+        { preserveUnmatchedExistingWhen: import_payment_utils.isIdentifiedPendingOrderPayment }
+      );
+    }
     return incoming.map((incomingItem) => {
       const existingItem = existingItems.find(
         (item) => (0, import_orderCollectionIdentity.isSameOrderCollectionItem)(kind, item, incomingItem)
@@ -460,17 +502,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;
@@ -482,6 +518,27 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   getOrderByOrderId(orderId) {
     return this.store.map.get(this.getIdKey(orderId));
   }
+  buildLocalPaymentOrderLogContext(order) {
+    if (!order)
+      return {};
+    return {
+      order_id: order.order_id ?? null,
+      external_sale_number: order.external_sale_number ?? null,
+      order_number: order.order_number ?? null,
+      shop_order_number: order.shop_order_number ?? null,
+      shop_full_order_number: order.shop_full_order_number ?? null,
+      order_status: order.status ?? null,
+      payment_status: order.payment_status ?? null,
+      is_draft_order: Number(order.is_draft_order || 0),
+      need_sync: Number(order.need_sync || 0),
+      platform: order.platform ?? null,
+      business_code: order.business_code ?? null,
+      order_sales_channel: order.order_sales_channel ?? null,
+      sales_channel: order.sales_channel ?? null,
+      order_type: order.type ?? null,
+      payments_count: Array.isArray(order.payments) ? order.payments.length : 0
+    };
+  }
   getLocalOrderFromMemoryByLookup(lookup) {
     const key = this.getIdKey(lookup);
     const memoryOrderById = this.store.map.get(key);
@@ -490,28 +547,200 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     const memoryOrder = this.store.list.find((order) => this.isOrderLookupMatch(order, key));
     return memoryOrder || null;
   }
-  async getLocalOrderByLookup(lookup) {
+  async getLocalOrderByLookup(lookup, options = {}) {
     const key = this.getIdKey(lookup);
+    const logContext = {
+      operation_id: options.operationId,
+      lookup: key,
+      memory_order_count: this.store.list.length
+    };
+    if (options.operationId) {
+      this.logInfo("getLocalOrderByLookup-localPayment-开始", logContext);
+    }
     const memoryOrderById = this.store.map.get(key);
-    if (memoryOrderById)
+    if (memoryOrderById) {
+      if (options.operationId) {
+        this.logInfo("getLocalOrderByLookup-localPayment-命中内存映射", {
+          ...logContext,
+          ...this.buildLocalPaymentOrderLogContext(memoryOrderById)
+        });
+      }
       return memoryOrderById;
+    }
     const memoryOrder = this.store.list.find((order) => this.isOrderLookupMatch(order, key));
-    if (memoryOrder)
+    if (memoryOrder) {
+      if (options.operationId) {
+        this.logInfo("getLocalOrderByLookup-localPayment-命中内存列表", {
+          ...logContext,
+          ...this.buildLocalPaymentOrderLogContext(memoryOrder)
+        });
+      }
       return memoryOrder;
+    }
+    if (options.operationId) {
+      this.logInfo("getLocalOrderByLookup-localPayment-开始读取SQLite", logContext);
+    }
     const orders = await this.loadOrdersFromSQLite();
     const localOrder = orders.find((order) => this.isOrderLookupMatch(order, key));
-    if (!localOrder)
+    if (!localOrder) {
+      if (options.operationId) {
+        this.logWarning("getLocalOrderByLookup-localPayment-SQLite未命中", {
+          ...logContext,
+          sqlite_order_count: orders.length
+        });
+      }
       return null;
-    this.store.list = orders.map((order) => this.normalizeOrderForMemoryList(order));
+    }
+    this.store.list = this.normalizeOrdersForMemoryList(
+      orders,
+      "getLocalOrderByLookup.sqliteMemory"
+    );
     this.syncOrdersMap();
-    return this.normalizeOrderForMemoryList(localOrder);
+    const normalizedOrder = this.normalizeOrderForMemoryList(localOrder);
+    if (options.operationId) {
+      this.logInfo("getLocalOrderByLookup-localPayment-SQLite命中", {
+        ...logContext,
+        sqlite_order_count: orders.length,
+        ...this.buildLocalPaymentOrderLogContext(normalizedOrder)
+      });
+    }
+    return normalizedOrder;
+  }
+  async getLocalPayment(params) {
+    const logContext = {
+      operation_id: params.operationId,
+      sale_id: params.saleId,
+      payment_number: params.paymentNumber
+    };
+    this.logInfo("getLocalPayment-开始", logContext);
+    try {
+      const order = await this.getLocalOrderByLookup(params.saleId, {
+        operationId: params.operationId
+      });
+      if (!order) {
+        this.logWarning("getLocalPayment-订单未命中", logContext);
+        return null;
+      }
+      const payments = order.payments || [];
+      const match = (0, import_payment_utils.resolveOrderPaymentIdentity)(
+        payments,
+        params.paymentNumber,
+        "compat"
+      );
+      if (!match) {
+        this.logWarning("getLocalPayment-支付项未命中", {
+          ...logContext,
+          ...this.buildLocalPaymentOrderLogContext(order),
+          payments
+        });
+        return null;
+      }
+      this.logInfo("getLocalPayment-支付项命中", {
+        ...logContext,
+        ...this.buildLocalPaymentOrderLogContext(order),
+        matched_by: match.matchedBy,
+        payment_index: match.index,
+        payment: match.payment
+      });
+      return {
+        order,
+        payment: match.payment,
+        paymentIndex: match.index,
+        matchedBy: match.matchedBy
+      };
+    } catch (error) {
+      this.logError("getLocalPayment-查询失败", {
+        ...logContext,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async updateLocalPayment(params) {
+    const logContext = {
+      operation_id: params.operationId,
+      sale_id: params.saleId,
+      payment_number: params.paymentNumber,
+      incoming_payment_update: params.updates
+    };
+    this.logInfo("updateLocalPayment-开始", logContext);
+    const found = await this.getLocalPayment(params);
+    if (!found) {
+      this.logWarning("updateLocalPayment-支付项未命中", logContext);
+      return null;
+    }
+    const previousPayment = (0, import_lodash_es.cloneDeep)(found.payment);
+    const nextPayment = (0, import_payment_utils.mergeOrderPaymentRecord)(found.payment, {
+      ...params.updates,
+      updated_at: params.updates.updated_at || (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss")
+    });
+    const nextOrder = {
+      ...found.order,
+      payments: (found.order.payments || []).map((payment, index) => index === found.paymentIndex ? nextPayment : payment),
+      updated_at: (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss")
+    };
+    const paymentContext = {
+      ...logContext,
+      matched_by: found.matchedBy,
+      payment_index: found.paymentIndex,
+      ...this.buildLocalPaymentOrderLogContext(nextOrder),
+      previous_payment: previousPayment,
+      payment: nextPayment
+    };
+    this.logInfo("updateLocalPayment-支付项合并完成", paymentContext);
+    const targetIndex = this.findOrderIndexByIdentity(this.store.list, found.order);
+    const shouldKeepInMemory = this.shouldKeepOrderInMemory(nextOrder);
+    if (targetIndex < 0 && shouldKeepInMemory) {
+      this.logError("updateLocalPayment-订单Store索引未命中", paymentContext);
+      return null;
+    }
+    const previousList = this.store.list;
+    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 {
+      this.logInfo("updateLocalPayment-SQLite写入开始", {
+        ...paymentContext,
+        storage_order_id: storageOrder.order_id ?? null
+      });
+      await this.updateOrderInSQLite(storageOrder, "updateLocalPayment", { throwOnError: true });
+      this.logInfo("updateLocalPayment-SQLite写入完成", {
+        ...paymentContext,
+        storage_order_id: storageOrder.order_id ?? null
+      });
+    } catch (error) {
+      this.store.list = previousList;
+      this.syncOrdersMap();
+      this.logError("updateLocalPayment-SQLite写入失败并回滚内存", {
+        ...paymentContext,
+        storage_order_id: storageOrder.order_id ?? null,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+    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.shouldProtectLocalOrderFromRemoteSnapshot(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,
+      protectedPendingPaymentCount: protectedOrdersBeforeRemoteFetch.reduce(
+        (count, order) => count + this.getIdentifiedPendingPayments(order).length,
+        0
+      )
     });
     if (this.orderDataSource) {
       try {
@@ -531,10 +760,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;
@@ -554,18 +792,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);
@@ -579,6 +813,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;
     }
@@ -590,6 +827,27 @@ 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)) {
+      return order;
+    }
+    const next = { ...order };
+    delete next.order_id;
+    return next;
+  }
   /**
    * 仅覆盖本地已存在的订单；不存在则直接跳过，不落库、不 emit。
    * 适用于"按 order_id 主动刷新本地订单详情"的代理场景。
@@ -638,13 +896,13 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    * 将远端拉取的订单合并进本地 store（已存在则更新，不存在则追加），落库并 emit onOrdersChanged。
    * 供 /update/localOrder 等在「本地尚无该单」时写入新建单。
    */
-  async upsertOrdersFromRemote(freshOrders) {
+  async upsertOrdersFromRemote(freshOrders, source = "upsertOrdersFromRemote") {
     if (!(freshOrders == null ? void 0 : freshOrders.length)) {
       this.logInfo("upsertOrdersFromRemote-订单列表为空", {});
       return;
     }
-    this.logInfo("upsertOrdersFromRemote-开始", { count: freshOrders.length });
-    await this.mergeOrdersToStore(freshOrders, "upsertOrdersFromRemote");
+    this.logInfo("upsertOrdersFromRemote-开始", { count: freshOrders.length, source });
+    await this.mergeOrdersToStore(freshOrders, source);
   }
   async markOrderSyncedByExternalSaleNumber(params) {
     const externalSaleNumber = params.externalSaleNumber;
@@ -670,7 +928,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       ...existing,
       ...params.patch || {},
       external_sale_number: existing.external_sale_number ?? externalSaleNumber,
-      need_sync: 0
+      need_sync: 0,
+      is_draft_order: 0
     });
     const storageKey = this.getOrderStorageKey(nextOrder) || key;
     this.store.list = this.store.list.map((order, index) => {
@@ -695,7 +954,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    * 将本地待同步订单按 SQLite storage key 合并进 store 并落库。
    * checkout 离线兜底可能没有 order_id，但通常会有 external_sale_number。
    */
-  async upsertPendingSyncOrders(pendingOrders) {
+  async upsertPendingSyncOrders(pendingOrders, options = {}) {
     if (!(pendingOrders == null ? void 0 : pendingOrders.length)) {
       this.logInfo("upsertPendingSyncOrders-订单列表为空", {});
       return;
@@ -707,14 +966,19 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         order,
         "upsertPendingSyncOrders.incoming"
       );
-      const storageKey = this.getOrderStorageKey(normalizedOrder);
+      const pendingOrder = {
+        ...normalizedOrder,
+        need_sync: 1,
+        is_draft_order: 0
+      };
+      const storageKey = this.getOrderStorageKey(pendingOrder);
       if (!storageKey)
         continue;
-      pendingMap.set(storageKey, normalizedOrder);
+      pendingMap.set(storageKey, pendingOrder);
       memoryPendingMap.set(
         storageKey,
         this.normalizeOrderForMemoryList(
-          normalizedOrder,
+          pendingOrder,
           "upsertPendingSyncOrders.memory"
         )
       );
@@ -745,7 +1009,12 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       if (matchIndex >= 0) {
         const existingOrder = updatedList[matchIndex];
         const mergedOrder = this.mergeOrderRecords(existingOrder, pendingOrder);
-        updatedList[matchIndex] = mergedOrder;
+        const nextOrder = {
+          ...mergedOrder,
+          need_sync: 1,
+          is_draft_order: 0
+        };
+        updatedList[matchIndex] = nextOrder;
         const pendingSnapshot = pendingMap.get(storageKey);
         if (pendingSnapshot) {
           pendingMap.set(
@@ -753,7 +1022,7 @@ var OrderModule = class extends import_BaseModule.BaseModule {
             this.reconcileOverwriteOrderCollections(existingOrder, pendingSnapshot)
           );
         }
-        this.registerOrderIdentityKeys(identityKeyToIndex, mergedOrder, matchIndex);
+        this.registerOrderIdentityKeys(identityKeyToIndex, nextOrder, matchIndex);
         mergeActions[storageKey] = "update";
         continue;
       }
@@ -763,15 +1032,125 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       mergeActions[storageKey] = "insert";
     }
     const patchedOrders = [...pendingMap.values()];
+    const previousList = this.store.list;
     this.store.list = this.runOrderStoreSelfCheck(updatedList, "upsertPendingSyncOrders.store");
     this.syncOrdersMap();
-    await this.patchOrdersInSQLite(patchedOrders, "upsertPendingSyncOrders", mergeActions);
+    try {
+      await this.patchOrdersInSQLite(
+        patchedOrders,
+        "upsertPendingSyncOrders",
+        mergeActions,
+        options
+      );
+    } catch (error) {
+      this.store.list = previousList;
+      this.syncOrdersMap();
+      throw error;
+    }
     this.logInfo("upsertPendingSyncOrders-结束", {
       count: patchedOrders.length,
       storeOrderCountAfter: this.store.list.length
     });
     await this.emitOrdersChanged(patchedOrders, "upsertPendingSyncOrders");
   }
+  /**
+   * 将 POS 草稿订单按 SQLite storage key 落库。
+   * 只有具备真实 order_id 的草稿进入 store；其余草稿仅供本地恢复查询。
+   */
+  async upsertLocalDraftOrders(draftOrders) {
+    if (!(draftOrders == null ? void 0 : draftOrders.length)) {
+      this.logInfo("upsertLocalDraftOrders-订单列表为空", {});
+      return;
+    }
+    const draftMap = /* @__PURE__ */ new Map();
+    const memoryDraftMap = /* @__PURE__ */ new Map();
+    for (const order of draftOrders) {
+      const draftOrder = {
+        ...order,
+        need_sync: 0,
+        is_draft_order: 1
+      };
+      const storageKey = this.getOrderStorageKey(draftOrder);
+      if (!storageKey)
+        continue;
+      draftMap.set(storageKey, draftOrder);
+      const memoryDraftOrder = this.normalizeOrderForMemoryList(draftOrder);
+      if (this.shouldKeepOrderInMemory(memoryDraftOrder)) {
+        memoryDraftMap.set(storageKey, memoryDraftOrder);
+      }
+    }
+    if (draftMap.size === 0) {
+      this.logError("upsertLocalDraftOrders-订单缺少可落库标识", {
+        count: draftOrders.length
+      });
+      return;
+    }
+    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.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])) {
+        if (!identityKeyToIndex.has(key))
+          identityKeyToIndex.set(key, index);
+      }
+    }
+    for (const [storageKey, draftOrder] of memoryDraftMap.entries()) {
+      const matchIndex = this.lookupOrderIndexByIdentityKeys(
+        identityKeyToIndex,
+        this.getOrderIdentityMatchKeys(draftOrder)
+      );
+      if (matchIndex >= 0) {
+        const mergedOrder = this.mergeOrderRecords(updatedList[matchIndex], draftOrder);
+        const nextOrder = {
+          ...mergedOrder,
+          need_sync: 0,
+          is_draft_order: 1
+        };
+        updatedList[matchIndex] = nextOrder;
+        this.registerOrderIdentityKeys(identityKeyToIndex, nextOrder, matchIndex);
+        mergeActions[storageKey] = "update";
+        continue;
+      }
+      const insertIndex = updatedList.length;
+      updatedList.push(draftOrder);
+      this.registerOrderIdentityKeys(identityKeyToIndex, draftOrder, insertIndex);
+      mergeActions[storageKey] = "insert";
+    }
+    const previousList = this.store.list;
+    this.store.list = this.runOrderStoreSelfCheck(updatedList, "upsertLocalDraftOrders.store");
+    this.syncOrdersMap();
+    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
+    });
+    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 精简字段）
    */
@@ -804,6 +1183,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);
@@ -1126,9 +1506,43 @@ var OrderModule = class extends import_BaseModule.BaseModule {
           });
           continue;
         }
-        const mergedOrder = this.mergeOrderRecords(existingOrder, fresh);
-        updatedList[matchIndex] = mergedOrder;
-        this.registerOrderIdentityKeys(identityKeyToIndex, mergedOrder, matchIndex);
+        if (this.isDraftOrder(existingOrder) && this.shouldProtectDraftOrderFromIncoming(source)) {
+          this.logInfo("mergeOrdersToStore-跳过 draft 订单远端覆盖", {
+            source,
+            order_id: existingOrder.order_id ?? fresh.order_id ?? null,
+            external_sale_number: existingOrder.external_sale_number ?? fresh.external_sale_number ?? null,
+            local_is_draft_order: existingOrder.is_draft_order ?? null,
+            remote_is_draft_order: fresh.is_draft_order ?? null,
+            reason: "protect_draft_order_from_remote_echo"
+          });
+          continue;
+        }
+        let mergedOrder = this.mergeOrderRecords(existingOrder, fresh);
+        let adjustedMatchIndex = matchIndex;
+        const duplicateIndexes = /* @__PURE__ */ new Set();
+        for (const key of freshIdentityKeys) {
+          const duplicateIndex = identityKeyToIndex.get(key);
+          if (duplicateIndex === void 0 || duplicateIndex === matchIndex)
+            continue;
+          duplicateIndexes.add(duplicateIndex);
+        }
+        if (duplicateIndexes.size > 0) {
+          for (const duplicateIndex of [...duplicateIndexes].sort((left, right) => right - left)) {
+            mergedOrder = this.mergeOrderRecords(mergedOrder, updatedList[duplicateIndex]);
+            updatedList.splice(duplicateIndex, 1);
+            if (duplicateIndex < adjustedMatchIndex)
+              adjustedMatchIndex -= 1;
+          }
+          identityKeyToIndex.clear();
+          for (let index = 0; index < updatedList.length; index += 1) {
+            for (const key of this.getOrderIdentityMatchKeys(updatedList[index])) {
+              if (!identityKeyToIndex.has(key))
+                identityKeyToIndex.set(key, index);
+            }
+          }
+        }
+        updatedList[adjustedMatchIndex] = mergedOrder;
+        this.registerOrderIdentityKeys(identityKeyToIndex, mergedOrder, adjustedMatchIndex);
         patchedOrders.push(mergedOrder);
         if (mergeKey)
           mergeActions[mergeKey] = "update";
@@ -1320,6 +1734,72 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       return right;
     return left;
   }
+  getProductIdentityKeys(product) {
+    var _a;
+    const record = product;
+    if (!record)
+      return [];
+    const keys = [];
+    const metadataUid = (_a = record.metadata) == null ? void 0 : _a.unique_identification_number;
+    if (!this.isBlankIdentityValue(metadataUid))
+      keys.push(`uid:${String(metadataUid)}`);
+    const topLevelUid = record.unique_identification_number;
+    if (!this.isBlankIdentityValue(topLevelUid))
+      keys.push(`uid:${String(topLevelUid)}`);
+    const orderDetailId = record.order_detail_id;
+    if (!this.isBlankIdentityValue(orderDetailId))
+      keys.push(`detail:${String(orderDetailId)}`);
+    const bookingUid = record.booking_uid;
+    if (!this.isBlankIdentityValue(bookingUid))
+      keys.push(`booking:${String(bookingUid)}`);
+    return keys;
+  }
+  mergeOrderProductLists(preferred, secondary) {
+    const preferredList = Array.isArray(preferred) ? preferred : [];
+    const secondaryList = Array.isArray(secondary) ? secondary : [];
+    if (secondaryList.length === 0)
+      return preferredList;
+    if (preferredList.length === 0)
+      return secondaryList;
+    const seenKeys = /* @__PURE__ */ new Set();
+    for (const item of preferredList) {
+      const keys = this.getProductIdentityKeys(item);
+      for (const key of keys)
+        seenKeys.add(key);
+    }
+    const result = [...preferredList];
+    for (const item of secondaryList) {
+      const keys = this.getProductIdentityKeys(item);
+      if (keys.length === 0 || keys.some((key) => seenKeys.has(key)))
+        continue;
+      for (const key of keys)
+        seenKeys.add(key);
+      result.push((0, import_lodash_es.cloneDeep)(item));
+    }
+    return result;
+  }
+  mergeOrderPaymentLists(existing, incoming) {
+    const existingList = Array.isArray(existing) ? existing : [];
+    const incomingList = Array.isArray(incoming) ? incoming : [];
+    if (incomingList.length === 0)
+      return (0, import_lodash_es.cloneDeep)(existingList);
+    return (0, import_payment_utils.mergeOrderPaymentListsByIdentity)(existingList, incomingList);
+  }
+  getIdentifiedPendingPayments(order) {
+    const payments = Array.isArray(order == null ? void 0 : order.payments) ? order.payments : [];
+    return payments.filter((payment) => (0, import_payment_utils.isIdentifiedPendingOrderPayment)(payment));
+  }
+  shouldProtectLocalOrderFromRemoteSnapshot(order) {
+    return this.isPendingSyncOrder(order) || this.isDraftOrder(order) || this.getIdentifiedPendingPayments(order).length > 0;
+  }
+  getUnmatchedIdentifiedPendingPayments(existing, incoming) {
+    const existingPayments = Array.isArray(existing) ? existing : [];
+    const incomingPayments = Array.isArray(incoming) ? incoming : [];
+    const incomingIdentityKeys = new Set(
+      incomingPayments.flatMap((payment) => (0, import_payment_utils.getOrderPaymentIdentityKeys)(payment))
+    );
+    return existingPayments.filter((payment) => (0, import_payment_utils.isIdentifiedPendingOrderPayment)(payment) && !(0, import_payment_utils.getOrderPaymentIdentityKeys)(payment).some((key) => incomingIdentityKeys.has(key)));
+  }
   mergeOrderRecords(existing, incoming) {
     const preferred = this.pickPreferredOrder(existing, incoming);
     const secondary = preferred === existing ? incoming : existing;
@@ -1349,7 +1829,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
       "contacts_info",
       "phone",
       "email",
-      "relation_forms"
+      "relation_forms",
+      "is_draft_order"
     ];
     const mergedRecord = merged;
     const preferredRecord = preferred;
@@ -1377,11 +1858,26 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     }
     for (const field of ORDER_AUTHORITATIVE_COLLECTION_FIELDS) {
       if (Array.isArray(incomingRecord[field])) {
+        if (field === "payments") {
+          const preservedPending = this.getUnmatchedIdentifiedPendingPayments(
+            existingRecord[field],
+            incomingRecord[field]
+          );
+          if (preservedPending.length > 0) {
+            this.logInfo("mergeOrderRecords-保留本地 pending 支付项", {
+              order_id: existing.order_id ?? incoming.order_id ?? null,
+              external_sale_number: existingRecord.external_sale_number ?? incomingRecord.external_sale_number ?? null,
+              preserved_pending_count: preservedPending.length,
+              preserved_payment_identities: preservedPending.map((payment) => (0, import_payment_utils.getOrderPaymentIdentityKeys)(payment))
+            });
+          }
+        }
         mergedRecord[field] = this.mergeAuthoritativeOrderCollection(
           field,
           existingRecord[field],
           incomingRecord[field],
-          childUidRemaps
+          childUidRemaps,
+          { preserveIdentifiedPendingPayments: field === "payments" }
         );
         continue;
       }
@@ -1416,7 +1912,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         external_sale_number: order.external_sale_number ?? null,
         shop_order_number: order.shop_order_number ?? null,
         shop_full_order_number: order.shop_full_order_number ?? null,
-        need_sync: order.need_sync ?? null
+        need_sync: order.need_sync ?? null,
+        is_draft_order: order.is_draft_order ?? null
       }))
     }));
   }
@@ -1533,18 +2030,48 @@ var OrderModule = class extends import_BaseModule.BaseModule {
   isPendingSyncOrder(order) {
     return Number(order == null ? void 0 : order.need_sync) === 1;
   }
+  isDraftOrder(order) {
+    return Number(order == null ? void 0 : order.is_draft_order) === 1;
+  }
+  shouldProtectDraftOrderFromIncoming(source) {
+    return source !== "checkoutSync";
+  }
   normalizeRemoteSyncedOrder(order) {
     const normalizedOrder = this.normalizeOrderCollectionsForIngress(
       order,
       "normalizeRemoteSyncedOrder"
     );
     if (this.isPendingSyncOrder(normalizedOrder))
-      return normalizedOrder;
+      return {
+        ...normalizedOrder,
+        is_draft_order: 0
+      };
     return {
       ...normalizedOrder,
-      need_sync: 0
+      need_sync: 0,
+      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) {
@@ -1552,11 +2079,18 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         rawOrder,
         "mergeRemoteSnapshotWithPendingOrders.existingSQLite"
       );
-      if (!this.isPendingSyncOrder(order))
+      if (!this.shouldProtectLocalOrderFromRemoteSnapshot(order))
         continue;
       const matchIndex = this.findOrderIndexByIdentity(merged, order);
       if (matchIndex >= 0) {
-        merged[matchIndex] = this.mergeOrderRecords(order, merged[matchIndex]);
+        if (this.isDraftOrder(order)) {
+          merged[matchIndex] = this.mergeRemoteIdentityIntoDraftOrder(
+            order,
+            merged[matchIndex]
+          );
+        } else {
+          merged[matchIndex] = this.mergeOrderRecords(order, merged[matchIndex]);
+        }
         continue;
       }
       if (!this.getOrderStorageKey(order))
@@ -1584,8 +2118,13 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    * @example
    * await this.patchOrdersInSQLite(freshOrders)
    */
-  async patchOrdersInSQLite(orders, source, mergeActions = {}) {
-    if (!this.dbManager || orders.length === 0) {
+  async patchOrdersInSQLite(orders, source, mergeActions = {}, options = {}) {
+    if (orders.length === 0) {
+      return;
+    }
+    if (!this.dbManager) {
+      if (options.throwOnError)
+        throw new Error("订单 SQLite 数据库未初始化");
       return;
     }
     const ordersSnapshot = (0, import_lodash_es.cloneDeep)(orders).map((order) => this.normalizeOrderCollectionsForIngress(order, `${source}.sqliteIngress`)).filter((order) => this.getOrderStorageKey(order));
@@ -1623,6 +2162,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
           for (const order of compactedToWrite) {
             await this.dbManager.update(INDEXDB_STORE_NAME, order);
           }
+        } else if (options.throwOnError) {
+          throw new Error("订单 SQLite 数据库不支持写入");
         }
         this.recordRecentSqliteWrite(source, compactedToWrite);
         this.logInfo("patchOrdersInSQLite-完成", {
@@ -1637,6 +2178,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         error: error instanceof Error ? error.message : String(error),
         orderCount: ordersSnapshot.length
       });
+      if (options.throwOnError)
+        throw error;
     }
   }
   /**
@@ -1645,8 +2188,15 @@ var OrderModule = class extends import_BaseModule.BaseModule {
    * @example
    * await this.updateOrderInSQLite(freshOrder)
    */
-  async updateOrderInSQLite(order, source) {
-    if (!this.dbManager || !this.getOrderStorageKey(order)) {
+  async updateOrderInSQLite(order, source, options = {}) {
+    if (!this.getOrderStorageKey(order)) {
+      if (options.throwOnError)
+        throw new Error("订单缺少可用的 SQLite 存储主键");
+      return;
+    }
+    if (!this.dbManager) {
+      if (options.throwOnError)
+        throw new Error("订单 SQLite 数据库未初始化");
       return;
     }
     const orderSnapshot = this.normalizeOrderCollectionsForIngress(
@@ -1670,6 +2220,8 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         } else if (typeof this.dbManager.bulkAdd === "function") {
           writeMethod = "bulkAdd";
           await this.dbManager.bulkAdd(INDEXDB_STORE_NAME, [orderSnapshot]);
+        } else if (options.throwOnError) {
+          throw new Error("订单 SQLite 数据库不支持写入");
         }
         this.recordRecentSqliteWrite(source, [orderSnapshot]);
         this.logInfo("updateOrderInSQLite-完成", {
@@ -1683,15 +2235,18 @@ var OrderModule = class extends import_BaseModule.BaseModule {
         error: error instanceof Error ? error.message : String(error),
         orderId: orderSnapshot.order_id ?? null
       });
+      if (options.throwOnError)
+        throw error;
     }
   }
   /**
-   * 全量快照替换 orders 表（clear + bulkAdd），用于 SSE 全量拉取与营业日窗口裁剪。
+   * 全量快照替换 orders 表（clear + bulkAdd），并保留本地 draft / need_sync / pending 支付订单。
+   * 用于 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)),
@@ -1708,16 +2263,52 @@ 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.shouldProtectLocalOrderFromRemoteSnapshot(order));
+        for (const rawCurrentOrder of existingOrders || []) {
+          const currentOrder = this.normalizeOrderCollectionsForIngress(
+            rawCurrentOrder,
+            `${source}.currentSQLite`
+          );
+          const protectedIndex = this.findOrderIndexByIdentity(
+            protectedLocalOrders,
+            currentOrder
+          );
+          const currentNeedsProtection = this.shouldProtectLocalOrderFromRemoteSnapshot(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,
-          preservedPendingCount: mergedSnapshot.length - remoteSnapshot.length
+          protectedBeforeRemoteFetchCount: protectedOrdersBeforeRemoteFetch.length,
+          protectedLocalOrderCount: protectedLocalOrders.length,
+          preservedLocalUnsyncedCount: mergedSnapshot.length - remoteSnapshot.length,
+          protectedPendingPaymentCount: protectedLocalOrders.reduce(
+            (count, order) => count + this.getIdentifiedPendingPayments(order).length,
+            0
+          ),
+          protectedPendingPaymentIdentities: protectedLocalOrders.flatMap((order) => this.getIdentifiedPendingPayments(order).map((payment) => ({
+            order_id: order.order_id ?? null,
+            external_sale_number: order.external_sale_number ?? null,
+            payment_identities: (0, import_payment_utils.getOrderPaymentIdentityKeys)(payment)
+          })))
         });
         await this.dbManager.clear(INDEXDB_STORE_NAME);
         this.logInfo("replaceOrdersSnapshotInSQLite-clear完成", {