@naman_deep_singh/communication-core 1.0.0

package/dist/types/abstract/BaseCompressionManager.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Abstract base compression manager implementation
+ * @packageDocumentation
+ */
+import type { ICompressionManager, CompressionAlgorithm, CompressionOptions, CompressionResult, DecompressionResult } from '../interfaces/Compression.interface.js';
+import type { CompressionConfig } from '../types/config.js';
+/**
+ * Abstract base compression manager implementation
+ * Provides common functionality for compression management
+ */
+export declare abstract class BaseCompressionManager implements ICompressionManager {
+    /** Compression manager name */
+    readonly name: string;
+    /** Compression configuration */
+    config: CompressionConfig;
+    /** Supported algorithms */
+    readonly supportedAlgorithms: CompressionAlgorithm[];
+    /** Compression statistics */
+    protected stats: {
+        totalCompressions: number;
+        totalDecompressions: number;
+        compressionErrors: number;
+        decompressionErrors: number;
+        totalCompressionTime: number;
+        totalDecompressionTime: number;
+        totalOriginalSize: number;
+        totalCompressedSize: number;
+        totalDecompressedSize: number;
+        averageCompressionTime: number;
+        averageDecompressionTime: number;
+        averageCompressionRatio: number;
+        algorithmUsage: Record<string, number>;
+    };
+    /**
+     * Create a new base compression manager instance
+     * @param name Compression manager name
+     * @param config Compression configuration
+     */
+    constructor(name: string, config: CompressionConfig);
+    /**
+     * Initialize compression manager
+     */
+    protected initialize(): void;
+    /**
+     * Detect supported compression algorithms
+     * @returns Array of supported algorithms
+     */
+    protected abstract detectSupportedAlgorithms(): CompressionAlgorithm[];
+    /**
+     * Compress data using specific algorithm
+     * @param data Data to compress
+     * @param algorithm Compression algorithm
+     * @param level Compression level
+     * @returns Compressed data
+     */
+    protected abstract compressData(data: Buffer | Uint8Array, algorithm: CompressionAlgorithm, level: number): Promise<Buffer | Uint8Array>;
+    /**
+     * Decompress data using specific algorithm
+     * @param data Data to decompress
+     * @param algorithm Compression algorithm
+     * @returns Decompressed data
+     */
+    protected abstract decompressData(data: Buffer | Uint8Array, algorithm: CompressionAlgorithm): Promise<Buffer>;
+    /**
+     * Compress data
+     * @param data Data to compress
+     * @param options Compression options
+     * @returns Promise resolving to compression result
+     * @throws {CommunicationError} If compression fails
+     */
+    compress(data: Buffer | string | Uint8Array, options?: CompressionOptions): Promise<CompressionResult>;
+    /**
+     * Compress data with detailed metrics
+     * @param data Data to compress
+     * @param options Compression options
+     * @returns Promise resolving to compression result with metrics
+     */
+    compressWithMetrics(data: Buffer | string | Uint8Array, options?: CompressionOptions): Promise<CompressionResult>;
+    /**
+     * Decompress data
+     * @param data Data to decompress
+     * @param options Decompression options
+     * @returns Promise resolving to decompression result
+     * @throws {CommunicationError} If decompression fails
+     */
+    decompress(data: Buffer | Uint8Array, options?: CompressionOptions): Promise<DecompressionResult>;
+    /**
+     * Detect compression algorithm from data
+     * @param data Compressed data
+     * @returns Detected algorithm or undefined
+     */
+    protected detectAlgorithm(data: Buffer | Uint8Array): CompressionAlgorithm | undefined;
+    /**
+     * Check if algorithm is supported
+     * @param algorithm Algorithm to check
+     * @returns True if algorithm is supported
+     */
+    isAlgorithmSupported(algorithm: CompressionAlgorithm): boolean;
+    /**
+     * Get content encoding header for algorithm
+     * @param algorithm Compression algorithm
+     * @returns Content-Encoding header value
+     */
+    getContentEncoding(algorithm: CompressionAlgorithm): string;
+    /**
+     * Get algorithm from content encoding header
+     * @param contentEncoding Content-Encoding header value
+     * @returns Compression algorithm or undefined
+     */
+    getAlgorithmFromEncoding(contentEncoding: string): CompressionAlgorithm | undefined;
+    /**
+     * Should compress based on configuration
+     * @param dataSize Data size in bytes
+     * @param contentType Content type
+     * @returns True if should compress
+     */
+    shouldCompress(dataSize: number, contentType?: string): boolean;
+    /**
+     * Create compression stream
+     * @param algorithm Compression algorithm
+     * @param options Compression options
+     * @returns Transform stream for compression
+     */
+    createCompressionStream(algorithm: CompressionAlgorithm, options?: CompressionOptions): TransformStream;
+    /**
+     * Create decompression stream
+     * @param algorithm Compression algorithm
+     * @returns Transform stream for decompression
+     */
+    createDecompressionStream(algorithm: CompressionAlgorithm): TransformStream;
+    /**
+     * Update compression statistics
+     * @param originalSize Original size in bytes
+     * @param compressedSize Compressed size in bytes
+     * @param compressionTime Compression time in milliseconds
+     * @param algorithm Compression algorithm used
+     */
+    protected updateCompressionStats(originalSize: number, compressedSize: number, compressionTime: number, algorithm: CompressionAlgorithm): void;
+    /**
+     * Update decompression statistics
+     * @param originalSize Original compressed size in bytes
+     * @param decompressedSize Decompressed size in bytes
+     * @param decompressionTime Decompression time in milliseconds
+     * @param algorithm Decompression algorithm used
+     */
+    protected updateDecompressionStats(originalSize: number, decompressedSize: number, decompressionTime: number, algorithm: CompressionAlgorithm): void;
+    /**
+     * Update compression configuration
+     * @param config New configuration
+     */
+    updateConfig(config: Partial<CompressionConfig>): void;
+    /**
+     * Get compression statistics
+     */
+    getStats(): {
+        totalCompressions: number;
+        totalDecompressions: number;
+        compressionErrors: number;
+        decompressionErrors: number;
+        averageCompressionTime: number;
+        averageDecompressionTime: number;
+        averageCompressionRatio: number;
+        algorithmUsage: Record<string, number>;
+        totalBytesCompressed: number;
+        totalBytesDecompressed: number;
+        bytesSaved: number;
+    };
+    /**
+     * Reset compression statistics
+     */
+    resetStats(): void;
+    /**
+     * Health check for compression manager
+     */
+    healthCheck(): {
+        healthy: boolean;
+        message?: string;
+        details?: Record<string, unknown>;
+    };
+}

