@be-link/ecommerce-trade-service-node-sdk 0.1.58 → 0.1.60

package/enums.d.ts

@@ -192,7 +192,9 @@ export declare namespace ENUM {
         /** 一元入会订单 */
         ONE_RMB_MEMBER = "ONE_RMB_MEMBER",
         /** 黑钻会员订单 */
-        BLACK_DIAMOND_MEMBER = "BLACK_DIAMOND_MEMBER"
+        BLACK_DIAMOND_MEMBER = "BLACK_DIAMOND_MEMBER",
+        /** 核销券订单 */
+        VOUCHER = "VOUCHER"
     }
     /** 订单类型中文映射 */
     const OrderType_CN: Record<ENUM.OrderType, string>;
@@ -229,6 +231,23 @@ export declare namespace ENUM {
         /** 商家手动退款 */
         MERCHANT_MANUAL = "MERCHANT_MANUAL"
     }
+    /**
+     * 直播状态
+     * - 1：直播中。
+     * - 2：预告。
+     * - 3：回放。
+     * - 4：结束。
+     */
+    enum LiveRoomStatus {
+        /** 直播中 */
+        LIVE = "1",
+        /** 预告 */
+        PREVIEW = "2",
+        /** 回放 */
+        PLAYBACK = "3",
+        /** 结束 */
+        ENDED = "4"
+    }
 }
 /** RabbitMQ 交换机路由枚举 */
 export declare namespace EXCHANGE_ENUM {

package/enums.js

@@ -214,6 +214,8 @@ var ENUM;
         OrderType["ONE_RMB_MEMBER"] = "ONE_RMB_MEMBER";
         /** 黑钻会员订单 */
         OrderType["BLACK_DIAMOND_MEMBER"] = "BLACK_DIAMOND_MEMBER";
+        /** 核销券订单 */
+        OrderType["VOUCHER"] = "VOUCHER";
     })(OrderType = ENUM.OrderType || (ENUM.OrderType = {}));
     /** 订单类型中文映射 */
     ENUM.OrderType_CN = {
@@ -222,6 +224,7 @@ var ENUM;
         [ENUM.OrderType.FULL_GIFT]: '满赠订单',
         [ENUM.OrderType.ONE_RMB_MEMBER]: '一元入会订单',
         [ENUM.OrderType.BLACK_DIAMOND_MEMBER]: '黑钻会员订单',
+        [ENUM.OrderType.VOUCHER]: '核销券订单',
     };
     let OrderPromotionType;
     (function (OrderPromotionType) {
@@ -260,6 +263,24 @@ var ENUM;
         /** 商家手动退款 */
         ReverseRefundHandlerEnum["MERCHANT_MANUAL"] = "MERCHANT_MANUAL";
     })(ReverseRefundHandlerEnum = ENUM.ReverseRefundHandlerEnum || (ENUM.ReverseRefundHandlerEnum = {}));
+    /**
+     * 直播状态
+     * - 1：直播中。
+     * - 2：预告。
+     * - 3：回放。
+     * - 4：结束。
+     */
+    let LiveRoomStatus;
+    (function (LiveRoomStatus) {
+        /** 直播中 */
+        LiveRoomStatus["LIVE"] = "1";
+        /** 预告 */
+        LiveRoomStatus["PREVIEW"] = "2";
+        /** 回放 */
+        LiveRoomStatus["PLAYBACK"] = "3";
+        /** 结束 */
+        LiveRoomStatus["ENDED"] = "4";
+    })(LiveRoomStatus = ENUM.LiveRoomStatus || (ENUM.LiveRoomStatus = {}));
 })(ENUM || (exports.ENUM = ENUM = {}));
 /** RabbitMQ 交换机路由枚举 */
 var EXCHANGE_ENUM;

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

@@ -84,6 +84,8 @@ export declare namespace PosCoreService {
                 skuId: string;
                 /** 直播间ID */
                 liveRoomId?: string;
+                /** 直播间状态 */
+                liveRoomStatus?: ENUM.LiveRoomStatus;
                 /** 订单来源类型k */
                 source: ENUM.OrderSource;
                 /** 订单来源平台类型 */

package/package.json

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

package/utils/http.d.ts

@@ -9,27 +9,3 @@ declare module '@fastify/request-context' {
     }
 }
 export declare function callApi<T extends (...args: any[]) => Promise<any>>(url: string, request?: Parameters<T>[0]): Promise<Awaited<ReturnType<T>>>;
