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

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

@@ -0,0 +1,412 @@
+"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 ApiClientRegistryService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClientRegistryService = exports.AuthType = void 0;
+const common_1 = require("@nestjs/common");
+const axios_1 = require("axios");
+const axios_retry_1 = require("axios-retry");
+const api_client_config_interface_1 = require("../interfaces/api-client-config.interface");
+Object.defineProperty(exports, "AuthType", { enumerable: true, get: function () { return api_client_config_interface_1.AuthType; } });
+const http_client_service_1 = require("./http-client.service");
+const circuit_breaker_service_1 = require("./circuit-breaker.service");
+const logging_service_1 = require("./logging.service");
+const cache_service_1 = require("./cache.service");
+const context_extractor_util_1 = require("../utils/context-extractor.util");
+const utils_1 = require("../../common/utils");
+let ApiClientRegistryService = ApiClientRegistryService_1 = class ApiClientRegistryService {
+    constructor(httpClientService, circuitBreakerService, loggingService, cacheService, globalConfig = {}) {
+        this.httpClientService = httpClientService;
+        this.circuitBreakerService = circuitBreakerService;
+        this.loggingService = loggingService;
+        this.cacheService = cacheService;
+        this.logger = new common_1.Logger(ApiClientRegistryService_1.name);
+        this.clients = new Map();
+        this.clientConfigs = new Map();
+        this.globalDefaults = Object.assign({ globalDefaults: {
+                retry: { enabled: true, retries: 3 },
+                logging: {
+                    enabled: true,
+                    logRequests: true,
+                    logResponses: true,
+                    logErrors: true,
+                    logHeaders: true,
+                    logBody: true,
+                    maxBodyLength: 10000,
+                    sanitizeHeaders: ['authorization', 'api-key'],
+                    logLevel: 'info',
+                },
+                timeout: 30000,
+            }, logCleanup: {
+                enabled: true,
+                retentionDays: 30,
+                maxRecords: 1000000,
+            }, enableGlobalRetry: true, enableCircuitBreaker: true }, globalConfig);
+    }
+    createClient(config) {
+        const clientName = config.name;
+        const existingClient = this.clients.get(clientName);
+        if (existingClient && !config.override) {
+            this.logger.warn(`Client '${clientName}' already exists. Use override: true to replace it.`);
+            return existingClient;
+        }
+        const finalConfig = this.mergeEnvironmentConfig(config);
+        const axiosInstance = this.createAxiosInstance(finalConfig);
+        const client = new ApiClientInstance(clientName, finalConfig, axiosInstance, this.httpClientService, this.loggingService, this.cacheService);
+        this.clients.set(clientName, client);
+        this.clientConfigs.set(clientName, finalConfig);
+        this.logger.log(`Created API client: ${clientName}`);
+        return client;
+    }
+    getClient(name) {
+        const client = this.clients.get(name);
+        if (!client) {
+            throw new Error(`API client '${name}' not found. Available clients: ${Array.from(this.clients.keys()).join(', ')}`);
+        }
+        return client;
+    }
+    listClients() {
+        return Array.from(this.clients.keys());
+    }
+    updateClient(name, config) {
+        const existingConfig = this.clientConfigs.get(name);
+        if (!existingConfig) {
+            throw new Error(`API client '${name}' not found`);
+        }
+        const updatedConfig = Object.assign(Object.assign({}, existingConfig), config);
+        this.clientConfigs.set(name, updatedConfig);
+        this.createClient(Object.assign(Object.assign({}, updatedConfig), { name, override: true }));
+        this.logger.log(`Updated API client: ${name}`);
+    }
+    removeClient(name) {
+        const removed = this.clients.delete(name);
+        this.clientConfigs.delete(name);
+        if (removed) {
+            this.logger.log(`Removed API client: ${name}`);
+        }
+    }
+    getClientConfig(name) {
+        return this.clientConfigs.get(name);
+    }
+    getAllClientConfigs() {
+        const configs = {};
+        this.clientConfigs.forEach((config, name) => {
+            configs[name] = config;
+        });
+        return configs;
+    }
+    createClients(configs) {
+        configs.forEach((config) => {
+            try {
+                this.createClient(config);
+            }
+            catch (error) {
+                this.logger.error(`Failed to create client '${config.name}':`, error);
+            }
+        });
+    }
+    getGlobalConfig() {
+        return this.globalDefaults;
+    }
+    updateGlobalConfig(config) {
+        Object.assign(this.globalDefaults, config);
+        this.logger.log('Global configuration updated');
+    }
+    getAllStats() {
+        const stats = {};
+        this.clients.forEach((client, name) => {
+            stats[name] = client.getStats();
+        });
+        return stats;
+    }
+    resetAllStats() {
+        this.clients.forEach((client) => {
+            client.resetStats();
+        });
+    }
+    healthCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = {};
+            let overallStatus = 'healthy';
+            for (const [name, client] of this.clients.entries()) {
+                try {
+                    client.getStats();
+                    results[name] = { status: 'healthy' };
+                }
+                catch (error) {
+                    results[name] = { status: 'unhealthy', error: error.message };
+                    overallStatus = 'unhealthy';
+                }
+            }
+            return {
+                status: overallStatus,
+                clients: results,
+            };
+        });
+    }
+    createAxiosInstance(config) {
+        var _a, _b, _c, _d, _e, _f;
+        const axiosConfig = {
+            baseURL: config.baseURL,
+            timeout: ((_a = config.httpConfig) === null || _a === void 0 ? void 0 : _a.timeout) || 30000,
+            headers: Object.assign({ 'Content-Type': 'application/json', 'User-Agent': `${config.name}/1.0.0` }, config.defaultHeaders),
+            params: config.defaultParams,
+        };
+        const instance = axios_1.default.create(axiosConfig);
+        const clientName = config.name;
+        instance.interceptors.request.use((config) => {
+            const authenticatedConfig = config;
+            if (config.auth) {
+                switch (config.auth.type) {
+                    case api_client_config_interface_1.AuthType.BEARER_TOKEN:
+                        const bearerConfig = config.auth.config;
+                        authenticatedConfig.headers = authenticatedConfig.headers || {};
+                        authenticatedConfig.headers['Authorization'] =
+                            `Bearer ${bearerConfig.token}`;
+                        break;
+                    case api_client_config_interface_1.AuthType.API_KEY:
+                        const apiKeyConfig = config.auth.config;
+                        if (apiKeyConfig.location === 'header') {
+                            const headerName = apiKeyConfig.name || 'X-API-Key';
+                            const value = apiKeyConfig.prefix
+                                ? `${apiKeyConfig.prefix} ${apiKeyConfig.key}`
+                                : apiKeyConfig.key;
+                            authenticatedConfig.headers = authenticatedConfig.headers || {};
+                            authenticatedConfig.headers[headerName] = value;
+                        }
+                        break;
+                }
+            }
+            const context = context_extractor_util_1.ContextExtractor.getHttpContext();
+            const requestId = context.requestId || (0, utils_1.generateRequestId)();
+            authenticatedConfig.headers = authenticatedConfig.headers || {};
+            authenticatedConfig.headers['X-Request-ID'] = requestId;
+            if (context.userId) {
+                authenticatedConfig.headers['X-User-ID'] = context.userId;
+            }
+            authenticatedConfig.headers['X-API-Client'] = clientName;
+            return authenticatedConfig;
+        }, (error) => {
+            this.logger.error(`[${clientName}] Request interceptor error`, error);
+            return Promise.reject(error);
+        });
+        instance.interceptors.response.use((response) => {
+            return this.applyResponseTransformer(response, config.responseTransformer);
+        }, (error) => {
+            var _a;
+            if ((_a = config.responseTransformer) === null || _a === void 0 ? void 0 : _a.error) {
+                return config.responseTransformer.error(error);
+            }
+            return Promise.reject(error);
+        });
+        if (((_b = config.retry) === null || _b === void 0 ? void 0 : _b.enabled) !== false &&
+            this.globalDefaults.enableGlobalRetry) {
+            (0, axios_retry_1.default)(instance, {
+                retries: ((_c = config.retry) === null || _c === void 0 ? void 0 : _c.retries) ||
+                    ((_e = (_d = this.globalDefaults.globalDefaults) === null || _d === void 0 ? void 0 : _d.retry) === null || _e === void 0 ? void 0 : _e.retries) ||
+                    3,
+                retryDelay: (retryCount) => Math.pow(2, retryCount) * 1000,
+                retryCondition: ((_f = config.retry) === null || _f === void 0 ? void 0 : _f.retryCondition) ||
+                    ((error) => {
+                        if (!error.response)
+                            return true;
+                        const status = error.response.status;
+                        return status >= 500 || status === 429;
+                    }),
+                shouldResetTimeout: true,
+                onRetry: (retryCount, error, requestConfig) => {
+                    var _a;
+                    this.logger.warn(`[${config.name}] Retrying request (attempt ${retryCount}): ${(_a = requestConfig.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()} ${requestConfig.url}`);
+                },
+            });
+        }
+        return instance;
+    }
+    applyAuthentication(config, auth) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!auth) {
+                return config;
+            }
+            const authenticatedConfig = Object.assign({}, config);
+            switch (auth.type) {
+                case api_client_config_interface_1.AuthType.NONE:
+                    break;
+                case api_client_config_interface_1.AuthType.API_KEY:
+                    const apiKeyConfig = auth.config;
+                    if (apiKeyConfig.location === 'header') {
+                        const headerName = apiKeyConfig.name || 'X-API-Key';
+                        const value = apiKeyConfig.prefix
+                            ? `${apiKeyConfig.prefix} ${apiKeyConfig.key}`
+                            : apiKeyConfig.key;
+                        authenticatedConfig.headers = Object.assign(Object.assign({}, authenticatedConfig.headers), { [headerName]: value });
+                    }
+                    else if (apiKeyConfig.location === 'query') {
+                        const paramName = apiKeyConfig.name || 'api_key';
+                        authenticatedConfig.params = Object.assign(Object.assign({}, authenticatedConfig.params), { [paramName]: apiKeyConfig.key });
+                    }
+                    break;
+                case api_client_config_interface_1.AuthType.BEARER_TOKEN:
+                    const bearerConfig = auth.config;
+                    const scheme = bearerConfig.scheme || 'Bearer';
+                    authenticatedConfig.headers = Object.assign(Object.assign({}, authenticatedConfig.headers), { Authorization: `${scheme} ${bearerConfig.token}` });
+                    break;
+                case api_client_config_interface_1.AuthType.BASIC_AUTH:
+                    const basicConfig = auth.config;
+                    const credentials = Buffer.from(`${basicConfig.username}:${basicConfig.password}`).toString('base64');
+                    authenticatedConfig.headers = Object.assign(Object.assign({}, authenticatedConfig.headers), { Authorization: `Basic ${credentials}` });
+                    break;
+                case api_client_config_interface_1.AuthType.OAUTH2:
+                    const oauthConfig = auth.config;
+                    authenticatedConfig.headers = Object.assign(Object.assign({}, authenticatedConfig.headers), { Authorization: `Bearer ${oauthConfig.clientSecret}` });
+                    break;
+                case api_client_config_interface_1.AuthType.CUSTOM:
+                    const customConfig = auth.config;
+                    return yield customConfig.authenticator(authenticatedConfig);
+            }
+            return authenticatedConfig;
+        });
+    }
+    applyResponseTransformer(response, transformer) {
+        if (!transformer) {
+            return response;
+        }
+        if (transformer.success) {
+            response.data = transformer.success(response);
+        }
+        if (transformer.dataPath) {
+            response.data = this.extractDataByPath(response.data, transformer.dataPath);
+        }
+        if (transformer.validateResponse && transformer.validator) {
+            if (!transformer.validator(response.data)) {
+                throw new Error(`Response validation failed for ${transformer.dataPath}`);
+            }
+        }
+        return response;
+    }
+    extractDataByPath(data, path) {
+        const keys = path.split('.');
+        let current = data;
+        for (const key of keys) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            current = current[key];
+        }
+        return current;
+    }
+    mergeEnvironmentConfig(config) {
+        var _a;
+        const env = process.env.NODE_ENV || 'development';
+        const environmentConfig = ((_a = config.environments) === null || _a === void 0 ? void 0 : _a[env]) || {};
+        return Object.assign(Object.assign({}, config), environmentConfig);
+    }
+};
+exports.ApiClientRegistryService = ApiClientRegistryService;
+exports.ApiClientRegistryService = ApiClientRegistryService = ApiClientRegistryService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [http_client_service_1.HttpClientService,
+        circuit_breaker_service_1.HttpCircuitBreakerService,
+        logging_service_1.HttpLoggingService,
+        cache_service_1.HttpCacheService, Object])
+], ApiClientRegistryService);
+class ApiClientInstance {
+    constructor(name, config, axiosInstance, httpClientService, loggingService, cacheService) {
+        this.name = name;
+        this.config = config;
+        this.axiosInstance = axiosInstance;
+        this.httpClientService = httpClientService;
+        this.loggingService = loggingService;
+        this.cacheService = cacheService;
+        this.stats = {
+            totalRequests: 0,
+            successfulRequests: 0,
+            failedRequests: 0,
+            totalResponseTime: 0,
+            averageResponseTime: 0,
+        };
+    }
+    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 }));
+        });
+    }
+    request(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            this.stats.totalRequests++;
+            try {
+                const response = yield this.axiosInstance.request(config);
+                const responseTime = Date.now() - startTime;
+                this.updateStats(true, responseTime);
+                return response.data;
+            }
+            catch (error) {
+                const responseTime = Date.now() - startTime;
+                this.updateStats(false, responseTime);
+                throw error;
+            }
+        });
+    }
+    getStats() {
+        return Object.assign({}, this.stats);
+    }
+    resetStats() {
+        this.stats.totalRequests = 0;
+        this.stats.successfulRequests = 0;
+        this.stats.failedRequests = 0;
+        this.stats.totalResponseTime = 0;
+        this.stats.averageResponseTime = 0;
+    }
+    updateStats(success, responseTime) {
+        if (success) {
+            this.stats.successfulRequests++;
+        }
+        else {
+            this.stats.failedRequests++;
+        }
+        this.stats.totalResponseTime += responseTime;
+        this.stats.averageResponseTime =
+            this.stats.totalResponseTime / this.stats.totalRequests;
+        if (this.config.responseTimeWarningThreshold &&
+            responseTime > this.config.responseTimeWarningThreshold) {
+            console.warn(`[API Client ${this.name}] Slow response detected: ${responseTime}ms for ${this.axiosInstance.defaults.baseURL}`);
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { HttpCacheConfig } from '../interfaces/http-client-config.interface';
+import { CacheService } from '../../cache/cache.service';
+export declare class HttpCacheService {
+    private readonly cacheService;
+    private readonly logger;
+    constructor(cacheService: CacheService);
+    get(config: AxiosRequestConfig, cacheOptions: HttpCacheConfig): Promise<AxiosResponse | null>;
+    set(config: AxiosRequestConfig, response: AxiosResponse, cacheOptions: HttpCacheConfig): Promise<void>;
+    clear(pattern?: string): Promise<void>;
+    getStats(): Promise<any>;
+    cleanup(): Promise<void>;
+    warmup(urls: string[], headers?: Record<string, string>): Promise<void>;
+    getDetailedStats(): Promise<any>;
+    private generateCacheKey;
+    private buildCacheKey;
+    private mapLayers;
+    private selectHeadersForCacheKey;
+    private isResponseCacheable;
+    private hashObject;
+    private calculateHitRate;
+    private getRecentCacheActivity;
+    private generateRecommendations;
+}