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

package/http-client/http-client.module.d.ts

@@ -0,0 +1,11 @@
+import { DynamicModule } from '@nestjs/common';
+import { HttpClientConfig } from './interfaces/http-client-config.interface';
+export declare class HttpClientModule {
+    static forRoot(config?: HttpClientConfig): DynamicModule;
+    static forRootAsync(config: {
+        useFactory: (...args: any[]) => Promise<HttpClientConfig> | HttpClientConfig;
+        inject?: any[];
+        imports?: any[];
+    }): DynamicModule;
+    private static loadConfigFromEnvironment;
+}

package/http-client/http-client.module.js

@@ -0,0 +1,257 @@
+"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 HttpClientModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientModule = void 0;
+const common_1 = require("@nestjs/common");
+const schedule_1 = require("@nestjs/schedule");
+const config_1 = require("@nestjs/config");
+const typeorm_1 = require("@nestjs/typeorm");
+const cache_service_1 = require("../cache/cache.service");
+const http_client_service_1 = require("./services/http-client.service");
+const circuit_breaker_service_1 = require("./services/circuit-breaker.service");
+const logging_service_1 = require("./services/logging.service");
+const cache_service_2 = require("./services/cache.service");
+const http_log_query_service_1 = require("./services/http-log-query.service");
+const log_cleanup_service_1 = require("./services/log-cleanup.service");
+const api_client_registry_service_1 = require("./services/api-client-registry.service");
+const entities_1 = require("./entities");
+const cache_options_interface_1 = require("../cache/interfaces/cache-options.interface");
+const redis_lock_service_1 = require("../redis-lock/redis-lock.service");
+let HttpClientModule = HttpClientModule_1 = class HttpClientModule {
+    static forRoot(config = {}) {
+        var _a, _b, _c;
+        const baseProviders = [
+            {
+                provide: 'HTTP_CLIENT_CONFIG',
+                useFactory: (configService, cacheService) => {
+                    const envConfig = this.loadConfigFromEnvironment(configService);
+                    return Object.assign(Object.assign({}, config), envConfig);
+                },
+                inject: [config_1.ConfigService, cache_service_1.CacheService],
+            },
+            circuit_breaker_service_1.HttpCircuitBreakerService,
+            logging_service_1.HttpLoggingService,
+            cache_service_2.HttpCacheService,
+            http_log_query_service_1.HttpLogQueryService,
+            log_cleanup_service_1.HttpLogCleanupService,
+            api_client_registry_service_1.ApiClientRegistryService,
+            {
+                provide: http_client_service_1.HttpClientService,
+                useFactory: (circuitBreakerService, loggingService, cacheService, redisLockService, httpConfig) => {
+                    return new http_client_service_1.HttpClientService(circuitBreakerService, loggingService, cacheService, redisLockService, httpConfig);
+                },
+                inject: [
+                    circuit_breaker_service_1.HttpCircuitBreakerService,
+                    logging_service_1.HttpLoggingService,
+                    cache_service_2.HttpCacheService,
+                    redis_lock_service_1.RedisLockService,
+                    'HTTP_CLIENT_CONFIG',
+                ],
+            },
+        ];
+        const baseExports = [
+            http_client_service_1.HttpClientService,
+            circuit_breaker_service_1.HttpCircuitBreakerService,
+            logging_service_1.HttpLoggingService,
+            cache_service_2.HttpCacheService,
+            http_log_query_service_1.HttpLogQueryService,
+            log_cleanup_service_1.HttpLogCleanupService,
+            api_client_registry_service_1.ApiClientRegistryService,
+        ];
+        const dynamicImports = [config_1.ConfigModule];
+        if ((_b = (_a = config.logging) === null || _a === void 0 ? void 0 : _a.databaseLogging) === null || _b === void 0 ? void 0 : _b.enabled) {
+            dynamicImports.push(typeorm_1.TypeOrmModule.forFeature([entities_1.HttpLogEntity]));
+        }
+        if ((_c = config.logCleanup) === null || _c === void 0 ? void 0 : _c.enabled) {
+            dynamicImports.push(schedule_1.ScheduleModule.forRoot());
+        }
+        return {
+            module: HttpClientModule_1,
+            imports: dynamicImports,
+            providers: baseProviders,
+            exports: baseExports,
+        };
+    }
+    static forRootAsync(config) {
+        const baseProviders = [
+            {
+                provide: 'HTTP_CLIENT_CONFIG',
+                useFactory: (...args) => __awaiter(this, void 0, void 0, function* () {
+                    const userConfig = yield config.useFactory(...args);
+                    const envConfig = this.loadConfigFromEnvironment(args[0]);
+                    return Object.assign(Object.assign({}, userConfig), envConfig);
+                }),
+                inject: config.inject || [config_1.ConfigService],
+            },
+            circuit_breaker_service_1.HttpCircuitBreakerService,
+            logging_service_1.HttpLoggingService,
+            cache_service_2.HttpCacheService,
+            http_log_query_service_1.HttpLogQueryService,
+            log_cleanup_service_1.HttpLogCleanupService,
+            api_client_registry_service_1.ApiClientRegistryService,
+            {
+                provide: http_client_service_1.HttpClientService,
+                useFactory: (circuitBreakerService, loggingService, cacheService, redisLockService, httpConfig) => {
+                    return new http_client_service_1.HttpClientService(circuitBreakerService, loggingService, cacheService, redisLockService, httpConfig);
+                },
+                inject: [
+                    circuit_breaker_service_1.HttpCircuitBreakerService,
+                    logging_service_1.HttpLoggingService,
+                    cache_service_2.HttpCacheService,
+                    redis_lock_service_1.RedisLockService,
+                    'HTTP_CLIENT_CONFIG',
+                ],
+            },
+        ];
+        const baseExports = [
+            http_client_service_1.HttpClientService,
+            circuit_breaker_service_1.HttpCircuitBreakerService,
+            logging_service_1.HttpLoggingService,
+            cache_service_2.HttpCacheService,
+            http_log_query_service_1.HttpLogQueryService,
+            log_cleanup_service_1.HttpLogCleanupService,
+            api_client_registry_service_1.ApiClientRegistryService,
+        ];
+        const dynamicImports = [config_1.ConfigModule, ...(config.imports || [])];
+        return {
+            module: HttpClientModule_1,
+            imports: dynamicImports,
+            providers: baseProviders,
+            exports: baseExports,
+        };
+    }
+    static loadConfigFromEnvironment(configService) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        return {
+            baseURL: configService.get('HTTP_CLIENT_BASE_URL'),
+            timeout: configService.get('HTTP_CLIENT_TIMEOUT')
+                ? parseInt(configService.get('HTTP_CLIENT_TIMEOUT'))
+                : undefined,
+            retry: {
+                enabled: configService.get('HTTP_CLIENT_RETRY_ENABLED') === 'true',
+                retries: configService.get('HTTP_CLIENT_RETRY_RETRIES')
+                    ? parseInt(configService.get('HTTP_CLIENT_RETRY_RETRIES'))
+                    : undefined,
+                retryDelay: configService.get('HTTP_CLIENT_RETRY_DELAY_STRATEGY') ===
+                    'exponential'
+                    ? (retryCount) => Math.pow(2, retryCount) * 1000
+                    : undefined,
+                retryCondition: configService.get('HTTP_CLIENT_RETRY_CONDITION') ===
+                    'network_only'
+                    ? (error) => !error.response
+                    : undefined,
+                shouldResetTimeout: configService.get('HTTP_CLIENT_RETRY_RESET_TIMEOUT') !==
+                    'false',
+            },
+            circuitBreaker: {
+                enabled: configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_ENABLED') ===
+                    'true',
+                failureThreshold: configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_FAILURE_THRESHOLD')
+                    ? parseInt(configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_FAILURE_THRESHOLD'))
+                    : 5,
+                recoveryTimeoutMs: configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_RECOVERY_TIMEOUT')
+                    ? parseInt(configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_RECOVERY_TIMEOUT'))
+                    : 60000,
+                monitoringPeriodMs: configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_MONITORING_PERIOD')
+                    ? parseInt(configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_MONITORING_PERIOD'))
+                    : 10000,
+                minimumThroughputThreshold: configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_MINIMUM_THROUGHPUT')
+                    ? parseInt(configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_MINIMUM_THROUGHPUT'))
+                    : 10,
+                countHalfOpenCalls: configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_COUNT_HALF_OPEN') === 'true',
+            },
+            cache: {
+                enabled: configService.get('HTTP_CLIENT_CACHE_ENABLED') !== 'false',
+                defaultTtl: configService.get('HTTP_CLIENT_CACHE_DEFAULT_TTL')
+                    ? parseInt(configService.get('HTTP_CLIENT_CACHE_DEFAULT_TTL'))
+                    : 300000,
+                cacheableMethods: ((_b = (_a = configService
+                    .get('HTTP_CLIENT_CACHEABLE_METHODS')) === null || _a === void 0 ? void 0 : _a.split(',')) === null || _b === void 0 ? void 0 : _b.map((method) => method.trim().toUpperCase())) || [
+                    'GET',
+                    'HEAD',
+                ],
+                cacheableStatusCodes: ((_d = (_c = configService
+                    .get('HTTP_CLIENT_CACHEABLE_STATUS_CODES')) === null || _c === void 0 ? void 0 : _c.split(',')) === null || _d === void 0 ? void 0 : _d.map((code) => parseInt(code.trim()))) || [200, 201, 304],
+                options: {
+                    layers: ((_f = (_e = configService
+                        .get('HTTP_CLIENT_CACHE_LAYERS')) === null || _e === void 0 ? void 0 : _e.split(',')) === null || _f === void 0 ? void 0 : _f.map((layer) => {
+                        const trimmed = layer.trim();
+                        switch (trimmed) {
+                            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;
+                        }
+                    })) || [cache_options_interface_1.CacheLayer.MEMORY],
+                },
+            },
+            logging: {
+                enabled: configService.get('HTTP_CLIENT_LOGGING_ENABLED') !== 'false',
+                logRequests: configService.get('HTTP_CLIENT_LOG_REQUESTS') !== 'false',
+                logResponses: configService.get('HTTP_CLIENT_LOG_RESPONSES') !== 'false',
+                logErrors: configService.get('HTTP_CLIENT_LOG_ERRORS') !== 'false',
+                logHeaders: configService.get('HTTP_CLIENT_LOG_HEADERS') !== 'false',
+                logBody: configService.get('HTTP_CLIENT_LOG_BODY') !== 'false',
+                maxBodyLength: configService.get('HTTP_CLIENT_LOG_MAX_BODY_LENGTH')
+                    ? parseInt(configService.get('HTTP_CLIENT_LOG_MAX_BODY_LENGTH'))
+                    : undefined,
+                sanitizeHeaders: (_g = configService
+                    .get('HTTP_CLIENT_LOG_SANITIZE_HEADERS')) === null || _g === void 0 ? void 0 : _g.split(','),
+                logLevel: configService.get('HTTP_CLIENT_LOG_LEVEL'),
+                databaseLogging: {
+                    enabled: configService.get('HTTP_CLIENT_DB_LOGGING_ENABLED') ===
+                        'true',
+                    dataSource: configService.get('HTTP_CLIENT_DB_LOGGING_DATA_SOURCE') ||
+                        'default',
+                    tableName: configService.get('HTTP_CLIENT_DB_LOGGING_TABLE_NAME') ||
+                        'http_logs',
+                },
+            },
+            proxy: {
+                enabled: configService.get('HTTP_CLIENT_PROXY_ENABLED') === 'true',
+                host: configService.get('HTTP_CLIENT_PROXY_HOST'),
+                port: configService.get('HTTP_CLIENT_PROXY_PORT')
+                    ? parseInt(configService.get('HTTP_CLIENT_PROXY_PORT'))
+                    : undefined,
+                protocol: configService.get('HTTP_CLIENT_PROXY_PROTOCOL'),
+            },
+            logCleanup: {
+                enabled: configService.get('HTTP_CLIENT_LOG_CLEANUP_ENABLED') ===
+                    'true',
+                retentionDays: configService.get('HTTP_CLIENT_LOG_CLEANUP_RETENTION_DAYS')
+                    ? parseInt(configService.get('HTTP_CLIENT_LOG_CLEANUP_RETENTION_DAYS'))
+                    : 30,
+                maxRecords: configService.get('HTTP_CLIENT_LOG_CLEANUP_MAX_RECORDS'),
+                batchSize: configService.get('HTTP_CLIENT_LOG_CLEANUP_BATCH_SIZE')
+                    ? parseInt(configService.get('HTTP_CLIENT_LOG_CLEANUP_BATCH_SIZE'))
+                    : 1000,
+                schedule: configService.get('HTTP_CLIENT_LOG_CLEANUP_SCHEDULE') || '0 2 * * *',
+                strategy: configService.get('HTTP_CLIENT_LOG_CLEANUP_STRATEGY') || 'retention',
+            },
+        };
+    }
+};
+exports.HttpClientModule = HttpClientModule;
+exports.HttpClientModule = HttpClientModule = HttpClientModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], HttpClientModule);

package/http-client/index.d.ts

@@ -0,0 +1,10 @@
+export { HttpClientConfig, RetryConfig, CircuitBreakerConfig, HttpCacheConfig, ProxyConfig, LoggingConfig, InterceptorConfig, ConnectionPoolConfig, HttpContext, HttpInterceptor, HttpMethod, HttpStats, } from './interfaces/http-client-config.interface';
+export * from './interfaces/api-client-config.interface';
+export { HttpLogEntity, RetryRecord } from './entities';
+export * from './decorators';
+export * from './services';
+export * from './utils';
+export * from './errors';
+export * from './config';
+export * from './http-client.module';
+export * from './examples';

package/http-client/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpLogEntity = void 0;
+__exportStar(require("./interfaces/api-client-config.interface"), exports);
+var entities_1 = require("./entities");
+Object.defineProperty(exports, "HttpLogEntity", { enumerable: true, get: function () { return entities_1.HttpLogEntity; } });
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./http-client.module"), exports);
+__exportStar(require("./examples"), exports);

package/http-client/interfaces/api-client-config.interface.d.ts

@@ -0,0 +1,152 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { HttpClientConfig } from './http-client-config.interface';
+export declare enum AuthType {
+    NONE = "none",
+    API_KEY = "apiKey",
+    BEARER_TOKEN = "bearer",
+    BASIC_AUTH = "basic",
+    OAUTH2 = "oauth2",
+    CUSTOM = "custom"
+}
+export interface ApiKeyConfig {
+    key: string;
+    location: 'header' | 'query';
+    name?: string;
+    prefix?: string;
+}
+export interface BearerTokenConfig {
+    token: string;
+    scheme?: string;
+}
+export interface BasicAuthConfig {
+    username: string;
+    password: string;
+}
+export interface OAuth2Config {
+    clientId: string;
+    clientSecret: string;
+    tokenUrl: string;
+    scopes?: string[];
+    grantType?: 'client_credentials' | 'password' | 'authorization_code';
+    username?: string;
+    password?: string;
+    redirectUri?: string;
+    refreshToken?: string;
+}
+export interface CustomAuthConfig {
+    authenticator: (config: AxiosRequestConfig) => Promise<AxiosRequestConfig>;
+    refresher?: (config: AxiosRequestConfig, error: any) => Promise<AxiosRequestConfig>;
+}
+export type AuthConfig = {
+    type: AuthType.NONE;
+} | {
+    type: AuthType.API_KEY;
+    config: ApiKeyConfig;
+} | {
+    type: AuthType.BEARER_TOKEN;
+    config: BearerTokenConfig;
+} | {
+    type: AuthType.BASIC_AUTH;
+    config: BasicAuthConfig;
+} | {
+    type: AuthType.OAUTH2;
+    config: OAuth2Config;
+} | {
+    type: AuthType.CUSTOM;
+    config: CustomAuthConfig;
+};
+export interface ResponseTransformerConfig {
+    success?: (response: AxiosResponse) => any;
+    error?: (error: any) => any;
+    dataPath?: string;
+    errorPath?: string;
+    validateResponse?: boolean;
+    validator?: (data: any) => boolean;
+}
+export interface ApiClientConfig {
+    name: string;
+    baseURL: string;
+    httpConfig?: HttpClientConfig;
+    auth?: AuthConfig;
+    responseTransformer?: ResponseTransformerConfig;
+    defaultHeaders?: Record<string, string>;
+    defaultParams?: Record<string, any>;
+    interceptors?: {
+        request?: Array<(config: AxiosRequestConfig) => AxiosRequestConfig | Promise<AxiosRequestConfig>>;
+        response?: Array<(response: AxiosResponse) => AxiosResponse | Promise<AxiosResponse>>;
+        error?: Array<(error: any) => any>;
+    };
+    retry?: {
+        enabled?: boolean;
+        retries?: number;
+        retryCondition?: (error: any) => boolean;
+    };
+    enableValidation?: boolean;
+    responseTimeWarningThreshold?: number;
+    tags?: string[];
+    enableDetailedLogging?: boolean;
+}
+export interface ApiClientInstanceConfig extends ApiClientConfig {
+    override?: boolean;
+    environments?: {
+        development?: Partial<ApiClientConfig>;
+        staging?: Partial<ApiClientConfig>;
+        production?: Partial<ApiClientConfig>;
+    };
+}
+export interface ApiClientRegistryConfig {
+    globalDefaults?: Partial<HttpClientConfig>;
+    logCleanup?: {
+        enabled?: boolean;
+        retentionDays?: number;
+        maxRecords?: number;
+    };
+    defaultResponseTransformer?: ResponseTransformerConfig;
+    enableGlobalRetry?: boolean;
+    enableCircuitBreaker?: boolean;
+}
+export interface ApiClientFactory {
+    createClient<T = any>(config: ApiClientInstanceConfig): T;
+    getClient<T = any>(name: string): T;
+    listClients(): string[];
+    updateClient(name: string, config: Partial<ApiClientConfig>): void;
+    removeClient(name: string): void;
+}
+export interface ApiClient {
+    name: string;
+    config: ApiClientConfig;
+    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>;
+    request<T = any>(config: AxiosRequestConfig): Promise<T>;
+    getStats(): any;
+    resetStats(): void;
+}
+export interface ApiResponse<T = any> {
+    data?: T;
+    code?: number;
+    message?: string;
+    success?: boolean;
+    error?: {
+        code?: string;
+        message?: string;
+        details?: any;
+    };
+    pagination?: {
+        page?: number;
+        pageSize?: number;
+        total?: number;
+        totalPages?: number;
+    };
+    requestId?: string;
+    timestamp?: string;
+}
+export interface ErrorResponse {
+    code: string | number;
+    message: string;
+    details?: any;
+    stack?: string;
+    requestId?: string;
+}

package/http-client/interfaces/api-client-config.interface.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthType = void 0;
+var AuthType;
+(function (AuthType) {
+    AuthType["NONE"] = "none";
+    AuthType["API_KEY"] = "apiKey";
+    AuthType["BEARER_TOKEN"] = "bearer";
+    AuthType["BASIC_AUTH"] = "basic";
+    AuthType["OAUTH2"] = "oauth2";
+    AuthType["CUSTOM"] = "custom";
+})(AuthType || (exports.AuthType = AuthType = {}));

package/http-client/interfaces/http-client-config.interface.d.ts

@@ -0,0 +1,123 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { CacheOptions } from '../../cache/interfaces/cache-options.interface';
+import { LogCleanupConfig } from '../services/log-cleanup.service';
+export interface HttpClientConfig {
+    baseURL?: string;
+    timeout?: number;
+    retry?: RetryConfig;
+    circuitBreaker?: CircuitBreakerConfig;
+    cache?: HttpCacheConfig;
+    proxy?: ProxyConfig;
+    logging?: LoggingConfig;
+    logCleanup?: LogCleanupConfig;
+    interceptors?: InterceptorConfig;
+    connectionPool?: ConnectionPoolConfig;
+}
+export interface RetryConfig {
+    enabled: boolean;
+    retries?: number;
+    retryDelay?: (retryCount: number) => number;
+    retryCondition?: (error: any) => boolean;
+    shouldResetTimeout?: boolean;
+    onRetry?: (retryCount: number, error: any, requestConfig: AxiosRequestConfig) => void;
+}
+export interface CircuitBreakerConfig {
+    enabled: boolean;
+    failureThreshold: number;
+    recoveryTimeoutMs: number;
+    monitoringPeriodMs: number;
+    minimumThroughputThreshold: number;
+    countHalfOpenCalls: boolean;
+}
+export interface HttpCacheConfig {
+    enabled: boolean;
+    options?: Omit<CacheOptions, 'ttl' | 'namespace'>;
+    defaultTtl?: number;
+    cacheableMethods: string[];
+    cacheableStatusCodes: number[];
+    keyGenerator?: (config: AxiosRequestConfig) => string;
+}
+export interface ProxyConfig {
+    enabled: boolean;
+    host?: string;
+    port?: number;
+    protocol?: 'http' | 'https';
+    auth?: {
+        username: string;
+        password: string;
+    };
+}
+export interface LoggingConfig {
+    enabled: boolean;
+    logRequests: boolean;
+    logResponses: boolean;
+    logErrors: boolean;
+    logHeaders: boolean;
+    logBody: boolean;
+    maxBodyLength: number;
+    sanitizeHeaders: string[];
+    logLevel: 'debug' | 'info' | 'warn' | 'error';
+    databaseLogging?: {
+        enabled: boolean;
+        dataSource: string;
+        tableName: string;
+    };
+}
+export interface InterceptorConfig {
+    requestInterceptors: string[];
+    responseInterceptors: string[];
+    errorInterceptors: string[];
+}
+export interface ConnectionPoolConfig {
+    enabled: boolean;
+    maxSockets: number;
+    maxFreeSockets: number;
+    timeoutMs: number;
+    keepAlive: boolean;
+}
+export interface HttpContext {
+    requestId: string;
+    startTime: number;
+    attemptCount: number;
+    parentRequestId?: string;
+    traceId?: string;
+    userId?: string;
+    correlationId?: string;
+    metadata: Record<string, any>;
+}
+export interface HttpLogEntity {
+    id: string;
+    requestId: string;
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: string;
+    statusCode?: number;
+    responseTime: number;
+    attemptCount: number;
+    success: boolean;
+    errorMessage?: string;
+    userId?: string;
+    timestamp: Date;
+    metadata: Record<string, any>;
+}
+export interface HttpInterceptor {
+    name: string;
+    order: number;
+    intercept(request: AxiosRequestConfig, next: () => Promise<AxiosResponse>): Promise<AxiosResponse>;
+}
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+export interface HttpStats {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    averageResponseTime: number;
+    requestsByMethod: Record<HttpMethod, number>;
+    requestsByStatus: Record<number, number>;
+    circuitBreakerStats: Record<string, any>;
+    cacheStats: {
+        hits: number;
+        misses: number;
+        hitRate: number;
+    };
+}

package/http-client/interfaces/http-client-config.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,41 @@
+import { ApiClientConfig, ApiClientInstanceConfig, ApiClientRegistryConfig, AuthType, OAuth2Config, ResponseTransformerConfig } from '../interfaces/api-client-config.interface';
+import { HttpClientService } from './http-client.service';
+import { HttpCircuitBreakerService } from './circuit-breaker.service';
+import { HttpLoggingService } from './logging.service';
+import { HttpCacheService } from './cache.service';
+export { ApiClientInstanceConfig, AuthType, OAuth2Config, ResponseTransformerConfig, };
+export declare class ApiClientRegistryService {
+    private readonly httpClientService;
+    private readonly circuitBreakerService;
+    private readonly loggingService;
+    private readonly cacheService;
+    private readonly logger;
+    private readonly clients;
+    private readonly clientConfigs;
+    private readonly globalDefaults;
+    constructor(httpClientService: HttpClientService, circuitBreakerService: HttpCircuitBreakerService, loggingService: HttpLoggingService, cacheService: HttpCacheService, globalConfig?: ApiClientRegistryConfig);
+    createClient<T = any>(config: ApiClientInstanceConfig): T;
+    getClient<T = any>(name: string): T;
+    listClients(): string[];
+    updateClient(name: string, config: Partial<ApiClientConfig>): void;
+    removeClient(name: string): void;
+    getClientConfig(name: string): ApiClientConfig | undefined;
+    getAllClientConfigs(): Record<string, ApiClientConfig>;
+    createClients(configs: ApiClientInstanceConfig[]): void;
+    getGlobalConfig(): ApiClientRegistryConfig;
+    updateGlobalConfig(config: Partial<ApiClientRegistryConfig>): void;
+    getAllStats(): Record<string, any>;
+    resetAllStats(): void;
+    healthCheck(): Promise<{
+        status: 'healthy' | 'unhealthy';
+        clients: Record<string, {
+            status: 'healthy' | 'unhealthy';
+            error?: string;
+        }>;
+    }>;
+    private createAxiosInstance;
+    private applyAuthentication;
+    private applyResponseTransformer;
+    private extractDataByPath;
+    private mergeEnvironmentConfig;
+}