@nest-omni/core 4.1.3-25 → 4.1.3-26

package/cache/cache.service.d.ts

@@ -1,6 +1,7 @@
 import type { CacheOptions, CacheStats } from './interfaces';
 import { CacheLayer } from './interfaces';
 import { ClsCacheProvider, LRUCacheProvider, RedisCacheProvider } from './providers';
+import { CacheSerializationService } from './cache-serialization.service';
 /**
  * Unified cache service with three-tier architecture
  *
@@ -16,10 +17,11 @@ export declare class CacheService {
     private readonly redisProvider;
     private readonly enableCompression;
     private readonly compressionThreshold;
+    private readonly serializationService;
     private readonly logger;
     private readonly providers;
     private readonly stats;
-    constructor(clsProvider: ClsCacheProvider, lruProvider: LRUCacheProvider, redisProvider: RedisCacheProvider, enableCompression?: boolean, compressionThreshold?: number);
+    constructor(clsProvider: ClsCacheProvider, lruProvider: LRUCacheProvider, redisProvider: RedisCacheProvider, enableCompression?: boolean, compressionThreshold?: number, serializationService?: CacheSerializationService);
     /**
      * Get or set cache value with factory function
      *

package/cache/cache.service.js

@@ -40,12 +40,13 @@ const cache_constants_1 = require("./cache.constants");
  * Supports automatic fallback, backfill, and dependency-based invalidation.
  */
 let CacheService = CacheService_1 = class CacheService {
-    constructor(clsProvider, lruProvider, redisProvider, enableCompression = false, compressionThreshold = 1024) {
+    constructor(clsProvider, lruProvider, redisProvider, enableCompression = false, compressionThreshold = 1024, serializationService = new cache_serialization_service_1.CacheSerializationService()) {
         this.clsProvider = clsProvider;
         this.lruProvider = lruProvider;
         this.redisProvider = redisProvider;
         this.enableCompression = enableCompression;
         this.compressionThreshold = compressionThreshold;
+        this.serializationService = serializationService;
         this.logger = new common_1.Logger(CacheService_1.name);
         this.providers = new Map();
         this.stats = {
@@ -125,8 +126,7 @@ let CacheService = CacheService_1 = class CacheService {
                         if (value !== null) {
                             // Check if value is compressed and decompress if needed
                             if (this.enableCompression && Buffer.isBuffer(value)) {
-                                const serializationService = new cache_serialization_service_1.CacheSerializationService();
-                                const decompressed = yield serializationService.deserialize(value);
+                                const decompressed = yield this.serializationService.deserialize(value);
                                 value = decompressed.data;
                             }
                             // Cache hit
@@ -206,14 +206,14 @@ let CacheService = CacheService_1 = class CacheService {
         return __awaiter(this, void 0, void 0, function* () {
             this.stats.totalDeletes++;
             const targetLayers = layers || this.getDefaultLayers();
-            const keys = Array.isArray(key) ? key : [key];
             const promises = targetLayers.map((layer) => __awaiter(this, void 0, void 0, function* () {
                 const provider = this.providers.get(layer);
                 if (!provider) {
                     return;
                 }
                 try {
-                    yield provider.delete(keys);
+                    // Pass the key directly (string or array) to the provider
+                    yield provider.delete(key);
                 }
                 catch (error) {
                     this.logger.warn(`Failed to delete from ${layer} cache: ${error instanceof Error ? error.message : String(error)}`);
@@ -357,8 +357,7 @@ let CacheService = CacheService_1 = class CacheService {
                 value !== null &&
                 value !== undefined &&
                 JSON.stringify(value).length >= this.compressionThreshold) {
-                const serializationService = new cache_serialization_service_1.CacheSerializationService();
-                const compressed = yield serializationService.serialize(value, {
+                const compressed = yield this.serializationService.serialize(value, {
                     compress: true,
                     compressThreshold: this.compressionThreshold,
                 });
@@ -471,7 +470,8 @@ exports.CacheService = CacheService = CacheService_1 = __decorate([
     __param(3, (0, common_1.Inject)(cache_constants_1.CACHE_COMPRESSION_ENABLED)),
     __param(4, (0, common_1.Optional)()),
     __param(4, (0, common_1.Inject)(cache_constants_1.CACHE_COMPRESSION_THRESHOLD)),
+    __param(5, (0, common_1.Optional)()),
     __metadata("design:paramtypes", [providers_1.ClsCacheProvider,
         providers_1.LRUCacheProvider,
-        providers_1.RedisCacheProvider, Boolean, Number])
+        providers_1.RedisCacheProvider, Boolean, Number, cache_serialization_service_1.CacheSerializationService])
 ], CacheService);

package/cache/decorators/cache-put.decorator.js

@@ -71,13 +71,14 @@ function CachePut(options = {}) {
                     }
                     // Generate cache key
                     const key = utils_1.KeyGenerator.generate(options, args);
-                    // Update cache with result
-                    yield cacheService.set(key, result, options);
+                    // Update cache with result - don't await, let it happen in background
+                    cacheService.set(key, result, options).catch((error) => {
+                        logger.warn(`Failed to update cache for ${target.constructor.name}.${methodName}: ${error instanceof Error ? error.message : String(error)}`);
+                    });
                     return result;
                 }
                 catch (error) {
-                    logger.error(`Cache put error in ${target.constructor.name}.${methodName}: ${error instanceof Error ? error.message : String(error)}`);
-                    // Re-throw the error (cache update failure shouldn't hide method errors)
+                    // Method execution error - rethrow it
                     throw error;
                 }
             });

package/cache/dependencies/callback.dependency.js

@@ -65,6 +65,11 @@ class CallbackDependency {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const currentData = yield this.getData();
+                // If oldData is null or undefined, consider it as changed
+                // (no previous valid data exists)
+                if (oldData === null || oldData === undefined) {
+                    return true;
+                }
                 return !this.isEqual(oldData, currentData);
             }
             catch (_a) {
@@ -86,6 +91,10 @@ class CallbackDependency {
         if (typeof a !== typeof b) {
             return false;
         }
+        // Handle Date objects
+        if (a instanceof Date && b instanceof Date) {
+            return a.getTime() === b.getTime();
+        }
         if (typeof a !== 'object') {
             return a === b;
         }

package/cache/dependencies/tag.dependency.d.ts

@@ -28,6 +28,7 @@ export declare class TagDependency implements CacheDependency {
     private readonly tags;
     private static readonly PREFIX;
     private static readonly REDIS_KEY_PREFIX;
+    private static readonly logger;
     private static tagVersions;
     private static redis;
     constructor(tags: string[]);
@@ -71,15 +72,6 @@ export declare class TagDependency implements CacheDependency {
      * @returns Map of tag names to versions
      */
     static getAllTags(): Map<string, number>;
-    /**
-     * Get tag version (synchronous version for backward compatibility)
-     * Only reads from in-memory storage
-     *
-     * @deprecated Use getTagVersion(tag) instead for distributed support
-     * @param tag - Tag name
-     * @returns Current tag version from memory
-     */
-    static getTagVersionSync(tag: string): number;
     getKey(): string;
     getData(): Promise<Record<string, number>>;
     isChanged(oldData: Record<string, number>): Promise<boolean>;

package/cache/dependencies/tag.dependency.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TagDependency = void 0;
+const common_1 = require("@nestjs/common");
 /**
  * Tag-based cache dependency
  *
@@ -73,7 +74,7 @@ class TagDependency {
                 }
                 catch (error) {
                     // Log warning but don't throw - fall back to memory
-                    console.warn(`[TagDependency] Failed to get tag version from Redis: ${error instanceof Error ? error.message : String(error)}`);
+                    TagDependency.logger.warn(`Failed to get tag version from Redis: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
             // Fall back to in-memory storage
@@ -99,7 +100,7 @@ class TagDependency {
                     yield TagDependency.redis.set(key, newVersion.toString());
                 }
                 catch (error) {
-                    console.error(`[TagDependency] Failed to invalidate tag in Redis: ${error instanceof Error ? error.message : String(error)}`);
+                    TagDependency.logger.error(`Failed to invalidate tag in Redis: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
         });
@@ -140,7 +141,7 @@ class TagDependency {
                     }
                 }
                 catch (error) {
-                    console.error(`[TagDependency] Failed to reset tags in Redis: ${error instanceof Error ? error.message : String(error)}`);
+                    TagDependency.logger.error(`Failed to reset tags in Redis: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
         });
@@ -154,17 +155,6 @@ class TagDependency {
     static getAllTags() {
         return new Map(TagDependency.tagVersions);
     }
-    /**
-     * Get tag version (synchronous version for backward compatibility)
-     * Only reads from in-memory storage
-     *
-     * @deprecated Use getTagVersion(tag) instead for distributed support
-     * @param tag - Tag name
-     * @returns Current tag version from memory
-     */
-    static getTagVersionSync(tag) {
-        return TagDependency.tagVersions.get(tag) || 0;
-    }
     getKey() {
         return `tag:${this.tags.sort().join(',')}`;
     }
@@ -203,6 +193,7 @@ class TagDependency {
 exports.TagDependency = TagDependency;
 TagDependency.PREFIX = 'cache:tag:';
 TagDependency.REDIS_KEY_PREFIX = 'cache:tag:versions';
+TagDependency.logger = new common_1.Logger(TagDependency.name);
 // In-memory fallback for when Redis is not available
 TagDependency.tagVersions = new Map();
 // Redis client for distributed tag version storage

package/cache/providers/lrucache.provider.d.ts

@@ -29,6 +29,7 @@ import { BaseCacheProvider } from './base-cache.provider';
  * ```
  */
 export declare class LRUCacheProvider extends BaseCacheProvider implements OnModuleDestroy {
+    private readonly logger;
     private cache;
     private namespace;
     private defaultTtl?;

package/cache/providers/lrucache.provider.js

@@ -17,6 +17,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var LRUCacheProvider_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LRUCacheProvider = void 0;
 const common_1 = require("@nestjs/common");
@@ -51,9 +52,10 @@ const LRUCacheClass = require('lru-cache').LRUCache;
  * });
  * ```
  */
-let LRUCacheProvider = class LRUCacheProvider extends base_cache_provider_1.BaseCacheProvider {
+let LRUCacheProvider = LRUCacheProvider_1 = class LRUCacheProvider extends base_cache_provider_1.BaseCacheProvider {
     constructor(options) {
         super();
+        this.logger = new common_1.Logger(LRUCacheProvider_1.name);
         const { maxSize = 500, ttl, namespace = 'cache:lru' } = options || {};
         this.namespace = namespace;
         this.defaultTtl = ttl;
@@ -75,7 +77,7 @@ let LRUCacheProvider = class LRUCacheProvider extends base_cache_provider_1.Base
                 return value !== undefined ? value : null;
             }
             catch (error) {
-                console.warn(`LRUCacheProvider: Failed to get key ${key}:`, error);
+                this.logger.warn(`Failed to get key ${key}: ${error instanceof Error ? error.message : String(error)}`);
                 return null;
             }
         });
@@ -161,7 +163,7 @@ let LRUCacheProvider = class LRUCacheProvider extends base_cache_provider_1.Base
                 });
             }
             catch (error) {
-                console.warn(`LRUCacheProvider: Failed to mget:`, error);
+                this.logger.warn(`Failed to mget: ${error instanceof Error ? error.message : String(error)}`);
                 return keys.map(() => null);
             }
         });
@@ -220,7 +222,7 @@ let LRUCacheProvider = class LRUCacheProvider extends base_cache_provider_1.Base
     }
 };
 exports.LRUCacheProvider = LRUCacheProvider;
-exports.LRUCacheProvider = LRUCacheProvider = __decorate([
+exports.LRUCacheProvider = LRUCacheProvider = LRUCacheProvider_1 = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [Object])
 ], LRUCacheProvider);

package/cache/providers/redis-cache.provider.d.ts

@@ -14,6 +14,7 @@ export declare const REDIS_CLIENT: unique symbol;
  */
 export declare class RedisCacheProvider extends BaseCacheProvider {
     private readonly redis?;
+    private readonly logger;
     private readonly keyPrefix;
     constructor(redis?: Redis);
     getName(): string;

package/cache/providers/redis-cache.provider.js

@@ -20,6 +20,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var RedisCacheProvider_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisCacheProvider = exports.REDIS_CLIENT = void 0;
 const common_1 = require("@nestjs/common");
@@ -36,13 +37,14 @@ exports.REDIS_CLIENT = Symbol('REDIS_CLIENT');
  *
  * Slowest but most persistent and widely shared cache layer.
  */
-let RedisCacheProvider = class RedisCacheProvider extends base_cache_provider_1.BaseCacheProvider {
+let RedisCacheProvider = RedisCacheProvider_1 = class RedisCacheProvider extends base_cache_provider_1.BaseCacheProvider {
     constructor(redis) {
         super();
         this.redis = redis;
+        this.logger = new common_1.Logger(RedisCacheProvider_1.name);
         this.keyPrefix = 'cache:';
         if (!redis) {
-            console.warn('RedisCacheProvider: Redis client not injected. Redis caching will be disabled.');
+            this.logger.warn('Redis client not injected. Redis caching will be disabled.');
         }
     }
     getName() {
@@ -62,7 +64,7 @@ let RedisCacheProvider = class RedisCacheProvider extends base_cache_provider_1.
                 return JSON.parse(value);
             }
             catch (error) {
-                console.warn(`RedisCacheProvider: Failed to get key ${key}: ${error instanceof Error ? error.message : String(error)}`);
+                this.logger.warn(`Failed to get key ${key}: ${error instanceof Error ? error.message : String(error)}`);
                 return null;
             }
         });
@@ -126,7 +128,7 @@ let RedisCacheProvider = class RedisCacheProvider extends base_cache_provider_1.
                 return deletedCount;
             }
             catch (error) {
-                console.warn(`RedisCacheProvider: deletePattern failed: ${error instanceof Error ? error.message : String(error)}`);
+                this.logger.warn(`deletePattern failed: ${error instanceof Error ? error.message : String(error)}`);
                 return 0;
             }
         });
@@ -184,7 +186,7 @@ let RedisCacheProvider = class RedisCacheProvider extends base_cache_provider_1.
                 });
             }
             catch (error) {
-                console.warn(`RedisCacheProvider: mget failed: ${error instanceof Error ? error.message : String(error)}`);
+                this.logger.warn(`mget failed: ${error instanceof Error ? error.message : String(error)}`);
                 return keys.map(() => null);
             }
         });
@@ -236,7 +238,7 @@ let RedisCacheProvider = class RedisCacheProvider extends base_cache_provider_1.
     }
 };
 exports.RedisCacheProvider = RedisCacheProvider;
