@naman_deep_singh/communication-core 1.0.0

package/dist/esm/abstract/BaseClient.js

@@ -0,0 +1,294 @@
+/**
+ * Abstract base client implementation
+ * @packageDocumentation
+ */
+import { CommunicationError } from '../errors/CommunicationError.js';
+import { COMMUNICATION_ERROR_CODES } from '../errors/communicationErrorCodes.js';
+/**
+ * Abstract base client implementation
+ * Provides common functionality for all client implementations
+ */
+export class BaseClient {
+    /**
+     * Create a new base client instance
+     * @param serviceName Service name to communicate with
+     * @param config Client configuration
+     * @param protocol Protocol instance
+     */
+    constructor(serviceName, config, protocol) {
+        /** Client interceptors */
+        this.interceptors = [];
+        /** Cached service instances */
+        this.cachedInstances = [];
+        /** Client metrics */
+        this.metrics = {};
+        /** Client start time */
+        this.startTime = Date.now();
+        /** Total calls made */
+        this.totalCalls = 0;
+        /** Successful calls */
+        this.successfulCalls = 0;
+        /** Failed calls */
+        this.failedCalls = 0;
+        this.serviceName = serviceName;
+        this.config = { ...config };
+        this.protocol = protocol;
+        this.name = config.custom?.name || `client_${serviceName}_${Date.now()}`;
+        // Initialize components
+        this.initializeComponents();
+    }
+    /**
+     * Initialize client components
+     */
+    initializeComponents() {
+        // Can be overridden by subclasses to initialize
+        // serviceDiscoverer, loadBalancer, circuitBreaker, retryStrategy
+    }
+    /**
+     * Get service discovery instance
+     */
+    getServiceDiscoverer() {
+        return this.serviceDiscoverer;
+    }
+    /**
+     * Get load balancer instance
+     */
+    getLoadBalancer() {
+        return this.loadBalancer;
+    }
+    /**
+     * Get circuit breaker instance
+     */
+    getCircuitBreaker() {
+        return this.circuitBreaker;
+    }
+    /**
+     * Get retry strategy instance
+     */
+    getRetryStrategy() {
+        return this.retryStrategy;
+    }
+    /**
+     * Add an interceptor to the client
+     * @param interceptor IInterceptor to add
+     */
+    addInterceptor(interceptor) {
+        this.interceptors.push(interceptor);
+        interceptor.initialize?.({ client: this.name, service: this.serviceName });
+        this.onInterceptorAdded(interceptor);
+    }
+    /**
+     * Hook for interceptor addition
+     * @param interceptor Added interceptor
+     */
+    onInterceptorAdded(interceptor) {
+        // Can be overridden by subclasses
+    }
+    /**
+     * Remove an interceptor from the client
+     * @param interceptorId IInterceptor identifier
+     */
+    removeInterceptor(interceptorId) {
+        const index = this.interceptors.findIndex(i => i.name === interceptorId);
+        if (index !== -1) {
+            const interceptor = this.interceptors[index];
+            interceptor.cleanup?.();
+            this.interceptors.splice(index, 1);
+            this.onInterceptorRemoved(interceptorId);
+        }
+    }
+    /**
+     * Hook for interceptor removal
+     * @param interceptorId Removed interceptor ID
+     */
+    onInterceptorRemoved(interceptorId) {
+        // Can be overridden by subclasses
+    }
+    /**
+     * Get all interceptors
+     */
+    getInterceptors() {
+        return [...this.interceptors];
+    }
+    /**
+     * Clear all interceptors
+     */
+    clearInterceptors() {
+        for (const interceptor of this.interceptors) {
+            interceptor.cleanup?.();
+        }
+        this.interceptors = [];
+        this.onInterceptorsCleared();
+    }
+    /**
+     * Hook for interceptors cleared
+     */
+    onInterceptorsCleared() {
+        // Can be overridden by subclasses
+    }
+    /**
+     * Discover service instances
+     * @returns Promise resolving to service instances
+     */
+    async discoverService() {
+        if (!this.serviceDiscoverer) {
+            throw new CommunicationError(COMMUNICATION_ERROR_CODES.DISCOVERY_ERROR, 503, {
+                message: 'Service discovery not configured',
+                service: this.serviceName,
+            });
+        }
+        const result = await this.serviceDiscoverer.resolve(this.serviceName);
+        this.cachedInstances = result.instances;
+        this.lastCacheRefresh = Date.now();
+        return this.cachedInstances;
+    }
+    /**
+     * Get current service instances (cached)
+     */
+    getServiceInstances() {
+        return [...this.cachedInstances];
+    }
+    /**
+     * Refresh service instances cache
+     */
+    async refreshServiceInstances() {
+        await this.discoverService();
+    }
+    /**
+     * Select a service instance using load balancer
+     * @param instances Available instances
+     * @returns Selected instance
+     */
+    selectInstance(instances) {
+        if (instances.length === 0) {
+            throw new CommunicationError(COMMUNICATION_ERROR_CODES.NO_AVAILABLE_INSTANCES, 503, {
+                service: this.serviceName,
+            });
+        }
+        if (instances.length === 1) {
+            return instances[0];
+        }
+        if (this.loadBalancer) {
+            return this.loadBalancer.select(instances, {
+                service: this.serviceName,
+                client: this.name,
+            });
+        }
+        // Default: round-robin selection
+        const index = this.totalCalls % instances.length;
+        return instances[index];
+    }
+    /**
+     * Update client metrics
+     * @param success Whether call was successful
+     * @param duration Call duration in milliseconds
+     */
+    updateMetrics(success, duration) {
+        this.totalCalls++;
+        if (success) {
+            this.successfulCalls++;
+        }
+        else {
+            this.failedCalls++;
+        }
+        this.metrics = {
+            ...this.metrics,
+            totalCalls: this.totalCalls,
+            successfulCalls: this.successfulCalls,
+            failedCalls: this.failedCalls,
+            successRate: this.totalCalls > 0 ? this.successfulCalls / this.totalCalls : 0,
+            averageResponseTime: this.calculateAverageResponseTime(duration),
+            uptime: Date.now() - this.startTime,
+            cachedInstances: this.cachedInstances.length,
+            lastCacheRefresh: this.lastCacheRefresh,
+        };
+    }
+    /**
+     * Calculate average response time
+     * @param newDuration New call duration
+     * @returns Average response time
+     */
+    calculateAverageResponseTime(newDuration) {
+        const currentAverage = this.metrics.averageResponseTime || 0;
+        const totalDuration = currentAverage * (this.totalCalls - 1) + newDuration;
+        return totalDuration / this.totalCalls;
+    }
+    /**
+     * Health check for the client
+     * @returns Promise resolving to health status
+     */
+    async healthCheck() {
+        const checks = [];
+        // Check protocol health
+        const protocolHealth = await this.protocol.healthCheck?.() || { healthy: false };
+        checks.push({
+            component: 'protocol',
+            healthy: protocolHealth.healthy,
+            message: protocolHealth.message,
+        });
+        // Check service discovery health if configured
+        if (this.serviceDiscoverer) {
+            const discoveryHealth = await this.serviceDiscoverer.healthCheckSelf();
+            checks.push({
+                component: 'service-discovery',
+                healthy: discoveryHealth.healthy,
+                message: discoveryHealth.message,
+            });
+        }
+        // Check if we have service instances
+        const hasInstances = this.cachedInstances.length > 0;
+        checks.push({
+            component: 'service-instances',
+            healthy: hasInstances,
+            message: hasInstances ? `Has ${this.cachedInstances.length} instances` : 'No instances available',
+        });
+        const allHealthy = checks.every(check => check.healthy);
+        return {
+            healthy: allHealthy,
+            message: allHealthy ? 'Client is healthy' : 'Client has issues',
+            details: {
+                name: this.name,
+                service: this.serviceName,
+                checks,
+                metrics: this.metrics,
+            },
+        };
+    }
+    /**
+     * Get client metrics
+     */
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    /**
+     * Reset client metrics
+     */
+    resetMetrics() {
+        this.totalCalls = 0;
+        this.successfulCalls = 0;
+        this.failedCalls = 0;
+        this.metrics = {
+            uptime: Date.now() - this.startTime,
+        };
+    }
+    /**
+     * Close/cleanup client resources
+     */
+    async close() {
+        // Clear interceptors
+        this.clearInterceptors();
+        // Close protocol
+        await this.protocol.disconnect?.();
+        // Close service discovery if configured
+        if (this.serviceDiscoverer) {
+            await this.serviceDiscoverer.close();
+        }
+        this.onClose();
+    }
+    /**
+     * Hook for client close
+     */
+    onClose() {
+        // Can be overridden by subclasses
+    }
+}

