@nest-omni/core 3.1.2-8 → 4.1.2-9

package/http-client/examples/auth-with-waiting-lock.example.js

@@ -0,0 +1,336 @@
+"use strict";
+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 AuthWithWaitingLockExample_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthWithWaitingLockExample = void 0;
+const common_1 = require("@nestjs/common");
+const http_client_service_1 = require("../services/http-client.service");
+const http_log_query_service_1 = require("../services/http-log-query.service");
+const http_replay_service_1 = require("../services/http-replay.service");
+let AuthWithWaitingLockExample = AuthWithWaitingLockExample_1 = class AuthWithWaitingLockExample {
+    constructor(httpClient, logQueryService, replayService) {
+        this.httpClient = httpClient;
+        this.logQueryService = logQueryService;
+        this.replayService = replayService;
+        this.logger = new common_1.Logger(AuthWithWaitingLockExample_1.name);
+    }
+    basicAuthWithLock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('=== 示例1: 基本带等待锁的认证请求 ===');
+            const requestConfig = {
+                method: 'GET',
+                url: 'https://api.github.com/user',
+                headers: {
+                    Accept: 'application/vnd.github.v3+json',
+                },
+            };
+            const tokenProvider = () => __awaiter(this, void 0, void 0, function* () {
+                this.logger.log('开始获取GitHub访问令牌...');
+                yield new Promise((resolve) => setTimeout(resolve, 1000));
+                const token = `ghp_${Math.random().toString(36).substring(2, 15)}${Date.now()}`;
+                this.logger.log(`成功获取令牌: ${token.substring(0, 20)}...`);
+                return token;
+            });
+            try {
+                const response = yield this.httpClient.authRequest(requestConfig, tokenProvider, {
+                    lockKey: 'github-token-refresh',
+                    lockTimeout: 30000,
+                    waitTimeout: 60000,
+                    enableRetry: true,
+                });
+                this.logger.log('认证请求成功完成');
+                return response;
+            }
+            catch (error) {
+                this.logger.error('认证请求失败', error);
+                throw error;
+            }
+        });
+    }
+    batchAuthWithLock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('=== 示例2: 批量带等待锁的认证请求 ===');
+            const requests = [
+                {
+                    config: {
+                        method: 'GET',
+                        url: 'https://api.github.com/user/repos',
+                    },
+                    key: 'user-repos',
+                },
+                {
+                    config: {
+                        method: 'GET',
+                        url: 'https://api.github.com/user/starred',
+                    },
+                    key: 'user-starred',
+                },
+                {
+                    config: {
+                        method: 'GET',
+                        url: 'https://api.github.com/user/followers',
+                    },
+                    key: 'user-followers',
+                },
+            ];
+            const tokenProvider = () => __awaiter(this, void 0, void 0, function* () {
+                this.logger.log('开始获取批量操作的GitHub访问令牌...');
+                yield new Promise((resolve) => setTimeout(resolve, 1500));
+                const token = `ghp_batch_${Math.random().toString(36).substring(2, 15)}${Date.now()}`;
+                this.logger.log(`成功获取批量令牌: ${token.substring(0, 20)}...`);
+                return token;
+            });
+            try {
+                const startTime = Date.now();
+                const results = yield this.httpClient.authBatchRequest(requests, tokenProvider, {
+                    lockKey: 'github-batch-token-refresh',
+                    lockTimeout: 60000,
+                    waitTimeout: 120000,
+                    maxConcurrency: 3,
+                });
+                const endTime = Date.now();
+                const duration = endTime - startTime;
+                const successful = results.filter((r) => r !== null).length;
+                this.logger.log(`
+批量认证请求完成:
+┌─────────────────┬──────────┐
+│ 总请求数        │ ${requests.length.toString().padStart(8)} │
+│ 成功请求        │ ${successful.toString().padStart(8)} │
+│ 总耗时          │ ${duration.toString().padStart(8)}ms │
+│ 平均耗时        │ ${(duration / requests.length).toFixed(1).padStart(7)}ms │
+└─────────────────┴──────────┘
+      `);
+                return results.filter((r) => r !== null);
+            }
+            catch (error) {
+                this.logger.error('批量认证请求失败', error);
+                throw error;
+            }
+        });
+    }
+    generateCurlFromLogs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('=== 示例3: 从HTTP日志生成curl命令 ===');
+            try {
+                const recentLogs = yield this.logQueryService.findLogs({
+                    limit: 5,
+                    sortBy: 'createdAt',
+                    sortOrder: 'DESC',
+                });
+                if (recentLogs.logs.length === 0) {
+                    this.logger.log('没有找到最近的HTTP日志');
+                    return;
+                }
+                this.logger.log(`找到 ${recentLogs.logs.length} 条最近的HTTP日志`);
+                for (const log of recentLogs.logs) {
+                    const curlCommand = yield this.logQueryService.generateCurlFromLog(log.id);
+                    if (curlCommand) {
+                        this.logger.log(`
+日志 ${log.id.substring(0, 8)}... 的curl命令:
+${curlCommand}
+          `);
+                    }
+                }
+                const batchCurlCommands = yield this.logQueryService.generateBatchCurlCommands({
+                    limit: 3,
+                    method: 'GET',
+                });
+                this.logger.log(`\n批量生成了 ${batchCurlCommands.length} 个curl命令`);
+            }
+            catch (error) {
+                this.logger.error('生成curl命令失败', error);
+            }
+        });
+    }
+    demonstrateRequestReplay() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            this.logger.log('=== 示例4: 请求重放功能 ===');
+            try {
+                const successfulLogs = yield this.logQueryService.findLogs({
+                    limit: 1,
+                    success: true,
+                    method: 'GET',
+                    sortBy: 'createdAt',
+                    sortOrder: 'DESC',
+                });
+                if (successfulLogs.logs.length === 0) {
+                    this.logger.log('没有找到可重放的请求日志');
+                    return;
+                }
+                const logToReplay = successfulLogs.logs[0];
+                this.logger.log(`准备重放请求: ${logToReplay.method} ${logToReplay.url}`);
+                const replayResult = yield this.replayService.replayByLogId(logToReplay.id, {
+                    overrideHeaders: false,
+                    additionalHeaders: {
+                        'X-Replay-By': 'http-client-example',
+                        'X-Replay-Timestamp': new Date().toISOString(),
+                    },
+                    logReplay: true,
+                    timeout: 30000,
+                });
+                this.logger.log(`
+重放结果:
+┌─────────────────┬──────────┐
+│ 重放ID          │ ${replayResult.replayId.substring(0, 20).padStart(8)}... │
+│ 原始状态码      │ ${((_a = logToReplay.statusCode) === null || _a === void 0 ? void 0 : _a.toString().padStart(8)) || 'N/A'} │
+│ 重放状态码      │ ${((_c = (_b = replayResult.response) === null || _b === void 0 ? void 0 : _b.status) === null || _c === void 0 ? void 0 : _c.toString().padStart(8)) || 'N/A'} │
+│ 原始响应时间    │ ${logToReplay.responseTime.toString().padStart(8)}ms │
+│ 重放响应时间    │ ${replayResult.responseTime.toString().padStart(8)}ms │
+│ 重放成功        │ ${replayResult.success ? 'YES'.padStart(8) : 'NO'.padStart(8)} │
+└─────────────────┴──────────┘
+      `);
+                if (!replayResult.success) {
+                    this.logger.error(`重放失败: ${replayResult.error}`);
+                }
+            }
+            catch (error) {
+                this.logger.error('请求重放失败', error);
+            }
+        });
+    }
+    batchReplayAndCompare() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            this.logger.log('=== 示例5: 批量重放和比较 ===');
+            try {
+                const batchReplayResult = yield this.replayService.batchReplayByQuery({
+                    method: 'GET',
+                    limit: 3,
+                    success: true,
+                    sortBy: 'createdAt',
+                    sortOrder: 'DESC',
+                }, {
+                    additionalHeaders: {
+                        'X-Batch-Replay': 'true',
+                    },
+                    logReplay: true,
+                }, 2);
+                this.logger.log(`
+批量重放统计:
+┌─────────────────┬──────────┐
+│ 总请求数        │ ${batchReplayResult.totalRequests.toString().padStart(8)} │
+│ 成功请求        │ ${batchReplayResult.successfulRequests.toString().padStart(8)} │
+│ 失败请求        │ ${batchReplayResult.failedRequests.toString().padStart(8)} │
+│ 成功率          │ ${batchReplayResult.successRate.toFixed(1).toString().padStart(7)}% │
+│ 总耗时          │ ${batchReplayResult.totalResponseTime.toString().padStart(8)}ms │
+│ 平均响应时间    │ ${batchReplayResult.averageResponseTime.toFixed(1).toString().padStart(7)}ms │
+└─────────────────┴──────────┘
+      `);
+                for (let i = 0; i < Math.min(batchReplayResult.results.length, 3); i++) {
+                    const result = batchReplayResult.results[i];
+                    if (result.originalLog.id) {
+                        try {
+                            const comparison = yield this.replayService.replayAndCompare(result.originalLog.id, { logReplay: false });
+                            this.logger.log(`
+重放比较 ${i + 1}:
+┌─────────────────┬──────────┐
+│ 原始状态码      │ ${((_a = comparison.original.statusCode) === null || _a === void 0 ? void 0 : _a.toString().padStart(8)) || 'N/A'} │
+│ 重放状态码      │ ${((_c = (_b = comparison.replay.response) === null || _b === void 0 ? void 0 : _b.status) === null || _c === void 0 ? void 0 : _c.toString().padStart(8)) || 'N/A'} │
+│ 状态匹配        │ ${comparison.comparison.statusMatch ? 'YES'.padStart(8) : 'NO'.padStart(8)} │
+│ 响应时间差异    │ ${comparison.comparison.responseTimeDifference.toString().padStart(8)}ms │
+│ 头部匹配        │ ${comparison.comparison.headersMatch ? 'YES'.padStart(8) : 'NO'.padStart(8)} │
+│ 内容匹配        │ ${comparison.comparison.bodyMatch ? 'YES'.padStart(8) : 'NO'.padStart(8)} │
+└─────────────────┴──────────┘
+            `);
+                        }
+                        catch (error) {
+                            this.logger.warn(`无法比较重放结果 ${i + 1}: ${error.message}`);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.error('批量重放和比较失败', error);
+            }
+        });
+    }
+    comprehensiveDemo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('=== 示例6: 综合演示 ===');
+            try {
+                this.logger.log('步骤1: 执行带等待锁的认证请求');
+                const authResponse = yield this.basicAuthWithLock();
+                this.logger.log('\n步骤2: 查询请求日志');
+                const recentLogs = yield this.logQueryService.findLogs({
+                    limit: 1,
+                    sortBy: 'createdAt',
+                    sortOrder: 'DESC',
+                });
+                if (recentLogs.logs.length > 0) {
+                    const log = recentLogs.logs[0];
+                    this.logger.log('\n步骤3: 生成curl命令');
+                    const curlCommand = yield this.logQueryService.generateCurlFromLog(log.id);
+                    if (curlCommand) {
+                        this.logger.log('生成的curl命令:');
+                        this.logger.log(curlCommand);
+                    }
+                    this.logger.log('\n步骤4: 重放请求');
+                    const replayResult = yield this.replayService.replayByLogId(log.id, {
+                        additionalHeaders: {
+                            'X-Demo-Step': 'replay',
+                        },
+                    });
+                    this.logger.log(`
+综合演示结果:
+┌─────────────────┬──────────┐
+│ 原始请求成功    │ ${log.success ? 'YES'.padStart(8) : 'NO'.padStart(8)} │
+│ 重放请求成功    │ ${replayResult.success ? 'YES'.padStart(8) : 'NO'.padStart(8)} │
+│ 原始响应时间    │ ${log.responseTime.toString().padStart(8)}ms │
+│ 重放响应时间    │ ${replayResult.responseTime.toString().padStart(8)}ms │
+└─────────────────┴──────────┘
+        `);
+                }
+            }
+            catch (error) {
+                this.logger.error('综合演示失败', error);
+            }
+        });
+    }
+    runAllExamples() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('开始运行HTTP客户端等待锁和请求重放示例...\n');
+            try {
+                yield this.basicAuthWithLock();
+                yield new Promise((resolve) => setTimeout(resolve, 1000));
+                yield this.batchAuthWithLock();
+                yield new Promise((resolve) => setTimeout(resolve, 1000));
+                yield this.generateCurlFromLogs();
+                yield new Promise((resolve) => setTimeout(resolve, 1000));
+                yield this.demonstrateRequestReplay();
+                yield new Promise((resolve) => setTimeout(resolve, 1000));
+                yield this.batchReplayAndCompare();
+                yield new Promise((resolve) => setTimeout(resolve, 1000));
+                yield this.comprehensiveDemo();
+                this.logger.log('\n所有示例运行完成！');
+            }
+            catch (error) {
+                this.logger.error('示例运行过程中出现错误', error);
+            }
+        });
+    }
+};
+exports.AuthWithWaitingLockExample = AuthWithWaitingLockExample;
+exports.AuthWithWaitingLockExample = AuthWithWaitingLockExample = AuthWithWaitingLockExample_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [http_client_service_1.HttpClientService,
+        http_log_query_service_1.HttpLogQueryService,
+        http_replay_service_1.HttpReplayService])
+], AuthWithWaitingLockExample);

