@nest-omni/core 4.1.3-33 → 4.1.3-34

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

@@ -24,7 +24,6 @@ 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);
@@ -40,7 +39,7 @@ function getFullResponseExample(httpClient) {
 function getCustomResponseExample(httpClient) {
     return __awaiter(this, void 0, void 0, function* () {
         // 自定义转换函数 - 只返回需要的字段
-        const customResponse = yield httpClient.get('https://api.example.com/users', {}, 'my-client', {
+        const customResponse = yield httpClient.get('https://api.example.com/users', {}, {
             returnType: 'custom',
             transform: (response) => {
                 var _a;
@@ -61,7 +60,7 @@ function getCustomResponseExample(httpClient) {
 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 response = yield httpClient.get('https://api.example.com/items?page=1&size=10', {}, { returnType: 'full' });
         // 提取分页信息
         const paginationInfo = {
             data: response.data,
@@ -79,7 +78,7 @@ function getPagedResponseExample(httpClient) {
 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' });
+        { returnType: 'full' });
         // 对于3xx重定向状态，获取重定向URL
         if (response.status >= 300 && response.status < 400) {
             const redirectUrl = response.headers['location'];
@@ -92,7 +91,7 @@ function getRedirectUrlExample(httpClient) {
 // 示例5: 向后兼容 - 默认行为（只返回data）
 function getDefaultBehaviorExample(httpClient) {
     return __awaiter(this, void 0, void 0, function* () {
-        // 不传递returnOptions参数，保持原有行为
+        // 不传递options参数，保持原有行为
         const data = yield httpClient.get('https://api.example.com/simple-data');
         // 直接得到data，无需.response.data
         console.log('Simple data:', data);
@@ -105,7 +104,8 @@ function conditionalReturnExample(httpClient, needHeaders) {
         const returnOptions = needHeaders
             ? { returnType: 'full' }
             : { returnType: 'data' }; // 默认
-        const result = yield httpClient.post('https://api.example.com/process', { action: 'calculate' }, {}, 'my-client', returnOptions);
+        const result = yield httpClient.post('https://api.example.com/process', { action: 'calculate' }, {}, // config
+        returnOptions);
         if (needHeaders) {
             // 处理完整响应
             const fullResponse = result;

package/http-client/examples/index.d.ts

@@ -3,3 +3,4 @@ export * from './advanced-usage.example';
 export * from './multi-api-configuration.example';
 export * from './axios-config-extended.example';
 export * from './ssl-certificate.example';
+export * from './request-options.example';

package/http-client/examples/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./advanced-usage.example"), exports);
 __exportStar(require("./multi-api-configuration.example"), exports);
 __exportStar(require("./axios-config-extended.example"), exports);
 __exportStar(require("./ssl-certificate.example"), exports);
+__exportStar(require("./request-options.example"), exports);

package/http-client/examples/request-options.example.d.ts

@@ -0,0 +1,58 @@
+/**
+ * HTTP 请求级别配置示例
+ * 演示 RequestOptions 的使用方式
+ */
+import { HttpClientService } from '../services/http-client.service';
+export declare class RequestOptionsExample {
+    private readonly httpClient;
+    private readonly logger;
+    constructor(httpClient: HttpClientService);
+    /**
+     * 示例1：最简单 - 禁用重试
+     */
+    disableRetry(): Promise<any>;
+    /**
+     * 示例2：启用重试
+     */
+    enableRetry(): Promise<any>;
+    /**
+     * 示例3：自定义重试条件
+     */
+    customRetryCondition(): Promise<any>;
+    /**
+     * 示例4：配置超时和返回类型
+     */
+    withTimeoutAndReturnType(): Promise<any>;
+    /**
+     * 示例5：使用客户端名称
+     */
+    withClientName(): Promise<any>;
+    /**
+     * 示例6：自定义重试延迟
+     */
+    customRetryDelay(): Promise<any>;
+    /**
+     * 示例7：组合多个配置
+     */
+    combinedOptions(): Promise<any>;
+    /**
+     * 示例8：在 PRTG 服务中使用
+     */
+    prtgCreateDevice(): Promise<any>;
+    /**
+     * 示例9：简洁写法 - 多个配置
+     */
+    multipleSettings(): Promise<any>;
+    /**
+     * 示例10：添加自定义 headers
+     */
+    withHeaders(): Promise<any>;
+    /**
+     * 示例11：添加查询参数
+     */
+    withParams(): Promise<any>;
+    /**
+     * 示例12：使用自定义转换函数
+     */
+    withTransform(): Promise<any>;
+}

package/http-client/examples/request-options.example.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * HTTP 请求级别配置示例
+ * 演示 RequestOptions 的使用方式
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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());
+    });
+};
+var RequestOptionsExample_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestOptionsExample = void 0;
+const common_1 = require("@nestjs/common");
+const http_client_service_1 = require("../services/http-client.service");
+let RequestOptionsExample = RequestOptionsExample_1 = class RequestOptionsExample {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.logger = new common_1.Logger(RequestOptionsExample_1.name);
+    }
+    /**
+     * 示例1：最简单 - 禁用重试
+     */
+    disableRetry() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.httpClient.get('/api/data', undefined, {
+                retry: { enabled: false },
+            });
+        });
+    }
+    /**
+     * 示例2：启用重试
+     */
+    enableRetry() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.httpClient.post('/api/data', { key: 'value' }, undefined, {
+                retry: { enabled: true, retries: 3 },
+            });
+        });
+    }
+    /**
+     * 示例3：自定义重试条件
+     */
+    customRetryCondition() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.httpClient.get('/api/service', undefined, {
+                retry: {
+                    enabled: true,
+                    retries: 2,
+                    retryCondition: (error) => {
+                        if (!error.response)
+                            return true;
+                        return error.response.status === 503;
+                    },
+                },
+            });
+        });
+    }
+    /**
+     * 示例4：配置超时和返回类型
+     */
+    withTimeoutAndReturnType() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.httpClient.request({ url: '/api/data', method: 'GET' }, {
+                retry: { enabled: false },
+                timeout: 5000,
+                returnType: 'full',
+            });
+            this.logger.log(`Status: ${response.status}`);
+            return response.data;
+        });
+    }
+    /**
+     * 示例5：使用客户端名称
+     */
+    withClientName() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.httpClient.get('/api/data', undefined, {
+                clientName: 'my-api-client',
+                retry: { enabled: false },
+            });
+        });
+    }
+    /**
+     * 示例6：自定义重试延迟
+     */
+    customRetryDelay() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.httpClient.request({ url: '/api/unstable', method: 'GET' }, {
+                retry: {
+                    enabled: true,
+                    retries: 3,
+                    retryDelay: (retryCount) => retryCount * 1000,
+                },
+            });
+        });
+    }
+    /**
+     * 示例7：组合多个配置
+     */
+    combinedOptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.httpClient.put('/api/resource/123', { status: 'active' }, undefined, {
+                clientName: 'api-client',
+                retry: {
+                    enabled: true,
+                    retries: 2,
+                    retryCondition: (error) => { var _a; return ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 503; },
+                    retryDelay: (retryCount) => Math.pow(3, retryCount) * 1000,
+                },
+                timeout: 10000,
+                returnType: 'full',
+            });
+            return response.data;
+        });
+    }
+    /**
+     * 示例8：在 PRTG 服务中使用
+     */
+    prtgCreateDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.httpClient.post('experimental/groups/123/device', {
+                basic: {
+                    name: 'MyDevice',
+                    host: '192.168.1.1',
+                    tags: ['sdwan'],
+                },
+            }, undefined, {
+                retry: { enabled: false },
+            });
+        });
+    }
+    /**
+     * 示例9：简洁写法 - 多个配置
+     */
+    multipleSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.httpClient.get('/api/data', undefined, {
+                clientName: 'prtg-v2-apac',
+                retry: { enabled: false },
+                timeout: 10000,
+                returnType: 'full',
+            });
+        });
+    }
+    /**
+     * 示例10：添加自定义 headers
+     */
+    withHeaders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.httpClient.get('/api/data', { headers: { 'X-Custom-Header': 'value' } }, {
+                retry: { enabled: false },
+            });
+        });
+    }
+    /**
+     * 示例11：添加查询参数
+     */
+    withParams() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.httpClient.get('/api/data', { params: { page: 1, limit: 10 } });
+        });
+    }
+    /**
+     * 示例12：使用自定义转换函数
+     */
+    withTransform() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.httpClient.get('/api/data', undefined, {
+                returnType: 'custom',
+                transform: (response) => ({
+                    id: response.data.id,
+                    name: response.data.name.toUpperCase(),
+                    timestamp: new Date().toISOString(),
+                }),
+            });
+        });
+    }
+};
+exports.RequestOptionsExample = RequestOptionsExample;
+exports.RequestOptionsExample = RequestOptionsExample = RequestOptionsExample_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [http_client_service_1.HttpClientService])
+], RequestOptionsExample);

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

