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

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

@@ -30,12 +30,14 @@ const decorators_1 = require("../decorators");
 const context_extractor_util_1 = require("../utils/context-extractor.util");
 const curl_generator_util_1 = require("../utils/curl-generator.util");
 const retry_recorder_util_1 = require("../utils/retry-recorder.util");
-const request_id_util_1 = require("../../../../http-client/src/utils/request-id.util");
+const request_id_util_1 = require("../utils/request-id.util");
+const redis_lock_service_1 = require("../../redis-lock/redis-lock.service");
 let HttpClientService = HttpClientService_1 = class HttpClientService {
-    constructor(circuitBreakerService, loggingService, cacheService, config = {}) {
+    constructor(circuitBreakerService, loggingService, cacheService, redisLockService, config = {}) {
         this.circuitBreakerService = circuitBreakerService;
         this.loggingService = loggingService;
         this.cacheService = cacheService;
+        this.redisLockService = redisLockService;
         this.logger = new common_1.Logger(HttpClientService_1.name);
         this.requestStats = {
             totalRequests: 0,
@@ -182,6 +184,123 @@ let HttpClientService = HttpClientService_1 = class HttpClientService {
             return this.request(Object.assign(Object.assign({}, config), { method: 'DELETE', url }));
         });
     }
+    authRequest(config, tokenProvider, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redisLockService) {
+                this.logger.warn('RedisLockService not available, proceeding without lock');
+                return this.request(config);
+            }
+            const { lockKey = `auth-request:${(0, request_id_util_1.generateRequestId)()}`, lockTimeout = 30000, waitTimeout = 60000, enableRetry = true, } = options || {};
+            try {
+                const result = yield this.redisLockService.withLock(lockKey, () => __awaiter(this, void 0, void 0, function* () {
+                    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);
+                }), {
+                    ttl: lockTimeout,
+                    retryCount: enableRetry ? 3 : 0,
+                    retryDelay: 1000,
+                    strategy: 'SKIP',
+                });
+                if (result === null) {
+                    throw new Error(`Failed to acquire lock for auth request: ${lockKey}`);
+                }
+                return result;
+            }
+            catch (error) {
+                this.logger.error(`Auth request failed with lock ${lockKey}`, error);
+                if (enableRetry && error.message.includes('Failed to acquire lock')) {
+                    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);
+                }
+                throw error;
+            }
+        });
+    }
+    authBatchRequest(requests, tokenProvider, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redisLockService) {
+                this.logger.warn('RedisLockService not available, proceeding batch auth requests without lock');
+                const token = yield tokenProvider();
+                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);
+                    }
+                    catch (error) {
+                        this.logger.error(`Batch auth request failed for key: ${request.key}`, error);
+                        return null;
+                    }
+                }));
+                return Promise.all(promises);
+            }
+            const { lockKey = `batch-auth-request:${(0, request_id_util_1.generateRequestId)()}`, lockTimeout = 60000, waitTimeout = 120000, maxConcurrency = 5, } = options || {};
+            try {
+                const results = yield this.redisLockService.withLock(lockKey, () => __awaiter(this, void 0, void 0, function* () {
+                    const token = yield tokenProvider();
+                    const semaphore = new Array(maxConcurrency).fill(null);
+                    const results = new Array(requests.length);
+                    const executing = new Set();
+                    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);
+                            results[index] = result;
+                            return result;
+                        }
+                        catch (error) {
+                            this.logger.error(`Batch auth request failed for key: ${key}`, error);
+                            results[index] = null;
+                            return null;
+                        }
+                        finally {
+                            executing.delete(key);
+                        }
+                    });
+                    const promises = requests.map((request, index) => __awaiter(this, void 0, void 0, function* () {
+                        return new Promise((resolve, reject) => {
+                            const checkSlot = () => {
+                                const slotIndex = semaphore.findIndex((slot) => slot === null);
+                                if (slotIndex !== -1) {
+                                    semaphore[slotIndex] = { resolve, reject };
+                                    executeRequest(request.config, request.key, index)
+                                        .then(() => {
+                                        semaphore[slotIndex] = null;
+                                        resolve();
+                                    })
+                                        .catch((error) => {
+                                        semaphore[slotIndex] = null;
+                                        reject(error);
+                                    });
+                                }
+                                else {
+                                    setTimeout(checkSlot, 10);
+                                }
+                            };
+                            checkSlot();
+                        });
+                    }));
+                    yield Promise.all(promises);
+                    return results;
+                }), {
+                    ttl: lockTimeout,
+                    retryCount: 2,
+                    retryDelay: 2000,
+                    strategy: 'SKIP',
+                });
+                if (results === null) {
+                    throw new Error(`Failed to acquire lock for batch auth request: ${lockKey}`);
+                }
+                return results;
+            }
+            catch (error) {
+                this.logger.error(`Batch auth request failed with lock ${lockKey}`, error);
+                throw error;
+            }
+        });
+    }
     createAxiosInstance() {
         var _a, _b;
         const instance = require('axios').create({
@@ -380,5 +499,6 @@ exports.HttpClientService = HttpClientService = HttpClientService_1 = __decorate
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [circuit_breaker_service_1.HttpCircuitBreakerService,
         logging_service_1.HttpLoggingService,
-        cache_service_1.HttpCacheService, Object])
+        cache_service_1.HttpCacheService,
+        redis_lock_service_1.RedisLockService, Object])
 ], HttpClientService);

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

