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

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

@@ -0,0 +1,264 @@
+"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 HttpCacheService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpCacheService = void 0;
+const common_1 = require("@nestjs/common");
+const cache_service_1 = require("../../cache/cache.service");
+const cache_options_interface_1 = require("../../cache/interfaces/cache-options.interface");
+let HttpCacheService = HttpCacheService_1 = class HttpCacheService {
+    constructor(cacheService) {
+        this.cacheService = cacheService;
+        this.logger = new common_1.Logger(HttpCacheService_1.name);
+    }
+    get(config, cacheOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const key = this.generateCacheKey(config, cacheOptions);
+            const cacheKey = this.buildCacheKey(cacheOptions, key);
+            try {
+                const cachedResponse = yield this.cacheService.get(cacheKey, {
+                    layers: this.mapLayers((_a = cacheOptions.options) === null || _a === void 0 ? void 0 : _a.layers),
+                    ttl: cacheOptions.defaultTtl,
+                });
+                if (cachedResponse) {
+                    this.logger.debug(`Cache hit: ${cacheKey}`);
+                    return cachedResponse;
+                }
+                this.logger.debug(`Cache miss: ${cacheKey}`);
+                return null;
+            }
+            catch (error) {
+                this.logger.warn(`Cache get error: ${error.message}`);
+                return null;
+            }
+        });
+    }
+    set(config, response, cacheOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const key = this.generateCacheKey(config, cacheOptions);
+            const cacheKey = this.buildCacheKey(cacheOptions, key);
+            if (!this.isResponseCacheable(response, cacheOptions)) {
+                this.logger.debug(`Response not cacheable: ${response.status} ${config.url}`);
+                return;
+            }
+            try {
+                yield this.cacheService.set(cacheKey, response, {
+                    layers: this.mapLayers((_a = cacheOptions.options) === null || _a === void 0 ? void 0 : _a.layers),
+                    ttl: cacheOptions.defaultTtl,
+                    namespace: ((_b = cacheOptions.options) === null || _b === void 0 ? void 0 : _b.prefix) || 'http',
+                    condition: (_c = cacheOptions.options) === null || _c === void 0 ? void 0 : _c.condition,
+                    backfill: (_d = cacheOptions.options) === null || _d === void 0 ? void 0 : _d.backfill,
+                });
+                this.logger.debug(`Response cached: ${cacheKey}`);
+            }
+            catch (error) {
+                this.logger.warn(`Cache set error: ${error.message}`);
+            }
+        });
+    }
+    clear(pattern) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (pattern) {
+                    yield this.cacheService.deletePattern(pattern);
+                    this.logger.debug(`Cache cleared with pattern: ${pattern}`);
+                }
+                else {
+                    yield this.cacheService.deletePattern('http:*');
+                    this.logger.debug('All HTTP cache cleared');
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Cache clear error: ${error.message}`);
+            }
+        });
+    }
+    getStats() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const stats = this.cacheService.getStats();
+                return stats;
+            }
+            catch (error) {
+                this.logger.warn(`Get cache stats error: ${error.message}`);
+                return null;
+            }
+        });
+    }
+    cleanup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.cacheService.deletePattern('http:*');
+                this.logger.debug('HTTP cache cleanup completed');
+            }
+            catch (error) {
+                this.logger.warn(`Cache cleanup error: ${error.message}`);
+            }
+        });
+    }
+    warmup(urls, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log(`Starting cache warmup for ${urls.length} URLs`);
+            this.logger.log('Cache warmup completed');
+        });
+    }
+    getDetailedStats() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const stats = yield this.getStats();
+                const recentHits = yield this.getRecentCacheActivity();
+                return Object.assign(Object.assign({}, stats), { recentActivity: recentHits, recommendations: this.generateRecommendations(stats) });
+            }
+            catch (error) {
+                this.logger.warn(`Get detailed cache stats error: ${error.message}`);
+                return null;
+            }
+        });
+    }
+    generateCacheKey(config, cacheOptions) {
+        var _a;
+        if (cacheOptions.keyGenerator) {
+            return cacheOptions.keyGenerator(config);
+        }
+        const keyData = {
+            method: (_a = config.method) === null || _a === void 0 ? void 0 : _a.toLowerCase(),
+            url: config.url,
+            params: config.params,
+            data: config.data,
+            headers: this.selectHeadersForCacheKey(config.headers),
+        };
+        return this.hashObject(keyData);
+    }
+    buildCacheKey(cacheOptions, key) {
+        var _a;
+        const namespace = ((_a = cacheOptions.options) === null || _a === void 0 ? void 0 : _a.prefix) || 'http';
+        return `${namespace}:${key}`;
+    }
+    mapLayers(layers) {
+        if (!layers || layers.length === 0) {
+            return [cache_options_interface_1.CacheLayer.MEMORY, cache_options_interface_1.CacheLayer.REDIS];
+        }
+        return layers.map((layer) => {
+            switch (layer) {
+                case 'cls':
+                    return cache_options_interface_1.CacheLayer.CLS;
+                case 'memory':
+                    return cache_options_interface_1.CacheLayer.MEMORY;
+                case 'redis':
+                    return cache_options_interface_1.CacheLayer.REDIS;
+                default:
+                    return cache_options_interface_1.CacheLayer.MEMORY;
+            }
+        });
+    }
+    selectHeadersForCacheKey(headers) {
+        if (!headers)
+            return {};
+        const cacheKeyHeaders = [
+            'accept',
+            'accept-language',
+            'accept-encoding',
+            'content-type',
+            'authorization',
+        ];
+        const selectedHeaders = {};
+        cacheKeyHeaders.forEach((key) => {
+            if (headers[key]) {
+                selectedHeaders[key] = headers[key];
+            }
+        });
+        return selectedHeaders;
+    }
+    isResponseCacheable(response, config) {
+        var _a;
+        if (!config.cacheableStatusCodes.includes(response.status)) {
+            return false;
+        }
+        const method = (_a = response.config.method) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        if (!config.cacheableMethods.includes(method || 'get')) {
+            return false;
+        }
+        const cacheControl = response.headers['cache-control'];
+        if (cacheControl) {
+            if (cacheControl.includes('no-store') ||
+                cacheControl.includes('no-cache')) {
+                return false;
+            }
+            if (cacheControl.includes('private')) {
+                this.logger.debug('Private cache detected, caching with caution');
+            }
+        }
+        if (response.data) {
+            const responseSize = JSON.stringify(response.data).length;
+            if (responseSize > 1024 * 1024) {
+                this.logger.warn(`Response too large for caching: ${responseSize} bytes`);
+                return false;
+            }
+        }
+        return true;
+    }
+    hashObject(obj) {
+        const str = JSON.stringify(obj, Object.keys(obj).sort());
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return Math.abs(hash).toString(36);
+    }
+    calculateHitRate(...stats) {
+        let totalHits = 0;
+        let totalRequests = 0;
+        stats.forEach((stat) => {
+            if (stat) {
+                totalHits += stat.hits || 0;
+                totalRequests += (stat.hits || 0) + (stat.misses || 0);
+            }
+        });
+        return totalRequests > 0 ? (totalHits / totalRequests) * 100 : 0;
+    }
+    getRecentCacheActivity() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                recentHits: 0,
+                recentMisses: 0,
+                topCacheKeys: [],
+            };
+        });
+    }
+    generateRecommendations(stats) {
+        const recommendations = [];
+        if (stats.combined.hitRate < 50) {
+            recommendations.push('Cache hit rate is low, consider increasing TTL or optimizing cache keys');
+        }
+        if (stats.redis.memoryUsage > 0.8) {
+            recommendations.push('Redis memory usage is high, consider increasing memory or cleaning up old cache entries');
+        }
+        return recommendations;
+    }
+};
+exports.HttpCacheService = HttpCacheService;
+exports.HttpCacheService = HttpCacheService = HttpCacheService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [cache_service_1.CacheService])
+], HttpCacheService);

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

@@ -0,0 +1,33 @@
+import { Logger } from '@nestjs/common';
+import { CircuitBreakerConfig } from '../interfaces/http-client-config.interface';
+export declare class HttpCircuitBreakerService {
+    private readonly logger;
+    private readonly circuitBreakers;
+    getCircuitBreaker(key: string, config: CircuitBreakerConfig): CircuitBreaker;
+    executeWithCircuitBreaker<T>(key: string, requestFn: () => Promise<T>, config: CircuitBreakerConfig): Promise<T>;
+    resetAll(): void;
+    getAllStates(): Record<string, any>;
+}
+declare class CircuitBreaker {
+    private readonly key;
+    private readonly config;
+    private readonly logger;
+    private state;
+    private failureCount;
+    private successCount;
+    private lastFailureTime;
+    private nextAttemptTime;
+    private requestCount;
+    private windowStartTime;
+    constructor(key: string, config: CircuitBreakerConfig, logger: Logger);
+    execute<T>(requestFn: () => Promise<T>): Promise<T>;
+    reset(): void;
+    getState(): any;
+    private onSuccess;
+    private onFailure;
+    private transitionToClosed;
+    private transitionToOpen;
+    private transitionToHalfOpen;
+    private resetMonitoringWindow;
+}
+export {};

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

@@ -0,0 +1,180 @@
+"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 __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 HttpCircuitBreakerService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpCircuitBreakerService = void 0;
+const common_1 = require("@nestjs/common");
+var CircuitBreakerState;
+(function (CircuitBreakerState) {
+    CircuitBreakerState["CLOSED"] = "CLOSED";
+    CircuitBreakerState["OPEN"] = "OPEN";
+    CircuitBreakerState["HALF_OPEN"] = "HALF_OPEN";
+})(CircuitBreakerState || (CircuitBreakerState = {}));
+let HttpCircuitBreakerService = HttpCircuitBreakerService_1 = class HttpCircuitBreakerService {
+    constructor() {
+        this.logger = new common_1.Logger(HttpCircuitBreakerService_1.name);
+        this.circuitBreakers = new Map();
+    }
+    getCircuitBreaker(key, config) {
+        if (!this.circuitBreakers.has(key)) {
+            this.circuitBreakers.set(key, new CircuitBreaker(key, config, this.logger));
+        }
+        return this.circuitBreakers.get(key);
+    }
+    executeWithCircuitBreaker(key, requestFn, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const circuitBreaker = this.getCircuitBreaker(key, config);
+            return circuitBreaker.execute(requestFn);
+        });
+    }
+    resetAll() {
+        this.circuitBreakers.forEach((cb) => cb.reset());
+    }
+    getAllStates() {
+        const states = {};
+        this.circuitBreakers.forEach((cb, key) => {
+            states[key] = cb.getState();
+        });
+        return states;
+    }
+};
+exports.HttpCircuitBreakerService = HttpCircuitBreakerService;
+exports.HttpCircuitBreakerService = HttpCircuitBreakerService = HttpCircuitBreakerService_1 = __decorate([
+    (0, common_1.Injectable)()
+], HttpCircuitBreakerService);
+class CircuitBreaker {
+    constructor(key, config, logger) {
+        this.key = key;
+        this.config = config;
+        this.logger = logger;
+        this.state = CircuitBreakerState.CLOSED;
+        this.failureCount = 0;
+        this.successCount = 0;
+        this.lastFailureTime = 0;
+        this.nextAttemptTime = 0;
+        this.requestCount = 0;
+        this.windowStartTime = Date.now();
+    }
+    execute(requestFn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentTime = Date.now();
+            if (currentTime - this.windowStartTime > this.config.monitoringPeriodMs) {
+                this.resetMonitoringWindow();
+            }
+            switch (this.state) {
+                case CircuitBreakerState.OPEN:
+                    if (currentTime < this.nextAttemptTime) {
+                        throw new Error(`Circuit breaker is OPEN for ${this.key}. Next attempt at ${new Date(this.nextAttemptTime)}`);
+                    }
+                    this.transitionToHalfOpen();
+                    break;
+                case CircuitBreakerState.HALF_OPEN:
+                    this.logger.debug(`Circuit breaker is HALF_OPEN for ${this.key}, attempting request`);
+                    break;
+                case CircuitBreakerState.CLOSED:
+                default:
+                    break;
+            }
+            this.requestCount++;
+            try {
+                const result = yield requestFn();
+                this.onSuccess();
+                return result;
+            }
+            catch (error) {
+                this.onFailure();
+                throw error;
+            }
+        });
+    }
+    reset() {
+        this.transitionToClosed();
+        this.resetMonitoringWindow();
+    }
+    getState() {
+        return {
+            state: this.state,
+            failureCount: this.failureCount,
+            successCount: this.successCount,
+            requestCount: this.requestCount,
+            lastFailureTime: this.lastFailureTime,
+            nextAttemptTime: this.nextAttemptTime,
+            windowStartTime: this.windowStartTime,
+            config: this.config,
+        };
+    }
+    onSuccess() {
+        this.failureCount = 0;
+        switch (this.state) {
+            case CircuitBreakerState.HALF_OPEN:
+                this.successCount++;
+                if (this.successCount >= (this.config.countHalfOpenCalls ? 3 : 1)) {
+                    this.transitionToClosed();
+                }
+                break;
+            case CircuitBreakerState.CLOSED:
+            default:
+                break;
+        }
+    }
+    onFailure() {
+        this.failureCount++;
+        this.lastFailureTime = Date.now();
+        switch (this.state) {
+            case CircuitBreakerState.HALF_OPEN:
+                this.transitionToOpen();
+                break;
+            case CircuitBreakerState.CLOSED:
+                if (this.requestCount >= this.config.minimumThroughputThreshold &&
+                    this.failureCount >= this.config.failureThreshold) {
+                    this.transitionToOpen();
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    transitionToClosed() {
+        if (this.state !== CircuitBreakerState.CLOSED) {
+            this.logger.log(`Circuit breaker ${this.key} transitioned to CLOSED`);
+            this.state = CircuitBreakerState.CLOSED;
+            this.failureCount = 0;
+            this.successCount = 0;
+        }
+    }
+    transitionToOpen() {
+        if (this.state !== CircuitBreakerState.OPEN) {
+            this.logger.warn(`Circuit breaker ${this.key} transitioned to OPEN due to ${this.failureCount} failures`);
+            this.state = CircuitBreakerState.OPEN;
+            this.nextAttemptTime = Date.now() + this.config.recoveryTimeoutMs;
+            this.successCount = 0;
+        }
+    }
+    transitionToHalfOpen() {
+        if (this.state !== CircuitBreakerState.HALF_OPEN) {
+            this.logger.log(`Circuit breaker ${this.key} transitioned to HALF_OPEN`);
+            this.state = CircuitBreakerState.HALF_OPEN;
+            this.successCount = 0;
+        }
+    }
+    resetMonitoringWindow() {
+        this.windowStartTime = Date.now();
+        this.requestCount = 0;
+        this.failureCount = 0;
+        this.logger.debug(`Reset monitoring window for circuit breaker ${this.key}`);
+    }
+}

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

@@ -0,0 +1,43 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { HttpClientConfig } from '../interfaces/http-client-config.interface';
+import { HttpCircuitBreakerService } from './circuit-breaker.service';
+import { HttpLoggingService } from './logging.service';
+import { HttpCacheService } from './cache.service';
+interface ExtendedAxiosRequestConfig extends AxiosRequestConfig {
+    metadata?: {
+        requestId?: string;
+        startTime?: number;
+        [key: string]: any;
+    };
+}
+export declare class HttpClientService {
+    private readonly circuitBreakerService;
+    private readonly loggingService;
+    private readonly cacheService;
+    private readonly logger;
+    private readonly axiosInstance;
+    private readonly defaultConfig;
+    private requestStats;
+    constructor(circuitBreakerService: HttpCircuitBreakerService, loggingService: HttpLoggingService, cacheService: HttpCacheService, config?: HttpClientConfig);
+    request<T = any>(config: ExtendedAxiosRequestConfig, decoratorContext?: any): Promise<T>;
+    generateCurlCommand(config: ExtendedAxiosRequestConfig): string;
+    generateDebugCurlCommand(config: ExtendedAxiosRequestConfig, response?: AxiosResponse): string;
+    getStats(): any;
+    resetStats(): void;
+    get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    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>;
+    private createAxiosInstance;
+    private executeWithFeatures;
+    private calculateRetryDelay;
+    private applyDecoratorConfig;
+    private shouldCacheRequest;
+    private generateCircuitBreakerKey;
+    private updateStats;
+    private updateErrorStats;
+    private mergeWithDefaults;
+    private deepMerge;
+}
+export {};