@@ -12,9 +12,22 @@ interface ExtendedAxiosRequestConfig extends AxiosRequestConfig {
     };
 }
 /**
- * 请求返回选项
+ * 请求级别配置选项
+ * 用于在单次请求中覆盖默认配置
  */
-interface RequestReturnOptions {
+export interface RequestOptions {
+    /** 客户端名称 */
+    clientName?: string;
+    /** 重试配置（请求级别，覆盖装饰器和全局配置） */
+    retry?: {
+        enabled?: boolean;
+        retries?: number;
+        retryCondition?: (error: any) => boolean;
+        retryDelay?: (retryCount: number) => number;
+        shouldResetTimeout?: boolean;
+    };
+    /** 超时配置（请求级别） */
+    timeout?: number;
     /** 返回类型: 'data'(默认) | 'full' | 'custom' */
     returnType?: 'data' | 'full' | 'custom';
     /** 自定义返回转换函数 */
@@ -65,15 +78,23 @@ export declare class HttpClientService {
     /**
      * 执行HTTP请求
      * @param config 请求配置
-     * @param decoratorContext 装饰器上下文
-     * @param clientName 客户端名称
-     * @param returnOptions 返回选项
-     *   - returnType: 'data'(默认)只返回response.data
-     *   - returnType: 'full'返回完整AxiosResponse对象
-     *   - returnType: 'custom'使用自定义转换函数
-     *   - transform: 自定义转换函数，接收完整response返回任意数据
+     * @param options 请求级别配置选项
+     * @returns 响应数据
+     *
+     * @example
+     * // 禁用重试
+     * await this.request({ url: '/api/data' }, { retry: { enabled: false } })
+     *
+     * @example
+     * // 完整配置
+     * await this.request({ url: '/api/data' }, {
+     *   clientName: 'api-client',
+     *   retry: { enabled: true, retries: 2 },
+     *   timeout: 5000,
+     *   returnType: 'full'
+     * })
      */
-    request<T = any>(config: ExtendedAxiosRequestConfig, decoratorContext?: any, clientName?: string, returnOptions?: RequestReturnOptions): Promise<T>;
+    request<T = any>(config: ExtendedAxiosRequestConfig, options?: RequestOptions): Promise<T>;
     /**
      * 生成curl命令（动态生成，不存储）
      */
@@ -94,26 +115,27 @@ export declare class HttpClientService {
      * 获取客户端名称
      */
     getName(): string | undefined;
-    get<T = any>(url: string, config?: AxiosRequestConfig, clientName?: string, returnOptions?: RequestReturnOptions): Promise<T>;
-    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig, clientName?: string, returnOptions?: RequestReturnOptions): Promise<T>;
-    put<T = any>(url: string, data?: any, config?: AxiosRequestConfig, clientName?: string, returnOptions?: RequestReturnOptions): Promise<T>;
-    patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig, clientName?: string, returnOptions?: RequestReturnOptions): Promise<T>;
-    delete<T = any>(url: string, config?: AxiosRequestConfig, clientName?: string, returnOptions?: RequestReturnOptions): Promise<T>;
+    get<T = any>(url: string, config?: AxiosRequestConfig, options?: RequestOptions): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig, options?: RequestOptions): Promise<T>;
+    put<T = any>(url: string, data?: any, config?: AxiosRequestConfig, options?: RequestOptions): Promise<T>;
+    patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig, options?: RequestOptions): Promise<T>;
+    delete<T = any>(url: string, config?: AxiosRequestConfig, options?: RequestOptions): Promise<T>;
     /**
      * 带等待锁的认证请求方法
      * 用于需要确保只有一个进程执行认证相关操作的场景
      *
      * @param config 请求配置
      * @param tokenProvider token提供函数
-     * @param options 等待锁选项
+     * @param lockOptions 等待锁选项
+     * @param requestOptions HTTP请求选项
      * @returns 响应数据
      */