-exports.RedisCacheProvider = RedisCacheProvider = __decorate([
+exports.RedisCacheProvider = RedisCacheProvider = RedisCacheProvider_1 = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Optional)()),
     __param(0, (0, common_1.Inject)(exports.REDIS_CLIENT)),

package/http-client/config/http-client.config.js

@@ -10,7 +10,9 @@ exports.getHttpClientConfig = getHttpClientConfig;
 function deepMerge(target, source) {
     const result = Object.assign({}, target);
     for (const key in source) {
-        if (source[key] instanceof Object && key in target && !Array.isArray(source[key])) {
+        if (source[key] instanceof Object &&
+            key in target &&
+            !Array.isArray(source[key])) {
             result[key] = deepMerge(target[key], source[key]);
         }
         else {

package/http-client/examples/axios-config-extended.example.js

@@ -304,9 +304,7 @@ function environmentSpecificConfig() {
                 ? (status) => status >= 200 && status < 500
                 : (status) => status >= 200 && status < 300,
             // 开发环境禁用 keep-alive 以便调试
-            httpAgent: isDevelopment
-                ? undefined
-                : new http_1.Agent({ keepAlive: true }),
+            httpAgent: isDevelopment ? undefined : new http_1.Agent({ keepAlive: true }),
         },
     };
     return config;

package/http-client/examples/flexible-response-example.d.ts

@@ -0,0 +1,28 @@
+/**
+ * HttpClientService 灵活返回示例
+ * 展示如何根据不同需求获取不同的响应数据
+ */
+import { HttpClientService } from '../services/http-client.service';
+declare function getFullResponseExample(httpClient: HttpClientService): Promise<any>;
+declare function getCustomResponseExample(httpClient: HttpClientService): Promise<any>;
+declare function getPagedResponseExample(httpClient: HttpClientService): Promise<{
+    data: any;
+    currentPage: number;
+    pageSize: number;
+    totalPages: number;
+    totalItems: number;
+    hasNextPage: any;
+    hasPrevPage: any;
+}>;
+declare function getRedirectUrlExample(httpClient: HttpClientService): Promise<{
+    redirected: boolean;
+    url: any;
+    data?: undefined;
+} | {
+    redirected: boolean;
+    data: any;
+    url?: undefined;
+}>;
+declare function getDefaultBehaviorExample(httpClient: HttpClientService): Promise<any>;
+declare function conditionalReturnExample(httpClient: HttpClientService, needHeaders: boolean): Promise<any>;
+export { getFullResponseExample, getCustomResponseExample, getPagedResponseExample, getRedirectUrlExample, getDefaultBehaviorExample, conditionalReturnExample, };

package/http-client/examples/flexible-response-example.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * HttpClientService 灵活返回示例
+ * 展示如何根据不同需求获取不同的响应数据
+ */
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFullResponseExample = getFullResponseExample;
+exports.getCustomResponseExample = getCustomResponseExample;
+exports.getPagedResponseExample = getPagedResponseExample;
+exports.getRedirectUrlExample = getRedirectUrlExample;
+exports.getDefaultBehaviorExample = getDefaultBehaviorExample;
+exports.conditionalReturnExample = conditionalReturnExample;
+// 示例1: 获取完整响应对象（包含headers, status等）
+function getFullResponseExample(httpClient) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 返回完整的AxiosResponse对象
+        const fullResponse = yield httpClient.get('https://api.example.com/data', {}, // config
+        'my-client', // clientName
+        { returnType: 'full' });
+        // 现在可以访问headers、status等信息
+        console.log('Status:', fullResponse.status);
+        console.log('Headers:', fullResponse.headers);
+        console.log('Data:', fullResponse.data);
+        // 例如检查特定header
+        const contentType = fullResponse.headers['content-type'];
+        const location = fullResponse.headers['location'];
+        return fullResponse.data; // 仍然可以获取data
+    });
+}
+// 示例2: 自定义返回格式
+function getCustomResponseExample(httpClient) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 自定义转换函数 - 只返回需要的字段
+        const customResponse = yield httpClient.get('https://api.example.com/users', {}, 'my-client', {
+            returnType: 'custom',
+            transform: (response) => {
+                var _a;
+                return ({
+                    data: response.data,
+                    totalCount: response.headers['x-total-count'],
+                    currentPage: response.headers['x-current-page'],
+                    hasNext: (_a = response.headers['link']) === null || _a === void 0 ? void 0 : _a.includes('rel="next"'),
+                });
+            },
+        });
+        console.log('Total Count:', customResponse.totalCount);
+        console.log('Has Next Page:', customResponse.hasNext);
+        return customResponse;
+    });
+}
+// 示例3: 从headers中提取分页信息
+function getPagedResponseExample(httpClient) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const response = yield httpClient.get('https://api.example.com/items?page=1&size=10', {}, 'my-client', { returnType: 'full' });
+        // 提取分页信息
+        const paginationInfo = {
+            data: response.data,
+            currentPage: parseInt(response.headers['x-page'] || '1'),
+            pageSize: parseInt(response.headers['x-per-page'] || '10'),
+            totalPages: parseInt(response.headers['x-total-pages'] || '1'),
+            totalItems: parseInt(response.headers['x-total-items'] || '0'),
+            hasNextPage: ((_a = response.headers['link']) === null || _a === void 0 ? void 0 : _a.includes('rel="next"')) || false,
+            hasPrevPage: ((_b = response.headers['link']) === null || _b === void 0 ? void 0 : _b.includes('rel="prev"')) || false,
+        };
+        return paginationInfo;
+    });
+}
+// 示例4: 检查重定向URL
+function getRedirectUrlExample(httpClient) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield httpClient.get('https://api.example.com/redirect-me', { maxRedirects: 0 }, // 禁止自动重定向以便捕获Location header
+        'my-client', { returnType: 'full' });
+        // 对于3xx重定向状态，获取重定向URL
+        if (response.status >= 300 && response.status < 400) {
+            const redirectUrl = response.headers['location'];
+            console.log('Redirect URL:', redirectUrl);
+            return { redirected: true, url: redirectUrl };
+        }
+        return { redirected: false, data: response.data };
+    });
+}
+// 示例5: 向后兼容 - 默认行为（只返回data）
+function getDefaultBehaviorExample(httpClient) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 不传递returnOptions参数，保持原有行为
+        const data = yield httpClient.get('https://api.example.com/simple-data');
+        // 直接得到data，无需.response.data
+        console.log('Simple data:', data);
+        return data;
+    });
+}
+// 示例6: 条件性返回不同格式
+function conditionalReturnExample(httpClient, needHeaders) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const returnOptions = needHeaders
+            ? { returnType: 'full' }
+            : { returnType: 'data' }; // 默认
+        const result = yield httpClient.post('https://api.example.com/process', { action: 'calculate' }, {}, 'my-client', returnOptions);
+        if (needHeaders) {
+            // 处理完整响应
+            const fullResponse = result;
+            console.log('Processing time:', fullResponse.headers['x-processing-time']);
+            return fullResponse.data;
+        }
+        else {
+            // 直接使用data
+            return result;
+        }
+    });
+}