package/dist/esm/abstract/BaseCompressionManager.js

@@ -0,0 +1,373 @@
+/**
+ * Abstract base compression manager implementation
+ * @packageDocumentation
+ */
+import { COMMUNICATION_ERROR_CODES } from '../errors/communicationErrorCodes.js';
+import { SerializationError } from '../errors/SerializationError.js';
+/**
+ * Abstract base compression manager implementation
+ * Provides common functionality for compression management
+ */
+export class BaseCompressionManager {
+    /**
+     * Create a new base compression manager instance
+     * @param name Compression manager name
+     * @param config Compression configuration
+     */
+    constructor(name, config) {
+        /** Supported algorithms */
+        this.supportedAlgorithms = ['none'];
+        /** Compression statistics */
+        this.stats = {
+            totalCompressions: 0,
+            totalDecompressions: 0,
+            compressionErrors: 0,
+            decompressionErrors: 0,
+            totalCompressionTime: 0,
+            totalDecompressionTime: 0,
+            totalOriginalSize: 0,
+            totalCompressedSize: 0,
+            totalDecompressedSize: 0,
+            averageCompressionTime: 0,
+            averageDecompressionTime: 0,
+            averageCompressionRatio: 0,
+            algorithmUsage: {},
+        };
+        this.name = name;
+        this.config = { ...config };
+        this.initialize();
+    }
+    /**
+     * Initialize compression manager
+     */
+    initialize() {
+        // Detect supported algorithms
+        this.supportedAlgorithms.push(...this.detectSupportedAlgorithms());
+    }
+    /**
+     * Compress data
+     * @param data Data to compress
+     * @param options Compression options
+     * @returns Promise resolving to compression result
+     * @throws {CommunicationError} If compression fails
+     */
+    async compress(data, options) {
+        const result = await this.compressWithMetrics(data, options);
+        return result;
+    }
+    /**
+     * Compress data with detailed metrics
+     * @param data Data to compress
+     * @param options Compression options
+     * @returns Promise resolving to compression result with metrics
+     */
+    async compressWithMetrics(data, options) {
+        const startTime = Date.now();
+        const algorithm = options?.algorithm || this.config.algorithm || 'gzip';
+        const level = options?.level || this.config.level || 6;
+        // Convert string to buffer if needed
+        const inputBuffer = typeof data === 'string'
+            ? Buffer.from(data, 'utf8')
+            : Buffer.from(data);
+        const originalSize = inputBuffer.length;
+        // Check if we should compress
+        if (!this.shouldCompress(originalSize)) {
+            return {
+                data: inputBuffer,
+                originalSize,
+                compressedSize: originalSize,
+                compressionRatio: 1,
+                algorithm: 'none',
+                level: 0,
+                compressionTime: Date.now() - startTime,
+            };
+        }
+        // Check algorithm support
+        if (!this.isAlgorithmSupported(algorithm)) {
+            throw new SerializationError(COMMUNICATION_ERROR_CODES.SERIALIZATION_ERROR, {
+                message: `Compression algorithm not supported: ${algorithm}`,
+                algorithm,
+                supportedAlgorithms: this.supportedAlgorithms,
+            });
+        }
+        try {
+            const compressedData = await this.compressData(inputBuffer, algorithm, level);
+            const compressionTime = Date.now() - startTime;
+            const compressedSize = compressedData.length;
+            const compressionRatio = compressedSize / originalSize;
+            // Update statistics
+            this.updateCompressionStats(originalSize, compressedSize, compressionTime, algorithm);
+            return {
+                data: compressedData,
+                originalSize,
+                compressedSize,
+                compressionRatio,
+                algorithm,
+                level,
+                compressionTime,
+            };
+        }
+        catch (error) {
+            this.stats.compressionErrors++;
+            throw new SerializationError(COMMUNICATION_ERROR_CODES.SERIALIZATION_ERROR, {
+                message: `Compression failed: ${error instanceof Error ? error.message : String(error)}`,
+                algorithm,
+                level,
+                originalSize,
+            }, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Decompress data
+     * @param data Data to decompress
+     * @param options Decompression options
+     * @returns Promise resolving to decompression result
+     * @throws {CommunicationError} If decompression fails
+     */
+    async decompress(data, options) {
+        const startTime = Date.now();
+        const algorithm = options?.algorithm || this.detectAlgorithm(data) || 'gzip';
+        // Check algorithm support
+        if (!this.isAlgorithmSupported(algorithm)) {
+            throw new SerializationError(COMMUNICATION_ERROR_CODES.DESERIALIZATION_ERROR, {
+                message: `Decompression algorithm not supported: ${algorithm}`,
+                algorithm,
+                supportedAlgorithms: this.supportedAlgorithms,
+            });
+        }
+        try {
+            const decompressedData = await this.decompressData(Buffer.from(data), algorithm);
+            const decompressionTime = Date.now() - startTime;
+            const originalSize = data.length;
+            const decompressedSize = decompressedData.length;
+            // Update statistics
+            this.updateDecompressionStats(originalSize, decompressedSize, decompressionTime, algorithm);
+            return {
+                data: decompressedData,
+                originalSize,
+                decompressedSize,
+                decompressionTime,
+                algorithm,
+            };
+        }
+        catch (error) {
+            this.stats.decompressionErrors++;
+            throw new SerializationError(COMMUNICATION_ERROR_CODES.DESERIALIZATION_ERROR, {
+                message: `Decompression failed: ${error instanceof Error ? error.message : String(error)}`,
+                algorithm,
+                originalSize: data.length,
+            }, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Detect compression algorithm from data
+     * @param data Compressed data
+     * @returns Detected algorithm or undefined
+     */
+    detectAlgorithm(data) {
+        const buffer = Buffer.from(data);
+        // Check for gzip magic number: 0x1F 0x8B
+        if (buffer.length >= 2 && buffer[0] === 0x1F && buffer[1] === 0x8B) {
+            return 'gzip';
+        }
+        // Check for deflate magic number: 0x78 (zlib header)
+        if (buffer.length >= 1 && (buffer[0] === 0x78 || buffer[0] === 0x58)) {
+            return 'deflate';
+        }
+        // Check for brotli magic number: 0xCE 0x2B 0x2F
+        if (buffer.length >= 3 && buffer[0] === 0xCE && buffer[1] === 0x2B && buffer[2] === 0x2F) {
+            return 'brotli';
+        }
+        return undefined;
+    }
+    /**
+     * Check if algorithm is supported
+     * @param algorithm Algorithm to check
+     * @returns True if algorithm is supported
+     */
+    isAlgorithmSupported(algorithm) {
+        return this.supportedAlgorithms.includes(algorithm);
+    }
+    /**
+     * Get content encoding header for algorithm
+     * @param algorithm Compression algorithm
+     * @returns Content-Encoding header value
+     */
+    getContentEncoding(algorithm) {
+        switch (algorithm) {
+            case 'gzip':
+                return 'gzip';
+            case 'deflate':
+                return 'deflate';
+            case 'brotli':
+                return 'br';
+            case 'none':
+                return 'identity';
+            default:
+                return algorithm;
+        }
+    }
+    /**
+     * Get algorithm from content encoding header
+     * @param contentEncoding Content-Encoding header value
+     * @returns Compression algorithm or undefined
+     */
+    getAlgorithmFromEncoding(contentEncoding) {
+        const normalized = contentEncoding.toLowerCase().trim();
+        switch (normalized) {
+            case 'gzip':
+            case 'x-gzip':
+                return 'gzip';
+            case 'deflate':
+                return 'deflate';
+            case 'br':
+                return 'brotli';
+            case 'identity':
+            case 'none':
+                return 'none';
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * Should compress based on configuration
+     * @param dataSize Data size in bytes
+     * @param contentType Content type
+     * @returns True if should compress
+     */
+    shouldCompress(dataSize, contentType) {
+        if (!this.config.enabled) {
+            return false;
+        }
+        // Check minimum size
+        if (this.config.minSize && dataSize < this.config.minSize) {
+            return false;
+        }
+        // Check maximum size
+        if (this.config.maxSize && dataSize > this.config.maxSize) {
+            return false;
+        }
+        // Check content types
+        if (this.config.contentTypes && contentType) {
+            const normalizedContentType = contentType.toLowerCase().split(';')[0].trim();
+            const shouldCompress = this.config.contentTypes.some(ct => normalizedContentType.includes(ct.toLowerCase()));
+            if (!shouldCompress) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Create compression stream
+     * @param algorithm Compression algorithm
+     * @param options Compression options
+     * @returns Transform stream for compression
+     */
+    createCompressionStream(algorithm, options) {
+        throw new Error('createCompressionStream not implemented');
+    }
+    /**
+     * Create decompression stream
+     * @param algorithm Compression algorithm
+     * @returns Transform stream for decompression
+     */
+    createDecompressionStream(algorithm) {
+        throw new Error('createDecompressionStream not implemented');
+    }
+    /**
+     * 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
+     */
+    updateCompressionStats(originalSize, compressedSize, compressionTime, algorithm) {
+        this.stats.totalCompressions++;
+        this.stats.totalCompressionTime += compressionTime;
+        this.stats.totalOriginalSize += originalSize;
+        this.stats.totalCompressedSize += compressedSize;
+        // Update algorithm usage
+        this.stats.algorithmUsage[algorithm] = (this.stats.algorithmUsage[algorithm] || 0) + 1;
+        // Update averages
+        this.stats.averageCompressionTime = this.stats.totalCompressionTime / this.stats.totalCompressions;
+        this.stats.averageCompressionRatio = this.stats.totalCompressedSize / this.stats.totalOriginalSize;
+    }
+    /**
+     * 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
+     */
+    updateDecompressionStats(originalSize, decompressedSize, decompressionTime, algorithm) {
+        this.stats.totalDecompressions++;
+        this.stats.totalDecompressionTime += decompressionTime;
+        this.stats.totalDecompressedSize += decompressedSize;
+        // Update algorithm usage
+        this.stats.algorithmUsage[algorithm] = (this.stats.algorithmUsage[algorithm] || 0) + 1;
+        // Update averages
+        this.stats.averageDecompressionTime = this.stats.totalDecompressionTime / this.stats.totalDecompressions;
+    }
+    /**
+     * Update compression configuration
+     * @param config New configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Get compression statistics
+     */
+    getStats() {
+        const bytesSaved = this.stats.totalOriginalSize - this.stats.totalCompressedSize;
+        return {
+            totalCompressions: this.stats.totalCompressions,
+            totalDecompressions: this.stats.totalDecompressions,
+            compressionErrors: this.stats.compressionErrors,
+            decompressionErrors: this.stats.decompressionErrors,
+            averageCompressionTime: this.stats.averageCompressionTime,
+            averageDecompressionTime: this.stats.averageDecompressionTime,
+            averageCompressionRatio: this.stats.averageCompressionRatio,
+            algorithmUsage: { ...this.stats.algorithmUsage },
+            totalBytesCompressed: this.stats.totalOriginalSize,
+            totalBytesDecompressed: this.stats.totalDecompressedSize,
+            bytesSaved: Math.max(0, bytesSaved),
+        };
+    }
+    /**
+     * Reset compression statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalCompressions: 0,
+            totalDecompressions: 0,
+            compressionErrors: 0,
+            decompressionErrors: 0,
+            totalCompressionTime: 0,
+            totalDecompressionTime: 0,
+            totalOriginalSize: 0,
+            totalCompressedSize: 0,
+            totalDecompressedSize: 0,
+            averageCompressionTime: 0,
+            averageDecompressionTime: 0,
+            averageCompressionRatio: 0,
+            algorithmUsage: {},
+        };
+    }
+    /**
+     * Health check for compression manager
+     */
+    healthCheck() {
+        const healthy = this.supportedAlgorithms.length > 0;
+        return {
+            healthy,
+            message: healthy ? 'Compression manager is operational' : 'No compression algorithms supported',
+            details: {
+                name: this.name,
+                supportedAlgorithms: this.supportedAlgorithms,
+                config: this.config,
+                statistics: this.getStats(),
+            },
+        };
+    }
+}