@naman_deep_singh/communication-core 1.0.0

package/dist/esm/abstract/BaseProtocol.js

@@ -0,0 +1,265 @@
+/**
+ * Abstract base protocol implementation
+ * @packageDocumentation
+ */
+import { CommunicationError } from '../errors/CommunicationError.js';
+/**
+ * Abstract base protocol implementation
+ * Provides common functionality for all protocol implementations
+ */
+export class BaseProtocol {
+    /**
+     * Create a new base protocol instance
+     * @param name Protocol name
+     * @param config Protocol configuration
+     */
+    constructor(name, config) {
+        /** Protocol interceptors */
+        this.interceptors = [];
+        /** Protocol metrics */
+        this.metrics = {};
+        /** Whether protocol is connected (for stateful protocols) */
+        this.connected = false;
+        /** Protocol start time */
+        this.startTime = Date.now();
+        /** Total requests sent */
+        this.totalRequests = 0;
+        /** Total successful requests */
+        this.successfulRequests = 0;
+        /** Total failed requests */
+        this.failedRequests = 0;
+        this.name = name;
+        this.config = { ...config };
+        this.version = config.options?.version || '1.0.0';
+    }
+    /**
+     * Configure the protocol with new settings
+     * @param config Configuration object
+     */
+    configure(config) {
+        this.config = { ...this.config, ...config };
+        this.onConfigure(config);
+    }
+    /**
+     * Hook for protocol configuration changes
+     * @param newConfig New configuration
+     */
+    onConfigure(newConfig) {
+        // Can be overridden by subclasses
+    }
+    /**
+     * Connect to the service (for stateful protocols)
+     * @returns Promise that resolves when connected
+     */
+    async connect() {
+        this.connected = true;
+        await this.onConnect?.();
+    }
+    /**
+     * Hook for connection logic
+     */
+    async onConnect() {
+        // Can be overridden by subclasses
+    }
+    /**
+     * Disconnect from the service (for stateful protocols)
+     * @returns Promise that resolves when disconnected
+     */
+    async disconnect() {
+        this.connected = false;
+        await this.onDisconnect?.();
+    }
+    /**
+     * Hook for disconnection logic
+     */
+    async onDisconnect() {
+        // Can be overridden by subclasses
+    }
+    /**
+     * Check if the protocol is currently connected
+     * @returns True if connected, false otherwise
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Add an interceptor to the protocol
+     * @param interceptor Interceptor to add
+     */
+    addInterceptor(interceptor) {
+        this.interceptors.push(interceptor);
+        interceptor.initialize?.({ protocol: this.name });
+        this.onInterceptorAdded(interceptor);
+    }
+    /**
+     * Hook for interceptor addition
+     * @param interceptor Added interceptor
+     */
+    onInterceptorAdded(interceptor) {
+        // Can be overridden by subclasses
+    }
+    /**
+     * Remove an interceptor from the protocol
+     * @param interceptorId Interceptor 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];
+    }
+    /**
+     * Execute request interceptors
+     * @param request Original request
+     * @param context Request context
+     * @returns Modified request
+     */
+    async executeRequestInterceptors(request, context) {
+        let modifiedRequest = request;
+        for (const interceptor of this.interceptors) {
+            if (interceptor.enabled && interceptor.onRequest) {
+                const result = await interceptor.onRequest(modifiedRequest, context);
+                if (result !== undefined) {
+                    modifiedRequest = result;
+                }
+            }
+        }
+        return modifiedRequest;
+    }
+    /**
+     * Execute response interceptors
+     * @param response Original response
+     * @param context Request context
+     * @returns Modified response
+     */
+    async executeResponseInterceptors(response, context) {
+        let modifiedResponse = response;
+        for (const interceptor of this.interceptors) {
+            if (interceptor.enabled && interceptor.onResponse) {
+                const result = await interceptor.onResponse(modifiedResponse, context);
+                if (result !== undefined) {
+                    modifiedResponse = result;
+                }
+            }
+        }
+        return modifiedResponse;
+    }
+    /**
+     * Execute error interceptors
+     * @param error Original error
+     * @param context Request context
+     * @returns Modified error or response
+     */
+    async executeErrorInterceptors(error, context) {
+        let result = error;
+        for (const interceptor of this.interceptors) {
+            if (interceptor.enabled && interceptor.onError) {
+                const interceptorResult = await interceptor.onError(result instanceof CommunicationError ? result : error, context);
+                if (interceptorResult !== undefined) {
+                    result = interceptorResult;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Update request metrics
+     * @param success Whether request was successful
+     * @param duration Request duration in milliseconds
+     */
+    updateMetrics(success, duration) {
+        this.totalRequests++;
+        if (success) {
+            this.successfulRequests++;
+        }
+        else {
+            this.failedRequests++;
+        }
+        this.metrics = {
+            ...this.metrics,
+            totalRequests: this.totalRequests,
+            successfulRequests: this.successfulRequests,
+            failedRequests: this.failedRequests,
+            successRate: this.totalRequests > 0 ? this.successfulRequests / this.totalRequests : 0,
+            averageResponseTime: this.calculateAverageResponseTime(duration),
+            uptime: Date.now() - this.startTime,
+        };
+    }
+    /**
+     * Calculate average response time
+     * @param newDuration New request duration
+     * @returns Average response time
+     */
+    calculateAverageResponseTime(newDuration) {
+        const currentAverage = this.metrics.averageResponseTime || 0;
+        const totalDuration = currentAverage * (this.totalRequests - 1) + newDuration;
+        return totalDuration / this.totalRequests;
+    }
+    /**
+     * Get protocol metrics
+     */
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    /**
+     * Reset protocol metrics
+     */
+    resetMetrics() {
+        this.totalRequests = 0;
+        this.successfulRequests = 0;
+        this.failedRequests = 0;
+        this.metrics = {
+            uptime: Date.now() - this.startTime,
+        };
+    }
+    /**
+     * Health check for the protocol
+     * @returns Promise resolving to health status
+     */
+    async healthCheck() {
+        const healthy = this.connected !== false;
+        return {
+            healthy,
+            message: healthy ? 'Protocol is healthy' : 'Protocol is not connected',
+            details: {
+                name: this.name,
+                version: this.version,
+                connected: this.connected,
+                totalRequests: this.totalRequests,
+                successRate: this.metrics.successRate,
+                uptime: this.metrics.uptime,
+            },
+        };
+    }
+    /**
+     * Create request context
+     * @param request Request object
+     * @param attempt Attempt number
+     * @returns Request context
+     */
+    createRequestContext(request, attempt = 1) {
+        return {
+            protocol: this.name,
+            requestId: request.id || `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            attempt,
+            startTime: Date.now(),
+            isRetry: attempt > 1,
+        };
+    }
+}

package/dist/esm/abstract/BaseRetryStrategy.js

@@ -0,0 +1,251 @@
+/**
+ * Abstract base retry strategy implementation
+ * @packageDocumentation
+ */
+/**
+ * Abstract base retry strategy implementation
+ * Provides common functionality for all retry strategy implementations
+ */
+export class BaseRetryStrategy {
+    /**
+     * Create a new base retry strategy instance
+     * @param name Strategy name
+     * @param config Strategy configuration
+     */
+    constructor(name, config) {
+        /** Total retry attempts made */
+        this.totalAttempts = 0;
+        /** Successful retries */
+        this.successfulRetries = 0;
+        /** Failed retries */
+        this.failedRetries = 0;
+        /** Retry statistics */
+        this.stats = {
+            totalExecutions: 0,
+            totalAttempts: 0,
+            successfulRetries: 0,
+            failedRetries: 0,
+            successRate: 0,
+            averageAttempts: 0,
+            averageDelay: 0,
+            totalTimeSpent: 0,
+        };
+        this.name = name;
+        this.config = { ...config };
+        this.initialize();
+    }
+    /**
+     * Initialize retry strategy
+     */
+    initialize() {
+        // Can be overridden by subclasses
+    }
+    /**
+     * Determine if a retry should be attempted
+     * @param error Error that occurred
+     * @param context Current retry context
+     * @returns Retry decision
+     */
+    shouldRetry(error, context) {
+        // Check max attempts
+        if (context.attempt >= context.maxAttempts) {
+            return {
+                shouldRetry: false,
+                reason: 'Max attempts reached',
+            };
+        }
+        // Check retry on status codes (for HTTP errors)
+        if (error.statusCode && this.config.retryOnStatus?.includes(error.statusCode)) {
+            return {
+                shouldRetry: true,
+                delay: this.calculateDelay(context.attempt, context),
+                reason: `Status code ${error.statusCode} is retryable`,
+            };
+        }
+        // Check retry on error types
+        if (this.config.retryOnErrors?.includes(error.code)) {
+            return {
+                shouldRetry: true,
+                delay: this.calculateDelay(context.attempt, context),
+                reason: `Error code ${error.code} is retryable`,
+            };
+        }
+        // Check if error is retryable based on type
+        if (this.isRetryableError(error)) {
+            return {
+                shouldRetry: true,
+                delay: this.calculateDelay(context.attempt, context),
+                reason: 'Error is retryable',
+            };
+        }
+        return {
+            shouldRetry: false,
+            reason: 'Error is not retryable',
+        };
+    }
+    /**
+     * Check if an error is retryable
+     * @param error Error to check
+     * @returns True if error is retryable
+     */
+    isRetryableError(error) {
+        // Default implementation: retry on network errors, timeouts, and 5xx errors
+        const networkErrors = ['ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND'];
+        const timeoutErrors = ['TIMEOUT', 'TIMEOUT_EXCEEDED'];
+        return (networkErrors.some(code => error.code?.includes(code)) ||
+            timeoutErrors.some(code => error.code?.includes(code)) ||
+            (error?.statusCode >= 500 && error?.statusCode < 600));
+    }
+    /**
+     * Calculate delay for next retry attempt
+     * @param attempt Current attempt number
+     * @param context Current retry context
+     * @returns Delay in milliseconds
+     */
+    calculateDelay(attempt, context) {
+        const backoff = this.config?.backoff || {};
+        const strategy = this.config.backoffStrategy || 'exponential';
+        switch (strategy) {
+            case 'fixed':
+                return backoff.initialDelay || 1000;
+            case 'exponential':
+                const baseDelay = backoff.initialDelay || 100;
+                const multiplier = backoff.multiplier || 2;
+                return Math.min(baseDelay * Math.pow(multiplier, attempt - 1), backoff.maxDelay || 30000);
+            case 'linear':
+                const linearDelay = backoff.initialDelay || 100;
+                const increment = backoff.multiplier || 1000;
+                return Math.min(linearDelay + (increment * (attempt - 1)), backoff.maxDelay || 30000);
+            case 'jitter':
+                const jitterDelay = backoff.initialDelay || 100;
+                const jitterMultiplier = backoff.multiplier || 2;
+                const base = jitterDelay * Math.pow(jitterMultiplier, attempt - 1);
+                const jitter = backoff.jitter || 0.3;
+                const jitterValue = base * jitter * Math.random();
+                return Math.min(base + jitterValue, backoff.maxDelay || 30000);
+            case 'fibonacci':
+                const fibDelay = backoff.initialDelay || 100;
+                let a = 0, b = 1;
+                for (let i = 0; i < attempt; i++) {
+                    [a, b] = [b, a + b];
+                }
+                return Math.min(fibDelay * a, backoff.maxDelay || 30000);
+            default:
+                // Custom strategy or fallback
+                if (backoff.custom) {
+                    return backoff.custom(attempt);
+                }
+                return backoff.initialDelay || 1000;
+        }
+    }
+    /**
+     * Create retry context
+     * @param initialContext Initial context values
+     * @returns Complete retry context
+     */
+    createRetryContext(initialContext) {
+        const defaultContext = {
+            attempt: 1,
+            maxAttempts: this.config.maxAttempts || 3,
+            lastError: undefined,
+            startTime: Date.now(),
+            elapsedTime: 0,
+            data: new Map(),
+            isRetry: false,
+        };
+        return {
+            ...defaultContext,
+            ...initialContext,
+        };
+    }
+    /**
+     * Update retry context after attempt
+     * @param context Current context
+     * @param error Error from attempt (if any)
+     * @returns Updated context
+     */
+    updateRetryContext(context, error) {
+        return {
+            ...context,
+            attempt: context.attempt + 1,
+            lastError: error,
+            elapsedTime: Date.now() - context.startTime,
+            isRetry: context.attempt > 1,
+        };
+    }
+    /**
+     * Update retry statistics
+     * @param success Whether retry was successful
+     * @param attempts Number of attempts
+     * @param totalDelay Total delay time
+     */
+    updateStats(success, attempts, totalDelay) {
+        this.totalAttempts += attempts;
+        this.stats.totalExecutions++;
+        this.stats.totalAttempts += attempts;
+        this.stats.totalTimeSpent += totalDelay;
+        if (success) {
+            this.successfulRetries++;
+            this.stats.successfulRetries++;
+        }
+        else {
+            this.failedRetries++;
+            this.stats.failedRetries++;
+        }
+        // Update calculated stats
+        const totalExecutions = this.stats.totalExecutions;
+        const totalAttempts = this.stats.totalAttempts;
+        this.stats.successRate = totalExecutions > 0 ?
+            this.stats.successfulRetries / totalExecutions : 0;
+        this.stats.averageAttempts = totalExecutions > 0 ?
+            totalAttempts / totalExecutions : 0;
+        this.stats.averageDelay = totalAttempts > 0 ?
+            this.stats.totalTimeSpent / totalAttempts : 0;
+    }
+    /**
+     * Update retry strategy configuration
+     * @param config New configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Get retry strategy statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Reset retry strategy statistics
+     */
+    resetStats() {
+        this.totalAttempts = 0;
+        this.successfulRetries = 0;
+        this.failedRetries = 0;
+        this.stats = {
+            totalExecutions: 0,
+            totalAttempts: 0,
+            successfulRetries: 0,
+            failedRetries: 0,
+            successRate: 0,
+            averageAttempts: 0,
+            averageDelay: 0,
+            totalTimeSpent: 0,
+        };
+    }
+    /**
+     * Health check for the retry strategy
+     */
+    healthCheck() {
+        const healthy = true; // Retry strategy is always healthy
+        return {
+            healthy,
+            message: 'Retry strategy is operational',
+            details: {
+                name: this.name,
+                config: this.config,
+                statistics: this.getStats(),
+            },
+        };
+    }
+}