@be-link/ecommerce-promotion-service-node-sdk 0.1.23 → 0.1.25

package/modules/BaseService.d.ts

@@ -8,7 +8,7 @@ export default abstract class BaseService {
     protected abstract prefixUrl: string;
     /** 子网域名 */
     protected readonly natDevHost = "http://192.168.3.168:8090/promotion";
-    protected readonly natProdHost = "http://10.1.0.97:8090/promotion";
+    protected readonly natProdHost = "http://192.168.87.191:8090/promotion";
     /** 公网域名 */
     protected readonly publicDevHost = "https://ecommerce-dev.wejourney.top/promotion";
     protected readonly publicProdHost = "";

package/modules/BaseService.js

@@ -13,7 +13,7 @@ class BaseService {
     constructor() {
         /** 子网域名 */
         this.natDevHost = 'http://192.168.3.168:8090/promotion';
-        this.natProdHost = 'http://10.1.0.97:8090/promotion';
+        this.natProdHost = 'http://192.168.87.191:8090/promotion';
         /** 公网域名 */
         this.publicDevHost = 'https://ecommerce-dev.wejourney.top/promotion';
         this.publicProdHost = '';

package/modules/award/service.d.ts

@@ -7,7 +7,6 @@ declare class AwardService extends BaseService implements Service.PrizeDistribut
     liveRoomIssueCoupon(request: Service.Request.liveRoomIssueCoupon): Promise<Service.Response.distributePrize>;
     queryLiveRoomDistributionStats(request: Service.Request.queryLiveRoomDistributionStats): Promise<Service.Response.queryLiveRoomDistributionStatsResponse>;
     adminSingleIssueCoupon(request: Service.Request.adminSingleIssueCoupon): Promise<Service.Response.distributePrize>;
-    batchIssueCoupon(request: Service.Request.batchIssueCoupon): Promise<Service.Response.distributePrize>;
 }
 export declare const awardService: AwardService;
 export default awardService;

package/modules/award/service.js

@@ -36,9 +36,6 @@ let AwardService = class AwardService extends BaseService_1.default {
     adminSingleIssueCoupon(request) {
         return (0, http_1.callApi)(this.getApiUrl(this.adminSingleIssueCoupon), request);
     }
-    batchIssueCoupon(request) {
-        return (0, http_1.callApi)(this.getApiUrl(this.batchIssueCoupon), request);
-    }
 };
 __decorate([
     (0, tsoa_1.OperationId)('发放奖励'),
@@ -65,11 +62,6 @@ __decorate([
     (0, tsoa_1.Post)('admin-single-issue-coupon'),
     __param(0, (0, tsoa_1.Body)())
 ], AwardService.prototype, "adminSingleIssueCoupon", null);
-__decorate([
-    (0, tsoa_1.OperationId)('批量发放券'),
-    (0, tsoa_1.Post)('batch-issue-coupon'),
-    __param(0, (0, tsoa_1.Body)())
-], AwardService.prototype, "batchIssueCoupon", null);
 AwardService = __decorate([
     (0, tsoa_1.Route)('award'),
     (0, tsoa_1.Tags)('Award')

package/modules/award/types.d.ts

@@ -47,30 +47,8 @@ export declare namespace Service {
     namespace Request {
         /** 发放奖励 */
         interface distributePrize {
-            /** 发奖记录ID */
-            id: string;
-            /** 用户ID */
-            userId: string;
-            /** 任务ID */
-            taskId: string;
-            /** 任务名称 */
-            taskName: string;
-            /** 任务类型 */
-            taskType: string;
-            /** 奖品类型 */
-            prizeType: string;
-            /** 直播间id */
-            liveStreamRoomId: string;
-            /** 业务ID */
-            bizId: string;
-            /** 发放数量 */
-            quantity: number;
-            /** 轮次编号（观看任务专用） */
-            roundNumber?: number;
-            /** 订单ID（满赠/买赠专用） */
-            orderId?: string;
-            /** 订单明细ID（买赠专用） */
-            orderDetailId?: string;
+            /** 业务编号 */
+            bizNo: string;
         }
         /** 作废奖励 */
         interface reversePrize {
@@ -124,32 +102,6 @@ export declare namespace Service {
             couponId: string;
             /** 用户ID */
             userId: string;
-            /** 数量 */
-            quantity?: number;
-        }
-        /** 批量发放券请求项 */
-        interface batchIssueCouponItem {
-            /** 业务编号 */
-            bizNo: string;
-            /** 直播间ID */
-            liveRoomId: string;
-            /** 用户ID */
-            userId: string;
-            /** 优惠券ID */
-            couponId: string;
-            /** 数量 */
-            quantity: number;
-            /** 业务ID */
-            bizId: string;
-            /** 操作人ID */
-            operatorId: string;
-        }
-        /** 批量发放券 */
-        interface batchIssueCoupon {
-            /** 批量发放券请求列表 */
-            requests: batchIssueCouponItem[];
-            /** 发放渠道 */
-            getChannel: ENUM.AWARD_ENUM.DISTRIBUTION_CHANNEL;
         }
     }
     namespace Response {
@@ -186,7 +138,5 @@ export declare namespace Service {
         queryLiveRoomDistributionStats(request: Service.Request.queryLiveRoomDistributionStats, req: any): Promise<Service.Response.queryLiveRoomDistributionStatsResponse>;
         /** 后台单个发券 */
         adminSingleIssueCoupon(request: Service.Request.adminSingleIssueCoupon, req: any): Promise<Service.Response.distributePrize>;
-        /** 批量发放券 */
-        batchIssueCoupon(request: Service.Request.batchIssueCoupon, req: any): Promise<Service.Response.distributePrize>;
     }
 }

package/modules/pointsMall/service.d.ts

@@ -9,6 +9,7 @@ declare class PointsMallService extends BaseService implements Service.PointsMal
     getProductDetail(request: Service.Request.getProductDetail): Promise<Service.Response.getProductDetail>;
     queryEnabledAndOnlineProducts(request: Service.Request.queryEnabledAndOnlineProducts): Promise<Service.Response.queryEnabledAndOnlineProducts>;
     getAvailableCouponCountForProduct(request: Service.Request.getAvailableCouponCountForProduct): Promise<Service.Response.getAvailableCouponCountForProduct>;
+    getConsumptionThresholdInfo(request: Service.Request.getConsumptionThresholdInfo): Promise<Service.Response.getConsumptionThresholdInfo>;
 }
 export declare const pointsMallService: PointsMallService;
 export default pointsMallService;

package/modules/pointsMall/service.js

@@ -42,6 +42,9 @@ let PointsMallService = class PointsMallService extends BaseService_1.default {
     getAvailableCouponCountForProduct(request) {
         return (0, http_1.callApi)(this.getApiUrl(this.getAvailableCouponCountForProduct), request);
     }
+    getConsumptionThresholdInfo(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.getConsumptionThresholdInfo), request);
+    }
 };
 __decorate([
     (0, tsoa_1.OperationId)('批量创建积分商城商品'),
@@ -78,6 +81,11 @@ __decorate([
     (0, tsoa_1.Post)('get-available-coupon-count-for-product'),
     __param(0, (0, tsoa_1.Body)())
 ], PointsMallService.prototype, "getAvailableCouponCountForProduct", null);
+__decorate([
+    (0, tsoa_1.OperationId)('查询商品消费门槛校验信息'),
+    (0, tsoa_1.Post)('get-consumption-threshold-info'),
+    __param(0, (0, tsoa_1.Body)())
+], PointsMallService.prototype, "getConsumptionThresholdInfo", null);
 PointsMallService = __decorate([
     (0, tsoa_1.Route)('points-mall'),
     (0, tsoa_1.Tags)('PointsMall')

package/modules/pointsMall/types.d.ts

@@ -23,6 +23,10 @@ export declare namespace Service {
             enabled: number;
             /** 排序权重 */
             sortOrder: number;
+            /** 消费周期天数 */
+            consumptionPeriodDays: number;
+            /** 消费门槛金额（单位：分） */
+            consumptionThresholdAmount: number;
         }
         /** 后台管理列表 - 完整12个字段 */
         interface AdminProductItem {
@@ -42,6 +46,8 @@ export declare namespace Service {
             limitPerUser?: number;
             pointsRequired: number;
             couponRequired: number;
+            consumptionPeriodDays: number | null;
+            consumptionThresholdAmount: number | null;
             productImage: string;
         }
         /** C端积分商城列表 - 精确7个字段 */
@@ -64,6 +70,8 @@ export declare namespace Service {
             exchangeType: ENUM.POINT_MALL.ExchangeType;
             enabled?: number;
             sortOrder?: number;
+            consumptionPeriodDays?: number;
+            consumptionThresholdAmount?: number;
         }
         export interface CreateProduct extends BaseParams {
         }
@@ -121,6 +129,13 @@ export declare namespace Service {
             /** 是否开启 */
             enabled?: number;
         }
+        /** 查询商品消费门槛校验信息 */
+        export interface getConsumptionThresholdInfo {
+            /** 用户ID */
+            userId: string;
+            /** 商品ID */
+            productId: string;
+        }
         export {};
     }
     namespace Response {
@@ -166,6 +181,17 @@ export declare namespace Service {
             /** 可用优惠券数量 */
             count: number;
         }
+        /** 查询商品消费门槛校验信息响应 */
+        interface getConsumptionThresholdInfo {
+            /** 是否需要校验消费门槛 */
+            needValidation: boolean;
+            /** 消费金额（单位：分，不需要校验返回-1） */
+            consumptionAmount: number;
+            /** 门槛金额（单位：分，不需要校验返回-1） */
+            thresholdAmount: number;
+            /** 是否满足消费门槛 */
+            isThresholdMet: boolean;
+        }
     }
     interface PointsMallController {
         /** 批量创建积分商城商品 */
@@ -182,5 +208,7 @@ export declare namespace Service {
         queryEnabledAndOnlineProducts(request: Service.Request.queryEnabledAndOnlineProducts): Promise<Service.Response.queryEnabledAndOnlineProducts>;
         /** 查询指定商品用户可用优惠券的数量 */
         getAvailableCouponCountForProduct(request: Service.Request.getAvailableCouponCountForProduct): Promise<Service.Response.getAvailableCouponCountForProduct>;
+        /** 查询商品消费门槛校验信息 */
+        getConsumptionThresholdInfo(request: Service.Request.getConsumptionThresholdInfo): Promise<Service.Response.getConsumptionThresholdInfo>;
     }
 }

package/modules/pricingCalculation/types.d.ts

@@ -153,12 +153,6 @@ export declare namespace Service {
                 originalAmount: number;
                 /** 券优惠金额（分） */
                 couponDiscountAmount: number;
-                /** 会员优惠金额（分） */
-                memberDiscount: {
-                    totalAmount: number;
-                    itemAmount: number;
-                    quantity: number;
-                };
                 /** 优惠后金额（分） */
                 discountedAmount: number;
                 /** 积分最高抵扣金额（分） */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@be-link/ecommerce-promotion-service-node-sdk",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "EcommercePromotionService Node.js SDK",
   "main": "index.js",
   "types": "index.d.ts",

package/utils/http.d.ts

@@ -9,3 +9,25 @@ 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;

package/utils/http.js

@@ -4,22 +4,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callApi = callApi;
+exports.getConnectionStats = getConnectionStats;
+exports.resetPeakStats = resetPeakStats;
 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 safe_stable_stringify_1 = __importDefault(require("safe-stable-stringify"));
 const http_1 = __importDefault(require("http"));
 const https_1 = __importDefault(require("https"));
-// HTTP 连接池配置 - 支持 2000 QPS（响应时间 2秒）
+// 针对高并发优化配置 - 支持高并发场景
 const HTTP_CONFIG = {
-    maxSockets: 3000, // 每个 host 最大并发连接数
-    maxFreeSockets: 1000, // 保持空闲连接数（减少连接重建开销）
-    maxTotalSockets: 10000, // 所有 host 总连接数上限（支持多个服务同时调用）
-    keepAliveMsecs: 60000, // 保持连接60秒
-    timeout: 5000, // socket超时5秒
-    requestTimeout: 5000, // 请求超时5秒
-    retries: 0, // 不重试（失败直接返回）
-    retryBaseDelay: 200, // 基础重试延迟200ms
+    maxSockets: 2000, // 每个主机的最大socket连接数（支持2000并发）
+    maxFreeSockets: 1000, // 空闲socket保留数（50%复用率，提高连接复用效率）
+    maxTotalSockets: 3000, // 所有主机总socket数（单后端场景优化）
+    keepAliveMsecs: 30000, // 保持连接30秒（平衡资源占用和连接复用）
+    timeout: 3000, // socket超时3秒（高并发场景快速失败）
+    requestTimeout: 3000, // 请求超时3秒（快速释放资源，避免慢请求占用连接）
+    retries: 1, // 重试1次（减少重试，避免高并发时加重后端压力）
+    retryBaseDelay: 100, // 基础重试延迟100ms（给服务恢复时间）
+    logThreshold: 1000, // 日志采样率（每1000个请求采样1次，降低日志开销）
+    monitorInterval: 5000, // 监控日志间隔（毫秒）
 };
 // 配置 HTTP/HTTPS Agent 以支持高并发连接池和 keepAlive
 const httpAgent = new http_1.default.Agent({
@@ -29,7 +34,7 @@ const httpAgent = new http_1.default.Agent({
     maxFreeSockets: HTTP_CONFIG.maxFreeSockets,
     maxTotalSockets: HTTP_CONFIG.maxTotalSockets,
     timeout: HTTP_CONFIG.timeout,
-    scheduling: 'lifo', // 后进先出调度（优先复用热连接，提高连接复用效率）
+    scheduling: 'fifo', // 先进先出调度
 });
 const httpsAgent = new https_1.default.Agent({
     keepAlive: true,
@@ -38,7 +43,7 @@ const httpsAgent = new https_1.default.Agent({
     maxFreeSockets: HTTP_CONFIG.maxFreeSockets,
     maxTotalSockets: HTTP_CONFIG.maxTotalSockets,
     timeout: HTTP_CONFIG.timeout,
-    scheduling: 'lifo', // 后进先出调度（优先复用热连接，提高连接复用效率）
+    scheduling: 'fifo',
 });
 // 配置 axios 默认使用这些 agent
 axios_1.default.defaults.httpAgent = httpAgent;
@@ -52,16 +57,10 @@ axios_1.default.defaults.maxContentLength = 50 * 1024 * 1024; // 50MB 最大响
     retryCondition(error) {
         // 重试临时错误和特定的网络错误
         const status = error.response?.status;
-        const isNetworkError = error.code === 'ECONNRESET' ||
-            error.code === 'ETIMEDOUT' ||
-            error.code === 'ECONNREFUSED' ||
-            error.code === 'ENOTFOUND' ||
-            error.code === 'ENETUNREACH' ||
-            error.code === 'EAI_AGAIN';
+        const isNetworkError = error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT';
         const isServerError = status === 502 || status === 503 || status === 504;
         const isRateLimited = status === 429;
-        const isTimeout = error.code === 'ECONNABORTED' || error.message?.includes('timeout');
-        return isNetworkError || isServerError || isRateLimited || isTimeout;
+        return isNetworkError || isServerError || isRateLimited;
     },
     retryDelay: (retryCount, error) => {
         // 指数退避 + 抖动
@@ -74,35 +73,138 @@ axios_1.default.defaults.maxContentLength = 50 * 1024 * 1024; // 50MB 最大响
             }
             return 1000 + Math.random() * 1000; // 1-2秒
         }
-        // 指数退避：200ms, 400ms, 800ms...
+        // 指数退避：100ms, 200ms, 400ms...
         const exponentialDelay = HTTP_CONFIG.retryBaseDelay * Math.pow(2, retryCount - 1);
-        const jitter = Math.random() * 100; // 0-100ms 抖动
-        return Math.min(exponentialDelay + jitter, 3000); // 最多延迟3秒
+        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; // 峰值并发
 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 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',
+    // 采样日志决策（提前计算，避免重复判断）
+    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--;
+    }
+}
+// 导出监控函数
+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,
         },
-        timeout: HTTP_CONFIG.requestTimeout,
-        httpAgent,
-        httpsAgent,
-    });
-    const responseData = response.data;
-    return responseData.data;
+        // 配置信息
+        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',
+    }));
 }