@nest-omni/core 4.1.3-2 → 4.1.3-20

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

@@ -22,21 +22,29 @@ 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 = {
@@ -44,158 +52,265 @@ 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();
     }
-    request(config, decoratorContext) {
+    /**
+     * 静态工厂方法：创建API客户端模式的 HttpClientService
+     * @param dependencies 依赖服务
+     * @param config API客户端配置
+     * @returns HttpClientService 实例
+     */
+    static createApiClient(dependencies, config) {
+        return new HttpClientService_1(dependencies.circuitBreakerService, dependencies.loggingService, dependencies.redisLockService, Object.assign({ baseURL: config.baseURL, timeout: config.timeout || 30000 }, config.httpConfig), config.name, config.auth);
+    }
+    /**
+     * 执行HTTP请求
+     */
+    request(config, decoratorContext, clientName) {
         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;
+            // 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 fullURL = config.url || '';
+            const baseURL = config.baseURL || this.defaultConfig.baseURL || '';
+            // 执行URL安全验证
+            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) {
+                config.url = sanitizeResult.url;
+                this.logger.debug(`URL sanitized from "${fullURL}" to "${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 enhancedConfig = this.applyDecoratorConfig(config, decoratorContext);
-                const decoratorConfigs = decoratorContext
-                    ? decorators_1.HttpDecoratorUtils.getAllDecoratorConfigs(decoratorContext.target, decoratorContext.propertyKey)
+                // 应用认证配置
+                let authConfig = yield this.applyAuthToConfig(config);
+                // 应用装饰器配置
+                const enhancedConfig = this.applyDecoratorConfig(authConfig, decoratorContext);
+                // 将 retryRecorder 存储到 config metadata 中,供 onRetry 回调使用
+                enhancedConfig.metadata = enhancedConfig.metadata || {};
+                enhancedConfig.metadata.retryRecorder = retryRecorder;
+                // 获取装饰器配置
+                const decoratorConfigs = effectiveDecoratorContext
+                    ? decorators_1.HttpDecoratorUtils.getAllDecoratorConfigs(effectiveDecoratorContext.target, effectiveDecoratorContext.propertyKey)
                     : {};
-                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: (_c = this.defaultConfig.logging) === null || _c === void 0 ? void 0 : _c.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, cacheHit, undefined, decoratorContext);
-                        }
-                        return cachedResponse.data;
-                    }
-                }
+                // 应用超时配置
                 const timeout = decoratorConfigs.timeout || this.defaultConfig.timeout;
                 if (timeout) {
                     enhancedConfig.timeout = timeout;
                 }
+                // 应用代理配置
                 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,
-                    };
-                }
-                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 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 resolvedProxy = this.resolveProxyConfig(proxyConfig, enhancedConfig.url);
+                    if (resolvedProxy !== false) {
+                        enhancedConfig.proxy = resolvedProxy;
+                    }
                 }
+                // 执行请求（带重试和熔断器）
+                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) ||
+                    const databaseLogging = (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.databaseLogging) ||
                         ((_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);
+                    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, response.config.method, response.status);
                 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: (_f = this.defaultConfig.logging) === null || _f === void 0 ? void 0 : _f.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);
+                        ((_h = (_g = this.defaultConfig.logging) === null || _g === void 0 ? void 0 : _g.databaseLogging) === null || _h === void 0 ? void 0 : _h.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 = (_j = error.config) === null || _j === void 0 ? void 0 : _j.method;
+                const errorStatus = (_k = error.response) === null || _k === void 0 ? void 0 : _k.status;
+                this.updateRequestStats(false, Date.now() - startTime, errorMethod, errorStatus);
                 throw error;
             }
         });
     }
+    /**
+     * 生成curl命令（动态生成，不存储）
+     */
     generateCurlCommand(config) {
         return curl_generator_util_1.CurlGenerator.generateSimplifiedCurl(config);
     }
+    /**
+     * 生成调试curl命令（动态生成，不存储）
+     */
     generateDebugCurlCommand(config, response) {
         return curl_generator_util_1.CurlGenerator.generateDebugCurl(config, response);
     }
+    /**
+     * 获取请求统计信息
+     */
     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(),
+        };
     }
+    /**
+     * 重置统计信息
+     */
     resetStats() {
         this.requestStats = {
             totalRequests: 0,
             successfulRequests: 0,
             failedRequests: 0,
             totalResponseTime: 0,
+            averageResponseTime: 0,
             requestsByMethod: {},
             requestsByStatus: {},
         };
     }
-    get(url, config) {
+    /**
+     * 获取客户端名称
+     */
+    getName() {
+        return this.clientName;
+    }
+    /**
+     * 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 {};
+        }
+    }
+    // 便捷方法
+    get(url, config, clientName) {
         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);
         });
     }
-    post(url, data, config) {
+    post(url, data, config, clientName) {
         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);
         });
     }
-    put(url, data, config) {
+    put(url, data, config, clientName) {
         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);
         });
     }
-    patch(url, data, config) {
+    patch(url, data, config, clientName) {
         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);
         });
     }
-    delete(url, config) {
+    delete(url, config, clientName) {
         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);
         });
     }
-    authRequest(config, tokenProvider, options) {
+    /**
+     * 带等待锁的认证请求方法
+     * 用于需要确保只有一个进程执行认证相关操作的场景
+     *
+     * @param config 请求配置
+     * @param tokenProvider token提供函数
+     * @param options 等待锁选项
+     * @returns 响应数据
+     */
+    authRequest(config, 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 without lock');
-                return this.request(config);
+                return this.request(config, undefined, effectiveClientName);
             }
             const { lockKey = `auth-request:${(0, request_id_util_1.generateRequestId)()}`, lockTimeout = 30000, waitTimeout = 60000, enableRetry = true, } = options || {};
             try {
+                // 尝试获取锁并执行请求
                 const result = yield this.redisLockService.withLock(lockKey, () => __awaiter(this, void 0, void 0, function* () {
+                    // 获取token
                     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);
                 }), {
                     ttl: lockTimeout,
                     retryCount: enableRetry ? 3 : 0,
@@ -209,25 +324,37 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
             }
             catch (error) {
                 this.logger.error(`Auth request failed with lock ${lockKey}`, error);
+                // 如果是锁获取失败且启用重试，尝试无锁执行
                 if (enableRetry && error.message.includes('Failed to acquire lock')) {
                     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;
             }
         });
     }
-    authBatchRequest(requests, tokenProvider, options) {
+    /**
+     * 带等待锁的批量认证请求
+     * 用于需要批量执行认证相关操作但避免重复认证的场景
+     *
+     * @param requests 请求数组
+     * @param tokenProvider token提供函数
+     * @param options 等待锁选项
+     * @returns 响应数组
+     */
+    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');
+                // 无锁批量执行
                 const token = yield tokenProvider();
                 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);
@@ -238,15 +365,18 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
             }
             const { lockKey = `batch-auth-request:${(0, request_id_util_1.generateRequestId)()}`, lockTimeout = 60000, waitTimeout = 120000, maxConcurrency = 5, } = options || {};
             try {
+                // 使用锁获取token并执行批量请求
                 const results = yield this.redisLockService.withLock(lockKey, () => __awaiter(this, void 0, void 0, function* () {
+                    // 获取token（只获取一次）
                     const token = yield tokenProvider();
+                    // 创建并发请求
                     const semaphore = new Array(maxConcurrency).fill(null);
                     const results = new Array(requests.length);
                     const executing = new Set();
                     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;
                         }
@@ -259,6 +389,7 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                             executing.delete(key);
                         }
                     });
+                    // 创建并发的请求Promise
                     const promises = requests.map((request, index) => __awaiter(this, void 0, void 0, function* () {
                         return new Promise((resolve, reject) => {
                             const checkSlot = () => {
@@ -301,21 +432,18 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
             }
         });
     }
+    /**
+     * 创建Axios实例并配置axios-retry
+     */
     createAxiosInstance() {
-        var _a, _b;
+        var _a;
         const instance = require('axios').create({
             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,
-                }
-                : undefined,
+            proxy: this.resolveProxyConfig(this.defaultConfig.proxy),
         });
-        if ((_b = this.defaultConfig.retry) === null || _b === void 0 ? void 0 : _b.enabled) {
+        // 配置axios-retry
+        if ((_a = this.defaultConfig.retry) === null || _a === void 0 ? void 0 : _a.enabled) {
             (0, axios_retry_1.default)(instance, {
                 retries: this.defaultConfig.retry.retries || 3,
                 retryDelay: this.defaultConfig.retry.retryDelay ||
@@ -323,26 +451,46 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                 retryCondition: this.defaultConfig.retry.retryCondition ||
                     ((error) => {
                         if (!error.response)
-                            return true;
+                            return true; // 网络错误
                         const status = error.response.status;
-                        return status >= 500 || status === 429;
+                        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}`);
+                    }
+                },
             });
         }
