@be-link/ecommerce-trade-service-node-sdk 0.1.66 → 0.1.68

package/enums.js

@@ -435,7 +435,7 @@ var ENUM_CN;
     };
     /** 退款方式中文映射 */
     ENUM_CN.ReverseRefundWay = {
-        [ENUM.ReverseRefundWay.USER_MANUAL]: '商家主动退款',
+        [ENUM.ReverseRefundWay.USER_MANUAL]: '商家审核退款',
         [ENUM.ReverseRefundWay.FAST]: '极速退款',
         [ENUM.ReverseRefundWay.MERCHANT_MANUAL]: '商家主动退款',
     };

package/modules/pos/orderQuery/types.d.ts

@@ -91,7 +91,7 @@ export declare namespace PosOrderQueryService {
                 orderIds?: string[];
                 sourceList?: ENUM.OrderSource[];
                 statusList?: ENUM.OrderStatus[];
-                orderTypeList?: ENUM.OrderType[];
+                isVerifyCoupon?: boolean;
                 refundStatusList?: ENUM.OrderRefundStatus[];
                 productPickList?: string[];
                 productDispatchList?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@be-link/ecommerce-trade-service-node-sdk",
-  "version": "0.1.66",
+  "version": "0.1.68",
   "description": "EcommerceTradeService Node.js SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/types.d.ts

@@ -270,6 +270,7 @@ export interface PosOrderPayload {
 }
 /** 正向订单头信息 (value=0或1) */
 export interface PosOrderHeaders {
+    isMemberOrder: string;
     isCombo: string;
     isVirtual: string;
     isVerification: string;

package/utils/http.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -41,28 +8,109 @@ const axios_1 = __importDefault(require("axios"));
 const uuid_1 = require("uuid");
 const axios_retry_1 = __importDefault(require("axios-retry"));
 const request_context_1 = require("@fastify/request-context");
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
 const safe_stable_stringify_1 = __importDefault(require("safe-stable-stringify"));
+// 针对高并发优化配置 - 支持2000并发
+const HTTP_CONFIG = {
+    maxSockets: 3000, // 每个主机的最大socket连接数（支持2000并发）
+    maxFreeSockets: 1000, // 空闲socket保留数（50%复用率，提高连接复用效率）
+    maxTotalSockets: 10000, // 所有主机总socket数（单后端场景优化）
+    keepAliveMsecs: 30000, // 保持连接30秒（平衡资源占用和连接复用）
+    timeout: 5000, // socket超时3秒（高并发场景快速失败）
+    requestTimeout: 5000, // 请求超时5秒（快速释放资源，避免慢请求占用连接）
+    retryBaseDelay: 200, // 基础重试延迟100ms（给服务恢复时间）
+    logThreshold: 1000, // 日志采样率（每1000个请求采样1次，降低日志开销）
+    monitorInterval: 5000, // 监控日志间隔（毫秒）
+};
+// 配置 HTTP/HTTPS Agent 以支持高并发连接池和 keepAlive
+const httpAgent = new http_1.default.Agent({
+    keepAlive: true,
+    keepAliveMsecs: HTTP_CONFIG.keepAliveMsecs,
+    maxSockets: HTTP_CONFIG.maxSockets,
+    maxFreeSockets: HTTP_CONFIG.maxFreeSockets,
+    maxTotalSockets: HTTP_CONFIG.maxTotalSockets,
+    timeout: HTTP_CONFIG.timeout,
+    scheduling: 'fifo', // 先进先出调度
+});
+const httpsAgent = new https_1.default.Agent({
+    keepAlive: true,
+    keepAliveMsecs: HTTP_CONFIG.keepAliveMsecs,
+    maxSockets: HTTP_CONFIG.maxSockets,
+    maxFreeSockets: HTTP_CONFIG.maxFreeSockets,
+    maxTotalSockets: HTTP_CONFIG.maxTotalSockets,
+    timeout: HTTP_CONFIG.timeout,
+    scheduling: 'fifo',
+});
+// 配置 axios 默认使用这些 agent
+axios_1.default.defaults.httpAgent = httpAgent;
+axios_1.default.defaults.httpsAgent = httpsAgent;
+axios_1.default.defaults.timeout = HTTP_CONFIG.requestTimeout;
+axios_1.default.defaults.maxRedirects = 3; // 限制重定向次数
+axios_1.default.defaults.maxContentLength = 50 * 1024 * 1024; // 50MB 最大响应大小
+// 高并发场景下的智能重试配置
 (0, axios_retry_1.default)(axios_1.default, {
-    retries: 1,
     retryCondition(error) {
-        return error.response?.status === 502;
-    },
-    retryDelay: (retryCount) => {
-        console.info(`retryCount: ${retryCount}, retryDelay: ${retryCount * 500}`);
-        return retryCount * 500;
+        // 重试临时错误和特定的网络错误
+        const status = error.response?.status;
+        const isNetworkError = error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT';
+        const isServerError = status === 502 || status === 503 || status === 504;
+        const isRateLimited = status === 429;
+        return isNetworkError || isServerError || isRateLimited;
     },
-    onRetry(retryCount, error, requestConfig) {
-        console.info(`retryCount: ${retryCount}, onRetry: ${error.message}, requestHeader: ${(0, safe_stable_stringify_1.default)(requestConfig.headers)}`);
+    retryDelay: (retryCount, error) => {
+        // 指数退避 + 抖动
+        const status = error.response?.status;
+        // 如果是限流错误，延迟更长
+        if (status === 429) {
+            const retryAfter = error.response?.headers['retry-after'];
+            if (retryAfter) {
+                return parseInt(retryAfter) * 1000;
+            }
+            return 1000 + Math.random() * 1000; // 1-2秒
+        }
+        // 指数退避：100ms, 200ms, 400ms...
+        const exponentialDelay = HTTP_CONFIG.retryBaseDelay * Math.pow(2, retryCount - 1);
+        const jitter = Math.random() * 50; // 0-50ms 抖动
+        return Math.min(exponentialDelay + jitter, 2000); // 最多延迟2秒
     },
+    shouldResetTimeout: true, // 重试时重置超时
 });
+// 连接池状态监控
+let requestCount = 0;
+let activeRequests = 0;
+let peakActiveRequests = 0; // 峰值并发
+// 注意：已移除应用层并发队列限制，完全依赖底层socket连接池控制
+// 这样可以避免应用层排队等待，充分利用socket连接池的并发能力
 async function callApi(url, request) {
-    const requestId = request_context_1.requestContext.get('requestId') || request_context_1.requestContext.get('traceMessageId') || (0, uuid_1.v4)();
-    const pandoraUserId = request_context_1.requestContext.get('pandoraUserId') || '';
-    const beLinkUserId = request_context_1.requestContext.get('beLinkUserId') || '';
-    const pandoraRoleId = request_context_1.requestContext.get('pandoraRoleId') || '';
-    const realIp = request_context_1.requestContext.get('realIp') || '';
+    // 不再等待应用层队列，直接发起请求，由底层socket连接池控制并发
+    const currentRequestId = ++requestCount;
+    activeRequests++;
+    // 记录峰值并发
+    if (activeRequests > peakActiveRequests) {
+        peakActiveRequests = activeRequests;
+    }
+    // 批量获取请求上下文，减少函数调用开销
+    const ctx = request_context_1.requestContext.get('requestId') ? request_context_1.requestContext : null;
+    const requestId = ctx?.get('requestId') || ctx?.get('traceMessageId') || (0, uuid_1.v4)();
+    const pandoraUserId = ctx?.get('pandoraUserId') || '';
+    const beLinkUserId = ctx?.get('beLinkUserId') || '';
+    const pandoraRoleId = ctx?.get('pandoraRoleId') || '';
+    const realIp = ctx?.get('realIp') || '';
+    // 采样日志决策（提前计算，避免重复判断）
+    const shouldLog = currentRequestId % HTTP_CONFIG.logThreshold === 0;
+    const startTime = shouldLog ? Date.now() : 0;
     try {
-        console.info(`准备发起ecommerce-trade-service请求[${requestId}]: ${url}, 参数: ${(0, safe_stable_stringify_1.default)(request)}`);
+        if (shouldLog) {
+            console.log((0, safe_stable_stringify_1.default)({
+                message: '发起HTTP请求',
+                currentRequestId,
+                activeRequests,
+                requestId,
+                url,
+                type: 'http_request_start',
+            }));
+        }
         const response = await axios_1.default.post(url, request, {
             headers: {
                 'x-request-id': requestId,
@@ -70,42 +118,181 @@ async function callApi(url, request) {
                 'x-belink-userid': beLinkUserId,
                 'x-belink-pandora-roleid': pandoraRoleId,
                 'x-real-ip': realIp,
+                Connection: 'keep-alive',
             },
+            timeout: HTTP_CONFIG.requestTimeout,
+            httpAgent,
+            httpsAgent,
         });
+        if (shouldLog) {
+            const duration = Date.now() - startTime;
+            if (duration > 3000) {
+                console.log((0, safe_stable_stringify_1.default)({
+                    message: '请求完成',
+                    currentRequestId,
+                    duration: `${duration}ms`,
+                    activeRequests,
+                    type: 'http_request_complete',
+                }));
+            }
+        }
         const responseData = response.data;
         return responseData.data;
     }
     catch (error) {
         const axiosError = error;
+        const duration = startTime ? Date.now() - startTime : 0;
+        // 错误始终记录（但简化输出）
+        console.error((0, safe_stable_stringify_1.default)({
+            message: '请求失败',
+            currentRequestId,
+            url,
+            duration: `${duration}ms`,
+            activeRequests,
+            errorMessage: axiosError.message,
+            type: 'http_request_failed',
+        }));
         if (axiosError.response) {
             const response = axiosError.response;
             const data = response.data;
-            console.error(`ecommerce-trade-service 异常: ${axiosError.message},requestId: ${requestId}`);
-            console.info('响应信息', data.message);
-            console.error('异常堆栈', (0, safe_stable_stringify_1.default)(error.stack));
-            // throw new Error(data.errorType + ' - ' + data.message)
-            throw error;
+            console.error((0, safe_stable_stringify_1.default)({
+                message: '响应异常',
+                status: response.status,
+                errorMessage: data?.message || axiosError.message,
+                type: 'http_response_error',
+            }));
         }
-        // 调用dns模块解析url
-        const dns = await Promise.resolve().then(() => __importStar(require('dns')));
-        const dnsPromise = new Promise((resolve, reject) => {
-            const lookupRes = dns.lookup(url, (err, address) => {
-                if (err) {
-                    console.error(err.message);
-                    reject(err);
-                }
-                console.info(`lookup: ${(0, safe_stable_stringify_1.default)(lookupRes)}`);
-                resolve(address);
-            });
-        });
-        try {
-            const address = await dnsPromise;
-            console.info(`address: ${(0, safe_stable_stringify_1.default)(address)}`);
-        }
-        catch (error) {
-            console.info(`error: ${(0, safe_stable_stringify_1.default)(error)}`);
-        }
-        console.error(`ecommerce-trade-service 未知异常: ${axiosError.message}`, error.stack);
         throw error;
     }
+    finally {
+        // 记录请求完成，减少活跃计数
+        activeRequests--;
+    }
 }
+// 导出监控函数
+// export function getConnectionStats() {
+//   const stats = {
+//     // 当前状态
+//     activeRequests,
+//     totalRequests: requestCount,
+//     // 峰值指标
+//     peakActiveRequests,
+//     // Socket连接池状态（这是真正的并发控制点）
+//     httpSockets: {
+//       total: Object.keys(httpAgent.sockets).reduce(
+//         (sum, host) => sum + (httpAgent.sockets[host]?.length || 0),
+//         0,
+//       ),
+//       hosts: Object.keys(httpAgent.sockets).length,
+//       details: httpAgent.sockets,
+//     },
+//     httpsSockets: {
+//       total: Object.keys(httpsAgent.sockets).reduce(
+//         (sum, host) => sum + (httpsAgent.sockets[host]?.length || 0),
+//         0,
+//       ),
+//       hosts: Object.keys(httpsAgent.sockets).length,
+//       details: httpsAgent.sockets,
+//     },
+//     // 配置信息
+//     config: {
+//       maxSockets: HTTP_CONFIG.maxSockets,
+//       maxTotalSockets: HTTP_CONFIG.maxTotalSockets,
+//       requestTimeout: HTTP_CONFIG.requestTimeout,
+//       note: '已移除应用层并发队列限制，完全依赖socket连接池',
+//     },
+//   }
+//   return stats
+// }
+// 重置峰值统计（可用于定期重置）
+// export function resetPeakStats() {
+//   peakActiveRequests = activeRequests
+//   console.log(
+//     stringify({
+//       message: '峰值统计已重置',
+//       type: 'stats_reset',
+//     }),
+//   )
+// }
+// // 定期监控日志
+// let monitorTimer: NodeJS.Timeout | null = null
+// export function startMonitoring(interval: number = HTTP_CONFIG.monitorInterval) {
+//   if (monitorTimer) {
+//     console.log(
+//       stringify({
+//         message: '监控已在运行中',
+//         type: 'monitor_already_running',
+//       }),
+//     )
+//     return
+//   }
+//   console.log(
+//     stringify({
+//       message: '启动并发监控',
+//       interval: `${interval}ms`,
+//       type: 'monitor_start',
+//     }),
+//   )
+//   monitorTimer = setInterval(() => {
+//     const stats = getConnectionStats()
+//     // 只在有活动时打印
+//     if (stats.totalRequests === 0) {
+//       return
+//     }
+//     // 检测异常情况（基于socket连接池使用率）
+//     const httpSocketsUsage = stats.httpSockets.total / HTTP_CONFIG.maxSockets
+//     const httpsSocketsUsage = stats.httpsSockets.total / HTTP_CONFIG.maxSockets
+//     const maxSocketUsage = Math.max(httpSocketsUsage, httpsSocketsUsage)
+//     // Socket连接池使用率超过80%视为瓶颈
+//     const hasIssue = maxSocketUsage > 0.8
+//     if (hasIssue) {
+//       console.warn(
+//         stringify({
+//           message: '并发监控检测到瓶颈',
+//           当前并发: stats.activeRequests,
+//           峰值并发: stats.peakActiveRequests,
+//           总请求数: stats.totalRequests,
+//           HTTP_Sockets: `${stats.httpSockets.total}/${HTTP_CONFIG.maxSockets} (${Math.round(
+//             httpSocketsUsage * 100,
+//           )}%)`,
+//           HTTPS_Sockets: `${stats.httpsSockets.total}/${HTTP_CONFIG.maxSockets} (${Math.round(
+//             httpsSocketsUsage * 100,
+//           )}%)`,
+//           建议: 'Socket连接池接近饱和，考虑提高maxSockets配置',
+//           type: 'monitor_bottleneck_detected',
+//         }),
+//       )
+//     } else if (stats.totalRequests % 10000 === 0) {
+//       // 每1万次请求打印一次正常状态
+//       console.log(
+//         stringify({
+//           message: '并发监控运行正常',
+//           总请求: stats.totalRequests,
+//           当前并发: stats.activeRequests,
+//           峰值并发: stats.peakActiveRequests,
+//           HTTP_Sockets使用率: `${Math.round(httpSocketsUsage * 100)}%`,
+//           HTTPS_Sockets使用率: `${Math.round(httpsSocketsUsage * 100)}%`,
+//           type: 'monitor_normal',
+//         }),
+//       )
+//     }
+//   }, interval)
+// }
+// export function stopMonitoring() {
+//   if (monitorTimer) {
+//     clearInterval(monitorTimer)
+//     monitorTimer = null
+//     console.log(
+//       stringify({
+//         message: '监控已停止',
+//         type: 'monitor_stop',
+//       }),
+//     )
+//   }
+// }
+// // 自动启动监控（可选，如果不想自动启动可以注释掉）
+// if (process.env.NODE_ENV !== 'test') {
+//   setTimeout(() => {
+//     startMonitoring()
+//   }, 3000) // 延迟3秒启动，避免服务启动时的干扰
+// }