-    authRequest<T = any>(config: AxiosRequestConfig, tokenProvider: () => Promise<string>, options?: {
+    authRequest<T = any>(config: AxiosRequestConfig, tokenProvider: () => Promise<string>, lockOptions?: {
         lockKey?: string;
         lockTimeout?: number;
         waitTimeout?: number;
         enableRetry?: boolean;
-    }, clientName?: string, returnOptions?: RequestReturnOptions): Promise<T>;
+    }, requestOptions?: RequestOptions): Promise<T>;
     /**
      * 带等待锁的批量认证请求
      * 用于需要批量执行认证相关操作但避免重复认证的场景
@@ -126,12 +148,12 @@ export declare class HttpClientService {
     authBatchRequest<T = any>(requests: Array<{
         config: AxiosRequestConfig;
         key: string;
-    }>, tokenProvider: () => Promise<string>, options?: {
+    }>, tokenProvider: () => Promise<string>, lockOptions?: {
         lockKey?: string;
         lockTimeout?: number;
         waitTimeout?: number;
         maxConcurrency?: number;
-    }, clientName?: string): Promise<Array<T | null>>;
+    }, requestOptions?: RequestOptions): Promise<Array<T | null>>;
     /**
      * Capture calling context information
      * @returns Calling context with service class and method name

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

@@ -96,22 +96,44 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
     /**
      * 执行HTTP请求
      * @param config 请求配置
-     * @param decoratorContext 装饰器上下文
-     * @param clientName 客户端名称
-     * @param returnOptions 返回选项
-     *   - returnType: 'data'(默认)只返回response.data
-     *   - returnType: 'full'返回完整AxiosResponse对象
-     *   - returnType: 'custom'使用自定义转换函数
-     *   - transform: 自定义转换函数，接收完整response返回任意数据
+     * @param options 请求级别配置选项
+     * @returns 响应数据
+     *
+     * @example
+     * // 禁用重试
+     * await this.request({ url: '/api/data' }, { retry: { enabled: false } })
+     *
+     * @example
+     * // 完整配置
+     * await this.request({ url: '/api/data' }, {
+     *   clientName: 'api-client',
+     *   retry: { enabled: true, retries: 2 },
+     *   timeout: 5000,
+     *   returnType: 'full'
+     * })
      */
