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

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

@@ -445,6 +445,10 @@ export declare namespace PosOrderQueryService {
                     isFullRefund: boolean;
                     /** 退货时商品核销状态 */
                     verificationStatus?: ENUM.OrderVerificationStatus;
+                    /** 已核销退货数量 */
+                    verifiedRefundQuantity: number;
+                    /** 未核销退货数量 */
+                    unverifiedRefundQuantity: number;
                     /** 退款资源信息 */
                     resource?: {
                         /** 资源ID */

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

@@ -59,8 +59,10 @@ export declare namespace RosOrderQueryService {
             reverseOrderIds?: string[];
             /** 订单ID列表 */
             orderIds?: string[];
-            /** 订单类型 */
-            orderTypeList?: ENUM.OrderType[];
+            /** 是否核销券订单（true=核销券订单，false=非核销券订单） */
+            isVerifyCoupon?: boolean;
+            /** 订单来源列表 */
+            sourceList?: ENUM.OrderSource[];
             /** 用户ID列表 */
             userIds?: string[];
             /** 门店ID列表 */
@@ -204,6 +206,10 @@ export declare namespace RosOrderQueryService {
                 operatorNickname?: string;
                 /** 上传的图片/视频附件 */
                 attachments?: string[];
+                /** 已核销已退货数量 */
+                verifiedRefundQuantity: number;
+                /** 未核销已退货数量 */
+                unverifiedRefundQuantity: number;
             };
             /** 正向订单信息 */
             positiveOrder: {

package/package.json

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

package/utils/http.js

@@ -10,18 +10,16 @@ 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并发
+// HTTP 连接池配置 - 支持 2000 QPS（响应时间 2秒）
 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, // 监控日志间隔（毫秒）
+    maxSockets: 3000, // 每个 host 最大并发连接数
+    maxFreeSockets: 1000, // 保持空闲连接数（减少连接重建开销）
+    maxTotalSockets: 10000, // 所有 host 总连接数上限（支持多个服务同时调用）
+    keepAliveMsecs: 60000, // 保持连接60秒
+    timeout: 10000, // socket超时10秒
+    requestTimeout: 10000, // 请求超时10秒
+    retries: 0, // 不重试（失败直接返回）
+    retryBaseDelay: 200, // 基础重试延迟200ms
 };
 // 配置 HTTP/HTTPS Agent 以支持高并发连接池和 keepAlive
 const httpAgent = new http_1.default.Agent({
@@ -31,7 +29,7 @@ const httpAgent = new http_1.default.Agent({
     maxFreeSockets: HTTP_CONFIG.maxFreeSockets,
     maxTotalSockets: HTTP_CONFIG.maxTotalSockets,
     timeout: HTTP_CONFIG.timeout,
-    scheduling: 'fifo', // 先进先出调度
+    scheduling: 'lifo', // 后进先出调度（优先复用热连接，提高连接复用效率）
 });
 const httpsAgent = new https_1.default.Agent({
     keepAlive: true,
@@ -40,7 +38,7 @@ const httpsAgent = new https_1.default.Agent({
     maxFreeSockets: HTTP_CONFIG.maxFreeSockets,
     maxTotalSockets: HTTP_CONFIG.maxTotalSockets,
     timeout: HTTP_CONFIG.timeout,
-    scheduling: 'fifo',
+    scheduling: 'lifo', // 后进先出调度（优先复用热连接，提高连接复用效率）
 });
 // 配置 axios 默认使用这些 agent
 axios_1.default.defaults.httpAgent = httpAgent;
@@ -50,13 +48,20 @@ axios_1.default.defaults.maxRedirects = 3; // 限制重定向次数
 axios_1.default.defaults.maxContentLength = 50 * 1024 * 1024; // 50MB 最大响应大小
 // 高并发场景下的智能重试配置
 (0, axios_retry_1.default)(axios_1.default, {
+    retries: HTTP_CONFIG.retries,
     retryCondition(error) {
         // 重试临时错误和特定的网络错误
         const status = error.response?.status;
-        const isNetworkError = error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT';
+        const isNetworkError = error.code === 'ECONNRESET' ||
+            error.code === 'ETIMEDOUT' ||
+            error.code === 'ECONNREFUSED' ||
+            error.code === 'ENOTFOUND' ||
+            error.code === 'ENETUNREACH' ||
+            error.code === 'EAI_AGAIN';
         const isServerError = status === 502 || status === 503 || status === 504;
         const isRateLimited = status === 429;
-        return isNetworkError || isServerError || isRateLimited;
+        const isTimeout = error.code === 'ECONNABORTED' || error.message?.includes('timeout');
+        return isNetworkError || isServerError || isRateLimited || isTimeout;
     },
     retryDelay: (retryCount, error) => {
         // 指数退避 + 抖动
@@ -69,230 +74,35 @@ axios_1.default.defaults.maxContentLength = 50 * 1024 * 1024; // 50MB 最大响
             }
             return 1000 + Math.random() * 1000; // 1-2秒
         }
-        // 指数退避：100ms, 200ms, 400ms...
+        // 指数退避：200ms, 400ms, 800ms...
         const exponentialDelay = HTTP_CONFIG.retryBaseDelay * Math.pow(2, retryCount - 1);
-        const jitter = Math.random() * 50; // 0-50ms 抖动
-        return Math.min(exponentialDelay + jitter, 2000); // 最多延迟2秒
+        const jitter = Math.random() * 100; // 0-100ms 抖动
+        return Math.min(exponentialDelay + jitter, 3000); // 最多延迟3秒
     },
     shouldResetTimeout: true, // 重试时重置超时
 });
-// 连接池状态监控
-let requestCount = 0;
-let activeRequests = 0;
-let peakActiveRequests = 0; // 峰值并发
-// 注意：已移除应用层并发队列限制，完全依赖底层socket连接池控制
-// 这样可以避免应用层排队等待，充分利用socket连接池的并发能力
 async function callApi(url, request) {
-    // 不再等待应用层队列，直接发起请求，由底层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 {
-        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,
-                'x-belink-pandora-userid': pandoraUserId,
-                '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((0, safe_stable_stringify_1.default)({
-                message: '响应异常',
-                status: response.status,
-                errorMessage: data?.message || axiosError.message,
-                type: 'http_response_error',
-            }));
-        }
-        throw error;
-    }
-    finally {
-        // 记录请求完成，减少活跃计数
-        activeRequests--;
-    }
+    const response = await axios_1.default.post(url, request || {}, {
+        headers: {
+            'x-request-id': requestId,
+            'x-belink-pandora-userid': pandoraUserId,
+            'x-belink-userid': beLinkUserId,
+            'x-belink-pandora-roleid': pandoraRoleId,
+            'x-real-ip': realIp,
+            Connection: 'keep-alive',
+            'Content-Type': 'application/json;charset=utf-8',
+        },
+        timeout: HTTP_CONFIG.requestTimeout,
+        httpAgent,
+        httpsAgent,
+    });
+    const responseData = response.data;
+    return responseData.data;
 }
-// 导出监控函数
-// 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秒启动，避免服务启动时的干扰
-// }