@be-link/ecommerce-trade-service-node-sdk 0.1.61 → 0.1.63

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

@@ -312,6 +312,9 @@ export declare namespace PosOrderQueryService {
                     };
                     user: {
                         userId: string;
+                        unionId: string;
+                        /** 用户昵称 */
+                        nickname?: string;
                         memberLevel?: string;
                         receiverName: string;
                         receiverPhone: string;
@@ -326,6 +329,9 @@ export declare namespace PosOrderQueryService {
                 };
                 userDetail: {
                     userId: string;
+                    unionId: string;
+                    /** 用户昵称 */
+                    nickname?: string;
                     memberLevel?: string;
                     receiverName: string;
                     receiverPhone: string;

package/modules/ros/index.d.ts

@@ -4,4 +4,5 @@ export { RosOrderQueryService as RosOrderQueryTypes } from './orderQuery/types';
 export { orderCoreByUserService } from './orderCore/userService';
 export { orderCoreByWebService } from './orderCore/webService';
 export { orderCoreByJobService } from './orderCore/jobService';
+export { orderCoreByInternalService } from './orderCore/internalService';
 export { RosOrderCoreService as RosOrderCoreTypes } from './orderCore/types';

package/modules/ros/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.orderCoreByJobService = exports.orderCoreByWebService = exports.orderCoreByUserService = exports.orderQueryByUserService = exports.orderQueryByWebService = void 0;
+exports.orderCoreByInternalService = exports.orderCoreByJobService = exports.orderCoreByWebService = exports.orderCoreByUserService = exports.orderQueryByUserService = exports.orderQueryByWebService = void 0;
 var webService_1 = require("./orderQuery/webService");
 Object.defineProperty(exports, "orderQueryByWebService", { enumerable: true, get: function () { return webService_1.orderQueryByWebService; } });
 var userService_1 = require("./orderQuery/userService");
@@ -11,3 +11,5 @@ var webService_2 = require("./orderCore/webService");
 Object.defineProperty(exports, "orderCoreByWebService", { enumerable: true, get: function () { return webService_2.orderCoreByWebService; } });
 var jobService_1 = require("./orderCore/jobService");
 Object.defineProperty(exports, "orderCoreByJobService", { enumerable: true, get: function () { return jobService_1.orderCoreByJobService; } });
+var internalService_1 = require("./orderCore/internalService");
+Object.defineProperty(exports, "orderCoreByInternalService", { enumerable: true, get: function () { return internalService_1.orderCoreByInternalService; } });

package/modules/ros/orderCore/internalService.d.ts

@@ -0,0 +1,8 @@
+import { RosOrderCoreService } from './types';
+import BaseService from '../../BaseService';
+declare class RosOrderCoreByInternalService extends BaseService implements RosOrderCoreService.CoreByInternalController {
+    protected prefixUrl: string;
+    orderCreateForVerifyCoupon(request: RosOrderCoreService.ByInternal.Request.IOrderCreateForVerifyCoupon): Promise<RosOrderCoreService.ByInternal.Response.IOrderCreateForVerifyCoupon>;
+}
+export declare const orderCoreByInternalService: RosOrderCoreByInternalService;
+export default orderCoreByInternalService;

package/modules/ros/orderCore/internalService.js

@@ -0,0 +1,38 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orderCoreByInternalService = void 0;
+const tsoa_1 = require("tsoa");
+const http_1 = require("../../../utils/http");
+const BaseService_1 = __importDefault(require("../../BaseService"));
+let RosOrderCoreByInternalService = class RosOrderCoreByInternalService extends BaseService_1.default {
+    constructor() {
+        super(...arguments);
+        this.prefixUrl = '/ros/core/internal';
+    }
+    orderCreateForVerifyCoupon(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.orderCreateForVerifyCoupon), request);
+    }
+};
+__decorate([
+    (0, tsoa_1.OperationId)('创建核销订单的逆向订单'),
+    (0, tsoa_1.Post)('order-create-for-verify-coupon'),
+    __param(0, (0, tsoa_1.Body)())
+], RosOrderCoreByInternalService.prototype, "orderCreateForVerifyCoupon", null);
+RosOrderCoreByInternalService = __decorate([
+    (0, tsoa_1.Route)('ros/core/internal'),
+    (0, tsoa_1.Tags)('RosOrderCore')
+], RosOrderCoreByInternalService);
+exports.orderCoreByInternalService = new RosOrderCoreByInternalService();
+exports.default = exports.orderCoreByInternalService;

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