@@ -49,8 +49,28 @@ export declare class HttpLogQueryService {
     }): Promise<HttpLogStats>;
     deleteOldLogs(daysToKeep?: number): Promise<number>;
     clearAllLogs(): Promise<number>;
+    generateCurlFromLog(logId: string): Promise<string | null>;
+    generateCurlFromRequestId(requestId: string): Promise<string | null>;
+    generateReplayConfigFromLog(logId: string): Promise<any | null>;
+    generateReplayConfigFromRequestId(requestId: string): Promise<any | null>;
+    generateBatchCurlCommands(options?: HttpLogQueryOptions): Promise<Array<{
+        logId: string;
+        requestId?: string;
+        curlCommand: string;
+    }>>;
+    getLogReplayInfo(logId: string): Promise<{
+        log: HttpLogEntity;
+        curlCommand: string | null;
+        replayConfig: any | null;
+    } | null>;
+    getLogReplayInfoByRequestId(requestId: string): Promise<{
+        log: HttpLogEntity;
+        curlCommand: string | null;
+        replayConfig: any | null;
+    } | null>;
     private initializeRepository;
     private calculatePercentiles;
     private formatStats;
     private buildQuery;
+    private sanitizeHeadersForCurl;
 }

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

@@ -23,6 +23,7 @@ exports.HttpLogQueryService = void 0;
 const common_1 = require("@nestjs/common");
 const typeorm_1 = require("typeorm");
 const http_log_entity_1 = require("../entities/http-log.entity");
+const curl_generator_util_1 = require("../utils/curl-generator.util");
 let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
     constructor(dataSource) {
         this.dataSource = dataSource;
@@ -255,6 +256,164 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             return 0;
         });
     }