-    request(config, decoratorContext, clientName, returnOptions) {
+    request(config, options) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-            // Use the instance's clientName as fallback if not provided
-            const effectiveClientName = clientName || this.clientName;
-            // If no decorator context provided, try to get it from CallStackExtractor
+            // 解析参数
+            let effectiveClientName;
+            let requestRetryConfig;
+            let requestReturnType;
+            let requestTransform;
+            let requestTimeout;
+            if (options) {
+                effectiveClientName = options.clientName || this.clientName || '';
+                requestRetryConfig = options.retry;
+                requestReturnType = options.returnType;
+                requestTransform = options.transform;
+                requestTimeout = options.timeout;
+            }
+            else {
+                effectiveClientName = this.clientName || '';
+            }
+            // Get decorator context from CallStackExtractor
             // This allows decorators on service methods to pass context to HTTP client
-            const effectiveDecoratorContext = decoratorContext || call_stack_extractor_util_1.CallStackExtractor.getDecoratorContext();
+            const effectiveDecoratorContext = call_stack_extractor_util_1.CallStackExtractor.getDecoratorContext();
             // ========== 安全验证开始 ==========
             // 构造完整URL进行验证
             const requestURL = config.url || '';
@@ -186,7 +208,7 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                 // 应用认证配置
                 const authConfig = yield this.applyAuthToConfig(config);
                 // 应用装饰器配置
-                const enhancedConfig = this.applyDecoratorConfig(authConfig, decoratorContext);
+                const enhancedConfig = this.applyDecoratorConfig(authConfig, effectiveDecoratorContext);
                 // 将 retryRecorder 存储到 config metadata 中,供 onRetry 回调使用
                 enhancedConfig.metadata = enhancedConfig.metadata || {};
                 enhancedConfig.metadata.retryRecorder = retryRecorder;
@@ -194,9 +216,17 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                 const decoratorConfigs = effectiveDecoratorContext
                     ? decorators_1.HttpDecoratorUtils.getAllDecoratorConfigs(effectiveDecoratorContext.target, effectiveDecoratorContext.propertyKey)
                     : {};
-                // 存储装饰器的重试配置到 metadata，供 retryCondition 使用
-                if (((_c = decoratorConfigs.retry) === null || _c === void 0 ? void 0 : _c.enabled) !== undefined) {
-                    enhancedConfig.metadata.retryEnabled = decoratorConfigs.retry.enabled;
+                // 存储重试配置到 metadata，供 retryCondition 使用
+                // 优先级：请求级别配置 > 装饰器配置 > 全局配置
+                const retryEnabled = (requestRetryConfig === null || requestRetryConfig === void 0 ? void 0 : requestRetryConfig.enabled) !== undefined
+                    ? requestRetryConfig.enabled
+                    : (_c = decoratorConfigs.retry) === null || _c === void 0 ? void 0 : _c.enabled;
+                if (retryEnabled !== undefined) {
+                    enhancedConfig.metadata.retryEnabled = retryEnabled;
+                }
+                // 如果请求级别提供了重试配置，存储到 metadata
+                if (requestRetryConfig) {
+                    enhancedConfig.metadata.requestRetryConfig = requestRetryConfig;
                 }
                 // 日志记录开始
                 const decoratorLogging = decoratorConfigs.logging || {};
@@ -209,8 +239,8 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                     enhancedConfig.metadata = enhancedConfig.metadata || {};
                     enhancedConfig.metadata.requestId = requestId;
                 }
-                // 应用超时配置
-                const timeout = decoratorConfigs.timeout || this.defaultConfig.timeout;
+                // 应用超时配置（优先级：请求级别 > 装饰器 > 全局）
+                const timeout = requestTimeout || decoratorConfigs.timeout || this.defaultConfig.timeout;
                 if (timeout) {
                     enhancedConfig.timeout = timeout;
                 }
@@ -232,20 +262,21 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                     const databaseLogging = (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.databaseLogging) ||
                         ((_f = (_e = this.defaultConfig.logging) === null || _e === void 0 ? void 0 : _e.databaseLogging) === null || _f === void 0 ? void 0 : _f.enabled);
                     this.logger.debug(`Logging request success with circuitBreakerState: ${circuitBreakerState || 'undefined'}`);
-                    this.loggingService.logRequestSuccess(response, startTime, requestId, loggingOptions, databaseLogging, retryRecorder.getRecords(), circuitBreakerState, decoratorContext, effectiveClientName, callingContext);
+                    this.loggingService.logRequestSuccess(response, startTime, requestId, loggingOptions, databaseLogging, retryRecorder.getRecords(), circuitBreakerState, effectiveDecoratorContext, effectiveClientName, callingContext);
                 }
                 // 更新统计信息
                 this.updateRequestStats(true, Date.now() - startTime, ((_g = response.config) === null || _g === void 0 ? void 0 : _g.method) || 'GET', response.status);
                 // 根据返回选项处理响应
