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

package/http-client/interfaces/http-client-config.interface.d.ts

@@ -1,37 +1,119 @@
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import { CacheOptions } from '../../cache/interfaces/cache-options.interface';
 import { LogCleanupConfig } from '../services/log-cleanup.service';
+import { SSRFProtectionConfig, URLValidationConfig } from '../utils/security-validator.util';
+import type { AgentOptions } from 'https';
+/**
+ * SSL/TLS 证书配置
+ * 兼容 Node.js https.Agent 的选项
+ * 参考: https://nodejs.org/api/tls.html#tls_tls_createsecurecontext_options
+ */
+export interface SslCertificateConfig extends Partial<Omit<AgentOptions, 'host' | 'port' | 'path'>> {
+    /**
+     * 是否禁用证书验证（仅用于开发/测试环境）
+     * 警告：设置为 true 会使连接不安全，生产环境严禁使用
+     */
+    rejectUnauthorized?: boolean;
+    /**
+     * CA 证书内容（PEM 格式）
+     * 可以是单个证书或多个证书的字符串
+     */
+    ca?: string | string[] | Buffer;
+    /**
+     * 客户端证书内容（PEM 格式）
+     */
+    cert?: string | string[] | Buffer;
+    /**
+     * 客户端私钥内容（PEM 格式）
+     */
+    key?: string | string[] | Buffer;
+    /**
+     * 私钥密码
+     */
+    passphrase?: string;
+    /**
+     * 服务器名称（用于 SNI）
+     */
+    servername?: string;
+    /**
+     * 支持的 TLS 版本
+     */
+    minVersion?: 'TLSv1' | 'TLSv1.1' | 'TLSv1.2' | 'TLSv1.3';
+    maxVersion?: 'TLSv1' | 'TLSv1.1' | 'TLSv1.2' | 'TLSv1.3';
+    /**
+     * 支持的加密套件
+     */
+    ciphers?: string;
+    /**
+     * 是否支持 DH 参数
+     */
+    dhparam?: string | Buffer;
+    /**
+     * 是否使用安全 renegotiation
+     */
+    secureOptions?: number;
+}
+/**
+ * Axios 原生配置透传
+ * 基于 AxiosRequestConfig，排除已在 HttpClientConfig 中定义的字段
+ *
+ * 使用方式：
+ * - 直接传 Axios 原生配置对象
+ * - 类型安全，支持所有 Axios 配置项
+ * - ssl 配置会被自动转换为 httpsAgent
+ */
+export type AxiosNativeConfig = Omit<AxiosRequestConfig, 'baseURL' | 'timeout' | 'proxy' | 'url' | 'method' | 'data' | 'headers' | 'params'> & {
+    /**
+     * SSL/TLS 证书配置（简化版）
+     * 会自动转换为 httpsAgent，优先级高于直接指定的 httpsAgent
+     */
+    ssl?: SslCertificateConfig;
+};
 /**
  * HTTP客户端配置接口
  * 基于Spring Boot的@ConfigurationProperties设计理念
+ * 所有字段都是可选的，模块会使用合理的默认值
  */
 export interface HttpClientConfig {
     /** 基础配置 */
     baseURL?: string;
     timeout?: number;
     /** 重试配置 */
-    retry?: RetryConfig;
+    retry?: Partial<RetryConfig>;
     /** 熔断器配置 */
-    circuitBreaker?: CircuitBreakerConfig;
-    /** 缓存配置 */
-    cache?: HttpCacheConfig;
+    circuitBreaker?: Partial<CircuitBreakerConfig>;
     /** 代理配置 */
-    proxy?: ProxyConfig;
+    proxy?: Partial<ProxyConfig>;
     /** 日志配置 */
-    logging?: LoggingConfig;
+    logging?: Partial<LoggingConfig>;
     /** 日志清理配置 */
-    logCleanup?: LogCleanupConfig;
+    logCleanup?: Partial<LogCleanupConfig>;
     /** 拦截器配置 */
-    interceptors?: InterceptorConfig;
+    interceptors?: Partial<InterceptorConfig>;
     /** 连接池配置 */
-    connectionPool?: ConnectionPoolConfig;
+    connectionPool?: Partial<ConnectionPoolConfig>;
+    /** 安全配置 */
+    security?: {
+        /** URL验证配置 */
+        urlValidation?: Partial<URLValidationConfig>;
+        /** SSRF防护配置 */
+        ssrfProtection?: Partial<SSRFProtectionConfig>;
+        /** 是否启用安全验证 */
+        enabled?: boolean;
+    };
+    /**
+     * Axios 原生配置透传
+     * 用于直接传递 Axios 支持的任何配置项，提供最大灵活性
+     * 优先级低于上述显式配置，会进行深度合并
+     */
+    axiosConfig?: AxiosNativeConfig;
 }
 /**
  * 重试配置
  * 基于axios-retry库的配置
+ * 所有字段都是可选的
  */
 export interface RetryConfig {
-    enabled: boolean;
+    enabled?: boolean;
     retries?: number;
     retryDelay?: (retryCount: number) => number;
     retryCondition?: (error: any) => boolean;
@@ -41,82 +123,80 @@ export interface RetryConfig {
 /**
  * 熔断器配置
  * 类似Spring Cloud CircuitBreaker
+ * 所有字段都是可选的
  */
 export interface CircuitBreakerConfig {
-    enabled: boolean;
-    failureThreshold: number;
-    recoveryTimeoutMs: number;
-    monitoringPeriodMs: number;
-    minimumThroughputThreshold: number;
-    countHalfOpenCalls: boolean;
-}
-/**
- * HTTP缓存配置
- * 集成现有的三层缓存架构
- */
-export interface HttpCacheConfig {
-    enabled: boolean;
-    /** 缓存选项，使用core中的CacheOptions */
-    options?: Omit<CacheOptions, 'ttl' | 'namespace'>;
-    /** 默认TTL（毫秒） */
-    defaultTtl?: number;
-    /** 可缓存的方法 */
-    cacheableMethods: string[];
-    /** 可缓存的状态码 */
-    cacheableStatusCodes: number[];
-    /** 自定义缓存键生成器 */
-    keyGenerator?: (config: AxiosRequestConfig) => string;
+    enabled?: boolean;
+    failureThreshold?: number;
+    recoveryTimeoutMs?: number;
+    monitoringPeriodMs?: number;
+    minimumThroughputThreshold?: number;
+    countHalfOpenCalls?: boolean;
 }
 /**
  * 代理配置
+ * 所有字段都是可选的
  */
 export interface ProxyConfig {
-    enabled: boolean;
+    enabled?: boolean;
+    /** 是否从环境变量读取代理配置 (HTTP_PROXY, HTTPS_PROXY, NO_PROXY) */
+    fromEnvironment?: boolean;
+    /** 手动指定的代理主机 (当 fromEnvironment 为 false 时使用) */
     host?: string;
+    /** 手动指定的代理端口 (当 fromEnvironment 为 false 时使用) */
     port?: number;
+    /** 代理协议 */
     protocol?: 'http' | 'https';
+    /** 代理认证信息 */
     auth?: {
-        username: string;
-        password: string;
+        username?: string;
+        password?: string;
     };
 }
 /**
  * 日志配置
  * 类似Spring Boot的logging配置
+ * 所有字段都是可选的
  */
 export interface LoggingConfig {
-    enabled: boolean;
-    logRequests: boolean;
-    logResponses: boolean;
-    logErrors: boolean;
-    logHeaders: boolean;
-    logBody: boolean;
-    maxBodyLength: number;
-    sanitizeHeaders: string[];
-    logLevel: 'debug' | 'info' | 'warn' | 'error';
+    enabled?: boolean;
+    logRequests?: boolean;
+    logResponses?: boolean;
+    logErrors?: boolean;
+    logHeaders?: boolean;
+    logBody?: boolean;
+    maxBodyLength?: number;
+    /**
+     * 脱敏配置
+     * 敏感字段列表，统一适用于 headers、body、query string
+     * 例如：['password', 'token', 'secret', 'apiKey']
+     */
+    sanitize?: string[];
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
     databaseLogging?: {
-        enabled: boolean;
-        dataSource: string;
-        tableName: string;
+        enabled?: boolean;
+        dataSource?: string;
     };
 }
 /**
  * 拦截器配置
+ * 所有字段都是可选的
  */
 export interface InterceptorConfig {
-    requestInterceptors: string[];
-    responseInterceptors: string[];
-    errorInterceptors: string[];
+    requestInterceptors?: string[];
+    responseInterceptors?: string[];
+    errorInterceptors?: string[];
 }
 /**
  * 连接池配置
+ * 所有字段都是可选的
  */
 export interface ConnectionPoolConfig {
-    enabled: boolean;
-    maxSockets: number;
-    maxFreeSockets: number;
-    timeoutMs: number;
-    keepAlive: boolean;
+    enabled?: boolean;
+    maxSockets?: number;
+    maxFreeSockets?: number;
+    timeoutMs?: number;
+    keepAlive?: boolean;
 }
 /**
  * HTTP请求上下文
@@ -175,9 +255,4 @@ export interface HttpStats {
     requestsByMethod: Record<HttpMethod, number>;
     requestsByStatus: Record<number, number>;
     circuitBreakerStats: Record<string, any>;
-    cacheStats: {
-        hits: number;
-        misses: number;
-        hitRate: number;
-    };
 }

package/http-client/services/api-client-registry.service.d.ts

@@ -1,24 +1,22 @@
-import { ApiClientConfig, ApiClientInstanceConfig, ApiClientRegistryConfig, AuthType, OAuth2Config, ResponseTransformerConfig } from '../interfaces/api-client-config.interface';
-import { HttpClientService } from './http-client.service';
+import { ApiClientConfig, ApiClientInstanceConfig, ApiClientRegistryConfig, AuthType, ResponseTransformerConfig } from '../interfaces/api-client-config.interface';
 import { HttpCircuitBreakerService } from './circuit-breaker.service';
 import { HttpLoggingService } from './logging.service';
-import { HttpCacheService } from './cache.service';
-export { ApiClientInstanceConfig, AuthType, OAuth2Config, ResponseTransformerConfig, };
+export { ApiClientInstanceConfig, AuthType, ResponseTransformerConfig };
 /**
  * API客户端注册服务
+ * 负责管理多个 HttpClientService 实例
  */
 export declare class ApiClientRegistryService {
-    private readonly httpClientService;
     private readonly circuitBreakerService;
     private readonly loggingService;
-    private readonly cacheService;
     private readonly logger;
     private readonly clients;
     private readonly clientConfigs;
     private readonly globalDefaults;
-    constructor(httpClientService: HttpClientService, circuitBreakerService: HttpCircuitBreakerService, loggingService: HttpLoggingService, cacheService: HttpCacheService, globalConfig?: ApiClientRegistryConfig);
+    constructor(circuitBreakerService: HttpCircuitBreakerService, loggingService: HttpLoggingService, globalConfig?: ApiClientRegistryConfig);
     /**
      * 创建API客户端实例
+     * 使用 HttpClientService.createApiClient 静态方法创建
      */
     createClient<T = any>(config: ApiClientInstanceConfig): T;
     /**
@@ -76,21 +74,10 @@ export declare class ApiClientRegistryService {
         }>;
     }>;
     /**
-     * 创建Axios实例
+     * 深度合并配置（已废弃，不再需要）
+     * @deprecated 配置结构简化后不再需要此方法
      */
-    private createAxiosInstance;
-    /**
-     * 应用鉴权配置
-     */
-    private applyAuthentication;
-    /**
-     * 应用响应转换器
-     */
-    private applyResponseTransformer;
-    /**
-     * 根据路径提取数据
-     */
-    private extractDataByPath;
+    private deepMergeConfigs;
     /**
      * 合并环境特定配置
      */

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

@@ -21,25 +21,19 @@ var ApiClientRegistryService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiClientRegistryService = exports.AuthType = void 0;
 const common_1 = require("@nestjs/common");
-const axios_1 = require("axios");
-const axios_retry_1 = require("axios-retry");
 const api_client_config_interface_1 = require("../interfaces/api-client-config.interface");
 Object.defineProperty(exports, "AuthType", { enumerable: true, get: function () { return api_client_config_interface_1.AuthType; } });
 const http_client_service_1 = require("./http-client.service");
 const circuit_breaker_service_1 = require("./circuit-breaker.service");
 const logging_service_1 = require("./logging.service");
-const cache_service_1 = require("./cache.service");
-const context_extractor_util_1 = require("../utils/context-extractor.util");
-const utils_1 = require("../../common/utils");
 /**
  * API客户端注册服务
+ * 负责管理多个 HttpClientService 实例
  */
 let ApiClientRegistryService = ApiClientRegistryService_1 = class ApiClientRegistryService {
-    constructor(httpClientService, circuitBreakerService, loggingService, cacheService, globalConfig = {}) {
-        this.httpClientService = httpClientService;
+    constructor(circuitBreakerService, loggingService, globalConfig = {}) {
         this.circuitBreakerService = circuitBreakerService;
         this.loggingService = loggingService;
-        this.cacheService = cacheService;
         this.logger = new common_1.Logger(ApiClientRegistryService_1.name);
         this.clients = new Map();
         this.clientConfigs = new Map();
@@ -53,7 +47,7 @@ let ApiClientRegistryService = ApiClientRegistryService_1 = class ApiClientRegis
                     logHeaders: true,
                     logBody: true,
                     maxBodyLength: 10000,
-                    sanitizeHeaders: ['authorization', 'api-key'],
+                    sanitize: ['authorization', 'api-key'],
                     logLevel: 'info',
                 },
                 timeout: 30000,
@@ -65,6 +59,7 @@ let ApiClientRegistryService = ApiClientRegistryService_1 = class ApiClientRegis
     }
     /**
      * 创建API客户端实例
+     * 使用 HttpClientService.createApiClient 静态方法创建
      */
     createClient(config) {
         const clientName = config.name;
@@ -75,15 +70,30 @@ let ApiClientRegistryService = ApiClientRegistryService_1 = class ApiClientRegis
         }
         // 合并环境特定配置
         const finalConfig = this.mergeEnvironmentConfig(config);
-        // 创建Axios实例
-        const axiosInstance = this.createAxiosInstance(finalConfig);
-        // 创建API客户端
-        const client = new ApiClientInstance(clientName, finalConfig, axiosInstance, this.httpClientService, this.loggingService, this.cacheService);
+        // 构建 HttpClient 配置
+        // 1. 从全局默认配置开始
+        // 2. 合并 ApiClient 的 httpConfig
+        // 3. 应用 ApiClient 特有的 retry 配置（兼容旧代码）
+        const mergedHttpConfig = Object.assign(Object.assign({}, this.globalDefaults.globalDefaults), finalConfig.httpConfig);
+        // 兼容：如果 ApiClientConfig 顶层有 retry 配置，合并到 httpConfig.retry
+        if (finalConfig.retry) {
+            mergedHttpConfig.retry = Object.assign(Object.assign({}, mergedHttpConfig.retry), finalConfig.retry);
+        }
+        // 使用静态工厂方法创建 HttpClientService 实例
+        const httpClient = http_client_service_1.HttpClientService.createApiClient({
+            circuitBreakerService: this.circuitBreakerService,
+            loggingService: this.loggingService,
+        }, {
+            name: clientName,
+            baseURL: finalConfig.baseURL,
+            httpConfig: mergedHttpConfig,
+            auth: finalConfig.auth,
+        });
         // 存储客户端和配置
-        this.clients.set(clientName, client);
+        this.clients.set(clientName, httpClient);
         this.clientConfigs.set(clientName, finalConfig);
         this.logger.log(`Created API client: ${clientName}`);
-        return client;
+        return httpClient;
     }
     /**
      * 获取已注册的客户端
@@ -210,180 +220,11 @@ let ApiClientRegistryService = ApiClientRegistryService_1 = class ApiClientRegis
         });
     }
     /**
-     * 创建Axios实例
-     */
-    createAxiosInstance(config) {
-        var _a, _b, _c, _d, _e, _f;
-        const axiosConfig = {
-            baseURL: config.baseURL,
-            timeout: ((_a = config.httpConfig) === null || _a === void 0 ? void 0 : _a.timeout) || 30000,
-            headers: Object.assign({ 'Content-Type': 'application/json', 'User-Agent': `${config.name}/1.0.0` }, config.defaultHeaders),
-            params: config.defaultParams,
-        };
-        const instance = axios_1.default.create(axiosConfig);
-        const clientName = config.name; // Capture client name for use in closures
-        // 配置请求拦截器
-        instance.interceptors.request.use((config) => {
-            // 添加鉴权信息 - for now, skip async authentication to avoid type issues
-            const authenticatedConfig = config;
-            // Add simple auth headers for basic cases
-            if (config.auth) {
-                switch (config.auth.type) {
-                    case api_client_config_interface_1.AuthType.BEARER_TOKEN:
-                        const bearerConfig = config.auth.config;
-                        authenticatedConfig.headers = authenticatedConfig.headers || {};
-                        authenticatedConfig.headers['Authorization'] =
-                            `Bearer ${bearerConfig.token}`;
-                        break;
-                    case api_client_config_interface_1.AuthType.API_KEY:
-                        const apiKeyConfig = config.auth.config;
-                        if (apiKeyConfig.location === 'header') {
-                            const headerName = apiKeyConfig.name || 'X-API-Key';
-                            const value = apiKeyConfig.prefix
-                                ? `${apiKeyConfig.prefix} ${apiKeyConfig.key}`
-                                : apiKeyConfig.key;
-                            authenticatedConfig.headers = authenticatedConfig.headers || {};
-                            authenticatedConfig.headers[headerName] = value;
-                        }
-                        break;
-                }
-            }
-            // 添加请求ID和上下文信息
-            const context = context_extractor_util_1.ContextExtractor.getHttpContext();
-            const requestId = context.requestId || (0, utils_1.generateRequestId)();
-            authenticatedConfig.headers = authenticatedConfig.headers || {};
-            authenticatedConfig.headers['X-Request-ID'] = requestId;
-            if (context.userId) {
-                authenticatedConfig.headers['X-User-ID'] = context.userId;
-            }
-            // 添加API标识
-            authenticatedConfig.headers['X-API-Client'] = clientName;
-            return authenticatedConfig;
-        }, (error) => {
-            this.logger.error(`[${clientName}] Request interceptor error`, error);
-            return Promise.reject(error);
-        });
-        // 配置响应拦截器
-        instance.interceptors.response.use((response) => {
-            // 应用响应转换器
-            return this.applyResponseTransformer(response, config.responseTransformer);
-        }, (error) => {
-            var _a;
-            // 应用错误转换器
-            if ((_a = config.responseTransformer) === null || _a === void 0 ? void 0 : _a.error) {
-                return config.responseTransformer.error(error);
-            }
-            return Promise.reject(error);
-        });
-        // 配置axios-retry
-        if (((_b = config.retry) === null || _b === void 0 ? void 0 : _b.enabled) !== false &&
-            this.globalDefaults.enableGlobalRetry) {
-            (0, axios_retry_1.default)(instance, {
-                retries: ((_c = config.retry) === null || _c === void 0 ? void 0 : _c.retries) ||
-                    ((_e = (_d = this.globalDefaults.globalDefaults) === null || _d === void 0 ? void 0 : _d.retry) === null || _e === void 0 ? void 0 : _e.retries) ||
-                    3,
-                retryDelay: (retryCount) => Math.pow(2, retryCount) * 1000,
-                retryCondition: ((_f = config.retry) === null || _f === void 0 ? void 0 : _f.retryCondition) ||
-                    ((error) => {
-                        if (!error.response)
-                            return true;
-                        const status = error.response.status;
-                        return status >= 500 || status === 429;
-                    }),
-                shouldResetTimeout: true,
-                onRetry: (retryCount, error, requestConfig) => {
-                    var _a;
-                    this.logger.warn(`[${config.name}] Retrying request (attempt ${retryCount}): ${(_a = requestConfig.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()} ${requestConfig.url}`);
-                },
-            });
-        }
-        return instance;
-    }
-    /**
-     * 应用鉴权配置
-     */
-    applyAuthentication(config, auth) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!auth) {
-                return config;
-            }
-            const authenticatedConfig = Object.assign({}, config);
-            switch (auth.type) {
-                case api_client_config_interface_1.AuthType.NONE:
-                    break;
-                case api_client_config_interface_1.AuthType.API_KEY:
-                    const apiKeyConfig = auth.config;
-                    if (apiKeyConfig.location === 'header') {
-                        const headerName = apiKeyConfig.name || 'X-API-Key';
-                        const value = apiKeyConfig.prefix
-                            ? `${apiKeyConfig.prefix} ${apiKeyConfig.key}`
-                            : apiKeyConfig.key;
-                        authenticatedConfig.headers = Object.assign(Object.assign({}, authenticatedConfig.headers), { [headerName]: value });
-                    }
-                    else if (apiKeyConfig.location === 'query') {
-                        const paramName = apiKeyConfig.name || 'api_key';
-                        authenticatedConfig.params = Object.assign(Object.assign({}, authenticatedConfig.params), { [paramName]: apiKeyConfig.key });
-                    }
-                    break;
-                case api_client_config_interface_1.AuthType.BEARER_TOKEN:
-                    const bearerConfig = auth.config;
-                    const scheme = bearerConfig.scheme || 'Bearer';
-                    authenticatedConfig.headers = Object.assign(Object.assign({}, authenticatedConfig.headers), { Authorization: `${scheme} ${bearerConfig.token}` });
-                    break;
-                case api_client_config_interface_1.AuthType.BASIC_AUTH:
-                    const basicConfig = auth.config;
-                    const credentials = Buffer.from(`${basicConfig.username}:${basicConfig.password}`).toString('base64');
-                    authenticatedConfig.headers = Object.assign(Object.assign({}, authenticatedConfig.headers), { Authorization: `Basic ${credentials}` });
-                    break;
-                case api_client_config_interface_1.AuthType.OAUTH2:
-                    const oauthConfig = auth.config;
-                    // OAuth2实现需要异步获取token
-                    // 这里简化处理，实际项目中可能需要更复杂的逻辑
-                    authenticatedConfig.headers = Object.assign(Object.assign({}, authenticatedConfig.headers), { Authorization: `Bearer ${oauthConfig.clientSecret}` });
-                    break;
-                case api_client_config_interface_1.AuthType.CUSTOM:
-                    const customConfig = auth.config;
-                    return yield customConfig.authenticator(authenticatedConfig);
-            }
-            return authenticatedConfig;
-        });
-    }
-    /**
-     * 应用响应转换器
-     */
-    applyResponseTransformer(response, transformer) {
-        if (!transformer) {
-            return response;
-        }
-        // 应用成功响应转换器
-        if (transformer.success) {
-            response.data = transformer.success(response);
-        }
-        // 应用数据路径提取
-        if (transformer.dataPath) {
-            response.data = this.extractDataByPath(response.data, transformer.dataPath);
-        }
-        // 应用响应验证
-        if (transformer.validateResponse && transformer.validator) {
-            if (!transformer.validator(response.data)) {
-                throw new Error(`Response validation failed for ${transformer.dataPath}`);
-            }
-        }
-        return response;
-    }
-    /**
-     * 根据路径提取数据
+     * 深度合并配置（已废弃，不再需要）
+     * @deprecated 配置结构简化后不再需要此方法
      */