package/http-client/examples/ssl-certificate.example.d.ts

@@ -27,10 +27,10 @@ export declare class DynamicCertificateManager {
         cert?: string;
         key?: string;
     });
-    private loadCerts;
-    private buildConfig;
     refreshCerts(): Promise<void>;
     get(url: string): Promise<void>;
+    private loadCerts;
+    private buildConfig;
 }
 export declare const sslEnvVars: {
     SSL_CA_PATH: string;

package/http-client/examples/ssl-certificate.example.js

@@ -339,9 +339,26 @@ class DynamicCertificateManager {
         this.cacheDuration = 5 * 60 * 1000; // 5分钟
         this.httpClient = new index_1.HttpClientService(this.circuitBreakerService, this.loggingService, null, this.buildConfig());
     }
+    // 重新创建客户端以使用新证书
+    refreshCerts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.lastUpdate = 0;
+            const config = this.buildConfig();
+            // 在实际应用中，可能需要重新创建 HttpClientService 实例
+            // 或者提供更新配置的方法
+        });
+    }
+    get(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 每次请求前检查是否需要更新证书
+            this.loadCerts();
+            // return this.httpClient.get(url);
+        });
+    }
     loadCerts() {
         const now = Date.now();
-        if (now - this.lastUpdate < this.cacheDuration && Object.keys(this.certCache).length > 0) {
+        if (now - this.lastUpdate < this.cacheDuration &&
+            Object.keys(this.certCache).length > 0) {
             return this.certCache;
         }
         // 重新加载证书
@@ -367,22 +384,6 @@ class DynamicCertificateManager {
             },
         };
     }