+    generateCurlFromLog(logId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const log = yield this.logRepository.findOne({
+                where: { id: logId },
+            });
+            if (!log) {
+                this.logger.warn(`Log with ID ${logId} not found`);
+                return null;
+            }
+            try {
+                const sanitizedHeaders = this.sanitizeHeadersForCurl(log.headers || {});
+                const requestConfig = {
+                    method: log.method,
+                    url: log.url,
+                    headers: sanitizedHeaders,
+                    data: log.body,
+                    params: log.params,
+                };
+                const curlCommand = curl_generator_util_1.CurlGenerator.generateCurlCommand(requestConfig);
+                this.logger.log(`Generated curl command for log ${logId}`);
+                return curlCommand;
+            }
+            catch (error) {
+                this.logger.error(`Failed to generate curl command for log ${logId}`, error);
+                return null;
+            }
+        });
+    }
+    generateCurlFromRequestId(requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const log = yield this.logRepository.findOne({
+                where: { requestId },
+                order: { createdAt: 'DESC' },
+            });
+            if (!log) {
+                this.logger.warn(`Log with requestId ${requestId} not found`);
+                return null;
+            }
+            return this.generateCurlFromLog(log.id);
+        });
+    }
+    generateReplayConfigFromLog(logId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const log = yield this.logRepository.findOne({
+                where: { id: logId },
+            });
+            if (!log) {
+                this.logger.warn(`Log with ID ${logId} not found`);
+                return null;
+            }
+            try {
+                const replayConfig = {
+                    method: log.method,
+                    url: log.url,
+                    headers: log.headers || {},
+                    data: log.body
+                        ? typeof log.body === 'string'
+                            ? JSON.parse(log.body)
+                            : log.body
+                        : undefined,
+                    params: log.params || {},
+                    metadata: {
+                        originalLogId: log.id,
+                        originalRequestId: log.requestId,
+                        replayTimestamp: new Date().toISOString(),
+                        replayedBy: 'http-log-query-service',
+                    },
+                };
+                this.logger.log(`Generated replay config for log ${logId}`);
+                return replayConfig;
+            }
+            catch (error) {
+                this.logger.error(`Failed to generate replay config for log ${logId}`, error);
+                return null;
+            }
+        });
+    }
+    generateReplayConfigFromRequestId(requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const log = yield this.logRepository.findOne({
+                where: { requestId },
+                order: { createdAt: 'DESC' },
+            });
+            if (!log) {
+                this.logger.warn(`Log with requestId ${requestId} not found`);
+                return null;
+            }
+            return this.generateReplayConfigFromLog(log.id);
+        });
+    }
+    generateBatchCurlCommands() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const limitedOptions = Object.assign(Object.assign({}, options), { limit: Math.min(options.limit || 10, 50) });
+            const result = yield this.findLogs(limitedOptions);
+            const curlCommands = [];
+            for (const log of result.logs) {
+                try {
+                    const curlCommand = yield this.generateCurlFromLog(log.id);
+                    if (curlCommand) {
+                        curlCommands.push({
+                            logId: log.id,
+                            requestId: log.requestId,
+                            curlCommand,
+                        });
+                    }
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to generate curl for log ${log.id}`, error);
+                }
+            }
+            this.logger.log(`Generated ${curlCommands.length} curl commands`);
+            return curlCommands;
+        });
+    }
+    getLogReplayInfo(logId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const log = yield this.findLogById(logId, true);
+            if (!log) {
+                return null;
+            }
+            const [curlCommand, replayConfig] = yield Promise.all([
+                this.generateCurlFromLog(logId),
+                this.generateReplayConfigFromLog(logId),
+            ]);
+            return {
+                log,
+                curlCommand,
+                replayConfig,
+            };
+        });
+    }
+    getLogReplayInfoByRequestId(requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const log = yield this.findLogByRequestId(requestId);
+            if (!log) {
+                return null;
+            }
+            return this.getLogReplayInfo(log.id);
+        });
+    }
     initializeRepository() {
         if (this.dataSource) {
             try {
@@ -406,6 +565,23 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
         }
         return queryBuilder;
     }
+    sanitizeHeadersForCurl(headers) {
+        const sensitiveHeaders = [
+            'authorization',
+            'apikey',
+            'x-api-key',
+            'x-auth-token',
+            'cookie',
+            'set-cookie',
+        ];
+        const sanitized = Object.assign({}, headers);
+        for (const header of sensitiveHeaders) {
+            if (sanitized[header]) {
+                sanitized[header] = '***REDACTED***';
+            }
+        }
+        return sanitized;
+    }
 };
 exports.HttpLogQueryService = HttpLogQueryService;
 exports.HttpLogQueryService = HttpLogQueryService = HttpLogQueryService_1 = __decorate([

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

@@ -0,0 +1,58 @@
+import { AxiosRequestConfig } from 'axios';
+import { HttpClientService } from './http-client.service';
+import { HttpLogQueryService } from './http-log-query.service';
+import { HttpLogEntity } from '../entities/http-log.entity';
+export interface HttpReplayOptions {
+    overrideHeaders?: boolean;
+    overrideBody?: boolean;
+    overrideParams?: boolean;
+    additionalHeaders?: Record<string, string>;
+    metadata?: Record<string, any>;
+    logReplay?: boolean;
+    timeout?: number;
+}
+export interface HttpReplayResult {
+    originalLog: HttpLogEntity;
+    requestConfig: AxiosRequestConfig;
+    response: any;
+    responseTime: number;
+    success: boolean;
+    error?: string;
+    replayTimestamp: string;
+    replayId: string;
+}
+export interface BatchReplayResult {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    successRate: number;
+    totalResponseTime: number;
+    averageResponseTime: number;
+    results: HttpReplayResult[];
+}
+export declare class HttpReplayService {
+    private readonly httpClient;
+    private readonly logQueryService;
+    private readonly logger;
+    constructor(httpClient: HttpClientService, logQueryService: HttpLogQueryService);
+    replayByLogId(logId: string, options?: HttpReplayOptions): Promise<HttpReplayResult>;
+    replayByRequestId(requestId: string, options?: HttpReplayOptions): Promise<HttpReplayResult>;
+    batchReplay(logIds: string[], options?: HttpReplayOptions, concurrency?: number): Promise<BatchReplayResult>;
+    batchReplayByQuery(queryOptions?: any, replayOptions?: HttpReplayOptions, concurrency?: number): Promise<BatchReplayResult>;
+    replayAndCompare(logId: string, options?: HttpReplayOptions): Promise<{
+        original: HttpLogEntity;
+        replay: HttpReplayResult;
+        comparison: {
+            statusMatch: boolean;
+            responseTimeDifference: number;
+            headersMatch: boolean;
+            bodyMatch: boolean;
+        };
+    }>;
+    private buildReplayConfig;
+    private executeReplayRequest;
+    private generateReplayId;
+    private chunkArray;
+    private compareHeaders;
+    private compareBodies;
+}