package/dist/types/abstract/BaseConnectionPool.d.ts

@@ -0,0 +1,210 @@
+/**
+ * Abstract base connection pool implementation
+ * @packageDocumentation
+ */
+import type { IConnection, IConnectionPool, ConnectionAcquisition } from '../interfaces/ConnectionPool.interface.js';
+import type { ConnectionPoolConfig } from '../types/config.js';
+/**
+ * Abstract base connection pool implementation
+ * Provides common functionality for connection pooling
+ */
+export declare abstract class BaseConnectionPool<T extends IConnection = IConnection> implements IConnectionPool<T> {
+    /** Pool name */
+    readonly name: string;
+    /** Pool configuration */
+    config: ConnectionPoolConfig;
+    /** Is pool healthy? */
+    isHealthy: boolean;
+    /** Total connections in pool */
+    totalConnections: number;
+    /** Active connections */
+    activeConnections: number;
+    /** Idle connections */
+    idleConnections: number;
+    /** Waiting clients */
+    waitingClients: number;
+    /** Connection factory function */
+    protected createConnectionFn: () => Promise<T>;
+    /** Connection validation function */
+    protected validateConnectionFn: (connection: T) => Promise<boolean>;
+    /** Connection pool */
+    protected pool: Set<T>;
+    /** Active connections set */
+    protected activeConnectionsSet: Set<T>;
+    /** Idle connections queue */
+    protected idleConnectionsQueue: T[];
+    /** Waiting clients queue */
+    protected waitingQueue: Array<{
+        resolve: (acquisition: ConnectionAcquisition<T>) => void;
+        reject: (error: Error) => void;
+        timeout: NodeJS.Timeout;
+        startTime: number;
+    }>;
+    /** Pool statistics */
+    protected stats: {
+        totalAcquisitions: number;
+        totalReleases: number;
+        totalDestructions: number;
+        totalErrors: number;
+        totalAcquisitionTime: number;
+        maxAcquisitionTime: number;
+        connectionStats: Map<string, {
+            createdAt: number;
+            lastUsedAt: number;
+            usageCount: number;
+            totalUsageTime: number;
+            isHealthy: boolean;
+        }>;
+    };
+    /** Cleanup interval */
+    protected cleanupInterval?: NodeJS.Timeout;
+    /** Health check interval */
+    protected healthCheckInterval?: NodeJS.Timeout;
+    /**
+     * Create a new base connection pool instance
+     * @param name Pool name
+     * @param config Pool configuration
+     * @param createConnection Connection factory function
+     * @param validateConnection Connection validation function
+     */
+    constructor(name: string, config: ConnectionPoolConfig, createConnection: () => Promise<T>, validateConnection?: (connection: T) => Promise<boolean>);
+    /**
+     * Initialize connection pool
+     */
+    protected initialize(): Promise<void>;
+    /**
+     * Warm up the pool with minimum connections
+     */
+    protected warmupPool(): Promise<void>;
+    /**
+     * Acquire a connection from the pool
+     * @param timeout Acquisition timeout in milliseconds
+     * @returns Promise resolving to connection acquisition
+     * @throws {CommunicationError} If timeout or pool exhausted
+     */
+    acquire(timeout?: number): Promise<ConnectionAcquisition<T>>;
+    /**
+     * Get or create a connection
+     * @returns Connection or null if cannot create
+     */
+    protected getOrCreateConnection(): Promise<T | null>;
+    /**
+     * Create a new connection (factory method)
+     * @returns New connection instance
+     */
+    abstract createConnection(): Promise<T>;
+    /**
+     * Validate a connection
+     * @param connection Connection to validate
+     * @returns True if connection is valid
+     */
+    validateConnection(connection: T): Promise<boolean>;
+    /**
+     * Release a connection back to the pool
+     * @param connection Connection to release
+     */
+    release(connection: T): Promise<void>;
+    /**
+     * Destroy a connection (remove from pool)
+     * @param connection Connection to destroy
+     */
+    destroy(connection: T): Promise<void>;
+    /**
+     * Destroy a connection (internal)
+     * @param connection Connection to destroy
+     */
+    protected destroyConnection(connection: T): Promise<void>;
+    /**
+     * Execute a function with a connection from the pool
+     * @param fn Function to execute with connection
+     * @param timeout Operation timeout in milliseconds
+     * @returns Promise resolving to function result
+     */
+    withConnection<R>(fn: (connection: T) => Promise<R>, timeout?: number): Promise<R>;
+    /**
+     * Record connection acquisition
+     * @param startTime Acquisition start time
+     * @param connection Acquired connection
+     */
+    protected recordAcquisition(startTime: number, connection: T): void;
+    /**
+     * Create acquisition result
+     * @param connection Acquired connection
+     * @param waitTime Wait time in milliseconds
+     * @returns Connection acquisition result
+     */
+    protected createAcquisitionResult(connection: T, waitTime: number): ConnectionAcquisition<T>;
+    /**
+     * Update connection statistics
+     * @param connection Connection
+     * @param released Whether connection was released
+     */
+    protected updateConnectionStats(connection: T, released: boolean): void;
+    /**
+     * Remove waiting client from queue
+     * @param reject Reject function
+     * @param startTime Start time
+     */
+    protected removeWaitingClient(reject: (error: Error) => void, startTime: number): void;
+    /**
+     * Notify waiting clients
+     */
+    protected notifyWaitingClients(): Promise<void>;
+    /**
+     * Clean up idle connections
+     */
+    protected cleanupIdleConnections(): Promise<void>;
+    /**
+     * Check pool health
+     */
+    protected checkPoolHealth(): Promise<void>;
+    /**
+     * Drain the pool (gracefully close all connections)
+     * @param force Force immediate drain
+     */
+    drain(force?: boolean): Promise<void>;
+    /**
+     * Clear the pool (force close all connections)
+     */
+    clear(): Promise<void>;
+    /**
+     * Health check for the pool
+     */
+    healthCheck(): Promise<{
+        healthy: boolean;
+        message?: string;
+        details?: Record<string, unknown>;
+    }>;
+    /**
+     * Get pool statistics
+     */
+    getStats(): {
+        totalConnections: number;
+        activeConnections: number;
+        idleConnections: number;
+        waitingClients: number;
+        totalAcquisitions: number;
+        totalReleases: number;
+        totalDestructions: number;
+        totalErrors: number;
+        acquisitionTimeAverage: number;
+        acquisitionTimeMax: number;
+        poolUtilization: number;
+        connectionStats: Array<{
+            id: string;
+            createdAt: number;
+            lastUsedAt: number;
+            usageCount: number;
+            isHealthy: boolean;
+        }>;
+    };
+    /**
+     * Reset pool statistics
+     */
+    resetStats(): void;
+    /**
+     * Update pool configuration
+     * @param config New configuration
+     */
+    updateConfig(config: Partial<ConnectionPoolConfig>): void;
+}