@@ -76,6 +76,21 @@ export declare namespace RosOrderCoreService {
         }
         namespace Response { }
     }
+    namespace ByInternal {
+        namespace Request {
+            interface IOrderCreateForVerifyCoupon {
+                /** 用户ID */
+                userId: string;
+                /** 优惠券ID */
+                couponId: string;
+                /** 优惠券码 */
+                couponCode: string;
+            }
+        }
+        namespace Response {
+            type IOrderCreateForVerifyCoupon = void;
+        }
+    }
     interface CoreByUserController {
         orderCreate(request: ByUser.Request.IReverseOrderCreate, req: any): Promise<ByUser.Response.IReverseOrderCreate>;
         orderCancel(request: ByUser.Request.IReverseOrderCancel, req: any): Promise<ByUser.Response.IReverseOrderCancel>;
@@ -89,4 +104,8 @@ export declare namespace RosOrderCoreService {
     interface CoreByJobController {
         autoApprove(request: ByJob.Request.IAutoApprove, req: any): Promise<void>;
     }
+    interface CoreByInternalController {
+        /** 创建核销订单的逆向订单 */
+        orderCreateForVerifyCoupon(request: ByInternal.Request.IOrderCreateForVerifyCoupon, req: any): Promise<ByInternal.Response.IOrderCreateForVerifyCoupon>;
+    }
 }

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

@@ -6,16 +6,35 @@ export declare namespace RosOrderQueryService {
         interface IOrderList {
             /** 查询条件 */
             conditions?: {
-                createdAt: string;
-                operateTime: string;
-                orderTime: string;
-                status: ENUM.ReverseOrderStatus;
-                arrivalStatusList: ENUM.ReverseArrivalStatus[];
-                wayList: ENUM.ReverseRefundWay[];
-                typeList: ENUM.ReverseRefundType[];
-                userIds: string[];
-                orderIds: string[];
-                storeIds: string[];
+                /** 下单时间范围 */
+                createdAt?: {
+                    start?: number;
+                    end?: number;
+                };
+                /** 退款操作时间范围 */
+                operateTime?: {
+                    start?: number;
+                    end?: number;
+                };
+                /** 退款申请时间范围 */
+                orderTime?: {
+                    start?: number;
+                    end?: number;
+                };
+                /** 退款订单状态列表 */
+                statusList?: ENUM.ReverseOrderStatus[];
+                /** 退款到账状态列表 */
+                arrivalStatusList?: ENUM.ReverseArrivalStatus[];
+                /** 退款方式列表 */
+                wayList?: ENUM.ReverseRefundWay[];
+                /** 退款类型列表 */
+                typeList?: ENUM.ReverseRefundType[];
+                /** 用户ID列表 */
+                userIds?: string[];
+                /** 正向订单ID列表 */
+                orderIds?: string[];
+                /** 门店ID列表 */
+                storeIds?: string[];
             };
             /** 分页 */
             pagination: {
@@ -40,6 +59,8 @@ export declare namespace RosOrderQueryService {
             reverseOrderIds?: string[];
             /** 订单ID列表 */
             orderIds?: string[];
+            /** 订单类型 */
+            orderTypeList?: ENUM.OrderType[];
             /** 用户ID列表 */
             userIds?: string[];
             /** 门店ID列表 */

package/package.json

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

package/types.d.ts

@@ -1,7 +1,7 @@
 /** 正向订单 */
 /** 基础信息 */
 import { ENUM } from './enums';
-import { PRODUCT_SERVICE_ENUM } from '@be-link/ecommerce-product-service-node-sdk';
+import { PRODUCT_SERVICE_ENUM, ProductServiceTypes } from '@be-link/ecommerce-product-service-node-sdk';
 export interface ITradeOrder {
     id: string;
     userId: string;
@@ -44,13 +44,36 @@ export interface ITradeOrderSkuInfo {
     id: string;
     orderId: string;
     quantity: number;
-    productSnapshot: string;
-    skuSnapshot: any;
+    /** 商品快照信息 */
+    productSnapshot: ProductServiceTypes.Response.getProductSkuInfo['productInfo'];
+    /** 商品SKU快照信息 */
+    skuSnapshot: ProductServiceTypes.Response.getProductSkuInfo['skuList'][0];
+    /** 商品Id */
     productId: string | null;
+    /** 商品名称 */
     productName: string | null;
+    /** skuId */
     skuId: string | null;
+    /** 商品规格编码 */
     skuCode: string | null;
+    /** 商品主图URL */
+    productImg: string | null;
+    /** 商品单价(分) */
     productPrice: number | null;
+    /** 商品规格列表 */
+    productSpec: ProductServiceTypes.Attr[] | null;
+    /** 商品提货方式 */
+    productPick: PRODUCT_SERVICE_ENUM.PRODUCT_ENUM.PICK_TYPE | null;
+    /** 商品发货方式 */
+    productDispatch: PRODUCT_SERVICE_ENUM.PRODUCT_ENUM.DISPATCH_TYPE | null;
+    /** 子商品SKU信息列表 */
+    subProductSkuInfos: {
+        productId: string;
+        skuId: string;
+        quantity: number;
+        productSnapshot: ProductServiceTypes.Response.getProductSkuInfo['productInfo'];
+        skuSnapshot: ProductServiceTypes.Response.getProductSkuInfo['skuList'][0];
+    }[] | null;
     createdAt: number;
     updatedAt: number;
 }
@@ -154,6 +177,7 @@ export interface ITradeReverseOrder {
     isFullRefund: number;
     createdAt: number;
     updatedAt: number;
+    orderItemIds: string[];
 }
 /** 资源扩展信息类型 */
 export interface IBizExtraInfo {

package/utils/http.js

@@ -1,4 +1,37 @@
 "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 };
 };
@@ -8,109 +41,28 @@ 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) {
-        // 重试临时错误和特定的网络错误
-        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;
+        return error.response?.status === 502;
     },
-    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秒
+    retryDelay: (retryCount) => {
+        console.info(`retryCount: ${retryCount}, retryDelay: ${retryCount * 500}`);
+        return retryCount * 500;
+    },
+    onRetry(retryCount, error, requestConfig) {
+        console.info(`retryCount: ${retryCount}, onRetry: ${error.message}, requestHeader: ${(0, safe_stable_stringify_1.default)(requestConfig.headers)}`);
     },
-    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;
+    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') || '';
     try {
-        if (shouldLog) {
-            console.log((0, safe_stable_stringify_1.default)({
-                message: '发起HTTP请求',
-                currentRequestId,
-                activeRequests,
-                requestId,
-                url,
-                type: 'http_request_start',
-            }));
-        }
+        console.info(`准备发起ecommerce-trade-service请求[${requestId}]: ${url}, 参数: ${(0, safe_stable_stringify_1.default)(request)}`);
         const response = await axios_1.default.post(url, request, {
             headers: {
                 'x-request-id': requestId,
@@ -118,181 +70,42 @@ 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((0, safe_stable_stringify_1.default)({
-                message: '响应异常',
-                status: response.status,
-                errorMessage: data?.message || axiosError.message,
-                type: 'http_response_error',
-            }));
+            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;
         }
+        // 调用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秒启动，避免服务启动时的干扰
-// }