-export declare function getConnectionStats(): {
-    activeRequests: number;
-    totalRequests: number;
-    peakActiveRequests: number;
-    httpSockets: {
-        total: number;
-        hosts: number;
-        details: NodeJS.ReadOnlyDict<import("net").Socket[]>;
-    };
-    httpsSockets: {
-        total: number;
-        hosts: number;
-        details: NodeJS.ReadOnlyDict<import("net").Socket[]>;
-    };
-    config: {
-        maxSockets: number;
-        maxTotalSockets: number;
-        requestTimeout: number;
-        note: string;
-    };
-};
-export declare function resetPeakStats(): void;
-export declare function startMonitoring(interval?: number): void;
-export declare function stopMonitoring(): void;

package/utils/http.js

@@ -4,10 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callApi = callApi;
-exports.getConnectionStats = getConnectionStats;
-exports.resetPeakStats = resetPeakStats;
-exports.startMonitoring = startMonitoring;
-exports.stopMonitoring = stopMonitoring;
 const axios_1 = __importDefault(require("axios"));
 const uuid_1 = require("uuid");
 const axios_retry_1 = __importDefault(require("axios-retry"));
@@ -17,13 +13,13 @@ const https_1 = __importDefault(require("https"));
 const safe_stable_stringify_1 = __importDefault(require("safe-stable-stringify"));
 // 针对高并发优化配置 - 支持2000并发
 const HTTP_CONFIG = {
-    maxSockets: 2000, // 每个主机的最大socket连接数（支持2000并发）
+    maxSockets: 3000, // 每个主机的最大socket连接数（支持2000并发）
     maxFreeSockets: 1000, // 空闲socket保留数（50%复用率，提高连接复用效率）
-    maxTotalSockets: 3000, // 所有主机总socket数（单后端场景优化）
+    maxTotalSockets: 10000, // 所有主机总socket数（单后端场景优化）
     keepAliveMsecs: 30000, // 保持连接30秒（平衡资源占用和连接复用）
-    timeout: 3000, // socket超时3秒（高并发场景快速失败）
-    requestTimeout: 30000, // 请求超时3秒（快速释放资源，避免慢请求占用连接）
-    retryBaseDelay: 100, // 基础重试延迟100ms（给服务恢复时间）
+    timeout: 5000, // socket超时3秒（高并发场景快速失败）
+    requestTimeout: 5000, // 请求超时5秒（快速释放资源，避免慢请求占用连接）
+    retryBaseDelay: 200, // 基础重试延迟100ms（给服务恢复时间）
     logThreshold: 1000, // 日志采样率（每1000个请求采样1次，降低日志开销）
     monitorInterval: 5000, // 监控日志间隔（毫秒）
 };
@@ -174,108 +170,129 @@ async function callApi(url, request) {
     }
 }
 // 导出监控函数
-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 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
+// }
 // 重置峰值统计（可用于定期重置）
-function resetPeakStats() {
-    peakActiveRequests = activeRequests;
-    console.log((0, safe_stable_stringify_1.default)({
-        message: '峰值统计已重置',
-        type: 'stats_reset',
-    }));
-}
-// 定期监控日志
-let monitorTimer = null;
-function startMonitoring(interval = HTTP_CONFIG.monitorInterval) {
-    if (monitorTimer) {
-        console.log((0, safe_stable_stringify_1.default)({
-            message: '监控已在运行中',
-            type: 'monitor_already_running',
-        }));
-        return;
-    }
-    console.log((0, safe_stable_stringify_1.default)({
-        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((0, safe_stable_stringify_1.default)({
-                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((0, safe_stable_stringify_1.default)({
-                message: '并发监控运行正常',
-                总请求: stats.totalRequests,
-                当前并发: stats.activeRequests,
-                峰值并发: stats.peakActiveRequests,
-                HTTP_Sockets使用率: `${Math.round(httpSocketsUsage * 100)}%`,
-                HTTPS_Sockets使用率: `${Math.round(httpsSocketsUsage * 100)}%`,
-                type: 'monitor_normal',
-            }));
-        }
-    }, interval);
-}
-function stopMonitoring() {
-    if (monitorTimer) {
-        clearInterval(monitorTimer);
-        monitorTimer = null;
-        console.log((0, safe_stable_stringify_1.default)({
-            message: '监控已停止',
-            type: 'monitor_stop',
-        }));
-    }
-}
-// 自动启动监控（可选，如果不想自动启动可以注释掉）
-if (process.env.NODE_ENV !== 'test') {
-    setTimeout(() => {
-        startMonitoring();
-    }, 3000); // 延迟3秒启动，避免服务启动时的干扰
-}
+// 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秒启动，避免服务启动时的干扰
+// }