-                const options = returnOptions || { returnType: 'data' };
-                switch (options.returnType) {
+                const returnType = requestReturnType || 'data';
+                const transform = requestTransform;
+                switch (returnType) {
                     case 'full':
                         // 返回完整响应对象
                         return response;
                     case 'custom':
                         // 使用自定义转换函数
-                        if (options.transform) {
-                            return options.transform(response);
+                        if (transform) {
+                            return transform(response);
                         }
                         // 如果没有提供转换函数，回退到返回data
                         return response.data;
@@ -328,29 +359,29 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
         return this.clientName;
     }
     // 便捷方法
-    get(url, config, clientName, returnOptions) {
+    get(url, config, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'GET', url }), undefined, clientName, returnOptions);
+            return this.request(Object.assign(Object.assign({}, config), { method: 'GET', url }), options);
         });
     }
-    post(url, data, config, clientName, returnOptions) {
+    post(url, data, config, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'POST', url, data }), undefined, clientName, returnOptions);
+            return this.request(Object.assign(Object.assign({}, config), { method: 'POST', url, data }), options);
         });
     }
-    put(url, data, config, clientName, returnOptions) {
+    put(url, data, config, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'PUT', url, data }), undefined, clientName, returnOptions);
+            return this.request(Object.assign(Object.assign({}, config), { method: 'PUT', url, data }), options);
         });
     }
