@pisell/pisellos 2.2.309 → 2.2.310

package/lib/modules/Rules/types.d.ts

@@ -29,6 +29,10 @@ export interface RulesCalcDiscountOptions {
     discountId?: number;
     selectedList?: SetDiscountSelectedParams[];
     scan?: boolean;
+    /** 本次扫码优先使用的次卡实例；普通重算不传，继续保留商品行当前选择。 */
+    preferredEntitlementPassIds?: number[];
+    /** 普通重算保留商品行已应用的次卡；最优选择传 false 恢复自动排序。 */
+    preserveEntitlementSelection?: boolean;
     /** Change time 重报价目标行：允许已选编辑态折扣卡重新应用到这些 booking 商品。 */
     reapplyBookingDiscountProductUids?: string[];
     /** Reweighed order lines only: reapply selected wallet discounts against their new amount. */

package/lib/server/index.js

@@ -29,6 +29,7 @@ var _BaseSales = require("../solution/BaseSales");
 var _paymentUtils = require("../modules/Order/payment-utils");
 var _salesNotes = require("../modules/Order/salesNotes");
 var _orderCollectionIdentity = require("../modules/Order/utils/orderCollectionIdentity");
+var _osPrivatePayload = require("../utils/os-private-payload");
 var _OpenData = require("../modules/OpenData");
 var _modules = require("./modules");
 Object.keys(_modules).forEach(function (key) {
@@ -643,7 +644,7 @@ class Server {
     } = params;
     const normalizedData = await this.normalizeCheckoutSubmitData(params.data, title);
     const numberedData = await this.ensureCheckoutOrderNumbers(normalizedData, title);
-    const checkoutData = this.normalizeCheckoutCollections(this.applyCheckoutFulfillmentBuzzer(numberedData, title));
+    const checkoutData = this.normalizeCheckoutCollections((0, _osPrivatePayload.stripOsPrivatePayloadFields)(this.applyCheckoutFulfillmentBuzzer(numberedData, title)));
     const remoteCheckoutData = this.buildRemoteCheckoutData(checkoutData, title);
     const deviceHeaders = await this.buildCheckoutDeviceHeaders(title);
     if (!this.app?.request?.post) {
@@ -715,11 +716,9 @@ class Server {
     return next;
   }
   buildRemoteCheckoutData(data, title) {
-    const next = (0, _lodashEs.cloneDeep)(this.omitCheckoutSyncMode(data));
+    const next = (0, _osPrivatePayload.stripOsPrivatePayloadFields)(this.omitCheckoutSyncMode(data));
     if (!next || typeof next !== 'object') return next;
     const record = next;
-    delete record[OS_FULFILLMENT_REF_MODE_FIELD];
-    delete record[OS_INVOICE_LAYOUT_CONFIG_FIELD];
     this.applyKioskCheckoutOperator(record);
     if (!Array.isArray(record.payments)) return next;
     const originalPayments = record.payments;
@@ -1297,6 +1296,10 @@ class Server {
       method: 'get',
       path: '/shop/pay/custom-payment/all',
       handler: this.handlePaymentMethods.bind(this)
+    }, {
+      method: 'get',
+      path: '/pay/custom-payment/all',
+      handler: this.handlePaymentMethods.bind(this)
     }, {
       method: 'get',
       path: '/shop/quotation/available',
@@ -4330,7 +4333,7 @@ class Server {
     }
     const normalizedData = await this.normalizeCheckoutSubmitData(data, title);
     const numberedData = await this.ensureCheckoutOrderNumbers(normalizedData, title);
-    const checkoutData = this.normalizeCheckoutCollections(this.applyCheckoutFulfillmentBuzzer(numberedData, title));
+    const checkoutData = this.normalizeCheckoutCollections((0, _osPrivatePayload.stripOsPrivatePayloadFields)(this.applyCheckoutFulfillmentBuzzer(numberedData, title)));
     const pendingResult = await this.handlePendingSyncCheckoutOrder({
       backendPath,
       data: checkoutData,

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

@@ -2036,6 +2036,12 @@ class OrderModule extends _BaseModule.BaseModule {
       mergedRecord[field] = (0, _lodashEs.cloneDeep)(incomingRecord[field]);
     }
 
+    // order_meta_list 是一次性生成的完整业务快照。incoming 明确携带时
+    // 必须整体覆盖（包括 null / 空对象 / 空数组）；省略时才保留 existing。
+    if (Object.prototype.hasOwnProperty.call(incomingRecord, 'order_meta_list')) {
+      mergedRecord.order_meta_list = (0, _lodashEs.cloneDeep)(incomingRecord.order_meta_list);
+    }
+
     // 子项数组遵循完整快照语义：incoming 自有且为数组（包括 []）时权威替换；
     // 字段缺席或不是数组时视为稀疏 patch，继续保留 existing。
     for (const field of ORDER_AUTHORITATIVE_COLLECTION_FIELDS) {

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

@@ -36,6 +36,8 @@ export type OrderSurchargeType = string;
 export interface OrderProductDiscountMetadata {
     /** 设备端本地唯一标识，用于与服务端记录对齐 */
     unique_identification_number?: string;
+    /** 月卡扣除本单新增使用后的剩余次数；不限次数时为 null。 */
+    balance?: number | null;
     [key: string]: unknown;
 }
 /**
@@ -452,10 +454,20 @@ export interface OrderData {
             id: number | string;
             tag: 'point_card';
             product_id?: number | string;
+            code?: string;
             product_name: string;
             par_value: string;
             used_par_value: string;
         }>;
+        virtual_currency_snapshot?: Array<{
+            id: number | string;
+            tag: 'virtual_currency';
+            product_id?: number | string;
+            product_name: string;
+            par_value: string;
+            used_par_value: string;
+            name: Record<string, string>;
+        }>;
     };
     /**
      * 金额汇总（仅输出）。

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

@@ -7,22 +7,41 @@ export declare class PaymentServerModule extends BaseModule implements Module {
     private request;
     private app;
     private logger;
+    private dbManager;
     private store;
-    private payMethodMemoryCache;
-    private payMethodListInFlight;
+    private paymentDataSource;
+    private initialLoadInFlight;
+    private refreshInFlight;
+    private hasLoadedPayMethods;
+    private hasEmittedLoaded;
+    private syncTimer;
+    private pendingMessageUuids;
+    private queuedTrailingRefresh;
+    private trailingMessageUuids;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options?: ModuleOptions): Promise<void>;
+    preload(): Promise<void>;
     getPayMethodListAsync(options?: {
         shouldFilter?: boolean;
     }): Promise<PaymentMethod[]>;
-    clearPayMethodCache(): void;
-    private loadPayMethodListAsync;
+    private ensureInitialPayMethods;
+    private initPaymentDataSource;
+    private setupPaymentMethodSync;
+    private schedulePaymentMethodRefresh;
+    private refreshPayMethodsSingleFlight;
+    private performRemoteRefresh;
     private fetchRemotePayMethods;
-    private shouldFilterPayMethods;
+    private loadPayMethodsFromSQLite;
+    private replacePayMethodsInSQLite;
+    private resolveCurrentShopScope;
+    private stripSnapshotFields;
+    private arePayMethodsEqual;
     private resolvePayMethods;
     private filterPayMethods;
-    private setPayMethodCache;
+    private setPayMethodMirror;
+    private getErrorMessage;
     private logInfo;
     private logWarning;
     private logError;
+    destroy(): void;
 }

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

@@ -5,18 +5,33 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PaymentServerModule = void 0;
 var _BaseModule = require("../../../modules/BaseModule");
+var _lodashEs = require("lodash-es");
 const WALLET_PASS_CODE = 'WALLET_PASS';
 const WALLET_DEPENDENT_CODES = new Set(['PRODUCTVOUCHER', 'GIFTCARD', 'POINTCARD']);
 const PAYMENT_METHODS_LOADED_EVENT = 'payment:onPaymentMethodsLoaded';
+const PAYMENT_METHODS_CHANGED_EVENT = 'payment:onPaymentMethodsChanged';
+const PAYMENT_METHOD_STORE_NAME = 'pay_method';
+const CUSTOM_PAYMENT_MODULE = 'custom_payment';
+const PAYMENT_METHOD_SYNC_DEBOUNCE_MS = 500;
+const SNAPSHOT_ORDER_FIELD = '__payment_snapshot_order';
+const SNAPSHOT_SHOP_ID_FIELD = '__payment_snapshot_shop_id';
 class PaymentServerModule extends _BaseModule.BaseModule {
   defaultName = 'payment';
   defaultVersion = '1.0.0';
   request;
   app;
   logger;
+  dbManager;
   store;
-  payMethodMemoryCache = null;
-  payMethodListInFlight = null;
+  paymentDataSource;
+  initialLoadInFlight = null;
+  refreshInFlight = null;
+  hasLoadedPayMethods = false;
+  hasEmittedLoaded = false;
+  syncTimer;
+  pendingMessageUuids = new Set();
+  queuedTrailingRefresh = false;
+  trailingMessageUuids = new Set();
   constructor(name, version) {
     super(name || 'payment', version);
   }
@@ -31,78 +46,327 @@ class PaymentServerModule extends _BaseModule.BaseModule {
     const appPlugin = core.getPlugin('app');
     this.app = appPlugin?.getApp();
     this.logger = this.app?.logger;
+    this.dbManager = this.app?.sqlite;
     if (!this.request && !this.app?.request) {
       throw new Error('PaymentServerModule 需要 request 插件或 app.request 支持');
     }
+    this.initPaymentDataSource();
+    this.setupPaymentMethodSync();
     this.logInfo('PaymentServerModule initialized successfully', {
-      hasAppRequest: !!this.app?.request
+      hasAppRequest: !!this.app?.request,
+      hasSQLite: !!this.dbManager,
+      hasPaymentDataSource: !!this.paymentDataSource
     });
   }
-
-  // getRoutes(): RouteDefinition[] {
-  //   return [
-  //     {
-  //       method: 'get',
-  //       path: '/pay/custom-payment/all',
-  //       handler: async ({ data, config }) => {
-  //         const payMethods = await this.getPayMethodListAsync({
-  //           shouldFilter: this.shouldFilterPayMethods(data, config),
-  //         });
-  //         return {
-  //           code: 200,
-  //           status: true,
-  //           data: payMethods,
-  //         };
-  //       },
-  //     },
-  //   ];
-  // }
-
+  async preload() {
+    try {
+      await this.ensureInitialPayMethods('preload');
+    } catch (error) {
+      this.logError('preload 支付方式失败，保持空列表并允许后续读取重试', {
+        error: this.getErrorMessage(error)
+      });
+    }
+  }
   async getPayMethodListAsync(options = {}) {
-    this.logInfo('Starting getPayMethodListAsync');
-    if (this.payMethodMemoryCache?.length) {
-      return this.resolvePayMethods(this.payMethodMemoryCache, options);
+    this.logInfo('Starting getPayMethodListAsync', {
+      hasLoadedPayMethods: this.hasLoadedPayMethods,
+      cachedCount: this.store.payMethods.length
+    });
+    if (!this.hasLoadedPayMethods) {
+      try {
+        await this.ensureInitialPayMethods('route');
+      } catch (error) {
+        this.logError('getPayMethodListAsync 初始化失败', {
+          error: this.getErrorMessage(error)
+        });
+      }
+    } else if (!this.paymentDataSource) {
+      try {
+        await this.refreshPayMethodsSingleFlight({
+          trigger: 'compat.route',
+          emitChanged: false
+        });
+      } catch (error) {
+        this.logWarning('兼容模式远端刷新失败，保留当前运行态快照', {
+          error: this.getErrorMessage(error)
+        });
+      }
     }
-    if (this.payMethodListInFlight) {
-      const payMethods = await this.payMethodListInFlight;
-      return this.resolvePayMethods(payMethods, options);
+    return this.resolvePayMethods(this.store.payMethods, options);
+  }
+  async ensureInitialPayMethods(trigger) {
+    if (this.hasLoadedPayMethods) return this.store.payMethods;
+    if (this.initialLoadInFlight) return this.initialLoadInFlight;
+    this.initialLoadInFlight = (async () => {
+      const localSnapshot = await this.loadPayMethodsFromSQLite();
+      if (localSnapshot.available) {
+        this.setPayMethodMirror(localSnapshot.methods);
+        this.logInfo('从 SQLite 加载支付方式兜底快照', {
+          trigger,
+          count: localSnapshot.methods.length,
+          shopScope: this.resolveCurrentShopScope(localSnapshot.methods)
+        });
+      }
+      try {
+        await this.refreshPayMethodsSingleFlight({
+          trigger,
+          emitChanged: false
+        });
+        this.hasLoadedPayMethods = true;
+      } catch (error) {
+        if (!localSnapshot.available) throw error;
+        this.hasLoadedPayMethods = true;
+        this.logWarning('远端刷新失败，继续使用 SQLite 支付方式快照', {
+          trigger,
+          count: localSnapshot.methods.length,
+          error: this.getErrorMessage(error)
+        });
+      }
+      if (!this.hasEmittedLoaded) {
+        this.hasEmittedLoaded = true;
+        await this.core.effects.emit(PAYMENT_METHODS_LOADED_EVENT, this.store.payMethods);
+      }
+      return this.store.payMethods;
+    })().finally(() => {
+      this.initialLoadInFlight = null;
+    });
+    return this.initialLoadInFlight;
+  }
+  initPaymentDataSource() {
+    const PaymentDataSourceClass = this.core.serverOptions?.All_DATA_SOURCES?.PaymentDataSource;
+    if (!PaymentDataSourceClass) {
+      this.logWarning('PaymentDataSource 不可用，使用无本地持久化的兼容模式');
+      return;
     }
-    this.payMethodListInFlight = this.loadPayMethodListAsync().finally(() => {
-      this.payMethodListInFlight = null;
+    this.paymentDataSource = new PaymentDataSourceClass();
+  }
+  setupPaymentMethodSync() {
+    if (!this.paymentDataSource) return;
+    this.paymentDataSource.run({
+      pubsub: {
+        callback: res => {
+          const message = res?.data || res;
+          if (!message || message.module !== CUSTOM_PAYMENT_MODULE) return;
+          const messageUuid = String(message.message_uuid || '').trim();
+          if (messageUuid) this.pendingMessageUuids.add(messageUuid);
+          this.logInfo('收到 custom_payment Ably 消息，等待全量刷新', {
+            message_uuid: messageUuid || undefined,
+            action: message.action,
+            operation: message.operation
+          });
+          this.schedulePaymentMethodRefresh();
+        }
+      }
+    }).catch(error => {
+      this.logError('建立 custom_payment pubsub 订阅失败', {
+        error: this.getErrorMessage(error)
+      });
     });
-    const payMethods = await this.payMethodListInFlight;
-    return this.resolvePayMethods(payMethods, options);
   }
-  clearPayMethodCache() {
-    this.payMethodMemoryCache = null;
-    this.store.payMethods = [];
+  schedulePaymentMethodRefresh() {
+    if (this.syncTimer) clearTimeout(this.syncTimer);
+    this.syncTimer = setTimeout(() => {
+      this.syncTimer = undefined;
+      const messageUuids = [...this.pendingMessageUuids];
+      this.pendingMessageUuids.clear();
+      void this.refreshPayMethodsSingleFlight({
+        trigger: 'ably',
+        emitChanged: true,
+        messageUuids
+      }).catch(error => {
+        this.logError('custom_payment Ably 全量刷新失败，保留旧快照', {
+          message_uuids: messageUuids,
+          error: this.getErrorMessage(error)
+        });
+      });
+    }, PAYMENT_METHOD_SYNC_DEBOUNCE_MS);
   }
-  async loadPayMethodListAsync() {
+  async refreshPayMethodsSingleFlight(context) {
+    if (this.refreshInFlight) {
+      if (context.trigger.startsWith('ably')) {
+        this.queuedTrailingRefresh = true;
+        context.messageUuids?.forEach(uuid => this.trailingMessageUuids.add(uuid));
+        this.logInfo('支付方式刷新进行中，已排队一次尾随刷新', {
+          trigger: context.trigger,
+          message_uuids: context.messageUuids || []
+        });
+      }
+      return this.refreshInFlight;
+    }
+    const refreshTask = this.performRemoteRefresh(context);
+    this.refreshInFlight = refreshTask;
     try {
-      const payMethods = await this.fetchRemotePayMethods();
-      this.setPayMethodCache(payMethods);
-      await this.core.effects.emit(PAYMENT_METHODS_LOADED_EVENT, payMethods);
-      this.logInfo('getPayMethodListAsync completed successfully', {
-        payMethods
+      return await refreshTask;
+    } finally {
+      if (this.refreshInFlight === refreshTask) this.refreshInFlight = null;
+      if (this.queuedTrailingRefresh) {
+        this.queuedTrailingRefresh = false;
+        const messageUuids = [...this.trailingMessageUuids];
+        this.trailingMessageUuids.clear();
+        void this.refreshPayMethodsSingleFlight({
+          trigger: 'ably.trailing',
+          emitChanged: true,
+          messageUuids
+        }).catch(error => {
+          this.logError('custom_payment 尾随刷新失败，保留当前快照', {
+            message_uuids: messageUuids,
+            error: this.getErrorMessage(error)
+          });
+        });
+      }
+    }
+  }
+  async performRemoteRefresh(context) {
+    const oldMethods = this.store.payMethods;
+    const payMethods = await this.fetchRemotePayMethods();
+    const persisted = await this.replacePayMethodsInSQLite(payMethods);
+    if (!persisted) {
+      this.logWarning('SQLite 不可用，支付方式仅用于当前运行时', {
+        trigger: context.trigger,
+        count: payMethods.length
       });
-      return payMethods;
-    } catch (error) {
-      console.error('[PaymentServerModule] 获取支付方式列表失败', error);
-      this.logError('getPayMethodListAsync failed', error);
-      return [];
     }
+    this.setPayMethodMirror(payMethods);
+    this.hasLoadedPayMethods = true;
+    const changed = !this.arePayMethodsEqual(oldMethods, payMethods);
+    if (context.emitChanged && changed) {
+      await this.core.effects.emit(PAYMENT_METHODS_CHANGED_EVENT, {
+        oldMethods,
+        newMethods: this.store.payMethods
+      });
+    }
+    this.logInfo('远端支付方式全量刷新成功', {
+      trigger: context.trigger,
+      message_uuids: context.messageUuids || [],
+      count: payMethods.length,
+      persisted,
+      changed
+    });
+    return this.store.payMethods;
   }
   async fetchRemotePayMethods() {
-    const requester = this.app?.request || this.request;
-    const response = await requester.get('/shop/pay/custom-payment/all', undefined);
-    const payMethods = response?.data || response || [];
-    return Array.isArray(payMethods) ? payMethods : [];
+    const response = this.paymentDataSource ? await this.paymentDataSource.run({
+      http: {
+        url: '/shop/pay/custom-payment/all'
+      }
+    }) : await (this.app?.request || this.request).get('/shop/pay/custom-payment/all', undefined);
+    const payMethods = response?.data !== undefined ? response.data : response;
+    if (!Array.isArray(payMethods)) {
+      throw new Error('支付方式全量接口返回值不是数组');
+    }
+    if (payMethods.some(method => !method || method.id === undefined || method.id === null)) {
+      throw new Error('支付方式全量接口存在缺少 id 的记录');
+    }
+    return payMethods;
+  }
+  async loadPayMethodsFromSQLite() {
+    if (!this.dbManager) return {
+      available: false,
+      methods: []
+    };
+    try {
+      const rows = await this.dbManager.getAll(PAYMENT_METHOD_STORE_NAME);
+      if (!Array.isArray(rows) || rows.length === 0) {
+        return {
+          available: false,
+          methods: []
+        };
+      }
+      const currentShopScope = this.resolveCurrentShopScope();
+      if (!currentShopScope) {
+        this.logWarning('无法确认当前店铺，忽略 SQLite 支付方式快照');
+        return {
+          available: false,
+          methods: []
+        };
+      }
+      const scopedRows = rows.filter(row => String(row?.[SNAPSHOT_SHOP_ID_FIELD] || '') === currentShopScope);
+      if (scopedRows.length === 0) {
+        this.logWarning('忽略其他店铺的 SQLite 支付方式快照', {
+          currentShopScope,
+          storedShopScopes: [...new Set(rows.map(row => String(row?.[SNAPSHOT_SHOP_ID_FIELD] || '')).filter(Boolean))]
+        });
+        return {
+          available: false,
+          methods: []
+        };
+      }
+      const methods = scopedRows.slice().sort((left, right) => Number(left?.[SNAPSHOT_ORDER_FIELD] || 0) - Number(right?.[SNAPSHOT_ORDER_FIELD] || 0)).map(row => this.stripSnapshotFields(row));
+      return {
+        available: true,
+        methods
+      };
+    } catch (error) {
+      this.logWarning('从 SQLite 读取支付方式失败', {
+        error: this.getErrorMessage(error)
+      });
+      return {
+        available: false,
+        methods: []
+      };
+    }
+  }
+  async replacePayMethodsInSQLite(payMethods) {
+    if (!this.dbManager) return false;
+    const previousRows = await this.dbManager.getAll(PAYMENT_METHOD_STORE_NAME);
+    const shopScope = this.resolveCurrentShopScope(payMethods);
+    const snapshotRows = payMethods.map((method, index) => ({
+      ...method,
+      [SNAPSHOT_ORDER_FIELD]: index,
+      [SNAPSHOT_SHOP_ID_FIELD]: shopScope
+    }));
+    try {
+      await this.dbManager.clear(PAYMENT_METHOD_STORE_NAME);
+      if (snapshotRows.length > 0) {
+        await this.dbManager.bulkAdd(PAYMENT_METHOD_STORE_NAME, snapshotRows);
+      }
+      return true;
+    } catch (error) {
+      const writeError = this.getErrorMessage(error);
+      try {
+        await this.dbManager.clear(PAYMENT_METHOD_STORE_NAME);
+        if (Array.isArray(previousRows) && previousRows.length > 0) {
+          await this.dbManager.bulkAdd(PAYMENT_METHOD_STORE_NAME, previousRows);
+        }
+      } catch (rollbackError) {
+        this.logError('支付方式 SQLite 快照回滚失败', {
+          writeError,
+          rollbackError: this.getErrorMessage(rollbackError)
+        });
+      }
+      throw new Error(`支付方式 SQLite 全量替换失败: ${writeError}`);
+    }
+  }
+  resolveCurrentShopScope(payMethods = []) {
+    const readStorageObject = key => {
+      try {
+        const raw = this.app?.storage?.getStorage?.(key);
+        if (!raw) return {};
+        if (typeof raw === 'object') return raw;
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+      } catch {
+        return {};
+      }
+    };
+    const selectedStore = readStorageObject('selectedStore');
+    const core = readStorageObject('core');
+    const scope = selectedStore.id ?? selectedStore.shop_id ?? core.id ?? core.shop_id ?? payMethods.find(method => method?.shop_id != null)?.shop_id;
+    return scope === undefined || scope === null ? '' : String(scope);
+  }
+  stripSnapshotFields(row) {
+    const {
+      [SNAPSHOT_ORDER_FIELD]: _snapshotOrder,
+      [SNAPSHOT_SHOP_ID_FIELD]: _snapshotShopId,
+      ...method
+    } = row;
+    return method;
   }
-  shouldFilterPayMethods(data, config) {
-    return data?.filterPaymentMethods === true || config?.filterPaymentMethods === true;
+  arePayMethodsEqual(left, right) {
+    return (0, _lodashEs.isEqual)(left, right);
   }
   resolvePayMethods(payMethods, options) {
-    if (!options.shouldFilter) return payMethods;
+    if (!options.shouldFilter) return [...payMethods];
     return this.filterPayMethods(payMethods);
   }
   filterPayMethods(payMethods) {
@@ -121,48 +385,56 @@ class PaymentServerModule extends _BaseModule.BaseModule {
     });
     return availableMethods;
   }
-  setPayMethodCache(payMethods) {
-    this.payMethodMemoryCache = payMethods;
-    this.store.payMethods = payMethods;
+  setPayMethodMirror(payMethods) {
+    this.store.payMethods = payMethods.map(method => ({
+      ...method
+    }));
+  }
+  getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
   }
   logInfo(title, metadata) {
     try {
-      if (this.logger) {
-        this.logger.addLog({
-          type: 'info',
-          title: `[PaymentServerModule] ${title}`,
-          metadata: metadata || {}
-        });
-      }
+      this.logger?.addLog({
+        type: 'info',
+        title: `[PaymentServerModule] ${title}`,
+        metadata: metadata || {}
+      });
     } catch {
       // 日志记录失败不影响主流程
     }
   }
   logWarning(title, metadata) {
     try {
-      if (this.logger) {
-        this.logger.addLog({
-          type: 'warning',
-          title: `[PaymentServerModule] ${title}`,
-          metadata: metadata || {}
-        });
-      }
+      this.logger?.addLog({
+        type: 'warning',
+        title: `[PaymentServerModule] ${title}`,
+        metadata: metadata || {}
+      });
     } catch {
       // 日志记录失败不影响主流程
     }
   }
   logError(title, metadata) {
     try {
-      if (this.logger) {
-        this.logger.addLog({
-          type: 'error',
-          title: `[PaymentServerModule] ${title}`,
-          metadata: metadata || {}
-        });
-      }
+      this.logger?.addLog({
+        type: 'error',
+        title: `[PaymentServerModule] ${title}`,
+        metadata: metadata || {}
+      });
     } catch {
       // 日志记录失败不影响主流程
     }
   }
+  destroy() {
+    if (this.syncTimer) clearTimeout(this.syncTimer);
+    this.syncTimer = undefined;
+    this.pendingMessageUuids.clear();
+    this.trailingMessageUuids.clear();
+    this.queuedTrailingRefresh = false;
+    this.paymentDataSource?.destroy?.();
+    this.paymentDataSource = undefined;
+    super.destroy();
+  }
 }
 exports.PaymentServerModule = PaymentServerModule;