-    // 重新创建客户端以使用新证书
-    refreshCerts() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.lastUpdate = 0;
-            const config = this.buildConfig();
-            // 在实际应用中，可能需要重新创建 HttpClientService 实例
-            // 或者提供更新配置的方法
-        });
-    }
-    get(url) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // 每次请求前检查是否需要更新证书
-            this.loadCerts();
-            // return this.httpClient.get(url);
-        });
-    }
 }
 exports.DynamicCertificateManager = DynamicCertificateManager;
 // ============================================================================

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

@@ -1,7 +1,7 @@
 import { ApiClientConfig, ApiClientInstanceConfig, ApiClientRegistryConfig, AuthType, ResponseTransformerConfig } from '../interfaces/api-client-config.interface';
 import { HttpCircuitBreakerService } from './circuit-breaker.service';
 import { HttpLoggingService } from './logging.service';
-export { ApiClientInstanceConfig, AuthType, ResponseTransformerConfig, };
+export { ApiClientInstanceConfig, AuthType, ResponseTransformerConfig };
 /**
  * API客户端注册服务
  * 负责管理多个 HttpClientService 实例
@@ -19,11 +19,6 @@ export declare class ApiClientRegistryService {
      * 使用 HttpClientService.createApiClient 静态方法创建
      */
     createClient<T = any>(config: ApiClientInstanceConfig): T;
