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

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

@@ -1,14 +1,21 @@
 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";
 export declare const CALL_INFO_KEY = "http_call_info";
+/**
+ * HTTP客户端装饰器
+ * 类似Spring Boot的@RestClient注解
+ */
 export declare const HttpClient: (options?: HttpClientConfig) => (target: any) => void;
+/**
+ * 重试装饰器
+ * 基于axios-retry库
+ */
 export declare const HttpRetry: (options?: {
     retries?: number;
     retryDelay?: (retryCount: number) => number;
@@ -16,20 +23,20 @@ export declare const HttpRetry: (options?: {
     shouldResetTimeout?: boolean;
     onRetry?: (retryCount: number, error: any, requestConfig: any) => void;
 }) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * 熔断器装饰器
+ * 类似Spring Cloud CircuitBreaker的@CircuitBreaker注解
+ */
 export declare const HttpCircuitBreaker: (options?: {
     failureThreshold?: number;
     recoveryTimeoutMs?: number;
     monitoringPeriodMs?: number;
     minimumThroughputThreshold?: number;
 }) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-export declare const HttpCacheable: (options?: {
-    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注解
+ */
 export declare const HttpLogRequest: (options?: {
     logHeaders?: boolean;
     logBody?: boolean;
@@ -40,29 +47,63 @@ export declare const HttpLogRequest: (options?: {
     methodName?: string;
     operationName?: string;
 }) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * 超时装饰器
+ * 类似Spring的@Timeout注解
+ */
 export declare const HttpTimeout: (timeoutMs: number) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * 代理装饰器
+ */
 export declare const HttpUseProxy: (options: {
-    host: string;
-    port: number;
+    enabled?: boolean;
+    fromEnvironment?: boolean;
+    host?: string;
+    port?: number;
     protocol?: "http" | "https";
     auth?: {
         username: string;
         password: string;
     };
 }) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * 装饰器工具函数
+ */
 export declare class HttpDecoratorUtils {
+    /**
+     * 获取方法上的重试配置
+     */
     static getRetryOptions(target: any, propertyKey: string): RetryConfig | undefined;
+    /**
+     * 获取方法上的熔断器配置
+     */
     static getCircuitBreakerOptions(target: any, propertyKey: string): CircuitBreakerConfig | undefined;
-    static getCacheOptions(target: any, propertyKey: string): HttpCacheConfig | undefined;
+    /**
+     * 获取方法上的日志配置
+     */
     static getLoggingOptions(target: any, propertyKey: string): any;
+    /**
+     * 获取方法上的超时配置
+     */
     static getTimeoutOptions(target: any, propertyKey: string): number | undefined;
+    /**
+     * 获取方法上的代理配置
+     */
     static getProxyOptions(target: any, propertyKey: string): any;
+    /**
+     * 获取类上的HTTP客户端配置
+     */
     static getHttpClientOptions(target: any): HttpClientConfig;
+    /**
+     * 获取方法上的调用信息配置
+     */
     static getCallInfoOptions(target: any, propertyKey: string): any;
+    /**
+     * 获取所有装饰器配置
+     */
     static getAllDecoratorConfigs(target: any, propertyKey: string): {
         retry?: RetryConfig;
         circuitBreaker?: CircuitBreakerConfig;
-        cache?: HttpCacheConfig;
         logging?: any;
         timeout?: number;
         proxy?: any;

package/http-client/decorators/http-client.decorators.js

@@ -1,24 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpDecoratorUtils = exports.HttpUseProxy = exports.HttpTimeout = exports.HttpLogRequest = exports.HttpCacheable = exports.HttpCircuitBreaker = exports.HttpRetry = exports.HttpClient = exports.CALL_INFO_KEY = exports.PROXY_OPTIONS_KEY = exports.TIMEOUT_OPTIONS_KEY = exports.LOGGING_OPTIONS_KEY = exports.CACHE_OPTIONS_KEY = exports.CIRCUIT_BREAKER_OPTIONS_KEY = exports.RETRY_OPTIONS_KEY = exports.HTTP_CLIENT_OPTIONS_KEY = void 0;
+exports.HttpDecoratorUtils = exports.HttpUseProxy = exports.HttpTimeout = exports.HttpLogRequest = exports.HttpCircuitBreaker = exports.HttpRetry = exports.HttpClient = exports.CALL_INFO_KEY = exports.PROXY_OPTIONS_KEY = exports.TIMEOUT_OPTIONS_KEY = exports.LOGGING_OPTIONS_KEY = exports.CIRCUIT_BREAKER_OPTIONS_KEY = exports.RETRY_OPTIONS_KEY = exports.HTTP_CLIENT_OPTIONS_KEY = void 0;
 require("reflect-metadata");
 const common_1 = require("@nestjs/common");
-const cache_options_interface_1 = require("../../cache/interfaces/cache-options.interface");
 const call_stack_extractor_util_1 = require("../utils/call-stack-extractor.util");
+// 装饰器元数据键
 exports.HTTP_CLIENT_OPTIONS_KEY = 'http_client_options';
 exports.RETRY_OPTIONS_KEY = 'http_retry_options';
 exports.CIRCUIT_BREAKER_OPTIONS_KEY = 'http_circuit_breaker_options';
-exports.CACHE_OPTIONS_KEY = 'http_cache_options';
 exports.LOGGING_OPTIONS_KEY = 'http_logging_options';
 exports.TIMEOUT_OPTIONS_KEY = 'http_timeout_options';
 exports.PROXY_OPTIONS_KEY = 'http_proxy_options';
 exports.CALL_INFO_KEY = 'http_call_info';
+/**
+ * HTTP客户端装饰器
+ * 类似Spring Boot的@RestClient注解
+ */
 const HttpClient = (options = {}) => {
     return (target) => {
         (0, common_1.SetMetadata)(exports.HTTP_CLIENT_OPTIONS_KEY, options)(target);
     };
 };
 exports.HttpClient = HttpClient;
+/**
+ * 重试装饰器
+ * 基于axios-retry库
+ */
 const HttpRetry = (options = {}) => {
     return (target, propertyKey, descriptor) => {
         const retryOptions = {
@@ -27,19 +34,46 @@ const HttpRetry = (options = {}) => {
             retryDelay: options.retryDelay || ((retryCount) => Math.pow(2, retryCount) * 1000),
             retryCondition: options.retryCondition ||
                 ((error) => {
+                    // 默认重试条件：网络错误、超时、5xx错误、429错误
                     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: options.shouldResetTimeout !== false,
             onRetry: options.onRetry,
         };
-        (0, common_1.SetMetadata)(`${exports.RETRY_OPTIONS_KEY}_${propertyKey}`, retryOptions)(descriptor.value);
+        // Wrap the method to pass decorator context to HTTP client
+        const originalMethod = descriptor.value;
+        const wrappedMethod = function (...args) {
+            // Set decorator context (reference counting prevents overwriting)
+            call_stack_extractor_util_1.CallStackExtractor.setDecoratorContext({
+                target,
+                propertyKey,
+            });
+            try {
+                return originalMethod.apply(this, args);
+            }
+            finally {
+                call_stack_extractor_util_1.CallStackExtractor.clearDecoratorContext();
+            }
+        };
+        // Copy metadata from original to wrapped method
+        const metadataKeys = Reflect.getMetadataKeys(originalMethod);
+        for (const key of metadataKeys) {
+            Reflect.defineMetadata(key, Reflect.getMetadata(key, originalMethod), wrappedMethod);
+        }
+        // Store the retry options on the wrapped method
+        (0, common_1.SetMetadata)(`${exports.RETRY_OPTIONS_KEY}_${propertyKey}`, retryOptions)(wrappedMethod);
+        descriptor.value = wrappedMethod;
         return descriptor;
     };
 };
 exports.HttpRetry = HttpRetry;
+/**
+ * 熔断器装饰器
+ * 类似Spring Cloud CircuitBreaker的@CircuitBreaker注解
+ */
 const HttpCircuitBreaker = (options = {}) => {
     return (target, propertyKey, descriptor) => {
         const circuitBreakerOptions = {
@@ -50,66 +84,41 @@ const HttpCircuitBreaker = (options = {}) => {
             minimumThroughputThreshold: options.minimumThroughputThreshold || 10,
             countHalfOpenCalls: true,
         };
-        (0, common_1.SetMetadata)(`${exports.CIRCUIT_BREAKER_OPTIONS_KEY}_${propertyKey}`, circuitBreakerOptions)(descriptor.value);
-        return descriptor;
-    };
-};
-exports.HttpCircuitBreaker = HttpCircuitBreaker;
-const HttpCacheable = (options = {}) => {
-    return (target, propertyKey, descriptor) => {
-        var _a;
-        const cacheOptions = {
-            enabled: true,
-            defaultTtl: options.ttl || 300000,
-            keyGenerator: typeof options.key === 'function'
-                ? (config) => options.key(config.url, config.method, config.data, config.params)
-                : options.key
-                    ? () => options.key
-                    : undefined,
-            options: {
-                layers: (_a = options.layers) === null || _a === void 0 ? void 0 : _a.map((layer) => {
-                    switch (layer) {
-                        case 'cls':
-                            return cache_options_interface_1.CacheLayer.CLS;
-                        case 'memory':
-                            return cache_options_interface_1.CacheLayer.MEMORY;
-                        case 'redis':
-                            return cache_options_interface_1.CacheLayer.REDIS;
-                        default:
-                            return cache_options_interface_1.CacheLayer.MEMORY;
-                    }
-                }),
-                condition: options.condition,
-                prefix: options.namespace,
-            },
-            cacheableMethods: ['get'],
-            cacheableStatusCodes: [200, 201, 202, 204, 301, 302, 304],
+        // Wrap the method to pass decorator context to HTTP client
+        const originalMethod = descriptor.value;
+        const wrappedMethod = function (...args) {
+            // Store decorator context in async local storage or call stack
+            // Only set if not already set by another decorator
+            if (!call_stack_extractor_util_1.CallStackExtractor.getDecoratorContext()) {
+                call_stack_extractor_util_1.CallStackExtractor.setDecoratorContext({
+                    target,
+                    propertyKey,
+                });
+            }
+            try {
+                return originalMethod.apply(this, args);
+            }
+            finally {
+                // Clean up the context after execution
+                call_stack_extractor_util_1.CallStackExtractor.clearDecoratorContext();
+            }
         };
-        if (options.unless) {
-            const originalMethod = descriptor.value;
-            descriptor.value = function (...args) {
-                const result = originalMethod.apply(this, args);
-                if (typeof options.unless === 'string') {
-                    if (evalInContext(options.unless, { result, args })) {
-                        return result;
-                    }
-                }
-                else if (typeof options.unless === 'function') {
-                    if (options.unless(result, args)) {
-                        return result;
-                    }
-                }
-                (0, common_1.SetMetadata)(`${exports.CACHE_OPTIONS_KEY}_${propertyKey}`, cacheOptions)(originalMethod);
-                return result;
-            };
-        }
-        else {
-            (0, common_1.SetMetadata)(`${exports.CACHE_OPTIONS_KEY}_${propertyKey}`, cacheOptions)(descriptor.value);
+        // Copy metadata from original to wrapped method
+        const metadataKeys = Reflect.getMetadataKeys(originalMethod);
+        for (const key of metadataKeys) {
+            Reflect.defineMetadata(key, Reflect.getMetadata(key, originalMethod), wrappedMethod);
         }
+        // Store the circuit breaker options on the wrapped method
+        (0, common_1.SetMetadata)(`${exports.CIRCUIT_BREAKER_OPTIONS_KEY}_${propertyKey}`, circuitBreakerOptions)(wrappedMethod);
+        descriptor.value = wrappedMethod;
         return descriptor;
     };
 };
-exports.HttpCacheable = HttpCacheable;
+exports.HttpCircuitBreaker = HttpCircuitBreaker;
+/**
+ * 请求日志装饰器
+ * 类似Spring Boot的@LogRequest注解
+ */
 const HttpLogRequest = (options = {}) => {
     return (target, propertyKey, descriptor) => {
         var _a, _b, _c;
@@ -128,62 +137,138 @@ const HttpLogRequest = (options = {}) => {
             databaseLog: (_c = options.databaseLog) !== null && _c !== void 0 ? _c : false,
             logLevel: options.logLevel || 'info',
         };
+        // 提取调用信息
         const decoratorInfo = call_stack_extractor_util_1.CallStackExtractor.extractFromDecorator(target, propertyKey);
         const callInfo = {
             serviceClass: options.serviceClass || decoratorInfo.serviceClass,
             methodName: options.methodName || decoratorInfo.methodName,
             operationName: options.operationName || decoratorInfo.operationName,
         };
-        (0, common_1.SetMetadata)(`${exports.LOGGING_OPTIONS_KEY}_${propertyKey}`, loggingOptions)(descriptor.value);
-        (0, common_1.SetMetadata)(`${exports.CALL_INFO_KEY}_${propertyKey}`, callInfo)(descriptor.value);
+        // Wrap the method to pass decorator context to HTTP client
+        const originalMethod = descriptor.value;
+        const wrappedMethod = function (...args) {
+            // Set decorator context (reference counting prevents overwriting)
+            call_stack_extractor_util_1.CallStackExtractor.setDecoratorContext({
+                target,
+                propertyKey,
+            });
+            try {
+                return originalMethod.apply(this, args);
+            }
+            finally {
+                call_stack_extractor_util_1.CallStackExtractor.clearDecoratorContext();
+            }
+        };
+        // Copy metadata from original to wrapped method
+        const metadataKeys = Reflect.getMetadataKeys(originalMethod);
+        for (const key of metadataKeys) {
+            Reflect.defineMetadata(key, Reflect.getMetadata(key, originalMethod), wrappedMethod);
+        }
+        // Store the logging options on the wrapped method
+        (0, common_1.SetMetadata)(`${exports.LOGGING_OPTIONS_KEY}_${propertyKey}`, loggingOptions)(wrappedMethod);
+        (0, common_1.SetMetadata)(`${exports.CALL_INFO_KEY}_${propertyKey}`, callInfo)(wrappedMethod);
+        descriptor.value = wrappedMethod;
         return descriptor;
     };
 };
 exports.HttpLogRequest = HttpLogRequest;
+/**
+ * 超时装饰器
+ * 类似Spring的@Timeout注解
+ */
 const HttpTimeout = (timeoutMs) => {
     return (target, propertyKey, descriptor) => {
-        (0, common_1.SetMetadata)(`${exports.TIMEOUT_OPTIONS_KEY}_${propertyKey}`, timeoutMs)(descriptor.value);
+        // Wrap the method to pass decorator context to HTTP client
+        const originalMethod = descriptor.value;
+        const wrappedMethod = function (...args) {
+            // Set decorator context (reference counting prevents overwriting)
+            call_stack_extractor_util_1.CallStackExtractor.setDecoratorContext({
+                target,
+                propertyKey,
+            });
+            try {
+                return originalMethod.apply(this, args);
+            }
+            finally {
+                call_stack_extractor_util_1.CallStackExtractor.clearDecoratorContext();
+            }
+        };
+        // Copy metadata from original to wrapped method
+        const metadataKeys = Reflect.getMetadataKeys(originalMethod);
+        for (const key of metadataKeys) {
+            Reflect.defineMetadata(key, Reflect.getMetadata(key, originalMethod), wrappedMethod);
+        }
+        // Store the timeout options on the wrapped method
+        (0, common_1.SetMetadata)(`${exports.TIMEOUT_OPTIONS_KEY}_${propertyKey}`, timeoutMs)(wrappedMethod);
+        descriptor.value = wrappedMethod;
         return descriptor;
     };
 };
 exports.HttpTimeout = HttpTimeout;
+/**
+ * 代理装饰器
+ */
 const HttpUseProxy = (options) => {
     return (target, propertyKey, descriptor) => {
-        (0, common_1.SetMetadata)(`${exports.PROXY_OPTIONS_KEY}_${propertyKey}`, options)(descriptor.value);
+        const proxyConfig = Object.assign({ enabled: options.enabled !== false }, options);
+        (0, common_1.SetMetadata)(`${exports.PROXY_OPTIONS_KEY}_${propertyKey}`, proxyConfig)(descriptor.value);
         return descriptor;
     };
 };
 exports.HttpUseProxy = HttpUseProxy;
+/**
+ * 装饰器工具函数
+ */
 class HttpDecoratorUtils {
+    /**
+     * 获取方法上的重试配置
+     */
     static getRetryOptions(target, propertyKey) {
         return Reflect.getMetadata(`${exports.RETRY_OPTIONS_KEY}_${propertyKey}`, target[propertyKey]);
     }
+    /**
+     * 获取方法上的熔断器配置
+     */
     static getCircuitBreakerOptions(target, propertyKey) {
         return Reflect.getMetadata(`${exports.CIRCUIT_BREAKER_OPTIONS_KEY}_${propertyKey}`, target[propertyKey]);
     }
-    static getCacheOptions(target, propertyKey) {
-        return Reflect.getMetadata(`${exports.CACHE_OPTIONS_KEY}_${propertyKey}`, target[propertyKey]);
-    }
+    /**
+     * 获取方法上的日志配置
+     */
     static getLoggingOptions(target, propertyKey) {
         return Reflect.getMetadata(`${exports.LOGGING_OPTIONS_KEY}_${propertyKey}`, target[propertyKey]);
     }
+    /**
+     * 获取方法上的超时配置
+     */
     static getTimeoutOptions(target, propertyKey) {
         return Reflect.getMetadata(`${exports.TIMEOUT_OPTIONS_KEY}_${propertyKey}`, target[propertyKey]);
     }
+    /**
+     * 获取方法上的代理配置
+     */
     static getProxyOptions(target, propertyKey) {
         return Reflect.getMetadata(`${exports.PROXY_OPTIONS_KEY}_${propertyKey}`, target[propertyKey]);
     }
+    /**
+     * 获取类上的HTTP客户端配置
+     */
     static getHttpClientOptions(target) {
         return Reflect.getMetadata(exports.HTTP_CLIENT_OPTIONS_KEY, target) || {};
     }
+    /**
+     * 获取方法上的调用信息配置
+     */
     static getCallInfoOptions(target, propertyKey) {
         return Reflect.getMetadata(`${exports.CALL_INFO_KEY}_${propertyKey}`, target[propertyKey]);
     }
+    /**
+     * 获取所有装饰器配置
+     */
     static getAllDecoratorConfigs(target, propertyKey) {
         return {
             retry: this.getRetryOptions(target, propertyKey),
             circuitBreaker: this.getCircuitBreakerOptions(target, propertyKey),
-            cache: this.getCacheOptions(target, propertyKey),
             logging: this.getLoggingOptions(target, propertyKey),
             timeout: this.getTimeoutOptions(target, propertyKey),
             proxy: this.getProxyOptions(target, propertyKey),
@@ -193,12 +278,3 @@ class HttpDecoratorUtils {
     }
 }
 exports.HttpDecoratorUtils = HttpDecoratorUtils;
-function evalInContext(expression, context) {
-    try {
-        const func = new Function(...Object.keys(context), `return ${expression}`);
-        return func(...Object.values(context));
-    }
-    catch (error) {
-        return false;
-    }
-}