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

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,40 @@
+import { ApiClientConfig, ApiClientInstanceConfig, ApiClientRegistryConfig } 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 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;
+}