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

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

@@ -0,0 +1,504 @@
+"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 HttpClientService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientService = void 0;
+const common_1 = require("@nestjs/common");
+const axios_retry_1 = require("axios-retry");
+const cache_1 = require("../../cache");
+const circuit_breaker_service_1 = require("./circuit-breaker.service");
+const logging_service_1 = require("./logging.service");
+const cache_service_1 = require("./cache.service");
+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("../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, 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,
+            successfulRequests: 0,
+            failedRequests: 0,
+            totalResponseTime: 0,
+            requestsByMethod: {},
+            requestsByStatus: {},
+        };
+        this.defaultConfig = this.mergeWithDefaults(config);
+        this.axiosInstance = this.createAxiosInstance();
+    }
+    request(config, decoratorContext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g;
+            const startTime = Date.now();
+            const retryRecorder = retry_recorder_util_1.RetryRecorder.create();
+            let requestId;
+            let circuitBreakerState;
+            let cacheHit = false;
+            try {
+                const enhancedConfig = this.applyDecoratorConfig(config, decoratorContext);
+                const decoratorConfigs = decoratorContext
+                    ? decorators_1.HttpDecoratorUtils.getAllDecoratorConfigs(decoratorContext.target, decoratorContext.propertyKey)
+                    : {};
+                const loggingOptions = decoratorConfigs.logging || this.defaultConfig.logging;
+                if (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.enabled) {
+                    requestId = this.loggingService.logRequestStart(enhancedConfig, loggingOptions);
+                    enhancedConfig.metadata = enhancedConfig.metadata || {};
+                    enhancedConfig.metadata.requestId = requestId;
+                }
+                const cacheConfig = decoratorConfigs.cache || this.defaultConfig.cache;
+                if ((cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.enabled) &&
+                    this.shouldCacheRequest(enhancedConfig, cacheConfig)) {
+                    const cachedResponse = yield this.cacheService.get(enhancedConfig, cacheConfig);
+                    if (cachedResponse) {
+                        cacheHit = true;
+                        if (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.enabled) {
+                            const databaseLogging = (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.databaseLog) ||
+                                ((_b = (_a = this.defaultConfig.logging) === null || _a === void 0 ? void 0 : _a.databaseLogging) === null || _b === void 0 ? void 0 : _b.enabled);
+                            this.loggingService.logRequestSuccess(cachedResponse, startTime, requestId, loggingOptions, databaseLogging, undefined, cacheHit, undefined, decoratorContext);
+                        }
+                        return cachedResponse.data;
+                    }
+                }
+                const timeout = decoratorConfigs.timeout || this.defaultConfig.timeout;
+                if (timeout) {
+                    enhancedConfig.timeout = timeout;
+                }
+                const proxyConfig = decoratorConfigs.proxy || this.defaultConfig.proxy;
+                if (proxyConfig === null || proxyConfig === void 0 ? void 0 : proxyConfig.enabled) {
+                    enhancedConfig.proxy = {
+                        host: proxyConfig.host,
+                        port: proxyConfig.port,
+                        protocol: proxyConfig.protocol,
+                        auth: proxyConfig.auth,
+                    };
+                }
+                if ((_c = this.defaultConfig.retry) === null || _c === void 0 ? void 0 : _c.enabled) {
+                    const originalOnRetry = this.defaultConfig.retry.onRetry;
+                    this.defaultConfig.retry.onRetry = (retryCount, error, requestConfig) => {
+                        const retryRecord = retry_recorder_util_1.RetryRecorder.recordRetry(retryCount, error, requestConfig, this.calculateRetryDelay(retryCount, this.defaultConfig.retry));
+                        retryRecorder.addRecord(retryRecord);
+                        if (originalOnRetry) {
+                            originalOnRetry(retryCount, error, requestConfig);
+                        }
+                    };
+                }
+                const response = yield this.executeWithFeatures(enhancedConfig, decoratorConfigs, requestId, startTime, retryRecorder, (state) => {
+                    circuitBreakerState = state;
+                });
+                if ((cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.enabled) &&
+                    this.shouldCacheRequest(enhancedConfig, cacheConfig)) {
+                    yield this.cacheService.set(enhancedConfig, response, cacheConfig);
+                }
+                if (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.enabled) {
+                    const databaseLogging = (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.databaseLog) ||
+                        ((_e = (_d = this.defaultConfig.logging) === null || _d === void 0 ? void 0 : _d.databaseLogging) === null || _e === void 0 ? void 0 : _e.enabled);
+                    this.loggingService.logRequestSuccess(response, startTime, requestId, loggingOptions, databaseLogging, retryRecorder.getRecords(), cacheHit, circuitBreakerState, decoratorContext);
+                }
+                return response.data;
+            }
+            catch (error) {
+                const loggingOptions = decoratorContext
+                    ? decorators_1.HttpDecoratorUtils.getLoggingOptions(decoratorContext.target, decoratorContext.propertyKey)
+                    : this.defaultConfig.logging;
+                if (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.enabled) {
+                    const databaseLogging = (loggingOptions === null || loggingOptions === void 0 ? void 0 : loggingOptions.databaseLog) ||
+                        ((_g = (_f = this.defaultConfig.logging) === null || _f === void 0 ? void 0 : _f.databaseLogging) === null || _g === void 0 ? void 0 : _g.enabled);
+                    this.loggingService.logRequestError(error, startTime, requestId, retryRecorder.getRecords().length || 1, loggingOptions, databaseLogging, retryRecorder.getRecords(), cacheHit, circuitBreakerState, decoratorContext);
+                }
+                throw error;
+            }
+        });
+    }
+    generateCurlCommand(config) {
+        return curl_generator_util_1.CurlGenerator.generateSimplifiedCurl(config);
+    }
+    generateDebugCurlCommand(config, response) {
+        return curl_generator_util_1.CurlGenerator.generateDebugCurl(config, response);
+    }
+    getStats() {
+        const avgResponseTime = this.requestStats.totalRequests > 0
+            ? this.requestStats.totalResponseTime / this.requestStats.totalRequests
+            : 0;
+        return Object.assign(Object.assign({}, this.requestStats), { averageResponseTime: avgResponseTime, successRate: this.requestStats.totalRequests > 0
+                ? (this.requestStats.successfulRequests /
+                    this.requestStats.totalRequests) *
+                    100
+                : 0, circuitBreakerStats: this.circuitBreakerService.getAllStates(), cacheStats: this.cacheService.getStats() });
+    }
+    resetStats() {
+        this.requestStats = {
+            totalRequests: 0,
+            successfulRequests: 0,
+            failedRequests: 0,
+            totalResponseTime: 0,
+            requestsByMethod: {},
+            requestsByStatus: {},
+        };
+    }
+    get(url, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(Object.assign(Object.assign({}, config), { method: 'GET', url }));
+        });
+    }
+    post(url, data, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(Object.assign(Object.assign({}, config), { method: 'POST', url, data }));
+        });
+    }
+    put(url, data, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(Object.assign(Object.assign({}, config), { method: 'PUT', url, data }));
+        });
+    }
+    patch(url, data, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(Object.assign(Object.assign({}, config), { method: 'PATCH', url, data }));
+        });
+    }
+    delete(url, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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({
+            baseURL: this.defaultConfig.baseURL,
+            timeout: this.defaultConfig.timeout,
+            proxy: ((_a = this.defaultConfig.proxy) === null || _a === void 0 ? void 0 : _a.enabled)
+                ? {
+                    host: this.defaultConfig.proxy.host,
+                    port: this.defaultConfig.proxy.port,
+                    protocol: this.defaultConfig.proxy.protocol,
+                    auth: this.defaultConfig.proxy.auth,
+                }
+                : undefined,
+        });
+        if ((_b = this.defaultConfig.retry) === null || _b === void 0 ? void 0 : _b.enabled) {
+            (0, axios_retry_1.default)(instance, {
+                retries: this.defaultConfig.retry.retries || 3,
+                retryDelay: this.defaultConfig.retry.retryDelay ||
+                    ((retryCount) => Math.pow(2, retryCount) * 1000),
+                retryCondition: this.defaultConfig.retry.retryCondition ||
+                    ((error) => {
+                        if (!error.response)
+                            return true;
+                        const status = error.response.status;
+                        return status >= 500 || status === 429;
+                    }),
+                shouldResetTimeout: this.defaultConfig.retry.shouldResetTimeout !== false,
+                onRetry: this.defaultConfig.retry.onRetry ||
+                    ((retryCount, error, requestConfig) => {
+                        var _a;
+                        this.logger.warn(`Retrying request (attempt ${retryCount}): ${(_a = requestConfig.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()} ${requestConfig.url}`);
+                    }),
+            });
+        }
+        instance.interceptors.request.use((config) => {
+            config.headers = config.headers || {};
+            const context = context_extractor_util_1.ContextExtractor.getHttpContext();
+            const requestId = context.requestId || (0, request_id_util_1.generateRequestId)();
+            config.headers['X-Request-ID'] = requestId;
+            if (context.userId) {
+                config.headers['X-User-ID'] = context.userId;
+            }
+            config.metadata = config.metadata || {};
+            config.metadata.requestId = requestId;
+            return config;
+        }, (error) => {
+            this.logger.error('Request interceptor error', error);
+            return Promise.reject(error);
+        });
+        instance.interceptors.response.use((response) => {
+            this.updateStats(response);
+            return response;
+        }, (error) => {
+            this.updateErrorStats(error);
+            return Promise.reject(error);
+        });
+        return instance;
+    }
+    executeWithFeatures(config, decoratorConfigs, requestId, startTime, retryRecorder, onCircuitBreakerStateChange) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestFn = () => this.axiosInstance.request(config);
+            const circuitBreakerConfig = decoratorConfigs.circuitBreaker || this.defaultConfig.circuitBreaker;
+            if (circuitBreakerConfig === null || circuitBreakerConfig === void 0 ? void 0 : circuitBreakerConfig.enabled) {
+                const circuitBreakerKey = this.generateCircuitBreakerKey(config);
+                return this.circuitBreakerService.executeWithCircuitBreaker(circuitBreakerKey, requestFn, circuitBreakerConfig);
+            }
+            else {
+                return requestFn();
+            }
+        });
+    }
+    calculateRetryDelay(retryCount, retryConfig) {
+        if (retryConfig.retryDelay) {
+            return retryConfig.retryDelay(retryCount);
+        }
+        return Math.pow(2, retryCount) * 1000;
+    }
+    applyDecoratorConfig(config, decoratorContext) {
+        if (!decoratorContext)
+            return Object.assign({}, config);
+        const httpClientConfig = decorators_1.HttpDecoratorUtils.getHttpClientOptions(decoratorContext.target);
+        return Object.assign(Object.assign({}, config), httpClientConfig);
+    }
+    shouldCacheRequest(config, cacheConfig) {
+        var _a;
+        const method = (_a = config.method) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        return cacheConfig.cacheableMethods.includes(method || 'get');
+    }
+    generateCircuitBreakerKey(config) {
+        var _a;
+        const method = ((_a = config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'UNKNOWN';
+        const url = new URL(config.url || '', this.defaultConfig.baseURL || 'http://localhost');
+        return `${method}:${url.host}${url.pathname}`;
+    }
+    updateStats(response) {
+        var _a, _b;
+        this.requestStats.totalRequests++;
+        this.requestStats.successfulRequests++;
+        const method = ((_a = response.config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'UNKNOWN';
+        const status = response.status;
+        this.requestStats.requestsByMethod[method] =
+            (this.requestStats.requestsByMethod[method] || 0) + 1;
+        this.requestStats.requestsByStatus[status] =
+            (this.requestStats.requestsByStatus[status] || 0) + 1;
+        if ((_b = response.config.metadata) === null || _b === void 0 ? void 0 : _b.startTime) {
+            const responseTime = Date.now() -
+                response.config.metadata
+                    .startTime;
+            this.requestStats.totalResponseTime += responseTime;
+        }
+    }
+    updateErrorStats(error) {
+        var _a;
+        this.requestStats.totalRequests++;
+        this.requestStats.failedRequests++;
+        if (error.config) {
+            const method = ((_a = error.config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'UNKNOWN';
+            this.requestStats.requestsByMethod[method] =
+                (this.requestStats.requestsByMethod[method] || 0) + 1;
+            if (error.response) {
+                const status = error.response.status;
+                this.requestStats.requestsByStatus[status] =
+                    (this.requestStats.requestsByStatus[status] || 0) + 1;
+            }
+        }
+    }
+    mergeWithDefaults(config) {
+        const defaults = {
+            baseURL: process.env.HTTP_CLIENT_BASE_URL,
+            timeout: 30000,
+            retry: {
+                enabled: true,
+                retries: 3,
+                retryDelay: (retryCount) => Math.pow(2, retryCount) * 1000,
+                retryCondition: (error) => {
+                    if (!error.response)
+                        return true;
+                    const status = error.response.status;
+                    return status >= 500 || status === 429;
+                },
+                shouldResetTimeout: true,
+            },
+            circuitBreaker: {
+                enabled: true,
+                failureThreshold: 5,
+                recoveryTimeoutMs: 60000,
+                monitoringPeriodMs: 10000,
+                minimumThroughputThreshold: 10,
+                countHalfOpenCalls: true,
+            },
+            cache: {
+                enabled: true,
+                defaultTtl: 300000,
+                cacheableMethods: ['get'],
+                cacheableStatusCodes: [200, 201, 202, 204, 301, 302, 304],
+                options: {
+                    layers: [cache_1.CacheLayer.MEMORY, cache_1.CacheLayer.REDIS],
+                },
+            },
+            logging: {
+                enabled: true,
+                logRequests: true,
+                logResponses: true,
+                logErrors: true,
+                logHeaders: true,
+                logBody: true,
+                maxBodyLength: 1000,
+                sanitizeHeaders: ['authorization', 'apikey', 'password', 'token'],
+                logLevel: 'info',
+                databaseLogging: {
+                    enabled: false,
+                    dataSource: 'default',
+                    tableName: 'http_logs',
+                },
+            },
+        };
+        return this.deepMerge(defaults, config);
+    }
+    deepMerge(target, source) {
+        const result = Object.assign({}, target);
+        for (const key in source) {
+            if (source[key] &&
+                typeof source[key] === 'object' &&
+                !Array.isArray(source[key])) {
+                result[key] = this.deepMerge(result[key] || {}, source[key]);
+            }
+            else {
+                result[key] = source[key];
+            }
+        }
+        return result;
+    }
+};
+exports.HttpClientService = HttpClientService;
+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,
+        redis_lock_service_1.RedisLockService, Object])
+], HttpClientService);

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

@@ -0,0 +1,76 @@
+import { DataSource } from 'typeorm';
+import { HttpLogEntity, HttpLogQueryOptions, HttpLogStats } from '../entities/http-log.entity';
+export declare class HttpLogQueryService {
+    private readonly dataSource?;
+    private readonly logger;
+    private logRepository;
+    constructor(dataSource?: DataSource);
+    findLogs(options?: HttpLogQueryOptions): Promise<{
+        logs: HttpLogEntity[];
+        total: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+    }>;
+    findLogById(id: string, includeDetails?: boolean): Promise<HttpLogEntity | null>;
+    findLogByRequestId(requestId: string): Promise<HttpLogEntity | null>;
+    findErrorLogs(options?: {
+        startDate?: Date;
+        endDate?: Date;
+        errorCode?: string;
+        statusCode?: number;
+        page?: number;
+        limit?: number;
+    }): Promise<{
+        logs: HttpLogEntity[];
+        total: number;
+    }>;
+    findSlowRequests(minResponseTime?: number, options?: {
+        page?: number;
+        limit?: number;
+    }): Promise<{
+        logs: HttpLogEntity[];
+        total: number;
+    }>;
+    findRetryLogs(options?: {
+        minRetries?: number;
+        page?: number;
+        limit?: number;
+    }): Promise<{
+        logs: HttpLogEntity[];
+        total: number;
+    }>;
+    getStats(options?: {
+        startDate?: Date;
+        endDate?: Date;
+        userId?: string;
+        serviceName?: string;
+        groupBy?: 'hour' | 'day' | 'week';
+    }): 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;
+}