-    patch(url, data, config, clientName, returnOptions) {
+    patch(url, data, config, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'PATCH', url, data }), undefined, clientName, returnOptions);
+            return this.request(Object.assign(Object.assign({}, config), { method: 'PATCH', url, data }), options);
         });
     }
-    delete(url, config, clientName, returnOptions) {
+    delete(url, config, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.request(Object.assign(Object.assign({}, config), { method: 'DELETE', url }), undefined, clientName, returnOptions);
+            return this.request(Object.assign(Object.assign({}, config), { method: 'DELETE', url }), options);
         });
     }
     /**
@@ -359,17 +390,17 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
      *
      * @param config 请求配置
      * @param tokenProvider token提供函数
-     * @param options 等待锁选项
+     * @param lockOptions 等待锁选项
+     * @param requestOptions HTTP请求选项
      * @returns 响应数据
      */
-    authRequest(config, tokenProvider, options, clientName, returnOptions) {
+    authRequest(config, tokenProvider, lockOptions, requestOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            const effectiveClientName = clientName || this.clientName;
             if (!this.redisLockService) {
                 this.logger.warn('RedisLockService not available, proceeding without lock');
-                return this.request(config, undefined, effectiveClientName, returnOptions);
+                return this.request(config, requestOptions);
             }
-            const { lockKey = `auth-request:${(0, request_id_util_1.generateRequestId)()}`, lockTimeout = 30000, waitTimeout = 60000, enableRetry = true, } = options || {};
+            const { lockKey = `auth-request:${(0, request_id_util_1.generateRequestId)()}`, lockTimeout = 30000, waitTimeout = 60000, enableRetry = true, } = lockOptions || {};
             try {
                 // 尝试获取锁并执行请求
                 const result = yield this.redisLockService.withLock(lockKey, () => __awaiter(this, void 0, void 0, function* () {
@@ -378,7 +409,7 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                     // 添加认证头
                     const authConfig = Object.assign(Object.assign({}, config), { headers: Object.assign(Object.assign({}, config.headers), { Authorization: `Bearer ${token}` }) });
                     // 执行请求
-                    return this.request(authConfig, undefined, effectiveClientName, returnOptions);
+                    return this.request(authConfig, requestOptions);
                 }), {
                     ttl: lockTimeout,
                     retryCount: enableRetry ? 3 : 0,
@@ -397,7 +428,7 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                     this.logger.warn('Retrying auth request without lock');
                     const token = yield tokenProvider();
                     const authConfig = Object.assign(Object.assign({}, config), { headers: Object.assign(Object.assign({}, config.headers), { Authorization: `Bearer ${token}` }) });
-                    return this.request(authConfig, undefined, effectiveClientName);
+                    return this.request(authConfig, requestOptions);
                 }
                 throw error;
             }
@@ -412,9 +443,8 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
      * @param options 等待锁选项
      * @returns 响应数组
      */
-    authBatchRequest(requests, tokenProvider, options, clientName) {
+    authBatchRequest(requests, tokenProvider, lockOptions, requestOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            const effectiveClientName = clientName || this.clientName;
             if (!this.redisLockService) {
                 this.logger.warn('RedisLockService not available, proceeding batch auth requests without lock');
                 // 无锁批量执行
@@ -422,7 +452,7 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                 const promises = requests.map((request) => __awaiter(this, void 0, void 0, function* () {
                     try {
                         const authConfig = Object.assign(Object.assign({}, request.config), { headers: Object.assign(Object.assign({}, request.config.headers), { Authorization: `Bearer ${token}` }) });
-                        return yield this.request(authConfig, undefined, effectiveClientName);
+                        return yield this.request(authConfig, requestOptions);
                     }
                     catch (error) {
                         this.logger.error(`Batch auth request failed for key: ${request.key}`, error);
@@ -431,7 +461,7 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                 }));
                 return Promise.all(promises);
             }
-            const { lockKey = `batch-auth-request:${(0, request_id_util_1.generateRequestId)()}`, lockTimeout = 60000, waitTimeout = 120000, maxConcurrency = 5, } = options || {};
+            const { lockKey = `batch-auth-request:${(0, request_id_util_1.generateRequestId)()}`, lockTimeout = 60000, waitTimeout = 120000, maxConcurrency = 5, } = lockOptions || {};
             try {
                 // 使用锁获取token并执行批量请求
                 const results = yield this.redisLockService.withLock(lockKey, () => __awaiter(this, void 0, void 0, function* () {
@@ -444,7 +474,7 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                     const executeRequest = (requestConfig, key, index) => __awaiter(this, void 0, void 0, function* () {
                         try {
                             const authConfig = Object.assign(Object.assign({}, requestConfig), { headers: Object.assign(Object.assign({}, requestConfig.headers), { Authorization: `Bearer ${token}` }) });
-                            const result = yield this.request(authConfig, undefined, effectiveClientName);
+                            const result = yield this.request(authConfig, requestOptions);
                             results[index] = result;
                             return result;
                         }
@@ -585,38 +615,67 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
                     ((retryCount) => Math.pow(2, retryCount) * 1000),
                 retryCondition: this.defaultConfig.retry.retryCondition ||
                     ((error) => {
-                        var _a;
-                        // 检查装饰器配置是否禁用了重试
+                        var _a, _b, _c;
                         const requestConfig = error.config;
-                        if (((_a = requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.metadata) === null || _a === void 0 ? void 0 : _a.retryEnabled) === false) {
+                        // 1. 检查请求级别的重试配置（最高优先级）
+                        const requestRetryConfig = (_a = requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.metadata) === null || _a === void 0 ? void 0 : _a.requestRetryConfig;
+                        if (requestRetryConfig) {
+                            // 如果请求级别明确设置了 enabled
+                            if (requestRetryConfig.enabled === false) {
+                                return false;
+                            }
+                            // 如果请求级别提供了自定义 retryCondition
+                            if (requestRetryConfig.retryCondition) {
+                                return requestRetryConfig.retryCondition(error);
+                            }
+                            // enabled: true 但没有自定义条件，使用默认逻辑
+                            if (requestRetryConfig.enabled === true) {
+                                if (!error.response)
+                                    return true;
+                                const status = error.response.status;
+                                return status >= 500 || status === 429;
+                            }
+                        }
+                        // 2. 检查装饰器配置
+                        if (((_b = requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.metadata) === null || _b === void 0 ? void 0 : _b.retryEnabled) === false) {
                             return false; // 装饰器明确禁用了重试
                         }
-                        // 默认重试条件：网络错误、超时、5xx错误、429错误
-                        if (!error.response)
-                            return true; // 网络错误
-                        const status = error.response.status;
-                        return status >= 500 || status === 429; // 5xx错误或429限流
+                        // 3. 检查装饰器是否启用了重试
+                        if (((_c = requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.metadata) === null || _c === void 0 ? void 0 : _c.retryEnabled) === true) {
+                            // 默认重试条件：网络错误、超时、5xx错误、429错误
+                            if (!error.response)
+                                return true;
+                            const status = error.response.status;
+                            return status >= 500 || status === 429;
+                        }
+                        // 4. 默认不重试
+                        return false;
                     }),
                 shouldResetTimeout: this.defaultConfig.retry.shouldResetTimeout !== false,
                 onRetry: (retryCount, error, requestConfig) => {
-                    var _a, _b, _c, _d;
+                    var _a, _b, _c, _d, _e, _f, _g;
                     // 从 request config metadata 中获取 retryRecorder
                     const retryRecorder = (_a = requestConfig.metadata) === null || _a === void 0 ? void 0 : _a.retryRecorder;
+                    const requestRetryConfig = (_b = requestConfig.metadata) === null || _b === void 0 ? void 0 : _b.requestRetryConfig;
                     if (retryRecorder) {
-                        this.logger.debug(`Recording retry attempt ${retryCount} for ${(_b = requestConfig.method) === null || _b === void 0 ? void 0 : _b.toUpperCase()} ${requestConfig.url}`);
-                        const retryRecord = retry_recorder_util_1.RetryRecorder.recordRetry(retryCount, error, requestConfig, this.calculateRetryDelay(retryCount, this.defaultConfig.retry));
+                        this.logger.debug(`Recording retry attempt ${retryCount} for ${(_c = requestConfig.method) === null || _c === void 0 ? void 0 : _c.toUpperCase()} ${requestConfig.url}`);
+                        // 使用请求级别的 retryDelay 或默认配置
+                        const retryDelay = (requestRetryConfig === null || requestRetryConfig === void 0 ? void 0 : requestRetryConfig.retryDelay) || ((_d = this.defaultConfig.retry) === null || _d === void 0 ? void 0 : _d.retryDelay);
+                        const retryConfig = retryDelay ? { retryDelay } : this.defaultConfig.retry;
+                        const retryRecord = retry_recorder_util_1.RetryRecorder.recordRetry(retryCount, error, requestConfig, this.calculateRetryDelay(retryCount, retryConfig));
                         retryRecorder.addRecord(retryRecord);
                     }
                     else {
-                        this.logger.warn(`RetryRecorder not found in request config metadata for ${(_c = requestConfig.method) === null || _c === void 0 ? void 0 : _c.toUpperCase()} ${requestConfig.url}. Retry records will not be saved.`);
+                        this.logger.warn(`RetryRecorder not found in request config metadata for ${(_e = requestConfig.method) === null || _e === void 0 ? void 0 : _e.toUpperCase()} ${requestConfig.url}. Retry records will not be saved.`);
                     }
-                    // 调用用户自定义的 onRetry 回调
-                    if (this.defaultConfig.retry.onRetry) {
-                        this.defaultConfig.retry.onRetry(retryCount, error, requestConfig);
+                    // 调用用户自定义的 onRetry 回调（请求级别 > 全局）
+                    const onRetryCallback = (requestRetryConfig === null || requestRetryConfig === void 0 ? void 0 : requestRetryConfig.onRetry) || ((_f = this.defaultConfig.retry) === null || _f === void 0 ? void 0 : _f.onRetry);
+                    if (onRetryCallback) {
+                        onRetryCallback(retryCount, error, requestConfig);
                     }
                     else {
                         // 默认日志
-                        this.logger.warn(`Retrying request (attempt ${retryCount}): ${(_d = requestConfig.method) === null || _d === void 0 ? void 0 : _d.toUpperCase()} ${requestConfig.url}`);
+                        this.logger.warn(`Retrying request (attempt ${retryCount}): ${(_g = requestConfig.method) === null || _g === void 0 ? void 0 : _g.toUpperCase()} ${requestConfig.url}`);
                     }
                 },
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-omni/core",
-  "version": "4.1.3-33",
+  "version": "4.1.3-34",
   "description": "A comprehensive NestJS framework for building enterprise-grade applications with best practices",
   "main": "index.js",
   "types": "index.d.ts",