-    /**
-     * 深度合并配置（已废弃，不再需要）
-     * @deprecated 配置结构简化后不再需要此方法
-     */
-    private deepMergeConfigs;
     /**
      * 获取已注册的客户端
      */
@@ -78,6 +73,11 @@ export declare class ApiClientRegistryService {
             error?: string;
         }>;
     }>;
+    /**
+     * 深度合并配置（已废弃，不再需要）
+     * @deprecated 配置结构简化后不再需要此方法
+     */
+    private deepMergeConfigs;
     /**
      * 合并环境特定配置
      */

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

@@ -74,7 +74,7 @@ let ApiClientRegistryService = ApiClientRegistryService_1 = class ApiClientRegis
         // 1. 从全局默认配置开始
         // 2. 合并 ApiClient 的 httpConfig
         // 3. 应用 ApiClient 特有的 retry 配置（兼容旧代码）
-        let mergedHttpConfig = Object.assign(Object.assign({}, this.globalDefaults.globalDefaults), finalConfig.httpConfig);
+        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);
@@ -95,13 +95,6 @@ let ApiClientRegistryService = ApiClientRegistryService_1 = class ApiClientRegis
         this.logger.log(`Created API client: ${clientName}`);
         return httpClient;
     }
-    /**
-     * 深度合并配置（已废弃，不再需要）
-     * @deprecated 配置结构简化后不再需要此方法
-     */
-    deepMergeConfigs(defaults, userConfig) {
-        return Object.assign(Object.assign({}, defaults), userConfig);
-    }
     /**
      * 获取已注册的客户端
      */
@@ -226,6 +219,13 @@ let ApiClientRegistryService = ApiClientRegistryService_1 = class ApiClientRegis
             };
         });
     }
+    /**
+     * 深度合并配置（已废弃，不再需要）
+     * @deprecated 配置结构简化后不再需要此方法
+     */
+    deepMergeConfigs(defaults, userConfig) {
+        return Object.assign(Object.assign({}, defaults), userConfig);
+    }
     /**
      * 合并环境特定配置
      */