@naman_deep_singh/communication-core 1.0.0

package/dist/cjs/interfaces/ServiceDiscovery.interface.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Service discovery interface for communication layer
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/interfaces/Timeout.interface.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Timeout interface for communication layer
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/interfaces/index.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Interface definitions for communication layer
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/config.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Configuration types for communication layer
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/events.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Event types for communication layer
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/index.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Type definitions for communication layer
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/request.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Request types and interfaces for communication layer
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/response.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Response types and interfaces for communication layer
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/service.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Service discovery and instance types
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * Utilities integration with @naman_deep_singh/utils package
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionUtils = exports.ConnectionPoolUtils = exports.TimeoutUtils = exports.BaseConnection = void 0;
+const utils_1 = require("@naman_deep_singh/utils");
+/**
+ * Base connection implementation that satisfies both interfaces
+ */
+class BaseConnection {
+}
+exports.BaseConnection = BaseConnection;
+/**
+ * Timeout utilities wrapper
+ */
+class TimeoutUtils {
+    /**
+     * Execute with timeout
+     */
+    static async withTimeout(promise, timeoutMs, errorMessage) {
+        return utils_1.TimeoutManager.withTimeout(promise, timeoutMs, errorMessage);
+    }
+    /**
+     * Create delay
+     */
+    static async delay(ms) {
+        return utils_1.TimeoutManager.delay(ms);
+    }
+    /**
+     * Retry with timeout
+     */
+    static async retryWithTimeout(fn, options) {
+        return utils_1.TimeoutManager.retryWithTimeout(fn, options);
+    }
+    /**
+     * Create a timeout promise
+     */
+    static createTimeout(timeoutMs, message) {
+        return new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(message || `Timeout after ${timeoutMs}ms`));
+            }, timeoutMs);
+        });
+    }
+    /**
+     * Create an abort signal for timeout
+     */
+    static createAbortSignal(timeoutMs) {
+        const controller = new AbortController();
+        setTimeout(() => controller.abort(), timeoutMs);
+        return controller.signal;
+    }
+    /**
+     * Race promises with timeout
+     */
+    static async raceWithTimeout(promises, timeoutMs, errorMessage) {
+        const timeoutPromise = this.createTimeout(timeoutMs, errorMessage);
+        return Promise.race([...promises, timeoutPromise]);
+    }
+}
+exports.TimeoutUtils = TimeoutUtils;
+/**
+ * Connection pool wrapper
+ */
+class ConnectionPoolUtils {
+    /**
+     * Create a generic connection pool
+     */
+    static createPool(config) {
+        return new utils_1.GenericPool({
+            name: config.name,
+            minConnections: config.minConnections,
+            maxConnections: config.maxConnections,
+            createConnection: config.createConnection,
+            validateConnection: config.validateConnection,
+            idleTimeoutMs: config.idleTimeout,
+            maxLifetimeMs: config.maxLifetime,
+            acquireTimeoutMs: config.acquireTimeout,
+        });
+    }
+    /**
+     * Create a simple pool with basic configuration
+     */
+    static createSimplePool(name, createConnection, options) {
+        return new utils_1.GenericPool({
+            name,
+            minConnections: options?.minConnections,
+            maxConnections: options?.maxConnections,
+            createConnection,
+            idleTimeoutMs: options?.idleTimeout,
+        });
+    }
+    /**
+     * Create an adapter to convert property-based isHealthy to function-based
+     */
+    static createConnectionAdapter(connection, closeFn = async () => { }, healthCheckFn = async () => true, resetFn = async () => { }) {
+        // Handle isHealthy conversion
+        const getIsHealthy = () => {
+            if (typeof connection.isHealthy === 'function') {
+                return connection.isHealthy();
+            }
+            return connection.isHealthy ?? true;
+        };
+        return {
+            id: connection.id || `conn-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            // isHealthy must be a function
+            isHealthy: getIsHealthy,
+            createdAt: connection.createdAt || Date.now(),
+            lastUsedAt: connection.lastUsedAt || Date.now(),
+            usageCount: connection.usageCount || 0,
+            metadata: connection.metadata || {},
+            close: closeFn,
+            healthCheck: healthCheckFn,
+            reset: resetFn,
+        };
+    }
+}
+exports.ConnectionPoolUtils = ConnectionPoolUtils;
+/**
+ * Compression utilities wrapper
+ */
+class CompressionUtils {
+    /**
+     * Compress data
+     */
+    static async compress(data, options) {
+        const result = await utils_1.Compression.compress(Buffer.from(data), {
+            algorithm: options?.algorithm || 'gzip',
+            level: options?.level || 6,
+        });
+        return Buffer.from(result);
+    }
+    /**
+     * Decompress data
+     */
+    static async decompress(data, options) {
+        const result = await utils_1.Compression.decompress(Buffer.from(data), {
+            algorithm: options?.algorithm || 'gzip',
+        });
+        return Buffer.from(result);
+    }
+    /**
+     * Compress data with metrics
+     */
+    static async compressWithMetrics(data, options) {
+        const startTime = Date.now();
+        const originalSize = Buffer.from(data).length;
+        const compressed = await utils_1.Compression.compress(Buffer.from(data), {
+            algorithm: options?.algorithm || 'gzip',
+            level: options?.level || 6,
+        });
+        const compressionTime = Date.now() - startTime;
+        const compressedSize = compressed.length;
+        const compressionRatio = compressedSize / originalSize;
+        return {
+            data: Buffer.from(compressed),
+            originalSize,
+            compressedSize,
+            compressionRatio,
+            compressionTime,
+        };
+    }
+    /**
+     * Get optimal compression level based on data size
+     */
+    static getOptimalLevel(dataSize) {
+        if (dataSize < 1024)
+            return 1; // Small data, fast compression
+        if (dataSize < 10240)
+            return 6; // Medium data, balanced
+        return 9; // Large data, best compression
+    }
+    /**
+     * Estimate compression ratio for data type
+     */
+    static estimateCompressionRatio(contentType) {
+        if (!contentType)
+            return 0.7;
+        const type = contentType.toLowerCase();
+        if (type.includes('json') || type.includes('xml'))
+            return 0.3;
+        if (type.includes('text'))
+            return 0.4;
+        if (type.includes('image') || type.includes('video'))
+            return 0.95;
+        return 0.7;
+    }
+}
+exports.CompressionUtils = CompressionUtils;
+/**
+ * Compression algorithm type
+ */
+CompressionUtils.Algorithm = {
+    GZIP: 'gzip',
+    DEFLATE: 'deflate',
+    BROTLI: 'brotli',
+    NONE: 'none',
+};

package/dist/esm/abstract/BaseCircuitBreaker.js

@@ -0,0 +1,249 @@
+/**
+ * Abstract base circuit breaker implementation
+ * @packageDocumentation
+ */
+/**
+ * Abstract base circuit breaker implementation
+ * Provides common functionality for all circuit breaker implementations
+ */
+export class BaseCircuitBreaker {
+    /**
+     * Create a new base circuit breaker instance
+     * @param name Circuit breaker name
+     * @param config Circuit breaker configuration
+     */
+    constructor(name, config) {
+        /** Current state */
+        this.state = 'closed';
+        /** Failure count */
+        this.failureCount = 0;
+        /** Success count */
+        this.successCount = 0;
+        /** Circuit breaker statistics */
+        this.stats = {
+            totalExecutions: 0,
+            totalSuccesses: 0,
+            totalFailures: 0,
+            successRate: 0,
+            failureRate: 0,
+            totalTimeOpen: 0,
+            totalTimeClosed: 0,
+            lastStateChange: Date.now(),
+        };
+        /** Time when current state was entered */
+        this.stateEnteredTime = Date.now();
+        this.name = name;
+        this.config = { ...config };
+        this.initialize();
+    }
+    /**
+     * Initialize circuit breaker
+     */
+    initialize() {
+        // Can be overridden by subclasses
+    }
+    /**
+     * Check if circuit breaker should allow execution
+     * @returns True if execution is allowed
+     */
+    shouldAllowExecution() {
+        switch (this.state) {
+            case 'closed':
+                return true;
+            case 'open':
+                if (this.nextResetTime && Date.now() >= this.nextResetTime) {
+                    this.transitionToHalfOpen();
+                    return true;
+                }
+                return false;
+            case 'half-open':
+                return this.failureCount < (this.config.halfOpenMaxAttempts || 1);
+            default:
+                return false;
+        }
+    }
+    /**
+     * Transition circuit breaker to closed state
+     */
+    transitionToClosed() {
+        const previousState = this.state;
+        this.state = 'closed';
+        this.failureCount = 0;
+        this.successCount = 0;
+        this.nextResetTime = undefined;
+        this.updateStateTime(previousState);
+        this.onStateChange('closed', previousState);
+    }
+    /**
+     * Transition circuit breaker to open state
+     * @param error Optional error that caused the transition
+     */
+    transitionToOpen(error) {
+        const previousState = this.state;
+        this.state = 'open';
+        this.nextResetTime = Date.now() + (this.config.resetTimeout || 30000);
+        this.updateStateTime(previousState);
+        this.onStateChange('open', previousState, error);
+    }
+    /**
+     * Transition circuit breaker to half-open state
+     */
+    transitionToHalfOpen() {
+        const previousState = this.state;
+        this.state = 'half-open';
+        this.failureCount = 0;
+        this.successCount = 0;
+        this.updateStateTime(previousState);
+        this.onStateChange('half-open', previousState);
+    }
+    /**
+     * Update state timing statistics
+     * @param previousState Previous state
+     */
+    updateStateTime(previousState) {
+        const now = Date.now();
+        const timeInState = now - this.stateEnteredTime;
+        if (previousState === 'open') {
+            this.stats.totalTimeOpen += timeInState;
+        }
+        else if (previousState === 'closed') {
+            this.stats.totalTimeClosed += timeInState;
+        }
+        this.stateEnteredTime = now;
+        this.stats.lastStateChange = now;
+    }
+    /**
+     * Hook for state changes
+     * @param newState New state
+     * @param previousState Previous state
+     * @param error Optional error that caused state change
+     */
+    onStateChange(newState, previousState, error) {
+        // Can be overridden by subclasses
+        // Emit events, log, etc.
+    }
+    /**
+     * Check if failure threshold is reached
+     * @returns True if failure threshold reached
+     */
+    isFailureThresholdReached() {
+        return this.failureCount >= (this.config.failureThreshold || 5);
+    }
+    /**
+     * Check if success threshold is reached
+     * @returns True if success threshold reached
+     */
+    isSuccessThresholdReached() {
+        return this.successCount >= (this.config.successThreshold || 1);
+    }
+    /**
+     * Manually trip the circuit breaker to open state
+     * @param error Error that caused the trip
+     */
+    trip(error) {
+        this.transitionToOpen(error);
+    }
+    /**
+     * Manually reset the circuit breaker to closed state
+     */
+    reset() {
+        this.transitionToClosed();
+    }
+    /**
+     * Check if circuit breaker is currently open
+     */
+    isOpen() {
+        return this.state === 'open';
+    }
+    /**
+     * Check if circuit breaker is currently closed
+     */
+    isClosed() {
+        return this.state === 'closed';
+    }
+    /**
+     * Check if circuit breaker is in half-open state
+     */
+    isHalfOpen() {
+        return this.state === 'half-open';
+    }
+    /**
+     * Record a successful execution
+     */
+    recordSuccess() {
+        this.successCount++;
+        this.lastSuccessTime = Date.now();
+        this.stats.totalSuccesses++;
+        if (this.state === 'half-open' && this.isSuccessThresholdReached()) {
+            this.transitionToClosed();
+        }
+    }
+    /**
+     * Record a failed execution
+     * @param error Error that occurred
+     */
+    recordFailure(error) {
+        this.failureCount++;
+        this.lastFailureTime = Date.now();
+        this.stats.totalFailures++;
+        if (this.state === 'half-open') {
+            this.transitionToOpen(error);
+        }
+        else if (this.state === 'closed' && this.isFailureThresholdReached()) {
+            this.transitionToOpen(error);
+        }
+    }
+    /**
+     * Get circuit breaker statistics
+     */
+    getStats() {
+        const total = this.stats.totalSuccesses + this.stats.totalFailures;
+        return {
+            ...this.stats,
+            successRate: total > 0 ? this.stats.totalSuccesses / total : 0,
+            failureRate: total > 0 ? this.stats.totalFailures / total : 0,
+        };
+    }
+    /**
+     * Reset circuit breaker statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalExecutions: 0,
+            totalSuccesses: 0,
+            totalFailures: 0,
+            successRate: 0,
+            failureRate: 0,
+            totalTimeOpen: 0,
+            totalTimeClosed: 0,
+            lastStateChange: Date.now(),
+        };
+    }
+    /**
+     * Update circuit breaker configuration
+     * @param config New configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Health check for the circuit breaker
+     */
+    healthCheck() {
+        const healthy = this.state === 'closed' || this.state === 'half-open';
+        return {
+            healthy,
+            state: this.state,
+            message: healthy ? 'Circuit breaker is operational' : 'Circuit breaker is open',
+            details: {
+                name: this.name,
+                failureCount: this.failureCount,
+                successCount: this.successCount,
+                lastFailureTime: this.lastFailureTime,
+                lastSuccessTime: this.lastSuccessTime,
+                nextResetTime: this.nextResetTime,
+                config: this.config,
+            },
+        };
+    }
+}