-    extractDataByPath(data, path) {
-        const keys = path.split('.');
-        let current = data;
-        for (const key of keys) {
-            if (current === null || current === undefined) {
-                return undefined;
-            }
-            current = current[key];
-        }
-        return current;
+    deepMergeConfigs(defaults, userConfig) {
+        return Object.assign(Object.assign({}, defaults), userConfig);
     }
     /**
      * 合并环境特定配置
@@ -398,98 +239,6 @@ let ApiClientRegistryService = ApiClientRegistryService_1 = class ApiClientRegis
 exports.ApiClientRegistryService = ApiClientRegistryService;
 exports.ApiClientRegistryService = ApiClientRegistryService = ApiClientRegistryService_1 = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [http_client_service_1.HttpClientService,
-        circuit_breaker_service_1.HttpCircuitBreakerService,
-        logging_service_1.HttpLoggingService,
-        cache_service_1.HttpCacheService, Object])
+    __metadata("design:paramtypes", [circuit_breaker_service_1.HttpCircuitBreakerService,
+        logging_service_1.HttpLoggingService, Object])
 ], ApiClientRegistryService);
-/**
- * API客户端实例实现
- */
-class ApiClientInstance {
-    constructor(name, config, axiosInstance, httpClientService, loggingService, cacheService) {
-        this.name = name;
-        this.config = config;
-        this.axiosInstance = axiosInstance;
-        this.httpClientService = httpClientService;
-        this.loggingService = loggingService;
-        this.cacheService = cacheService;
-        this.stats = {
-            totalRequests: 0,
-            successfulRequests: 0,
-            failedRequests: 0,
-            totalResponseTime: 0,
-            averageResponseTime: 0,
-        };
-    }
-    get(url, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'GET', url }));
-        });
-    }
-    post(url, data, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'POST', url, data }));
-        });
-    }
-    put(url, data, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'PUT', url, data }));
-        });
-    }
-    patch(url, data, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'PATCH', url, data }));
-        });
-    }
-    delete(url, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'DELETE', url }));
-        });
-    }
-    request(config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const startTime = Date.now();
-            this.stats.totalRequests++;
-            try {
-                const response = yield this.axiosInstance.request(config);
-                // 更新统计信息
-                const responseTime = Date.now() - startTime;
-                this.updateStats(true, responseTime);
-                return response.data;
-            }
-            catch (error) {
-                // 更新统计信息
-                const responseTime = Date.now() - startTime;
-                this.updateStats(false, responseTime);
-                throw error;
-            }
-        });
-    }
-    getStats() {
-        return Object.assign({}, this.stats);
-    }
-    resetStats() {
-        this.stats.totalRequests = 0;
-        this.stats.successfulRequests = 0;
-        this.stats.failedRequests = 0;
-        this.stats.totalResponseTime = 0;
-        this.stats.averageResponseTime = 0;
-    }
-    updateStats(success, responseTime) {
-        if (success) {
-            this.stats.successfulRequests++;
-        }
-        else {
-            this.stats.failedRequests++;
-        }
-        this.stats.totalResponseTime += responseTime;
-        this.stats.averageResponseTime =
-            this.stats.totalResponseTime / this.stats.totalRequests;
-        // 响应时间警告
-        if (this.config.responseTimeWarningThreshold &&
-            responseTime > this.config.responseTimeWarningThreshold) {
-            console.warn(`[API Client ${this.name}] Slow response detected: ${responseTime}ms for ${this.axiosInstance.defaults.baseURL}`);
-        }
-    }
-}