package/http-client/examples/basic-usage.example.d.ts

@@ -33,14 +33,7 @@ export declare class BasicHttpExample {
         logs: import("../entities").HttpLogEntity[];
         total: number;
     }>;
-    findLogsByServiceClass(serviceClass: string, limit?: number): Promise<{
-        logs: import("../entities").HttpLogEntity[];
-        total: number;
-        page: number;
-        limit: number;
-        totalPages: number;
-    }>;
-    findLogsByMethodName(methodName: string, limit?: number): Promise<{
+    findLogsByServiceName(serviceName: string, limit?: number): Promise<{
         logs: import("../entities").HttpLogEntity[];
         total: number;
         page: number;
@@ -56,6 +49,5 @@ export declare class BasicHttpExample {
     }>;
     getHttpStats(startDate?: Date, endDate?: Date): Promise<import("../entities").HttpLogStats>;
     findLogByRequestId(requestId: string): Promise<import("../entities").HttpLogEntity>;
-    findLogsByCorrelationId(correlationId: string): Promise<any>;
     cleanupOldLogs(daysToKeep?: number): Promise<number>;
 }

package/http-client/examples/basic-usage.example.js

@@ -64,7 +64,7 @@ let BasicHttpExample = class BasicHttpExample {
     uploadFile(file, filename) {
         return __awaiter(this, void 0, void 0, function* () {
             const formData = new FormData();
-            formData.append('file', new Blob([file]), filename);
+            formData.append('file', new Blob([new Uint8Array(file)], { type: 'application/octet-stream' }), filename);
             return this.httpClient.post('/upload', formData, {
                 headers: {
                     'Content-Type': 'multipart/form-data',
@@ -127,14 +127,9 @@ let BasicHttpExample = class BasicHttpExample {
             return this.logQueryService.findRetryLogs({ minRetries });
         });
     }
-    findLogsByServiceClass(serviceClass_1) {
-        return __awaiter(this, arguments, void 0, function* (serviceClass, limit = 20) {
-            return this.logQueryService.findLogs({ serviceClass, limit });
-        });
-    }
-    findLogsByMethodName(methodName_1) {
-        return __awaiter(this, arguments, void 0, function* (methodName, limit = 20) {
-            return this.logQueryService.findLogs({ methodName, limit });
+    findLogsByServiceName(serviceName_1) {
+        return __awaiter(this, arguments, void 0, function* (serviceName, limit = 20) {
+            return this.logQueryService.findLogs({ serviceName, limit });
         });
     }
     findLogsByOperationName(operationName_1) {
@@ -152,11 +147,6 @@ let BasicHttpExample = class BasicHttpExample {
             return this.logQueryService.findLogByRequestId(requestId);
         });
     }
-    findLogsByCorrelationId(correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.logQueryService.findLogsByCorrelationId(correlationId);
-        });
-    }
     cleanupOldLogs() {
         return __awaiter(this, arguments, void 0, function* (daysToKeep = 30) {
             return this.logQueryService.deleteOldLogs(daysToKeep);

package/http-client/examples/multi-api-configuration.example.js

@@ -283,13 +283,13 @@ let ExampleController = class ExampleController {
     }
     getGitHubUser(username) {
         return __awaiter(this, void 0, void 0, function* () {
-            const github = this.githubApi.github();
+            const github = this.githubApi.github;
             return github.get(`/users/${username}`);
         });
     }
     createStripePayment(amount, currency) {
         return __awaiter(this, void 0, void 0, function* () {
-            const stripe = this.stripeApi.stripe();
+            const stripe = this.stripeApi.stripe;
             return stripe.post('/charges', {
                 amount,
                 currency,
@@ -299,7 +299,7 @@ let ExampleController = class ExampleController {
     }
     sendWeChatMessage(openid, content) {
         return __awaiter(this, void 0, void 0, function* () {
-            const wechat = this.wechatApi.wechat();
+            const wechat = this.wechatApi.wechat;
             return wechat.post('/cgi-bin/message/custom/send', {
                 touser: openid,
                 msgtype: 'text',
@@ -311,7 +311,7 @@ let ExampleController = class ExampleController {
     }
     getCustomData(id) {
         return __awaiter(this, void 0, void 0, function* () {
-            const custom = this.customApi.customApi();
+            const custom = this.customApi.customApi;
             return custom.get(`/data/${id}`);
         });
     }

package/http-client/http-client.module.js

@@ -31,6 +31,7 @@ const log_cleanup_service_1 = require("./services/log-cleanup.service");
 const api_client_registry_service_1 = require("./services/api-client-registry.service");
 const entities_1 = require("./entities");
 const cache_options_interface_1 = require("../cache/interfaces/cache-options.interface");
+const redis_lock_service_1 = require("../redis-lock/redis-lock.service");
 let HttpClientModule = HttpClientModule_1 = class HttpClientModule {
     static forRoot(config = {}) {
         var _a, _b, _c;
@@ -51,13 +52,14 @@ let HttpClientModule = HttpClientModule_1 = class HttpClientModule {
             api_client_registry_service_1.ApiClientRegistryService,
             {
                 provide: http_client_service_1.HttpClientService,
-                useFactory: (circuitBreakerService, loggingService, cacheService, httpConfig) => {
-                    return new http_client_service_1.HttpClientService(circuitBreakerService, loggingService, cacheService, httpConfig);
+                useFactory: (circuitBreakerService, loggingService, cacheService, redisLockService, httpConfig) => {
+                    return new http_client_service_1.HttpClientService(circuitBreakerService, loggingService, cacheService, redisLockService, httpConfig);
                 },
                 inject: [
                     circuit_breaker_service_1.HttpCircuitBreakerService,
                     logging_service_1.HttpLoggingService,
                     cache_service_2.HttpCacheService,
+                    redis_lock_service_1.RedisLockService,
                     'HTTP_CLIENT_CONFIG',
                 ],
             },
@@ -104,13 +106,14 @@ let HttpClientModule = HttpClientModule_1 = class HttpClientModule {
             api_client_registry_service_1.ApiClientRegistryService,
             {
                 provide: http_client_service_1.HttpClientService,
-                useFactory: (circuitBreakerService, loggingService, cacheService, httpConfig) => {
-                    return new http_client_service_1.HttpClientService(circuitBreakerService, loggingService, cacheService, httpConfig);
+                useFactory: (circuitBreakerService, loggingService, cacheService, redisLockService, httpConfig) => {
+                    return new http_client_service_1.HttpClientService(circuitBreakerService, loggingService, cacheService, redisLockService, httpConfig);
                 },
                 inject: [
                     circuit_breaker_service_1.HttpCircuitBreakerService,
                     logging_service_1.HttpLoggingService,
                     cache_service_2.HttpCacheService,
+                    redis_lock_service_1.RedisLockService,
                     'HTTP_CLIENT_CONFIG',
                 ],
             },

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

@@ -1,8 +1,9 @@
-import { ApiClientConfig, ApiClientInstanceConfig, ApiClientRegistryConfig } from '../interfaces/api-client-config.interface';
+import { ApiClientConfig, ApiClientInstanceConfig, ApiClientRegistryConfig, AuthType, OAuth2Config, ResponseTransformerConfig } from '../interfaces/api-client-config.interface';
 import { HttpClientService } from './http-client.service';
 import { HttpCircuitBreakerService } from './circuit-breaker.service';
 import { HttpLoggingService } from './logging.service';
 import { HttpCacheService } from './cache.service';
+export { ApiClientInstanceConfig, AuthType, OAuth2Config, ResponseTransformerConfig, };
 export declare class ApiClientRegistryService {
     private readonly httpClientService;
     private readonly circuitBreakerService;

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

@@ -19,11 +19,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 var ApiClientRegistryService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiClientRegistryService = void 0;
+exports.ApiClientRegistryService = exports.AuthType = void 0;
 const common_1 = require("@nestjs/common");
 const axios_1 = require("axios");
 const axios_retry_1 = require("axios-retry");
 const api_client_config_interface_1 = require("../interfaces/api-client-config.interface");
+Object.defineProperty(exports, "AuthType", { enumerable: true, get: function () { return api_client_config_interface_1.AuthType; } });
 const http_client_service_1 = require("./http-client.service");
 const circuit_breaker_service_1 = require("./circuit-breaker.service");
 const logging_service_1 = require("./logging.service");

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

@@ -3,6 +3,7 @@ import { HttpClientConfig } from '../interfaces/http-client-config.interface';
 import { HttpCircuitBreakerService } from './circuit-breaker.service';
 import { HttpLoggingService } from './logging.service';
 import { HttpCacheService } from './cache.service';
+import { RedisLockService } from '../../redis-lock/redis-lock.service';
 interface ExtendedAxiosRequestConfig extends AxiosRequestConfig {
     metadata?: {
         requestId?: string;
@@ -14,11 +15,12 @@ export declare class HttpClientService {
     private readonly circuitBreakerService;
     private readonly loggingService;
     private readonly cacheService;
+    private readonly redisLockService?;
     private readonly logger;
     private readonly axiosInstance;
     private readonly defaultConfig;
     private requestStats;
-    constructor(circuitBreakerService: HttpCircuitBreakerService, loggingService: HttpLoggingService, cacheService: HttpCacheService, config?: HttpClientConfig);
+    constructor(circuitBreakerService: HttpCircuitBreakerService, loggingService: HttpLoggingService, cacheService: HttpCacheService, redisLockService?: RedisLockService, config?: HttpClientConfig);
     request<T = any>(config: ExtendedAxiosRequestConfig, decoratorContext?: any): Promise<T>;
     generateCurlCommand(config: ExtendedAxiosRequestConfig): string;
     generateDebugCurlCommand(config: ExtendedAxiosRequestConfig, response?: AxiosResponse): string;
@@ -29,6 +31,21 @@ export declare class HttpClientService {
     put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
     patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
     delete<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    authRequest<T = any>(config: AxiosRequestConfig, tokenProvider: () => Promise<string>, options?: {
+        lockKey?: string;
+        lockTimeout?: number;
+        waitTimeout?: number;
+        enableRetry?: boolean;
+    }): Promise<T>;
+    authBatchRequest<T = any>(requests: Array<{
+        config: AxiosRequestConfig;
+        key: string;
+    }>, tokenProvider: () => Promise<string>, options?: {
+        lockKey?: string;
+        lockTimeout?: number;
+        waitTimeout?: number;
+        maxConcurrency?: number;
+    }): Promise<Array<T | null>>;
     private createAxiosInstance;
     private executeWithFeatures;
     private calculateRetryDelay;