@nest-omni/core 4.1.3-3 → 4.1.3-31

package/http-client/services/http-client.service.js

@@ -8,6 +8,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -17,30 +20,45 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var HttpClientService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClientService = void 0;
 const common_1 = require("@nestjs/common");
 const axios_retry_1 = require("axios-retry");
-const cache_1 = require("../../cache");
+const api_client_config_interface_1 = require("../interfaces/api-client-config.interface");
 const circuit_breaker_service_1 = require("./circuit-breaker.service");
 const logging_service_1 = require("./logging.service");
-const cache_service_1 = require("./cache.service");
 const decorators_1 = require("../decorators");
 const context_extractor_util_1 = require("../utils/context-extractor.util");
 const curl_generator_util_1 = require("../utils/curl-generator.util");
+const call_stack_extractor_util_1 = require("../utils/call-stack-extractor.util");
 const retry_recorder_util_1 = require("../utils/retry-recorder.util");
 const request_id_util_1 = require("../utils/request-id.util");
+const proxy_environment_util_1 = require("../utils/proxy-environment.util");
 const redis_lock_service_1 = require("../../redis-lock/redis-lock.service");
+const security_validator_util_1 = require("../utils/security-validator.util");
 /**
  * HTTP客户端服务
  * 基于Spring RestTemplate的设计理念，集成axios-retry库
+ * 支持两种创建模式:
+ * 1. 直接创建: 用于简单的HTTP请求场景
+ * 2. API客户端模式: 用于需要认证、统计等高级功能的API客户端
  */
 let HttpClientService = HttpClientService_1 = class HttpClientService {
-    constructor(circuitBreakerService, loggingService, cacheService, redisLockService, config = {}) {
+    constructor(circuitBreakerService, loggingService, redisLockService, config = {}, clientName, authConfig) {
         this.circuitBreakerService = circuitBreakerService;
         this.loggingService = loggingService;
-        this.cacheService = cacheService;
         this.redisLockService = redisLockService;
         this.logger = new common_1.Logger(HttpClientService_1.name);
         this.requestStats = {
@@ -48,55 +66,149 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
             successfulRequests: 0,
             failedRequests: 0,
             totalResponseTime: 0,
+            averageResponseTime: 0,
             requestsByMethod: {},
             requestsByStatus: {},
         };
         this.defaultConfig = this.mergeWithDefaults(config);
+        this.clientName = clientName;
+        this.authConfig = authConfig;
         this.axiosInstance = this.createAxiosInstance();
     }
+    /**
+     * 静态工厂方法：创建API客户端模式的 HttpClientService
+     * @param dependencies 依赖服务
+     * @param config API客户端配置
+     * @returns HttpClientService 实例
+     */
+    static createApiClient(dependencies, config) {
+        // 构建配置，只在值有效时才覆盖
+        const mergedConfig = Object.assign({}, config.httpConfig);
+        // 只在显式提供且值有效时才覆盖
+        if (config.baseURL !== undefined) {
+            mergedConfig.baseURL = config.baseURL;
+        }
+        if (config.timeout !== undefined) {
+            mergedConfig.timeout = config.timeout;
+        }
+        return new HttpClientService_1(dependencies.circuitBreakerService, dependencies.loggingService, dependencies.redisLockService, mergedConfig, config.name, config.auth);
+    }
     /**
      * 执行HTTP请求
+     * @param config 请求配置
+     * @param decoratorContext 装饰器上下文
+     * @param clientName 客户端名称
+     * @param returnOptions 返回选项
+     *   - returnType: 'data'(默认)只返回response.data
+     *   - returnType: 'full'返回完整AxiosResponse对象
+     *   - returnType: 'custom'使用自定义转换函数
+     *   - transform: 自定义转换函数，接收完整response返回任意数据
      */
-    request(config, decoratorContext) {
+    request(config, decoratorContext, clientName, returnOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+            // Use the instance's clientName as fallback if not provided
+            const effectiveClientName = clientName || this.clientName;
+            // If no decorator context provided, try to get it from CallStackExtractor
+            // This allows decorators on service methods to pass context to HTTP client
+            const effectiveDecoratorContext = decoratorContext || call_stack_extractor_util_1.CallStackExtractor.getDecoratorContext();
+            // ========== 安全验证开始 ==========
+            // 构造完整URL进行验证
+            const requestURL = config.url || '';
+            const baseURL = config.baseURL || this.defaultConfig.baseURL || '';
+            // 构建完整的URL用于验证
+            let fullURL = requestURL;
+            if (requestURL &&
+                !requestURL.startsWith('http://') &&
+                !requestURL.startsWith('https://') &&
+                baseURL) {
+                // 处理相对URL
+                try {
+                    fullURL = new URL(requestURL, baseURL).href;
+                }
+                catch (_o) {
+                    // 如果URL构建失败，使用原始URL
+                    fullURL = requestURL;
+                }
+            }
+            // 执行URL安全验证（只对完整URL进行验证）
+            if (fullURL &&
+                (fullURL.startsWith('http://') || fullURL.startsWith('https://'))) {
+                const sanitizeResult = security_validator_util_1.SecurityValidator.sanitizeURL(fullURL, {
+                    urlConfig: (_a = this.defaultConfig.security) === null || _a === void 0 ? void 0 : _a.urlValidation,
+                    ssrfConfig: (_b = this.defaultConfig.security) === null || _b === void 0 ? void 0 : _b.ssrfProtection,
+                });
+                if (!sanitizeResult.valid) {
+                    const error = new Error(`URL validation failed: ${sanitizeResult.error}`);
+                    this.logger.error(`URL validation failed for ${fullURL}: ${sanitizeResult.error}`);
+                    throw error;
+                }
+                // 如果URL被修改，更新配置
+                if (sanitizeResult.url !== fullURL) {
+                    // 更新URL为清洗后的安全URL
+                    this.logger.debug(`URL sanitized from "${fullURL}" to "${sanitizeResult.url}"`);
+                    // 如果原始URL是相对路径，保持相对路径；否则更新为清洗后的完整URL
+                    if (requestURL && !requestURL.startsWith('http://') && !requestURL.startsWith('https://')) {
+                        // 相对路径情况：从清洗后的完整URL中提取相对路径部分
+                        try {
+                            const sanitizedURL = new URL(sanitizeResult.url);
+                            const baseURLParts = baseURL.split('/');
+                            const sanitizedPathParts = sanitizedURL.pathname.split('/');
+                            // 计算相对路径
+                            let relativePath = sanitizedURL.pathname;
+                            if (baseURLParts.length > 3) {
+                                const basePath = baseURLParts.slice(3).join('/');
+                                if (relativePath.startsWith(basePath)) {
+                                    relativePath = relativePath.substring(basePath.length);
+                                }
+                            }
+                            config.url = relativePath || requestURL;
+                        }
+                        catch (_p) {
+                            // 如果提取失败，保持原始URL
+                            config.url = requestURL;
+                        }
+                    }
+                    else {
+                        // 绝对路径情况：直接使用清洗后的URL
+                        config.url = sanitizeResult.url;
+                    }
+                }
+            }
+            // ========== 安全验证结束 ==========
+            // Capture the calling context information
+            const callingContext = this.captureCallingContext();
             const startTime = Date.now();
             const retryRecorder = retry_recorder_util_1.RetryRecorder.create();
             let requestId;
             let circuitBreakerState;
-            let cacheHit = false;
             try {
+                // 应用认证配置
+                const authConfig = yield this.applyAuthToConfig(config);
                 // 应用装饰器配置
-                const enhancedConfig = this.applyDecoratorConfig(config, decoratorContext);
+                const enhancedConfig = this.applyDecoratorConfig(authConfig, decoratorContext);
+                // 将 retryRecorder 存储到 config metadata 中,供 onRetry 回调使用
+                enhancedConfig.metadata = enhancedConfig.metadata || {};
+                enhancedConfig.metadata.retryRecorder = retryRecorder;
                 // 获取装饰器配置
-                const decoratorConfigs = decoratorContext
-                    ? decorators_1.HttpDecoratorUtils.getAllDecoratorConfigs(decoratorContext.target, decoratorContext.propertyKey)
+                const decoratorConfigs = effectiveDecoratorContext
+                    ? decorators_1.HttpDecoratorUtils.getAllDecoratorConfigs(effectiveDecoratorContext.target, effectiveDecoratorContext.propertyKey)
                     : {};
+                // 存储装饰器的重试配置到 metadata，供 retryCondition 使用
+                if (((_c = decoratorConfigs.retry) === null || _c === void 0 ? void 0 : _c.enabled) !== undefined) {
+                    enhancedConfig.metadata.retryEnabled = decoratorConfigs.retry.enabled;
+                }
                 // 日志记录开始
-                const loggingOptions = decoratorConfigs.logging || this.defaultConfig.logging;
+                const decoratorLogging = decoratorConfigs.logging || {};
+                this.logger.debug(`Logging config merge: decoratorLogging=${JSON.stringify(decoratorLogging)}, defaultLogging=${JSON.stringify(this.defaultConfig.logging)}`);
+                const loggingOptions = Object.assign(Object.assign(Object.assign({}, this.defaultConfig.logging), decoratorLogging), { databaseLogging: (_d = this.defaultConfig.logging) === null || _d === void 0 ? void 0 : _d.databaseLogging });
+                this.logger.debug(`Merged loggingOptions: databaseLog=${loggingOptions.databaseLog}, hasDatabaseLogging=${!!loggingOptions.databaseLogging}`);
                 if (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.enabled) {
                     requestId = this.loggingService.logRequestStart(enhancedConfig, loggingOptions);
                     // 将requestId保存到config中
                     enhancedConfig.metadata = enhancedConfig.metadata || {};
                     enhancedConfig.metadata.requestId = requestId;
                 }
-                // 缓存检查
-                const cacheConfig = decoratorConfigs.cache || this.defaultConfig.cache;
-                if ((cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.enabled) &&
-                    this.shouldCacheRequest(enhancedConfig, cacheConfig)) {
-                    const cachedResponse = yield this.cacheService.get(enhancedConfig, cacheConfig);
-                    if (cachedResponse) {
-                        cacheHit = true;
-                        if (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.enabled) {
-                            const databaseLogging = (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.databaseLog) ||
-                                ((_b = (_a = this.defaultConfig.logging) === null || _a === void 0 ? void 0 : _a.databaseLogging) === null || _b === void 0 ? void 0 : _b.enabled);
-                            this.loggingService.logRequestSuccess(cachedResponse, startTime, requestId, loggingOptions, databaseLogging, undefined, // no retry records for cache hit
-                            cacheHit, undefined, // circuit breaker state
-                            decoratorContext);
-                        }
-                        return cachedResponse.data;
-                    }
-                }
                 // 应用超时配置
                 const timeout = decoratorConfigs.timeout || this.defaultConfig.timeout;
                 if (timeout) {
@@ -105,53 +217,60 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                 // 应用代理配置
                 const proxyConfig = decoratorConfigs.proxy || this.defaultConfig.proxy;
                 if (proxyConfig === null || proxyConfig === void 0 ? void 0 : proxyConfig.enabled) {
-                    enhancedConfig.proxy = {
-                        host: proxyConfig.host,
-                        port: proxyConfig.port,
-                        protocol: proxyConfig.protocol,
-                        auth: proxyConfig.auth,
-                    };
-                }
-                // 配置axios-retry的onRetry回调以记录重试
-                if ((_c = this.defaultConfig.retry) === null || _c === void 0 ? void 0 : _c.enabled) {
-                    const originalOnRetry = this.defaultConfig.retry.onRetry;
-                    this.defaultConfig.retry.onRetry = (retryCount, error, requestConfig) => {
-                        // 记录重试
-                        const retryRecord = retry_recorder_util_1.RetryRecorder.recordRetry(retryCount, error, requestConfig, this.calculateRetryDelay(retryCount, this.defaultConfig.retry));
-                        retryRecorder.addRecord(retryRecord);
-                        // 调用原始回调
-                        if (originalOnRetry) {
-                            originalOnRetry(retryCount, error, requestConfig);
-                        }
-                    };
+                    const resolvedProxy = this.resolveProxyConfig(proxyConfig, enhancedConfig.url);
+                    if (resolvedProxy !== false) {
+                        enhancedConfig.proxy = resolvedProxy;
+                    }
                 }
                 // 执行请求（带重试和熔断器）
-                const response = yield this.executeWithFeatures(enhancedConfig, decoratorConfigs, requestId, startTime, retryRecorder, (state) => {
-                    circuitBreakerState = state;
-                });
-                // 缓存响应
-                if ((cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.enabled) &&
-                    this.shouldCacheRequest(enhancedConfig, cacheConfig)) {
-                    yield this.cacheService.set(enhancedConfig, response, cacheConfig);
-                }
+                const { response, circuitBreakerState: state } = yield this.executeWithFeatures(enhancedConfig, decoratorConfigs, requestId, startTime, retryRecorder);
+                // 更新 circuitBreakerState 变量
+                circuitBreakerState = state;
+                this.logger.debug(`Request completed, circuitBreakerState: ${circuitBreakerState || 'undefined'}`);
                 // 成功日志
                 if (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.enabled) {
-                    const databaseLogging = (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.databaseLog) ||
-                        ((_e = (_d = this.defaultConfig.logging) === null || _d === void 0 ? void 0 : _d.databaseLogging) === null || _e === void 0 ? void 0 : _e.enabled);
-                    this.loggingService.logRequestSuccess(response, startTime, requestId, loggingOptions, databaseLogging, retryRecorder.getRecords(), cacheHit, circuitBreakerState, decoratorContext);
+                    const databaseLogging = (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.databaseLogging) ||
+                        ((_f = (_e = this.defaultConfig.logging) === null || _e === void 0 ? void 0 : _e.databaseLogging) === null || _f === void 0 ? void 0 : _f.enabled);
+                    this.logger.debug(`Logging request success with circuitBreakerState: ${circuitBreakerState || 'undefined'}`);
+                    this.loggingService.logRequestSuccess(response, startTime, requestId, loggingOptions, databaseLogging, retryRecorder.getRecords(), circuitBreakerState, decoratorContext, effectiveClientName, callingContext);
+                }
+                // 更新统计信息
+                this.updateRequestStats(true, Date.now() - startTime, ((_g = response.config) === null || _g === void 0 ? void 0 : _g.method) || 'GET', response.status);
+                // 根据返回选项处理响应
+                const options = returnOptions || { returnType: 'data' };
+                switch (options.returnType) {
+                    case 'full':
+                        // 返回完整响应对象
+                        return response;
+                    case 'custom':
+                        // 使用自定义转换函数
+                        if (options.transform) {
+                            return options.transform(response);
+                        }
+                        // 如果没有提供转换函数，回退到返回data
+                        return response.data;
+                    case 'data':
+                    default:
+                        // 默认只返回data（保持向后兼容）
+                        return response.data;
                 }
-                return response.data;
             }
             catch (error) {
                 // 错误日志
-                const loggingOptions = decoratorContext
-                    ? decorators_1.HttpDecoratorUtils.getLoggingOptions(decoratorContext.target, decoratorContext.propertyKey)
-                    : this.defaultConfig.logging;
+                const decoratorLogging = effectiveDecoratorContext
+                    ? decorators_1.HttpDecoratorUtils.getLoggingOptions(effectiveDecoratorContext.target, effectiveDecoratorContext.propertyKey)
+                    : {};
+                const loggingOptions = Object.assign(Object.assign(Object.assign({}, this.defaultConfig.logging), decoratorLogging), { databaseLogging: (_h = this.defaultConfig.logging) === null || _h === void 0 ? void 0 : _h.databaseLogging });
                 if (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.enabled) {
                     const databaseLogging = (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.databaseLog) ||
-                        ((_g = (_f = this.defaultConfig.logging) === null || _f === void 0 ? void 0 : _f.databaseLogging) === null || _g === void 0 ? void 0 : _g.enabled);
-                    this.loggingService.logRequestError(error, startTime, requestId, retryRecorder.getRecords().length || 1, loggingOptions, databaseLogging, retryRecorder.getRecords(), cacheHit, circuitBreakerState, decoratorContext);
+                        ((_k = (_j = this.defaultConfig.logging) === null || _j === void 0 ? void 0 : _j.databaseLogging) === null || _k === void 0 ? void 0 : _k.enabled);
+                    const records = retryRecorder.getRecords();
+                    this.loggingService.logRequestError(error, startTime, requestId, (records === null || records === void 0 ? void 0 : records.length) ? Math.max(...records.map((r) => r.attempt)) + 1 : 1, loggingOptions, databaseLogging, records, circuitBreakerState, effectiveDecoratorContext, effectiveClientName, callingContext);
                 }
+                // 更新统计信息
+                const errorMethod = (_l = error.config) === null || _l === void 0 ? void 0 : _l.method;
+                const errorStatus = (_m = error.response) === null || _m === void 0 ? void 0 : _m.status;
+                this.updateRequestStats(false, Date.now() - startTime, errorMethod, errorStatus);
                 throw error;
             }
         });
@@ -172,14 +291,21 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
      * 获取请求统计信息
      */
     getStats() {
-        const avgResponseTime = this.requestStats.totalRequests > 0
-            ? this.requestStats.totalResponseTime / this.requestStats.totalRequests
-            : 0;
-        return Object.assign(Object.assign({}, this.requestStats), { averageResponseTime: avgResponseTime, successRate: this.requestStats.totalRequests > 0
+        return {
+            totalRequests: this.requestStats.totalRequests,
+            successfulRequests: this.requestStats.successfulRequests,
+            failedRequests: this.requestStats.failedRequests,
+            totalResponseTime: this.requestStats.totalResponseTime,
+            averageResponseTime: this.requestStats.averageResponseTime,
+            successRate: this.requestStats.totalRequests > 0
                 ? (this.requestStats.successfulRequests /
                     this.requestStats.totalRequests) *
                     100
-                : 0, circuitBreakerStats: this.circuitBreakerService.getAllStates(), cacheStats: this.cacheService.getStats() });
+                : 0,
+            requestsByMethod: this.requestStats.requestsByMethod,
+            requestsByStatus: this.requestStats.requestsByStatus,
+            circuitBreakerStats: this.circuitBreakerService.getAllStates(),
+        };
     }
     /**
      * 重置统计信息
@@ -190,34 +316,41 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
             successfulRequests: 0,
             failedRequests: 0,
             totalResponseTime: 0,
+            averageResponseTime: 0,
             requestsByMethod: {},
             requestsByStatus: {},
         };
     }
+    /**
+     * 获取客户端名称
+     */
+    getName() {
+        return this.clientName;
+    }
     // 便捷方法
-    get(url, config) {
+    get(url, config, clientName, returnOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'GET', url }));
+            return this.request(Object.assign(Object.assign({}, config), { method: 'GET', url }), undefined, clientName, returnOptions);
         });
     }