package/dist/types/abstract/BaseInterceptor.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Abstract base interceptor implementation
+ * @packageDocumentation
+ */
+import type { CommunicationErrorType } from '../errors/CommunicationError.js';
+import type { Request, RequestContext } from '../types/request.js';
+import type { IInterceptor, InterceptorOrder } from '../interfaces/Interceptor.interface.js';
+import type { Response } from '../types/response.js';
+/**
+ * Abstract base interceptor implementation
+ * Provides common functionality for all interceptor implementations
+ */
+export declare abstract class BaseInterceptor<TRequest = Request, TResponse = Response> implements IInterceptor<TRequest, TResponse> {
+    /** Interceptor name */
+    readonly name: string;
+    /** Interceptor version */
+    readonly version?: string;
+    /** Interceptor description */
+    readonly description?: string;
+    /** Whether interceptor is enabled */
+    enabled: boolean;
+    /** Interceptor execution order */
+    readonly order: InterceptorOrder;
+    /** Interceptor statistics */
+    protected stats: {
+        totalRequests: number;
+        totalResponses: number;
+        totalErrors: number;
+        modifications: number;
+        totalProcessingTime: number;
+        averageProcessingTime: number;
+        lastError?: string;
+    };
+    /** Configuration */
+    protected config: Record<string, unknown>;
+    /** Last processing time */
+    protected lastProcessingTime?: number;
+    /**
+     * Create a new base interceptor instance
+     * @param name Interceptor name
+     * @param options Interceptor options
+     */
+    constructor(name: string, options?: Record<string, unknown>);
+    /**
+     * Setup interceptor (internal initialization)
+     * @param options Initialization options
+     */
+    protected setup(options?: Record<string, unknown>): void;
+    /**
+     * Intercept request before it's sent
+     * @param request Original request
+     * @param context Request context
+     * @returns Modified request or void
+     */
+    abstract onRequest?(request: TRequest, context: RequestContext): TRequest | void | Promise<TRequest | void>;
+    /**
+     * Intercept response after it's received
+     * @param response Original response
+     * @param context Request context
+     * @returns Modified response or void
+     */
+    abstract onResponse?(response: TResponse, context: RequestContext): TResponse | void | Promise<TResponse | void>;
+    /**
+     * Intercept error when request fails
+     * @param error Error that occurred
+     * @param context Request context
+     * @returns Modified error, new response, or void
+     */
+    abstract onError?(error: CommunicationErrorType, context: RequestContext): CommunicationErrorType | TResponse | void | Promise<CommunicationErrorType | TResponse | void>;
+    /**
+     * Initialize interceptor (called when added to client/protocol)
+     * @param options Initialization options
+     */
+    initialize(options?: Record<string, unknown>): void | Promise<void>;
+    /**
+     * Cleanup interceptor (called when removed from client/protocol)
+     */
+    cleanup(): void | Promise<void>;
+    /**
+     * Get interceptor configuration
+     */
+    getConfig(): Record<string, unknown>;
+    /**
+     * Update interceptor configuration
+     * @param config New configuration
+     */
+    updateConfig(config: Record<string, unknown>): void;
+    /**
+     * Health check for the interceptor
+     */
+    healthCheck(): {
+        healthy: boolean;
+        message?: string;
+        details?: Record<string, unknown>;
+    };
+    /**
+     * Get interceptor statistics
+     */
+    getStats(): {
+        totalRequests: number;
+        totalResponses: number;
+        totalErrors: number;
+        modifications: number;
+        averageProcessingTime: number;
+        lastError?: string;
+    };
+    /**
+     * Reset interceptor statistics
+     */
+    resetStats(): void;
+    /**
+     * Execute request interception with timing and error handling
+     * @param request Original request
+     * @param context Request context
+     * @returns Modified request or original if not modified
+     */
+    protected executeOnRequest(request: TRequest, context: RequestContext): Promise<TRequest>;
+    /**
+     * Execute response interception with timing and error handling
+     * @param response Original response
+     * @param context Request context
+     * @returns Modified response or original if not modified
+     */
+    protected executeOnResponse(response: TResponse, context: RequestContext): Promise<TResponse>;
+    /**
+     * Execute error interception with timing and error handling
+     * @param error Original error
+     * @param context Request context
+     * @returns Modified error or response, or original error if not modified
+     */
+    protected executeOnError(error: CommunicationErrorType, context: RequestContext): Promise<CommunicationErrorType | TResponse>;
+    /**
+     * Update request statistics
+     * @param processingTime Processing time in milliseconds
+     * @param modified Whether request was modified
+     */
+    protected updateRequestStats(processingTime: number, modified: boolean): void;
+    /**
+     * Update response statistics
+     * @param processingTime Processing time in milliseconds
+     * @param modified Whether response was modified
+     */
+    protected updateResponseStats(processingTime: number, modified: boolean): void;
+    /**
+     * Update error statistics
+     * @param processingTime Processing time in milliseconds
+     * @param modified Whether error was modified
+     */
+    protected updateErrorStats(processingTime: number, modified: boolean): void;
+}