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

package/cache/cache.module.d.ts

@@ -1,5 +1,4 @@
 import { DynamicModule, OnModuleInit } from '@nestjs/common';
-import type { DataSource } from 'typeorm';
 import type { Redis } from 'ioredis';
 import { CacheService } from './cache.service';
 /**
@@ -20,11 +19,6 @@ export interface CacheModuleOptions {
      * If not provided, Redis caching will be disabled
      */
     redisClient?: Redis;
-    /**
-     * TypeORM DataSource for DbDependency
-     * If not provided, DbDependency will throw error when used
-     */
-    dataSource?: DataSource;
     /**
      * Default TTL for memory cache in milliseconds
      */

package/cache/cache.module.js

@@ -80,10 +80,10 @@ let CacheModule = CacheModule_1 = class CacheModule {
      * Register cache module with options
      */
     static forRoot(options = {}) {
-        const { isGlobal = true, redisClient, dataSource, memoryTtl, memoryNamespace, enableCompression = false, compressionThreshold = 1024, } = options;
-        // Set DataSource for DbDependency if provided
-        if (dataSource) {
-            dependencies_1.DbDependency.setDataSource(dataSource);
+        const { isGlobal = true, redisClient, memoryTtl, memoryNamespace, enableCompression = false, compressionThreshold = 1024, } = options;
+        // Set Redis client for TagDependency for distributed tag support
+        if (redisClient) {
+            dependencies_1.TagDependency.setRedisClient(redisClient);
         }
         return {
             module: CacheModule_1,
@@ -161,9 +161,9 @@ let CacheModule = CacheModule_1 = class CacheModule {
                 {
                     provide: providers_1.MemoryCacheProvider,
                     useFactory: (moduleOptions) => {
-                        // Set DataSource for DbDependency if provided
-                        if (moduleOptions.dataSource) {
-                            dependencies_1.DbDependency.setDataSource(moduleOptions.dataSource);
+                        // Set Redis client for TagDependency for distributed tag support
+                        if (moduleOptions.redisClient) {
+                            dependencies_1.TagDependency.setRedisClient(moduleOptions.redisClient);
                         }
                         return new providers_1.MemoryCacheProvider({
                             ttl: moduleOptions.memoryTtl,

package/cache/cache.service.js

@@ -333,6 +333,18 @@ let CacheService = CacheService_1 = class CacheService {
     setWithOptions(key, value, options) {
         return __awaiter(this, void 0, void 0, function* () {
             this.stats.totalSets++;
+            // Validate TTL if provided
+            if ((options === null || options === void 0 ? void 0 : options.ttl) !== undefined) {
+                if (typeof options.ttl !== 'number' || options.ttl < 0) {
+                    this.logger.warn(`Invalid TTL value: ${options.ttl}. TTL must be a non-negative number. Using default behavior.`);
+                    // Continue without TTL
+                    options.ttl = undefined;
+                }
+                else if (options.ttl === 0) {
+                    // TTL of 0 means no expiration
+                    options.ttl = undefined;
+                }
+            }
             // Check condition
             if ((options === null || options === void 0 ? void 0 : options.condition) && !(yield Promise.resolve(options.condition()))) {
                 return;

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

@@ -1,4 +1,3 @@
-import { DataSource } from 'typeorm';
 import type { CacheDependency } from '../interfaces';
 /**
  * Options for DbDependency
@@ -77,18 +76,6 @@ export declare class DbDependency implements CacheDependency {
     private static fallbackDataSource;
     private static defaultDataSourceName;
     constructor(sql: string, paramsFactory?: (...args: any[]) => any[], options?: DbDependencyOptions);
-    /**
-     * Set a fallback DataSource for database queries
-     * This is used when DataSourceUtil cannot provide a DataSource
-     * This method is deprecated - use DataSourceUtil.registerDataSource() instead
-     * @deprecated Use DataSourceUtil.registerDataSource() to register DataSources
-     */
-    static setDataSource(dataSource: DataSource): void;
-    /**
-     * Set the default data source name for DbDependency
-     * @param name The data source name (default: 'default')
-     */
-    static setDefaultDataSourceName(name: string): void;
     /**
      * Get DataSource for executing queries
      * Priority: 1. Specific dataSourceName from options, 2. Default from getDataSourceByName, 3. Fallback

package/cache/dependencies/db.dependency.js

@@ -75,22 +75,6 @@ class DbDependency {
             throw new Error('DbDependency requires a valid SQL query');
         }
     }
-    /**
-     * Set a fallback DataSource for database queries
-     * This is used when DataSourceUtil cannot provide a DataSource
-     * This method is deprecated - use DataSourceUtil.registerDataSource() instead
-     * @deprecated Use DataSourceUtil.registerDataSource() to register DataSources
-     */
-    static setDataSource(dataSource) {
-        this.fallbackDataSource = dataSource;
-    }
-    /**
-     * Set the default data source name for DbDependency
-     * @param name The data source name (default: 'default')
-     */
-    static setDefaultDataSourceName(name) {
-        this.defaultDataSourceName = name;
-    }
     /**
      * Get DataSource for executing queries
      * Priority: 1. Specific dataSourceName from options, 2. Default from getDataSourceByName, 3. Fallback

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

@@ -1,4 +1,5 @@
 import type { CacheDependency } from '../interfaces/cache-dependency.interface';
+import type Redis from 'ioredis';
 /**
  * Tag-based cache dependency
  *
@@ -7,6 +8,9 @@ import type { CacheDependency } from '../interfaces/cache-dependency.interface';
  *
  * This is the most commonly used dependency type for managing related cache entries.
  *
+ * **Distributed Support**: Tag versions are stored in Redis for multi-instance deployments.
+ * Falls back to in-memory storage if Redis is not available.
+ *
  * @example
  * ```typescript
  * // Cache user list with tag dependency
@@ -23,28 +27,59 @@ import type { CacheDependency } from '../interfaces/cache-dependency.interface';
 export declare class TagDependency implements CacheDependency {
     private readonly tags;
     private static readonly PREFIX;
+    private static readonly REDIS_KEY_PREFIX;
     private static tagVersions;
+    private static redis;
     constructor(tags: string[]);
+    /**
+     * Set Redis client for distributed tag version storage
+     * Called by CacheModule during initialization
+     *
+     * @param redis - Redis client instance
+     */
+    static setRedisClient(redis: Redis): void;
     /**
      * Get current version of a tag
+     * Prioritizes Redis, falls back to in-memory storage
+     *
+     * @param tag - Tag name
+     * @returns Current tag version
      */
-    static getTagVersion(tag: string): number;
+    static getTagVersion(tag: string): Promise<number>;
     /**
      * Invalidate a tag (increment its version)
+     * Updates both Redis and in-memory storage
+     *
+     * @param tag - Tag name to invalidate
      */
-    static invalidateTag(tag: string): void;
+    static invalidateTag(tag: string): Promise<void>;
     /**
      * Invalidate multiple tags
+     *
+     * @param tags - Array of tag names to invalidate
      */
-    static invalidateTags(tags: string[]): void;
+    static invalidateTags(tags: string[]): Promise<void>;
     /**
      * Reset all tag versions (useful for testing)
+     * Clears both Redis and in-memory storage
      */
-    static resetAllTags(): void;
+    static resetAllTags(): Promise<void>;
     /**
      * Get all tags and their versions
+     * Note: This only returns in-memory tags for backward compatibility
+     *
+     * @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

@@ -18,6 +18,9 @@ exports.TagDependency = void 0;
  *
  * This is the most commonly used dependency type for managing related cache entries.
  *
+ * **Distributed Support**: Tag versions are stored in Redis for multi-instance deployments.
+ * Falls back to in-memory storage if Redis is not available.
+ *
  * @example
  * ```typescript
  * // Cache user list with tag dependency
@@ -38,38 +41,129 @@ class TagDependency {
             throw new Error('TagDependency requires at least one tag');
         }
     }
+    /**
+     * Set Redis client for distributed tag version storage
+     * Called by CacheModule during initialization
+     *
+     * @param redis - Redis client instance
+     */
+    static setRedisClient(redis) {
+        TagDependency.redis = redis;
+    }
     /**
      * Get current version of a tag
+     * Prioritizes Redis, falls back to in-memory storage
+     *
+     * @param tag - Tag name
+     * @returns Current tag version
      */
     static getTagVersion(tag) {
-        return this.tagVersions.get(tag) || 0;
+        return __awaiter(this, void 0, void 0, function* () {
+            // Try to get from Redis first
+            if (TagDependency.redis) {
+                try {
+                    const key = `${TagDependency.REDIS_KEY_PREFIX}:${tag}`;
+                    const result = yield TagDependency.redis.get(key);
+                    if (result !== null) {
+                        const version = parseInt(result, 10);
+                        // Cache in memory for faster access
+                        TagDependency.tagVersions.set(tag, version);
+                        return version;
+                    }
+                }
+                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)}`);
+                }
+            }
+            // Fall back to in-memory storage
+            return TagDependency.tagVersions.get(tag) || 0;
+        });
     }
     /**
      * Invalidate a tag (increment its version)
+     * Updates both Redis and in-memory storage
+     *
+     * @param tag - Tag name to invalidate
      */
     static invalidateTag(tag) {
-        const currentVersion = this.tagVersions.get(tag) || 0;
-        this.tagVersions.set(tag, currentVersion + 1);
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentVersion = TagDependency.tagVersions.get(tag) || 0;
+            const newVersion = currentVersion + 1;
+            // Update in-memory storage
+            TagDependency.tagVersions.set(tag, newVersion);
+            // Update Redis if available
+            if (TagDependency.redis) {
+                try {
+                    const key = `${TagDependency.REDIS_KEY_PREFIX}:${tag}`;
+                    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)}`);
+                }
+            }
+        });
     }
     /**
      * Invalidate multiple tags
+     *
+     * @param tags - Array of tag names to invalidate
      */
     static invalidateTags(tags) {
-        for (const tag of tags) {
-            this.invalidateTag(tag);
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(tags.map((tag) => TagDependency.invalidateTag(tag)));
+        });
     }
     /**
      * Reset all tag versions (useful for testing)
+     * Clears both Redis and in-memory storage
      */
     static resetAllTags() {
-        this.tagVersions.clear();
+        return __awaiter(this, void 0, void 0, function* () {
+            // Clear in-memory storage
+            TagDependency.tagVersions.clear();
+            // Clear Redis storage
+            if (TagDependency.redis) {
+                try {
+                    let cursor = '0';
+                    const pattern = `${TagDependency.REDIS_KEY_PREFIX}:*`;
+                    const keysToDelete = [];
+                    // Use SCAN to find all tag version keys
+                    do {
+                        const [nextCursor, keys] = yield TagDependency.redis.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+                        cursor = nextCursor;
+                        keysToDelete.push(...keys);
+                    } while (cursor !== '0');
+                    // Delete all found keys
+                    if (keysToDelete.length > 0) {
+                        yield TagDependency.redis.del(...keysToDelete);
+                    }
+                }
+                catch (error) {
+                    console.error(`[TagDependency] Failed to reset tags in Redis: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        });
     }
     /**
      * Get all tags and their versions
+     * Note: This only returns in-memory tags for backward compatibility
+     *
+     * @returns Map of tag names to versions
      */
     static getAllTags() {
-        return new Map(this.tagVersions);
+        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(',')}`;
@@ -78,7 +172,7 @@ class TagDependency {
         return __awaiter(this, void 0, void 0, function* () {
             const data = {};
             for (const tag of this.tags) {
-                data[tag] = TagDependency.getTagVersion(tag);
+                data[tag] = yield TagDependency.getTagVersion(tag);
             }
             return data;
         });
@@ -89,7 +183,7 @@ class TagDependency {
                 return true;
             }
             for (const tag of this.tags) {
-                const currentVersion = TagDependency.getTagVersion(tag);
+                const currentVersion = yield TagDependency.getTagVersion(tag);
                 const oldVersion = oldData[tag];
                 if (currentVersion !== oldVersion) {
                     return true;
@@ -101,11 +195,15 @@ class TagDependency {
     reset() {
         return __awaiter(this, void 0, void 0, function* () {
             for (const tag of this.tags) {
-                TagDependency.invalidateTag(tag);
+                yield TagDependency.invalidateTag(tag);
             }
         });
     }
 }
 exports.TagDependency = TagDependency;
 TagDependency.PREFIX = 'cache:tag:';
+TagDependency.REDIS_KEY_PREFIX = 'cache:tag:versions';
+// In-memory fallback for when Redis is not available
 TagDependency.tagVersions = new Map();
+// Redis client for distributed tag version storage
+TagDependency.redis = null;

package/cache/interfaces/cache-options.interface.d.ts

@@ -35,6 +35,14 @@ export interface CacheOptions {
      * @returns true to cache, false to skip
      */
     condition?: (...args: any[]) => boolean | Promise<boolean>;
+    /**
+     * Unless condition - skip caching when this condition is true
+     * Can be a function (safe) or a string expression (use with caution)
+     * @param result - Method return value
+     * @param args - Method arguments
+     * @returns true to skip caching, false to cache normally
+     */
+    unless?: ((result: any, args: any[]) => boolean) | string;
     /**
      * Cache dependencies - cache will be invalidated when dependencies change
      * Similar to Yii2 cache dependency system

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

@@ -6,16 +6,36 @@ import { BaseCacheProvider } from './base-cache.provider';
  * Data is stored in memory and shared across all requests in the same process.
  *
  * Faster than Redis but not shared across multiple processes/servers.
+ *
+ * **Automatic Cleanup**: Includes periodic cleanup of expired items to prevent memory leaks.
  */
 export declare class MemoryCacheProvider extends BaseCacheProvider {
     private cache;
     private keys;
     private defaultTtl?;
     private namespace;
+    private cleanupTimer?;
+    /**
+     * Cleanup interval in milliseconds
+     * @default 300000 (5 minutes)
+     */
+    private readonly CLEANUP_INTERVAL;
     constructor(options?: {
         ttl?: number;
         namespace?: string;
     });
+    /**
+     * Start periodic cleanup of expired items
+     */
+    private startCleanupTimer;
+    /**
+     * Stop automatic cleanup timer
+     */
+    private stopCleanupTimer;
+    /**
+     * Destroy the provider and cleanup resources
+     */
+    destroy(): void;
     getName(): string;
     get<T>(key: string): Promise<T | null>;
     set<T>(key: string, value: T, ttl?: number): Promise<void>;

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

@@ -18,14 +18,54 @@ const base_cache_provider_1 = require("./base-cache.provider");
  * Data is stored in memory and shared across all requests in the same process.
  *
  * Faster than Redis but not shared across multiple processes/servers.
+ *
+ * **Automatic Cleanup**: Includes periodic cleanup of expired items to prevent memory leaks.
  */
 class MemoryCacheProvider extends base_cache_provider_1.BaseCacheProvider {
     constructor(options) {
         super();
         this.cache = new Map();
         this.keys = new Set();
+        /**
+         * Cleanup interval in milliseconds
+         * @default 300000 (5 minutes)
+         */
+        this.CLEANUP_INTERVAL = 5 * 60 * 1000;
         this.defaultTtl = options === null || options === void 0 ? void 0 : options.ttl;
         this.namespace = (options === null || options === void 0 ? void 0 : options.namespace) || 'cache:memory';
+        // Start automatic cleanup timer
+        this.startCleanupTimer();
+    }
+    /**
+     * Start periodic cleanup of expired items
+     */
+    startCleanupTimer() {
+        this.cleanupTimer = setInterval(() => {
+            const cleaned = this.cleanup();
+            if (cleaned > 0) {
+                console.debug(`[MemoryCache] Cleaned up ${cleaned} expired items from namespace: ${this.namespace}`);
+            }
+        }, this.CLEANUP_INTERVAL);
+        // Allow Node.js to exit if this is the only active timer
+        if (this.cleanupTimer.unref) {
+            this.cleanupTimer.unref();
+        }
+    }
+    /**
+     * Stop automatic cleanup timer
+     */
+    stopCleanupTimer() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = undefined;
+        }
+    }
+    /**
+     * Destroy the provider and cleanup resources
+     */
+    destroy() {
+        this.stopCleanupTimer();
+        this.clear();
     }
     getName() {
         return 'Memory';

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

@@ -1,4 +1,9 @@
 import { HttpClientConfig } from '../interfaces/http-client-config.interface';
+/**
+ * 深度合并配置
+ * 将用户配置与默认配置合并，用户配置会覆盖默认配置
+ */
+export declare function mergeHttpClientConfig(userConfig?: Partial<HttpClientConfig>, defaultConfig?: Partial<HttpClientConfig>): HttpClientConfig;
 /**
  * HTTP客户端默认配置
  */

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

@@ -1,8 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TEST_HTTP_CLIENT_CONFIG = exports.PRODUCTION_HTTP_CLIENT_CONFIG = exports.DEVELOPMENT_HTTP_CLIENT_CONFIG = exports.DEFAULT_HTTP_CLIENT_CONFIG = void 0;
+exports.mergeHttpClientConfig = mergeHttpClientConfig;
 exports.getHttpClientConfig = getHttpClientConfig;
-const cache_options_interface_1 = require("../../cache/interfaces/cache-options.interface");
+/**
+ * 深度合并对象
+ * 用于合并用户配置和默认配置
+ */
+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])) {
+            result[key] = deepMerge(target[key], source[key]);
+        }
+        else {
+            result[key] = source[key];
+        }
+    }
+    return result;
+}
+/**
+ * 深度合并配置
+ * 将用户配置与默认配置合并，用户配置会覆盖默认配置
+ */
+function mergeHttpClientConfig(userConfig = {}, defaultConfig = exports.DEFAULT_HTTP_CLIENT_CONFIG) {
+    return deepMerge(defaultConfig, userConfig);
+}
 /**
  * HTTP客户端默认配置
  */
@@ -29,15 +52,6 @@ exports.DEFAULT_HTTP_CLIENT_CONFIG = {
         minimumThroughputThreshold: 10,
         countHalfOpenCalls: false,
     },
-    cache: {
-        enabled: true,
-        defaultTtl: 300000, // 5分钟
-        cacheableMethods: ['GET', 'HEAD'],
-        cacheableStatusCodes: [200, 201, 304],
-        options: {
-            layers: [cache_options_interface_1.CacheLayer.CLS, cache_options_interface_1.CacheLayer.MEMORY, cache_options_interface_1.CacheLayer.REDIS],
-        },
-    },
     logging: {
         enabled: true,
         logRequests: true,
@@ -51,7 +65,6 @@ exports.DEFAULT_HTTP_CLIENT_CONFIG = {
         databaseLogging: {
             enabled: false, // 默认不启用数据库日志
             dataSource: 'default',
-            tableName: 'http_logs',
         },
     },
     logCleanup: {
@@ -69,7 +82,6 @@ exports.DEFAULT_HTTP_CLIENT_CONFIG = {
 exports.DEVELOPMENT_HTTP_CLIENT_CONFIG = Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG), { logging: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.logging), { enabled: true, logHeaders: true, logBody: true, logLevel: 'debug', databaseLogging: {
             enabled: true, // 开发环境启用数据库日志
             dataSource: 'default',
-            tableName: 'http_logs',
         } }), logCleanup: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.logCleanup), { enabled: false }) });
 /**
  * 生产环境配置
@@ -77,7 +89,6 @@ exports.DEVELOPMENT_HTTP_CLIENT_CONFIG = Object.assign(Object.assign({}, exports
 exports.PRODUCTION_HTTP_CLIENT_CONFIG = Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG), { timeout: 60000, retry: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.retry), { retries: 5 }), circuitBreaker: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.circuitBreaker), { failureThreshold: 3, recoveryTimeoutMs: 120000 }), logging: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.logging), { enabled: true, logHeaders: false, logBody: false, logLevel: 'warn', databaseLogging: {
             enabled: true, // 生产环境启用数据库日志
             dataSource: 'default',
-            tableName: 'http_logs',
         } }), logCleanup: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.logCleanup), { enabled: true, retentionDays: 7, maxRecords: 50000, schedule: '0 3 * * *' }) });
 /**
  * 测试环境配置

package/http-client/decorators/http-client.decorators.d.ts

@@ -1,9 +1,8 @@
 import 'reflect-metadata';
-import { CircuitBreakerConfig, HttpCacheConfig, HttpClientConfig, RetryConfig } from '../interfaces/http-client-config.interface';
+import { CircuitBreakerConfig, HttpClientConfig, RetryConfig } from '../interfaces/http-client-config.interface';
 export declare const HTTP_CLIENT_OPTIONS_KEY = "http_client_options";
 export declare const RETRY_OPTIONS_KEY = "http_retry_options";
 export declare const CIRCUIT_BREAKER_OPTIONS_KEY = "http_circuit_breaker_options";
-export declare const CACHE_OPTIONS_KEY = "http_cache_options";
 export declare const LOGGING_OPTIONS_KEY = "http_logging_options";
 export declare const TIMEOUT_OPTIONS_KEY = "http_timeout_options";
 export declare const PROXY_OPTIONS_KEY = "http_proxy_options";
@@ -34,24 +33,6 @@ export declare const HttpCircuitBreaker: (options?: {
     monitoringPeriodMs?: number;
     minimumThroughputThreshold?: number;
 }) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-/**
- * HTTP缓存装饰器
- * 集成现有的三层缓存架构
- */
-export declare const HttpCacheable: (options?: {
-    /** 缓存TTL（毫秒） */
-    ttl?: number;
-    /** 缓存键 */
-    key?: string | ((...args: any[]) => string);
-    /** 缓存层 */
-    layers?: Array<"cls" | "memory" | "redis">;
-    /** 缓存条件 */
-    condition?: (...args: any[]) => boolean | Promise<boolean>;
-    /** 除非条件 */
-    unless?: string | ((result: any, args: any[]) => boolean);
-    /** 命名空间 */
-    namespace?: string;
-}) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
 /**
  * 请求日志装饰器
  * 类似Spring Boot的@LogRequest注解
@@ -97,10 +78,6 @@ export declare class HttpDecoratorUtils {
      * 获取方法上的熔断器配置
      */
     static getCircuitBreakerOptions(target: any, propertyKey: string): CircuitBreakerConfig | undefined;
-    /**
-     * 获取方法上的缓存配置
-     */
-    static getCacheOptions(target: any, propertyKey: string): HttpCacheConfig | undefined;
     /**
      * 获取方法上的日志配置
      */
@@ -127,7 +104,6 @@ export declare class HttpDecoratorUtils {
     static getAllDecoratorConfigs(target: any, propertyKey: string): {
         retry?: RetryConfig;
         circuitBreaker?: CircuitBreakerConfig;
-        cache?: HttpCacheConfig;
         logging?: any;
         timeout?: number;
         proxy?: any;