-    post(url, data, config) {
+    post(url, data, config, clientName, returnOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'POST', url, data }));
+            return this.request(Object.assign(Object.assign({}, config), { method: 'POST', url, data }), undefined, clientName, returnOptions);
         });
     }
-    put(url, data, config) {
+    put(url, data, config, clientName, returnOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'PUT', url, data }));
+            return this.request(Object.assign(Object.assign({}, config), { method: 'PUT', url, data }), undefined, clientName, returnOptions);
         });
     }
-    patch(url, data, config) {
+    patch(url, data, config, clientName, returnOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'PATCH', url, data }));
+            return this.request(Object.assign(Object.assign({}, config), { method: 'PATCH', url, data }), undefined, clientName, returnOptions);
         });
     }
-    delete(url, config) {
+    delete(url, config, clientName, returnOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'DELETE', url }));
+            return this.request(Object.assign(Object.assign({}, config), { method: 'DELETE', url }), undefined, clientName, returnOptions);
         });
     }
     /**
@@ -229,11 +362,12 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
      * @param options 等待锁选项
      * @returns 响应数据
      */
-    authRequest(config, tokenProvider, options) {
+    authRequest(config, tokenProvider, options, clientName, returnOptions) {
         return __awaiter(this, void 0, void 0, function* () {
+            const effectiveClientName = clientName || this.clientName;
             if (!this.redisLockService) {
                 this.logger.warn('RedisLockService not available, proceeding without lock');
-                return this.request(config);
+                return this.request(config, undefined, effectiveClientName, returnOptions);
             }
             const { lockKey = `auth-request:${(0, request_id_util_1.generateRequestId)()}`, lockTimeout = 30000, waitTimeout = 60000, enableRetry = true, } = options || {};
             try {
@@ -244,7 +378,7 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                     // 添加认证头
                     const authConfig = Object.assign(Object.assign({}, config), { headers: Object.assign(Object.assign({}, config.headers), { Authorization: `Bearer ${token}` }) });
                     // 执行请求
-                    return this.request(authConfig);
+                    return this.request(authConfig, undefined, effectiveClientName, returnOptions);
                 }), {
                     ttl: lockTimeout,
                     retryCount: enableRetry ? 3 : 0,
@@ -263,7 +397,7 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                     this.logger.warn('Retrying auth request without lock');
                     const token = yield tokenProvider();
                     const authConfig = Object.assign(Object.assign({}, config), { headers: Object.assign(Object.assign({}, config.headers), { Authorization: `Bearer ${token}` }) });
-                    return this.request(authConfig);
+                    return this.request(authConfig, undefined, effectiveClientName);
                 }
                 throw error;
             }
@@ -278,8 +412,9 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
      * @param options 等待锁选项
      * @returns 响应数组
      */
-    authBatchRequest(requests, tokenProvider, options) {
+    authBatchRequest(requests, tokenProvider, options, clientName) {
         return __awaiter(this, void 0, void 0, function* () {
+            const effectiveClientName = clientName || this.clientName;
             if (!this.redisLockService) {
                 this.logger.warn('RedisLockService not available, proceeding batch auth requests without lock');
                 // 无锁批量执行
@@ -287,7 +422,7 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                 const promises = requests.map((request) => __awaiter(this, void 0, void 0, function* () {
                     try {
                         const authConfig = Object.assign(Object.assign({}, request.config), { headers: Object.assign(Object.assign({}, request.config.headers), { Authorization: `Bearer ${token}` }) });
-                        return yield this.request(authConfig);
+                        return yield this.request(authConfig, undefined, effectiveClientName);
                     }
                     catch (error) {
                         this.logger.error(`Batch auth request failed for key: ${request.key}`, error);
@@ -309,7 +444,7 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                     const executeRequest = (requestConfig, key, index) => __awaiter(this, void 0, void 0, function* () {
                         try {
                             const authConfig = Object.assign(Object.assign({}, requestConfig), { headers: Object.assign(Object.assign({}, requestConfig.headers), { Authorization: `Bearer ${token}` }) });
-                            const result = yield this.request(authConfig);
+                            const result = yield this.request(authConfig, undefined, effectiveClientName);
                             results[index] = result;
                             return result;
                         }
@@ -365,42 +500,125 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
             }
         });
     }
+    /**
+     * Capture calling context information
+     * @returns Calling context with service class and method name
+     */
+    captureCallingContext() {
+        try {
+            // Use CallStackExtractor to get the calling context
+            const stackInfo = call_stack_extractor_util_1.CallStackExtractor.getCallInfo();
+            // Skip internal HTTP client calls
+            if (stackInfo.serviceClass && stackInfo.methodName) {
+                // Check if it's an internal call
+                const isInternal = call_stack_extractor_util_1.CallStackExtractor['isInternalCall'](stackInfo.serviceClass);
+                if (!isInternal) {
+                    return {
+                        serviceClass: stackInfo.serviceClass,
+                        methodName: stackInfo.methodName,
+                        operationName: stackInfo.operationName,
+                    };
+                }
+            }
+            // If no useful context found, return empty
+            return {};
+        }
+        catch (error) {
+            this.logger.warn('Failed to capture calling context:', error.message);
+            return {};
+        }
+    }
     /**
      * 创建Axios实例并配置axios-retry
      */
     createAxiosInstance() {
-        var _a, _b;
-        const instance = require('axios').create({
+        var _a, _b, _c;
+        // 合并代理配置和 axiosConfig 透传配置
+        const resolvedProxy = this.resolveProxyConfig(this.defaultConfig.proxy);
+        // 处理 SSL 配置和 httpsAgent
+        let httpsAgent = (_a = this.defaultConfig.axiosConfig) === null || _a === void 0 ? void 0 : _a.httpsAgent;
+        if ((_b = this.defaultConfig.axiosConfig) === null || _b === void 0 ? void 0 : _b.ssl) {
+            const ssl = this.defaultConfig.axiosConfig.ssl;
+            const https = require('https');
+            if (!httpsAgent) {
+                // 如果没有预定义的 httpsAgent，使用 SSL 配置创建
+                httpsAgent = new https.Agent(Object.assign(Object.assign({}, ssl), { keepAlive: true }));
+            }
+            else {
+                // 如果同时提供了 httpsAgent 和 ssl 配置
+                // ssl 配置会覆盖 httpsAgent 的相关选项
+                this.logger.warn('Both httpsAgent and ssl config provided. SSL config will take precedence for certificate options.');
+                // 创建新的 Agent，合并原有配置和 SSL 配置
+                httpsAgent = new https.Agent(Object.assign({ 
+                    // 保留原 Agent 的选项（除了证书相关）
+                    keepAlive: true }, ssl));
+            }
+        }
+        // 构建 axios 创建配置
+        const axiosCreateConfig = {
             baseURL: this.defaultConfig.baseURL,
             timeout: this.defaultConfig.timeout,
-            proxy: ((_a = this.defaultConfig.proxy) === null || _a === void 0 ? void 0 : _a.enabled)
-                ? {
-                    host: this.defaultConfig.proxy.host,
-                    port: this.defaultConfig.proxy.port,
-                    protocol: this.defaultConfig.proxy.protocol,
-                    auth: this.defaultConfig.proxy.auth,
-                }
+            // 只有当 resolvedProxy 是有效的配置对象时才设置代理
+            // false 和 undefined 都表示不使用代理
+            proxy: resolvedProxy && typeof resolvedProxy === 'object'
+                ? resolvedProxy
                 : undefined,
-        });
+            // 应用处理后的 httpsAgent
+            httpsAgent: httpsAgent,
+        };
+        // 透传所有其他 axiosConfig 配置（排除已特殊处理的字段）
+        // 只在值有效时才覆盖
+        if (this.defaultConfig.axiosConfig) {
+            const _d = this.defaultConfig.axiosConfig, { ssl, httpsAgent: _ } = _d, restAxiosConfig = __rest(_d, ["ssl", "httpsAgent"]);
+            for (const key in restAxiosConfig) {
+                if (restAxiosConfig[key] !== undefined) {
+                    axiosCreateConfig[key] = restAxiosConfig[key];
+                }
+            }
+        }
+        const instance = require('axios').create(axiosCreateConfig);
         // 配置axios-retry
-        if ((_b = this.defaultConfig.retry) === null || _b === void 0 ? void 0 : _b.enabled) {
+        if ((_c = this.defaultConfig.retry) === null || _c === void 0 ? void 0 : _c.enabled) {
             (0, axios_retry_1.default)(instance, {
                 retries: this.defaultConfig.retry.retries || 3,
                 retryDelay: this.defaultConfig.retry.retryDelay ||
                     ((retryCount) => Math.pow(2, retryCount) * 1000),
                 retryCondition: this.defaultConfig.retry.retryCondition ||
                     ((error) => {
+                        var _a;
+                        // 检查装饰器配置是否禁用了重试
+                        const requestConfig = error.config;
+                        if (((_a = requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.metadata) === null || _a === void 0 ? void 0 : _a.retryEnabled) === false) {
+                            return false; // 装饰器明确禁用了重试
+                        }
+                        // 默认重试条件：网络错误、超时、5xx错误、429错误
                         if (!error.response)
                             return true; // 网络错误
                         const status = error.response.status;
                         return status >= 500 || status === 429; // 5xx错误或429限流
                     }),
                 shouldResetTimeout: this.defaultConfig.retry.shouldResetTimeout !== false,
-                onRetry: this.defaultConfig.retry.onRetry ||
-                    ((retryCount, error, requestConfig) => {
-                        var _a;
-                        this.logger.warn(`Retrying request (attempt ${retryCount}): ${(_a = requestConfig.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()} ${requestConfig.url}`);
-                    }),
+                onRetry: (retryCount, error, requestConfig) => {
+                    var _a, _b, _c, _d;
+                    // 从 request config metadata 中获取 retryRecorder
+                    const retryRecorder = (_a = requestConfig.metadata) === null || _a === void 0 ? void 0 : _a.retryRecorder;
+                    if (retryRecorder) {
+                        this.logger.debug(`Recording retry attempt ${retryCount} for ${(_b = requestConfig.method) === null || _b === void 0 ? void 0 : _b.toUpperCase()} ${requestConfig.url}`);
+                        const retryRecord = retry_recorder_util_1.RetryRecorder.recordRetry(retryCount, error, requestConfig, this.calculateRetryDelay(retryCount, this.defaultConfig.retry));
+                        retryRecorder.addRecord(retryRecord);
+                    }
+                    else {
+                        this.logger.warn(`RetryRecorder not found in request config metadata for ${(_c = requestConfig.method) === null || _c === void 0 ? void 0 : _c.toUpperCase()} ${requestConfig.url}. Retry records will not be saved.`);
+                    }
+                    // 调用用户自定义的 onRetry 回调
+                    if (this.defaultConfig.retry.onRetry) {
+                        this.defaultConfig.retry.onRetry(retryCount, error, requestConfig);
+                    }
+                    else {
+                        // 默认日志
+                        this.logger.warn(`Retrying request (attempt ${retryCount}): ${(_d = requestConfig.method) === null || _d === void 0 ? void 0 : _d.toUpperCase()} ${requestConfig.url}`);
+                    }
+                },
             });
         }
         // 设置请求拦截器
@@ -413,7 +631,8 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
             if (context.userId) {
                 config.headers['X-User-ID'] = context.userId;
             }
-            // 存储requestId到config中供后续使用
+            // 存储requestId到config metadata中供后续使用
+            // 注意：不要覆盖已存在的 metadata，保留 retryRecorder 等其他数据
             config.metadata = config.metadata || {};
             config.metadata.requestId = requestId;
             return config;
@@ -422,17 +641,19 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
             return Promise.reject(error);
         });
         // 设置响应拦截器
+        // 注意: 统计信息已移至 request() 方法中统一管理,避免双重计数
         instance.interceptors.response.use((response) => {
-            this.updateStats(response);
+            // 不再在这里更新统计,由 request() 方法统一管理
             return response;
         }, (error) => {
-            this.updateErrorStats(error);
+            // 不再在这里更新统计,由 request() 方法统一管理
             return Promise.reject(error);
         });
         return instance;
     }
     /**
      * 执行带特性的请求（重试、熔断器等）
+     * 返回响应和熔断器状态
      */
     executeWithFeatures(config, decoratorConfigs, requestId, startTime, retryRecorder, onCircuitBreakerStateChange) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -441,10 +662,17 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
             const circuitBreakerConfig = decoratorConfigs.circuitBreaker || this.defaultConfig.circuitBreaker;
             if (circuitBreakerConfig === null || circuitBreakerConfig === void 0 ? void 0 : circuitBreakerConfig.enabled) {
                 const circuitBreakerKey = this.generateCircuitBreakerKey(config);
-                return this.circuitBreakerService.executeWithCircuitBreaker(circuitBreakerKey, requestFn, circuitBreakerConfig);
+                this.logger.debug(`Circuit breaker key: ${circuitBreakerKey}`);
+                // 执行请求
+                const result = yield this.circuitBreakerService.executeWithCircuitBreaker(circuitBreakerKey, requestFn, circuitBreakerConfig, onCircuitBreakerStateChange);
+                // 请求完成后，主动获取当前熔断器状态
+                const currentState = this.circuitBreakerService.getCircuitBreakerState(circuitBreakerKey);
+                this.logger.debug(`After request, circuit breaker state: ${currentState || 'undefined'}`);
+                return { response: result, circuitBreakerState: currentState };
             }
             else {
-                return requestFn();
+                const result = yield requestFn();
+                return { response: result, circuitBreakerState: undefined };
             }
         });
     }
@@ -460,67 +688,42 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
     }
     /**
      * 应用装饰器配置
+     * 只在装饰器配置值有效时才覆盖请求配置
      */
     applyDecoratorConfig(config, decoratorContext) {
         if (!decoratorContext)
             return Object.assign({}, config);
         const httpClientConfig = decorators_1.HttpDecoratorUtils.getHttpClientOptions(decoratorContext.target);
-        return Object.assign(Object.assign({}, config), httpClientConfig);
-    }
-    /**
-     * 判断是否应该缓存请求
-     */
-    shouldCacheRequest(config, cacheConfig) {
-        var _a;
-        const method = (_a = config.method) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-        return cacheConfig.cacheableMethods.includes(method || 'get');
+        // 只在值有效时才合并
+        const result = Object.assign({}, config);
+        for (const key in httpClientConfig) {
+            if (httpClientConfig[key] !== undefined) {
+                result[key] = httpClientConfig[key];
+            }
+        }
+        return result;
     }
+    // Note: applyDecoratorConfig is not currently being called in executeWithFeatures
+    // The decorator config is already being applied via effectiveDecoratorContext
     /**
      * 生成熔断器键
      */
     generateCircuitBreakerKey(config) {
         var _a;
         const method = ((_a = config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'UNKNOWN';
-        const url = new URL(config.url || '', this.defaultConfig.baseURL || 'http://localhost');
-        return `${method}:${url.host}${url.pathname}`;
-    }
-    /**
-     * 更新请求统计
-     */
-    updateStats(response) {
-        var _a, _b;
-        this.requestStats.totalRequests++;
-        this.requestStats.successfulRequests++;
-        const method = ((_a = response.config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'UNKNOWN';
-        const status = response.status;
-        this.requestStats.requestsByMethod[method] =
-            (this.requestStats.requestsByMethod[method] || 0) + 1;
-        this.requestStats.requestsByStatus[status] =
-            (this.requestStats.requestsByStatus[status] || 0) + 1;
-        if ((_b = response.config.metadata) === null || _b === void 0 ? void 0 : _b.startTime) {
-            const responseTime = Date.now() -
-                response.config.metadata
-                    .startTime;
-            this.requestStats.totalResponseTime += responseTime;
+        let url;
+        try {
+            // Try to construct URL with proper base
+            url = new URL(config.url || '', this.defaultConfig.baseURL || 'http://localhost');
         }
-    }
-    /**
-     * 更新错误统计
-     */
-    updateErrorStats(error) {
-        var _a;
-        this.requestStats.totalRequests++;
-        this.requestStats.failedRequests++;
-        if (error.config) {
-            const method = ((_a = error.config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'UNKNOWN';
-            this.requestStats.requestsByMethod[method] =
-                (this.requestStats.requestsByMethod[method] || 0) + 1;
-            if (error.response) {
-                const status = error.response.status;
-                this.requestStats.requestsByStatus[status] =
-                    (this.requestStats.requestsByStatus[status] || 0) + 1;
-            }
+        catch (error) {
+            // If URL construction fails, fall back to simple string format
+            this.logger.warn(`Failed to construct URL for circuit breaker key: ${config.url}, using fallback format`);
+            const baseURL = this.defaultConfig.baseURL || 'http://localhost';
+            const urlPath = config.url || '/';
+            return `${method}:${baseURL}${urlPath}`;
         }
+        return `${method}:${url.host}${url.pathname}`;
     }
     /**
      * 合并默认配置
@@ -549,15 +752,6 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                 minimumThroughputThreshold: 10,
                 countHalfOpenCalls: true,
             },
-            cache: {
-                enabled: true,
-                defaultTtl: 300000, // 5分钟
-                cacheableMethods: ['get'],
-                cacheableStatusCodes: [200, 201, 202, 204, 301, 302, 304],
-                options: {
-                    layers: [cache_1.CacheLayer.MEMORY, cache_1.CacheLayer.REDIS],
-                },
-            },
             logging: {
                 enabled: true,
                 logRequests: true,
@@ -566,12 +760,11 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                 logHeaders: true,
                 logBody: true,
                 maxBodyLength: 1000,
-                sanitizeHeaders: ['authorization', 'apikey', 'password', 'token'],
+                sanitize: ['password', 'secret', 'token', 'apiKey', 'authorization', 'cookie'],
                 logLevel: 'info',
                 databaseLogging: {
-                    enabled: false,
+                    enabled: true,
                     dataSource: 'default',
-                    tableName: 'http_logs',
                 },
             },
         };
@@ -579,10 +772,15 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
     }
     /**
      * 深度合并对象
+     * 只在源值有效（非 undefined）时才覆盖目标值
      */
     deepMerge(target, source) {
         const result = Object.assign({}, target);
         for (const key in source) {
+            // 跳过 undefined 值，不覆盖目标值
+            if (source[key] === undefined) {
+                continue;
+            }
             if (source[key] &&
                 typeof source[key] === 'object' &&
                 !Array.isArray(source[key])) {
@@ -594,12 +792,158 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
         }
         return result;
     }
+    /**
+     * 解析代理配置
+     * 支持从环境变量或手动配置中读取
+     * @param proxyConfig 代理配置
+     * @param targetUrl 目标 URL（用于 NO_PROXY 检查）
+     * @returns 解析后的代理配置，如果不应使用代理则返回 false 或 undefined
+     */
+    resolveProxyConfig(proxyConfig, targetUrl) {
+        var _a, _b, _c, _d;
+        if (!(proxyConfig === null || proxyConfig === void 0 ? void 0 : proxyConfig.enabled)) {
+            return undefined;
+        }
+        // 如果启用从环境变量读取
+        if (proxyConfig.fromEnvironment) {
+            // 确定目标协议
+            let protocol = 'http';
+            if (targetUrl) {
+                try {
+                    const url = new URL(targetUrl, this.defaultConfig.baseURL);
+                    protocol = url.protocol === 'https:' ? 'https' : 'http';
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to parse target URL: ${error.message}`);
+                }
+            }
+            // 从环境变量解析
+            const fullUrl = targetUrl
+                ? new URL(targetUrl, this.defaultConfig.baseURL).href
+                : undefined;
+            const envProxy = proxy_environment_util_1.ProxyEnvironmentParser.parseFromEnvironment(protocol, fullUrl);
+            if (envProxy === false) {
+                this.logger.debug('Proxy bypassed based on environment configuration');
+                return false;
+            }
+            const result = {
+                host: envProxy.host,
+                port: envProxy.port,
+                protocol: envProxy.protocol,
+            };
+            // 只有当 auth 存在且包含有效值时才添加
+            if (((_a = envProxy.auth) === null || _a === void 0 ? void 0 : _a.username) && ((_b = envProxy.auth) === null || _b === void 0 ? void 0 : _b.password)) {
+                result.auth = {
+                    username: envProxy.auth.username,
+                    password: envProxy.auth.password,
+                };
+            }
+            return result;
+        }
+        // 使用手动配置
+        if (proxyConfig.host && proxyConfig.port) {
+            const result = {
+                host: proxyConfig.host,
+                port: proxyConfig.port,
+                protocol: proxyConfig.protocol,
+            };
+            // 只有当 auth 存在且包含有效值时才添加
+            if (((_c = proxyConfig.auth) === null || _c === void 0 ? void 0 : _c.username) && ((_d = proxyConfig.auth) === null || _d === void 0 ? void 0 : _d.password)) {
+                result.auth = {
+                    username: proxyConfig.auth.username,
+                    password: proxyConfig.auth.password,
+                };
+            }
+            return result;
+        }
+        this.logger.warn('Proxy is enabled but neither fromEnvironment nor manual configuration is provided');
+        return undefined;
+    }
+    /**
+     * 应用认证配置到请求配置
+     */
+    applyAuthToConfig(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.authConfig) {
+                return config;
+            }
+            // Create a new config object to avoid type issues
+            const authConfig = Object.assign({}, config);
+            switch (this.authConfig.type) {
+                case api_client_config_interface_1.AuthType.NONE:
+                    break;
+                case api_client_config_interface_1.AuthType.API_KEY:
+                    const apiKeyConfig = this.authConfig.config;
+                    if (apiKeyConfig.location === 'header') {
+                        const headerName = apiKeyConfig.name || 'X-API-Key';
+                        const value = apiKeyConfig.prefix
+                            ? `${apiKeyConfig.prefix} ${apiKeyConfig.key}`
+                            : apiKeyConfig.key;
+                        authConfig.headers = Object.assign(Object.assign({}, authConfig.headers), { [headerName]: value });
+                    }
+                    else if (apiKeyConfig.location === 'query') {
+                        const paramName = apiKeyConfig.name || 'api_key';
+                        authConfig.params = Object.assign(Object.assign({}, authConfig.params), { [paramName]: apiKeyConfig.key });
+                    }
+                    break;
+                case api_client_config_interface_1.AuthType.BEARER_TOKEN:
+                    const bearerConfig = this.authConfig.config;
+                    const scheme = bearerConfig.scheme || 'Bearer';
+                    authConfig.headers = Object.assign(Object.assign({}, authConfig.headers), { Authorization: `${scheme} ${bearerConfig.token}` });
+                    break;
+                case api_client_config_interface_1.AuthType.BASIC_AUTH:
+                    const basicConfig = this.authConfig.config;
+                    const credentials = Buffer.from(`${basicConfig.username}:${basicConfig.password}`).toString('base64');
+                    authConfig.headers = Object.assign(Object.assign({}, authConfig.headers), { Authorization: `Basic ${credentials}` });
+                    break;
+                case api_client_config_interface_1.AuthType.OAUTH2:
+                    const oauthConfig = this.authConfig.config;
+                    // For now, using the access token directly if available
+                    if (oauthConfig.accessToken) {
+                        authConfig.headers = Object.assign(Object.assign({}, authConfig.headers), { Authorization: `Bearer ${oauthConfig.accessToken}` });
+                    }
+                    break;
+                case api_client_config_interface_1.AuthType.CUSTOM:
+                    // Handle CUSTOM authentication which requires async processing
+                    const customConfig = this.authConfig.config;
+                    return yield customConfig.authenticator(authConfig);
+            }
+            return authConfig;
+        });
+    }
+    /**
+     * 更新请求统计信息
+     * 统一管理所有统计,避免在拦截器中重复统计
+     */
+    updateRequestStats(success, responseTime, method, status) {
+        this.requestStats.totalRequests++;
+        if (success) {
+            this.requestStats.successfulRequests++;
+        }
+        else {
+            this.requestStats.failedRequests++;
+        }
+        this.requestStats.totalResponseTime += responseTime;
+        this.requestStats.averageResponseTime =
+            this.requestStats.totalResponseTime / this.requestStats.totalRequests;
+        // 统计方法分布
+        if (method) {
+            const normalizedMethod = method.toUpperCase();
+            this.requestStats.requestsByMethod[normalizedMethod] =
+                (this.requestStats.requestsByMethod[normalizedMethod] || 0) + 1;
+        }
+        // 统计状态码分布
+        if (status) {
+            this.requestStats.requestsByStatus[status] =
+                (this.requestStats.requestsByStatus[status] || 0) + 1;
+        }
+    }
 };
 exports.HttpClientService = HttpClientService;
 exports.HttpClientService = HttpClientService = HttpClientService_1 = __decorate([
     (0, common_1.Injectable)(),
+    __param(2, (0, common_1.Optional)()),
     __metadata("design:paramtypes", [circuit_breaker_service_1.HttpCircuitBreakerService,
         logging_service_1.HttpLoggingService,
-        cache_service_1.HttpCacheService,
-        redis_lock_service_1.RedisLockService, Object])
+        redis_lock_service_1.RedisLockService, Object, String, Object])
 ], HttpClientService);