+        // 设置请求拦截器
         instance.interceptors.request.use((config) => {
             config.headers = config.headers || {};
+            // 从ContextProvider获取上下文信息
             const context = context_extractor_util_1.ContextExtractor.getHttpContext();
             const requestId = context.requestId || (0, request_id_util_1.generateRequestId)();
             config.headers['X-Request-ID'] = requestId;
             if (context.userId) {
                 config.headers['X-User-ID'] = context.userId;
             }
+            // 存储requestId到config metadata中供后续使用
+            // 注意：不要覆盖已存在的 metadata，保留 retryRecorder 等其他数据
             config.metadata = config.metadata || {};
             config.metadata.requestId = requestId;
             return config;
@@ -350,83 +498,86 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
             this.logger.error('Request interceptor error', error);
             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* () {
             const requestFn = () => this.axiosInstance.request(config);
+            // 熔断器保护
             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 };
             }
         });
     }
+    /**
+     * 计算重试延迟
+     */
     calculateRetryDelay(retryCount, retryConfig) {
         if (retryConfig.retryDelay) {
             return retryConfig.retryDelay(retryCount);
         }
+        // 默认指数退避
         return Math.pow(2, retryCount) * 1000;
     }
+    /**
+     * 应用装饰器配置
+     */
     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');
-    }
+    // 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}`;
     }
+    /**
+     * 合并默认配置
+     */
     mergeWithDefaults(config) {
         const defaults = {
             baseURL: process.env.HTTP_CLIENT_BASE_URL,
@@ -451,15 +602,6 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                 minimumThroughputThreshold: 10,
                 countHalfOpenCalls: true,
             },
-            cache: {
-                enabled: true,
-                defaultTtl: 300000,
-                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,
@@ -471,14 +613,16 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                 sanitizeHeaders: ['authorization', 'apikey', 'password', 'token'],
                 logLevel: 'info',
                 databaseLogging: {
-                    enabled: false,
+                    enabled: true,
                     dataSource: 'default',
-                    tableName: 'http_logs',
                 },
             },
         };
         return this.deepMerge(defaults, config);
     }
+    /**
+     * 深度合并对象
+     */
     deepMerge(target, source) {
         const result = Object.assign({}, target);
         for (const key in source) {
@@ -493,12 +637,157 @@ 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)(),
     __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);