@pisell/pisellos 2.2.1 → 2.2.2

package/dist/modules/Payment/index.js

@@ -131,6 +131,10 @@ export var PaymentModule = /*#__PURE__*/function (_BaseModule) {
               return this.ensurePaymentTables();
             case 14:
               this.registerNetworkHandlers();
+
+              // // 预连接数据库
+              // this.dbManager.connect()
+
               console.log('[PaymentModule] 初始化完成');
               this.logInfo('PaymentModule initialized successfully');
             case 17:
@@ -657,7 +661,8 @@ export var PaymentModule = /*#__PURE__*/function (_BaseModule) {
     key: "createPaymentOrderAsync",
     value: (function () {
       var _createPaymentOrderAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(params) {
-        var existingOrder, newOrder;
+        var _this3 = this;
+        var newOrder, dbAddStartTime, dbAddDuration;
         return _regeneratorRuntime().wrap(function _callee7$(_context7) {
           while (1) switch (_context7.prev = _context7.next) {
             case 0:
@@ -666,41 +671,41 @@ export var PaymentModule = /*#__PURE__*/function (_BaseModule) {
                 totalAmount: params.total_amount
               });
               _context7.prev = 1;
-              _context7.next = 4;
-              return this.dbManager.get('order', params.order_id);
-            case 4:
-              existingOrder = _context7.sent;
-              this.logInfo('createPaymentOrderAsync existingOrder', {
-                existingOrder: existingOrder
-              });
+              // 检测是否有重复的 order_id
+              // console.time('createLocalOrderAsync: getExistingOrder')
+              // const existingOrder = await this.dbManager.get('order', params.order_id);
+              // const existingOrders = await this.dbManager.getAll('order');
               // const existingOrder = existingOrders.find(
               //   (order: PaymentOrder) => String(order.id) === String(params.order_id),
               // );
-              if (!existingOrder) {
-                _context7.next = 20;
-                break;
-              }
-              // 如果存在相同 order_id 的订单，更新该订单信息
-              this.logInfo("createPaymentOrderAsync found duplicate order ID: ".concat(params.order_id, ", updating existing payment order"));
-
-              // const originalOrder = { ...existingOrder };
-              existingOrder.order_info = params.order_info;
-              existingOrder.total_amount = params.total_amount;
-              existingOrder.is_deposit = params.is_deposit || 0;
-              existingOrder.deposit_amount = params.deposit_amount || '0.00';
-
-              // 重新计算待付金额
-              this.recalculateOrderAmount(existingOrder);
-
-              // 更新到数据库
-              _context7.next = 15;
-              return this.dbManager.update('order', existingOrder);
-            case 15:
-              _context7.next = 17;
-              return this.core.effects.emit("".concat(this.name, ":onOrderUpdated"), existingOrder);
-            case 17:
-              return _context7.abrupt("return", existingOrder);
-            case 20:
+              // this.logInfo('createPaymentOrderAsync existingOrder', {
+              //   existingOrder
+              // });
+              // console.timeEnd('createLocalOrderAsync: getExistingOrder')
+              // const existingOrder = existingOrders.find(
+              //   (order: PaymentOrder) => String(order.id) === String(params.order_id),
+              // );
+              // if (existingOrder) {
+              //   // 如果存在相同 order_id 的订单，更新该订单信息
+              //   this.logInfo(
+              //     `createPaymentOrderAsync found duplicate order ID: ${params.order_id}, updating existing payment order`,
+              //   );
+              //   // const originalOrder = { ...existingOrder };
+              //   existingOrder.order_info = params.order_info;
+              //   existingOrder.total_amount = params.total_amount;
+              //   existingOrder.is_deposit = params.is_deposit || 0;
+              //   existingOrder.deposit_amount = params.deposit_amount || '0.00';
+              //   // 重新计算待付金额
+              //   this.recalculateOrderAmount(existingOrder);
+              //   // 更新到数据库
+              //   await this.dbManager.update('order', existingOrder);
+              //   // 触发更新事件
+              //   this.core.effects.emit(
+              //     `${this.name}:onOrderUpdated`,
+              //     existingOrder,
+              //   );
+              //   return existingOrder;
+              // } else {
               // 创建新的支付订单
               newOrder = {
                 uuid: getUniqueId('pay_order_'),
@@ -715,32 +720,37 @@ export var PaymentModule = /*#__PURE__*/function (_BaseModule) {
                 tax_fee: '0.00',
                 is_deposit: params.is_deposit || 0,
                 deposit_amount: params.deposit_amount || '0.00'
-              };
-              _context7.next = 23;
+              }; // 🚀 性能监控：记录数据库添加操作耗时
+              dbAddStartTime = Date.now();
+              _context7.next = 6;
               return this.dbManager.add('order', newOrder);
-            case 23:
-              this.core.effects.emit("".concat(this.name, ":onOrderAdded"), newOrder);
-              this.logInfo('createPaymentOrderAsync completed - new payment order created', {
+            case 6:
+              dbAddDuration = Date.now() - dbAddStartTime;
+              this.logInfo('Database add operation completed', {
+                operation: 'dbManager.add',
+                table: 'order',
                 orderUuid: newOrder.uuid,
-                orderId: newOrder.id
+                orderId: newOrder.order_id,
+                duration: "".concat(dbAddDuration, "ms"),
+                performance: dbAddDuration > 100 ? 'slow' : dbAddDuration > 50 ? 'medium' : 'fast'
               });
+              setTimeout(function () {
+                _this3.core.effects.emit("".concat(_this3.name, ":onOrderAdded"), newOrder);
+              }, 0);
               return _context7.abrupt("return", newOrder);
-            case 26:
-              _context7.next = 33;
-              break;
-            case 28:
-              _context7.prev = 28;
+            case 12:
+              _context7.prev = 12;
               _context7.t0 = _context7["catch"](1);
               console.error('[PaymentModule] 创建支付订单失败', _context7.t0);
               this.logError('createPaymentOrderAsync failed', _context7.t0, {
                 orderId: params.order_id
               });
               throw _context7.t0;
-            case 33:
+            case 17:
             case "end":
               return _context7.stop();
           }
-        }, _callee7, this, [[1, 28]]);
+        }, _callee7, this, [[1, 12]]);
       }));
       function createPaymentOrderAsync(_x6) {
         return _createPaymentOrderAsync.apply(this, arguments);

package/dist/plugins/request.d.ts

@@ -35,6 +35,23 @@ export interface RequestPlugin extends Plugin {
      */
     request: <T = any>(options: RequestOptions) => Promise<T>;
 }
+export declare enum RequestModeENUM {
+    LOCAL = "local",
+    REMOTE = "remote",
+    LOCAL_REMOTE = "local_remote",
+    REMOTE_LOCAL = "remote_local",
+    OS_SERVER = "os_server"
+}
+export type RequestModeType = RequestModeENUM.LOCAL | RequestModeENUM.REMOTE | RequestModeENUM.LOCAL_REMOTE | RequestModeENUM.REMOTE_LOCAL | RequestModeENUM.OS_SERVER;
+export type CacheType = 'memory' | 'storage' | 'indexDB';
+export interface CacheProps {
+    key?: string;
+    type?: CacheType;
+    updateCache?: boolean;
+    cacheUpdateChange?: (data: any) => void;
+    mode?: RequestModeType;
+    cacheKeyData?: any;
+}
 /**
  * 请求配置
  */
@@ -49,6 +66,7 @@ export interface RequestOptions {
     responseType?: 'json' | 'text' | 'arraybuffer' | 'blob';
     withCredentials?: boolean;
     useCache?: boolean;
+    cache?: CacheProps;
     osServer?: boolean;
 }
 /**

package/dist/plugins/request.js

@@ -31,6 +31,17 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
  * RequestPlugin 接口定义
  */
 
+export var RequestModeENUM = /*#__PURE__*/function (RequestModeENUM) {
+  RequestModeENUM["LOCAL"] = "local";
+  RequestModeENUM["REMOTE"] = "remote";
+  RequestModeENUM["LOCAL_REMOTE"] = "local_remote";
+  RequestModeENUM["REMOTE_LOCAL"] = "remote_local";
+  RequestModeENUM["OS_SERVER"] = "os_server";
+  return RequestModeENUM;
+}({});
+
+// 请求模式  
+
 /**
  * 请求配置
  */

package/dist/server/modules/products/index.js

@@ -22,6 +22,7 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { BaseModule } from "../../../modules/BaseModule";
 import { cloneDeep } from 'lodash-es';
+import { RequestModeENUM } from "../../../plugins";
 import { ProductsHooks } from "./types";
 import { applyDetailValueToProducts, applyPriceDataToProducts } from "../../utils/product";
 
@@ -126,7 +127,12 @@ export var ProductsModule = /*#__PURE__*/function (_BaseModule) {
                 customer_id: customer_id,
                 schedule_date: schedule_date
               }, {
-                useCache: true
+                useCache: true,
+                cache: {
+                  mode: RequestModeENUM.REMOTE_LOCAL,
+                  updateCache: true,
+                  type: "indexDB"
+                }
               });
             case 3:
               productsData = _context2.sent;

package/dist/solution/Checkout/index.d.ts

@@ -19,6 +19,7 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
     private store;
     private otherParams;
     private logger;
+    private calculationCache;
     order: OrderModule;
     payment: PaymentModule;
     constructor(name?: string, version?: string);
@@ -302,16 +303,46 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * 删除本地 IndexDB 中超过指定天数且已同步到后端的订单数据
      */
     private cleanupExpiredOrdersAsync;
+    /**
+     * 清除计算缓存
+     */
+    private clearCalculationCache;
+    /**
+     * 批量获取订单数据（用于性能优化）
+     * 一次性获取所有需要的数据，避免重复查询
+     */
+    private fetchOrderDataBatch;
+    /**
+     * 从支付项数组计算已支付金额（纯计算，不查询数据库）
+     */
+    private calculatePaidAmountFromItems;
     /**
      * 计算已支付金额（从 Payment 模块获取最新数据）
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
      */
     private calculatePaidAmountAsync;
+    /**
+     * 从订单和支付项计算剩余金额（纯计算，不查询数据库）
+     */
+    private calculateRemainingAmountFromData;
+    /**
+     * 从订单和支付项计算剩余总金额（纯计算，排除定金）
+     */
+    private calculateRemainingTotalAmountFromData;
     /**
      * 计算剩余未支付金额（从 Payment 模块获取最新数据）
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
      */
     private calculateRemainingAmountAsync;
     /**
      * 计算剩余未支付金额（排除定金计算，始终使用订单总金额）
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
      */
     private calculateRemainingTotalAmountAsync;
     /**
@@ -320,12 +351,24 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
     private updateBalanceDueAmount;
     /**
      * 更新 stateAmount 为当前剩余未支付金额
+     *
+     * 优化版本：批量获取数据，避免重复查询数据库
      */
     private updateStateAmountToRemaining;
+    /**
+     * 检查订单支付是否完成（优化版，复用已获取的数据）
+     *
+     * @param paymentItems 已获取的支付项数据
+     * @param remainingAmount 已计算的剩余金额
+     */
+    private checkOrderPaymentCompletionOptimized;
     /**
      * 检查订单支付是否完成
      *
      * 当剩余待付款金额 <= 0 时，触发订单支付完成事件
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 中会使用优化版本。
      */
     private checkOrderPaymentCompletion;
     /**
@@ -381,6 +424,8 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * 重置 store 状态
      *
      * 在创建新订单前调用，确保状态完全干净
+     *
+     * 🚀 性能优化：改为同步方法，事件发射不阻塞主流程
      */
-    private resetStoreStateAsync;
+    private resetStoreState;
 }