@nest-omni/core 3.1.2-7 → 3.1.2-9

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

@@ -0,0 +1,332 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentHttpService = exports.GitHubHttpService = void 0;
+const common_1 = require("@nestjs/common");
+const decorators_1 = require("../decorators");
+const http_client_service_1 = require("../services/http-client.service");
+const cache_options_interface_1 = require("../../cache/interfaces/cache-options.interface");
+let GitHubHttpService = class GitHubHttpService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    getUser(username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`/users/${username}`);
+        });
+    }
+    searchRepositories(query_1) {
+        return __awaiter(this, arguments, void 0, function* (query, sort = 'stars', order = 'desc') {
+            return this.httpClient.get('/search/repositories', {
+                params: {
+                    q: query,
+                    sort,
+                    order,
+                    per_page: 20,
+                },
+            });
+        });
+    }
+    getUserRepositories(username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`/users/${username}/repos`, {
+                params: {
+                    type: 'owner',
+                    sort: 'updated',
+                    per_page: 50,
+                },
+            });
+        });
+    }
+    createRepository(repoData, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.post('/user/repos', repoData, {
+                headers: {
+                    Authorization: `token ${token}`,
+                    Accept: 'application/vnd.github.v3+json',
+                },
+            });
+        });
+    }
+    getRepositoryContributors(owner, repo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`/repos/${owner}/${repo}/contributors`);
+        });
+    }
+    getMultipleUsers(usernames) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = usernames.map((username) => this.getUser(username).catch((error) => {
+                console.error(`Failed to get user ${username}:`, error.message);
+                return null;
+            }));
+            return Promise.all(promises);
+        });
+    }
+    getRepositoryDetails(owner, repo, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`/repos/${owner}/${repo}`);
+        });
+    }
+};
+exports.GitHubHttpService = GitHubHttpService;
+__decorate([
+    (0, decorators_1.HttpRetry)({
+        retries: 5,
+        retryDelay: (retryCount) => Math.pow(2, retryCount) * 1000,
+        retryCondition: (error) => {
+            if (!error.response)
+                return true;
+            const status = error.response.status;
+            return status >= 500 || status === 429;
+        },
+    }),
+    (0, decorators_1.HttpCircuitBreaker)({
+        failureThreshold: 3,
+        recoveryTimeoutMs: 30000,
+    }),
+    (0, decorators_1.HttpCacheable)({
+        ttl: 300000,
+        layers: ['cls', 'memory', 'redis'],
+        namespace: 'github',
+    }),
+    (0, decorators_1.HttpLogRequest)({
+        databaseLog: true,
+        logHeaders: true,
+        logBody: false,
+        serviceClass: 'GitHubHttpService',
+        methodName: 'getUser',
+        operationName: 'github.getUser',
+    }),
+    (0, decorators_1.HttpTimeout)(15000),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], GitHubHttpService.prototype, "getUser", null);
+__decorate([
+    (0, decorators_1.HttpRetry)({ retries: 3 }),
+    (0, decorators_1.HttpCacheable)({
+        ttl: 600000,
+        layers: ['memory', 'redis'],
+        namespace: 'github-search',
+        condition: (args) => args[0].length > 2,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], GitHubHttpService.prototype, "searchRepositories", null);
+__decorate([
+    (0, decorators_1.HttpUseProxy)({
+        host: 'proxy.example.com',
+        port: 8080,
+        protocol: 'http',
+    }),
+    (0, decorators_1.HttpCacheable)({
+        ttl: 120000,
+        namespace: 'github-repos',
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], GitHubHttpService.prototype, "getUserRepositories", null);
+__decorate([
+    (0, decorators_1.HttpLogRequest)({
+        logHeaders: true,
+        logBody: true,
+        databaseLog: true,
+        sanitizeHeaders: ['authorization', 'x-api-key'],
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], GitHubHttpService.prototype, "createRepository", null);
+__decorate([
+    (0, decorators_1.HttpCircuitBreaker)({
+        failureThreshold: 5,
+        recoveryTimeoutMs: 60000,
+    }),
+    (0, decorators_1.HttpCacheable)({
+        ttl: 900000,
+        namespace: 'github-contributors',
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], GitHubHttpService.prototype, "getRepositoryContributors", null);
+__decorate([
+    (0, decorators_1.HttpCacheable)({
+        ttl: 120000,
+        layers: ['memory'],
+        namespace: 'github-repo-details',
+        condition: (args) => { var _a; return ((_a = args[2]) === null || _a === void 0 ? void 0 : _a.public) === true; },
+        unless: (result, args) => (result === null || result === void 0 ? void 0 : result.archived) === true,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], GitHubHttpService.prototype, "getRepositoryDetails", null);
+exports.GitHubHttpService = GitHubHttpService = __decorate([
+    (0, decorators_1.HttpClient)({
+        baseURL: 'https://api.github.com',
+        timeout: 10000,
+        cache: {
+            enabled: true,
+            defaultTtl: 300000,
+            cacheableMethods: ['GET', 'HEAD'],
+            cacheableStatusCodes: [200, 304],
+            options: {
+                layers: [cache_options_interface_1.CacheLayer.MEMORY, cache_options_interface_1.CacheLayer.REDIS],
+            },
+        },
+        logging: {
+            enabled: true,
+            logRequests: true,
+            logResponses: true,
+            logErrors: true,
+            logHeaders: true,
+            logBody: true,
+            maxBodyLength: 1000,
+            sanitizeHeaders: ['authorization'],
+            logLevel: 'info',
+        },
+    }),
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [http_client_service_1.HttpClientService])
+], GitHubHttpService);
+let PaymentHttpService = class PaymentHttpService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    createPayment(paymentData, apiKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.post('/payments', paymentData, {
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    'X-Idempotency-Key': this.generateIdempotencyKey(),
+                    'Content-Type': 'application/json',
+                },
+            });
+        });
+    }
+    getPaymentStatus(paymentId, apiKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`/payments/${paymentId}`, {
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                },
+            });
+        });
+    }
+    refundPayment(paymentId, refundData, apiKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.post(`/payments/${paymentId}/refund`, refundData, {
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    'X-Idempotency-Key': this.generateIdempotencyKey(),
+                },
+            });
+        });
+    }
+    callExternalApi(url_1) {
+        return __awaiter(this, arguments, void 0, function* (url, method = 'GET', data) {
+            const { CallStackExtractor } = require('../utils');
+            CallStackExtractor.setCallInfo('PaymentHttpService', 'callExternalApi', `payment.${method.toLowerCase()}`);
+            try {
+                return this.httpClient.request({
+                    url,
+                    method,
+                    data,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: 'Bearer token123',
+                    },
+                });
+            }
+            finally {
+                CallStackExtractor.clearCallInfo();
+            }
+        });
+    }
+    generateIdempotencyKey() {
+        return `pay_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+};
+exports.PaymentHttpService = PaymentHttpService;
+__decorate([
+    (0, decorators_1.HttpLogRequest)({
+        logHeaders: false,
+        logBody: false,
+        databaseLog: false,
+    }),
+    (0, decorators_1.HttpTimeout)(10000),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], PaymentHttpService.prototype, "createPayment", null);
+__decorate([
+    (0, decorators_1.HttpCacheable)({
+        ttl: 30000,
+        layers: ['redis'],
+        namespace: 'payment-status',
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], PaymentHttpService.prototype, "getPaymentStatus", null);
+__decorate([
+    (0, decorators_1.HttpRetry)({
+        retries: 2,
+        retryDelay: (retryCount) => retryCount * 2000,
+        retryCondition: (error) => {
+            if (!error.response)
+                return true;
+            return error.response.status >= 500;
+        },
+    }),
+    (0, decorators_1.HttpLogRequest)({
+        logHeaders: false,
+        logBody: false,
+        databaseLog: true,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, String]),
+    __metadata("design:returntype", Promise)
+], PaymentHttpService.prototype, "refundPayment", null);
+exports.PaymentHttpService = PaymentHttpService = __decorate([
+    (0, decorators_1.HttpClient)({
+        baseURL: 'https://api.payment-provider.com',
+        timeout: 15000,
+        retry: {
+            enabled: false,
+        },
+        logging: {
+            enabled: true,
+            logRequests: true,
+            logResponses: true,
+            logErrors: true,
+            logHeaders: false,
+            logBody: false,
+            maxBodyLength: 1000,
+            sanitizeHeaders: ['authorization', 'x-api-key', 'x-client-secret'],
+            logLevel: 'info',
+        },
+    }),
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [http_client_service_1.HttpClientService])
+], PaymentHttpService);

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

@@ -0,0 +1,17 @@
+import { HttpClientService } from '../services/http-client.service';
+import { HttpLogQueryService } from '../services/http-log-query.service';
+import { HttpReplayService } from '../services/http-replay.service';
+export declare class AuthWithWaitingLockExample {
+    private readonly httpClient;
+    private readonly logQueryService;
+    private readonly replayService;
+    private readonly logger;
+    constructor(httpClient: HttpClientService, logQueryService: HttpLogQueryService, replayService: HttpReplayService);
+    basicAuthWithLock(): Promise<any>;
+    batchAuthWithLock(): Promise<any[]>;
+    generateCurlFromLogs(): Promise<void>;
+    demonstrateRequestReplay(): Promise<void>;
+    batchReplayAndCompare(): Promise<void>;
+    comprehensiveDemo(): Promise<void>;
+    runAllExamples(): Promise<void>;
+}

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);