@naman_deep_singh/communication-core 1.0.0

package/dist/cjs/abstract/BaseTimeoutManager.js

@@ -0,0 +1,295 @@
+"use strict";
+/**
+ * Abstract base timeout manager implementation
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTimeoutManager = void 0;
+const utils_1 = require("@naman_deep_singh/utils");
+const CommunicationError_js_1 = require("../errors/CommunicationError.js");
+/**
+ * Abstract base timeout manager implementation
+ * Provides common functionality for timeout management
+ */
+class BaseTimeoutManager {
+    /**
+     * Create a new base timeout manager instance
+     * @param name Timeout manager name
+     * @param config Timeout configuration
+     */
+    constructor(name, config) {
+        /** Operation-specific timeouts */
+        this.operationTimeouts = new Map();
+        /** Timeout statistics */
+        this.stats = {
+            totalOperations: 0,
+            timedOutOperations: 0,
+            totalOperationTime: 0,
+            averageOperationTime: 0,
+            timeoutRate: 0,
+            perOperationStats: new Map(),
+        };
+        this.name = name;
+        this.config = { ...config };
+        this.initialize();
+    }
+    /**
+     * Initialize timeout manager
+     */
+    initialize() {
+        // Can be overridden by subclasses
+        // Set up default operation timeouts
+        if (this.config.global) {
+            this.operationTimeouts.set('global', this.config.global);
+        }
+        if (this.config.connection) {
+            this.operationTimeouts.set('connection', this.config.connection);
+        }
+        if (this.config.read) {
+            this.operationTimeouts.set('read', this.config.read);
+        }
+        if (this.config.write) {
+            this.operationTimeouts.set('write', this.config.write);
+        }
+        if (this.config.request) {
+            this.operationTimeouts.set('request', this.config.request);
+        }
+    }
+    /**
+     * Execute a function with timeout
+     * @param fn Function to execute
+     * @param options Timeout options
+     * @returns Promise resolving to function result
+     * @throws {CommunicationError} If timeout occurs
+     */
+    async execute(fn, options) {
+        const operationName = options?.name || 'anonymous';
+        const timeoutMs = options?.timeout || this.getOperationTimeout(operationName) || this.config.global || 30000;
+        const throwOnTimeout = options?.throwOnTimeout !== false;
+        const startTime = Date.now();
+        // Create timeout promise
+        const timeoutPromise = this.createTimeout(timeoutMs, options?.errorMessage || `Operation '${operationName}' timed out after ${timeoutMs}ms`);
+        // Create cleanup function
+        const cleanup = options?.cleanup;
+        try {
+            // Race between function and timeout
+            const result = await Promise.race([
+                fn(),
+                timeoutPromise,
+            ]);
+            const duration = Date.now() - startTime;
+            this.recordSuccess(operationName, duration);
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            // Check if it's a timeout error
+            if (error instanceof utils_1.TimeoutError || error instanceof CommunicationError_js_1.CommunicationError) {
+                this.recordTimeout(operationName, duration);
+                // Call cleanup if provided
+                if (cleanup) {
+                    try {
+                        await cleanup();
+                    }
+                    catch (cleanupError) {
+                        // Ignore cleanup errors
+                    }
+                }
+                if (throwOnTimeout) {
+                    throw error;
+                }
+                // If not throwing, return default value
+                return undefined;
+            }
+            // Record failure but not timeout
+            this.recordFailure(operationName, duration, error);
+            throw error;
+        }
+    }
+    /**
+     * Create a timeout promise
+     * @param timeout Timeout in milliseconds
+     * @param message Error message
+     * @returns Promise that rejects after timeout
+     */
+    createTimeout(timeout, message) {
+        return new Promise((_, reject) => {
+            const timer = setTimeout(() => {
+                clearTimeout(timer);
+                reject(new utils_1.TimeoutError(message || `Operation timed out after ${timeout}ms`, timeout));
+            }, timeout);
+        });
+    }
+    /**
+     * Create an abort signal for timeout
+     * @param timeout Timeout in milliseconds
+     * @returns AbortSignal
+     */
+    createAbortSignal(timeout) {
+        const controller = new AbortController();
+        setTimeout(() => controller.abort(), timeout);
+        return controller.signal;
+    }
+    /**
+     * Execute multiple promises with timeout
+     * @param promises Array of promises
+     * @param timeout Timeout in milliseconds
+     * @returns Promise that resolves when first promise resolves or times out
+     */
+    async race(promises, timeout) {
+        const timeoutPromise = this.createTimeout(timeout);
+        return Promise.race([...promises, timeoutPromise]);
+    }
+    /**
+     * Delay execution for specified time
+     * @param delay Delay in milliseconds
+     * @returns Promise that resolves after delay
+     */
+    delay(delay) {
+        return new Promise(resolve => setTimeout(resolve, delay));
+    }
+    /**
+     * Set operation timeout
+     * @param operation Operation identifier
+     * @param timeout Timeout in milliseconds
+     */
+    setOperationTimeout(operation, timeout) {
+        this.operationTimeouts.set(operation, timeout);
+    }
+    /**
+     * Get operation timeout
+     * @param operation Operation identifier
+     * @returns Timeout in milliseconds or undefined
+     */
+    getOperationTimeout(operation) {
+        // Check operation-specific timeout
+        const operationTimeout = this.operationTimeouts.get(operation);
+        if (operationTimeout !== undefined) {
+            return operationTimeout;
+        }
+        // Fall back to global timeout
+        return this.config.global;
+    }
+    /**
+     * Record successful operation
+     * @param operation Operation name
+     * @param duration Duration in milliseconds
+     */
+    recordSuccess(operation, duration) {
+        this.stats.totalOperations++;
+        this.stats.totalOperationTime += duration;
+        this.stats.averageOperationTime = this.stats.totalOperationTime / this.stats.totalOperations;
+        // Update per-operation stats
+        this.updateOperationStats(operation, duration, false);
+    }
+    /**
+     * Record timed out operation
+     * @param operation Operation name
+     * @param duration Duration in milliseconds
+     */
+    recordTimeout(operation, duration) {
+        this.stats.totalOperations++;
+        this.stats.timedOutOperations++;
+        this.stats.totalOperationTime += duration;
+        this.stats.averageOperationTime = this.stats.totalOperationTime / this.stats.totalOperations;
+        this.stats.timeoutRate = this.stats.timedOutOperations / this.stats.totalOperations;
+        // Update per-operation stats
+        this.updateOperationStats(operation, duration, true);
+    }
+    /**
+     * Record failed operation (not timeout)
+     * @param operation Operation name
+     * @param duration Duration in milliseconds
+     * @param error Error that occurred
+     */
+    recordFailure(operation, duration, error) {
+        this.stats.totalOperations++;
+        this.stats.totalOperationTime += duration;
+        this.stats.averageOperationTime = this.stats.totalOperationTime / this.stats.totalOperations;
+        // Update per-operation stats
+        this.updateOperationStats(operation, duration, false);
+    }
+    /**
+     * Update operation-specific statistics
+     * @param operation Operation name
+     * @param duration Duration in milliseconds
+     * @param isTimeout Whether operation timed out
+     */
+    updateOperationStats(operation, duration, isTimeout) {
+        let opStats = this.stats.perOperationStats.get(operation);
+        if (!opStats) {
+            opStats = {
+                calls: 0,
+                timeouts: 0,
+                totalTime: 0,
+                averageTime: 0,
+            };
+            this.stats.perOperationStats.set(operation, opStats);
+        }
+        opStats.calls++;
+        if (isTimeout) {
+            opStats.timeouts++;
+        }
+        opStats.totalTime += duration;
+        opStats.averageTime = opStats.totalTime / opStats.calls;
+    }
+    /**
+     * Update timeout configuration
+     * @param config New configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+        // Re-initialize operation timeouts
+        this.initialize();
+    }
+    /**
+     * Get timeout statistics
+     */
+    getStats() {
+        const perOperationStats = {};
+        for (const [operation, stats] of this.stats.perOperationStats) {
+            perOperationStats[operation] = {
+                calls: stats.calls,
+                timeouts: stats.timeouts,
+                averageTime: stats.averageTime,
+            };
+        }
+        return {
+            totalOperations: this.stats.totalOperations,
+            timedOutOperations: this.stats.timedOutOperations,
+            averageOperationTime: this.stats.averageOperationTime,
+            timeoutRate: this.stats.timeoutRate,
+            perOperationStats,
+        };
+    }
+    /**
+     * Reset timeout statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalOperations: 0,
+            timedOutOperations: 0,
+            totalOperationTime: 0,
+            averageOperationTime: 0,
+            timeoutRate: 0,
+            perOperationStats: new Map(),
+        };
+    }
+    /**
+     * Health check for timeout manager
+     */
+    healthCheck() {
+        const healthy = true; // Timeout manager is always healthy
+        return {
+            healthy,
+            message: 'Timeout manager is operational',
+            details: {
+                name: this.name,
+                config: this.config,
+                operationTimeouts: Object.fromEntries(this.operationTimeouts),
+                statistics: this.getStats(),
+            },
+        };
+    }
+}
+exports.BaseTimeoutManager = BaseTimeoutManager;

package/dist/cjs/abstract/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCompressionManager = exports.BaseConnectionPool = exports.BaseTimeoutManager = exports.BaseInterceptor = exports.BaseServiceDiscoverer = exports.BaseSerializer = exports.BaseLoadBalancer = exports.BaseRetryStrategy = exports.BaseCircuitBreaker = exports.BaseClient = exports.BaseProtocol = void 0;
+var BaseProtocol_js_1 = require("./BaseProtocol.js");
+Object.defineProperty(exports, "BaseProtocol", { enumerable: true, get: function () { return BaseProtocol_js_1.BaseProtocol; } });
+var BaseClient_js_1 = require("./BaseClient.js");
+Object.defineProperty(exports, "BaseClient", { enumerable: true, get: function () { return BaseClient_js_1.BaseClient; } });
+var BaseCircuitBreaker_js_1 = require("./BaseCircuitBreaker.js");
+Object.defineProperty(exports, "BaseCircuitBreaker", { enumerable: true, get: function () { return BaseCircuitBreaker_js_1.BaseCircuitBreaker; } });
+var BaseRetryStrategy_js_1 = require("./BaseRetryStrategy.js");
+Object.defineProperty(exports, "BaseRetryStrategy", { enumerable: true, get: function () { return BaseRetryStrategy_js_1.BaseRetryStrategy; } });
+var BaseLoadBalancer_js_1 = require("./BaseLoadBalancer.js");
+Object.defineProperty(exports, "BaseLoadBalancer", { enumerable: true, get: function () { return BaseLoadBalancer_js_1.BaseLoadBalancer; } });
+var BaseSerializer_js_1 = require("./BaseSerializer.js");
+Object.defineProperty(exports, "BaseSerializer", { enumerable: true, get: function () { return BaseSerializer_js_1.BaseSerializer; } });
+var BaseServiceDiscoverer_js_1 = require("./BaseServiceDiscoverer.js");
+Object.defineProperty(exports, "BaseServiceDiscoverer", { enumerable: true, get: function () { return BaseServiceDiscoverer_js_1.BaseServiceDiscoverer; } });
+var BaseInterceptor_js_1 = require("./BaseInterceptor.js");
+Object.defineProperty(exports, "BaseInterceptor", { enumerable: true, get: function () { return BaseInterceptor_js_1.BaseInterceptor; } });
+var BaseTimeoutManager_js_1 = require("./BaseTimeoutManager.js");
+Object.defineProperty(exports, "BaseTimeoutManager", { enumerable: true, get: function () { return BaseTimeoutManager_js_1.BaseTimeoutManager; } });
+var BaseConnectionPool_js_1 = require("./BaseConnectionPool.js");
+Object.defineProperty(exports, "BaseConnectionPool", { enumerable: true, get: function () { return BaseConnectionPool_js_1.BaseConnectionPool; } });
+var BaseCompressionManager_js_1 = require("./BaseCompressionManager.js");
+Object.defineProperty(exports, "BaseCompressionManager", { enumerable: true, get: function () { return BaseCompressionManager_js_1.BaseCompressionManager; } });

package/dist/cjs/errors/CircuitBreakerError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreakerError = void 0;
+const CommunicationError_js_1 = require("./CommunicationError.js");
+const communicationErrorCodes_js_1 = require("./communicationErrorCodes.js");
+/**
+ * Circuit breaker error - when circuit is open
+ */
+class CircuitBreakerError extends CommunicationError_js_1.CommunicationError {
+    constructor(details, cause) {
+        super(communicationErrorCodes_js_1.COMMUNICATION_ERROR_CODES.CIRCUIT_BREAKER_OPEN, 503, // Service Unavailable
+        details, cause);
+        this.name = 'CircuitBreakerError';
+    }
+}
+exports.CircuitBreakerError = CircuitBreakerError;

package/dist/cjs/errors/CommunicationError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommunicationError = void 0;
+const errors_1 = require("@naman_deep_singh/errors");
+/**
+ * Base communication error class
+ * Extends AppError from errors package
+ */
+class CommunicationError extends errors_1.AppError {
+    constructor(code, statusCode = 500, details, cause) {
+        super(code, statusCode, details, cause);
+        this.name = 'CommunicationError';
+    }
+}
+exports.CommunicationError = CommunicationError;

package/dist/cjs/errors/ConnectionError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionError = void 0;
+const CommunicationError_js_1 = require("./CommunicationError.js");
+const communicationErrorCodes_js_1 = require("./communicationErrorCodes.js");
+/**
+ * Connection error - when connection fails
+ */
+class ConnectionError extends CommunicationError_js_1.CommunicationError {
+    constructor(code = communicationErrorCodes_js_1.COMMUNICATION_ERROR_CODES.CONNECTION_ERROR, details, cause) {
+        super(code, 503, details, cause);
+        this.name = 'ConnectionError';
+    }
+}
+exports.ConnectionError = ConnectionError;

package/dist/cjs/errors/DiscoveryError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryError = void 0;
+const CommunicationError_js_1 = require("./CommunicationError.js");
+const communicationErrorCodes_js_1 = require("./communicationErrorCodes.js");
+/**
+ * Service discovery error
+ */
+class DiscoveryError extends CommunicationError_js_1.CommunicationError {
+    constructor(code = communicationErrorCodes_js_1.COMMUNICATION_ERROR_CODES.DISCOVERY_ERROR, details, cause) {
+        super(code, 503, details, cause); // 503 Service Unavailable
+        this.name = 'DiscoveryError';
+    }
+}
+exports.DiscoveryError = DiscoveryError;

package/dist/cjs/errors/LoadBalancerError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadBalancerError = void 0;
+const CommunicationError_js_1 = require("./CommunicationError.js");
+const communicationErrorCodes_js_1 = require("./communicationErrorCodes.js");
+/**
+ * Load balancer error - when load balancing fails
+ */
+class LoadBalancerError extends CommunicationError_js_1.CommunicationError {
+    constructor(code = communicationErrorCodes_js_1.COMMUNICATION_ERROR_CODES.LOAD_BALANCER_ERROR, details, cause) {
+        super(code, 503, details, cause);
+        this.name = 'LoadBalancerError';
+    }
+}
+exports.LoadBalancerError = LoadBalancerError;

package/dist/cjs/errors/ProtocolError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtocolError = void 0;
+const CommunicationError_js_1 = require("./CommunicationError.js");
+const communicationErrorCodes_js_1 = require("./communicationErrorCodes.js");
+/**
+ * Protocol error - when protocol communication fails
+ */
+class ProtocolError extends CommunicationError_js_1.CommunicationError {
+    constructor(code = communicationErrorCodes_js_1.COMMUNICATION_ERROR_CODES.PROTOCOL_ERROR, details, cause) {
+        super(code, 502, details, cause); // 502 Bad Gateway
+        this.name = 'ProtocolError';
+    }
+}
+exports.ProtocolError = ProtocolError;

package/dist/cjs/errors/RetryError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryError = void 0;
+const CommunicationError_js_1 = require("./CommunicationError.js");
+const communicationErrorCodes_js_1 = require("./communicationErrorCodes.js");
+/**
+ * Retry exhausted error - when all retry attempts fail
+ */
+class RetryError extends CommunicationError_js_1.CommunicationError {
+    constructor(details, cause) {
+        super(communicationErrorCodes_js_1.COMMUNICATION_ERROR_CODES.RETRY_EXHAUSTED, 503, // Service Unavailable
+        details, cause);
+        this.name = 'RetryError';
+    }
+}
+exports.RetryError = RetryError;

package/dist/cjs/errors/SerializationError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializationError = void 0;
+const CommunicationError_js_1 = require("./CommunicationError.js");
+const communicationErrorCodes_js_1 = require("./communicationErrorCodes.js");
+/**
+ * Serialization error - when serialization/deserialization fails
+ */
+class SerializationError extends CommunicationError_js_1.CommunicationError {
+    constructor(code = communicationErrorCodes_js_1.COMMUNICATION_ERROR_CODES.SERIALIZATION_ERROR, details, cause) {
+        super(code, 500, details, cause);
+        this.name = 'SerializationError';
+    }
+}
+exports.SerializationError = SerializationError;

package/dist/cjs/errors/ServiceUnavailableError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceUnavailableError = void 0;
+const errors_1 = require("@naman_deep_singh/errors");
+/**
+ * Service unavailable error for communication layer
+ * Extends the existing ServiceUnavailableError
+ */
+class ServiceUnavailableError extends errors_1.ServiceUnavailableError {
+    constructor(details, cause) {
+        super(details, cause);
+        this.name = 'ServiceUnavailableError';
+    }
+}
+exports.ServiceUnavailableError = ServiceUnavailableError;

package/dist/cjs/errors/TimeoutError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutError = void 0;
+const CommunicationError_js_1 = require("./CommunicationError.js");
+const communicationErrorCodes_js_1 = require("./communicationErrorCodes.js");
+/**
+ * Timeout error - when operation times out
+ */
+class TimeoutError extends CommunicationError_js_1.CommunicationError {
+    constructor(details, cause) {
+        super(communicationErrorCodes_js_1.COMMUNICATION_ERROR_CODES.TIMEOUT_EXHAUSTED, 504, // Gateway Timeout
+        details, cause);
+        this.name = 'TimeoutError';
+    }
+}
+exports.TimeoutError = TimeoutError;

package/dist/cjs/errors/communicationErrorCodes.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMUNICATION_ERROR_CODES = void 0;
+/**
+ * Communication-specific error codes
+ * Extends the existing ERROR_CODES
+ */
+exports.COMMUNICATION_ERROR_CODES = {
+    // Protocol errors
+    PROTOCOL_ERROR: 'Protocol communication failed',
+    HTTP_PROTOCOL_ERROR: 'HTTP protocol error occurred',
+    GRPC_PROTOCOL_ERROR: 'gRPC protocol error occurred',
+    WEBSOCKET_PROTOCOL_ERROR: 'WebSocket protocol error occurred',
+    // Discovery errors
+    DISCOVERY_ERROR: 'Service discovery failed',
+    SERVICE_NOT_FOUND: 'Service not found in registry',
+    NO_AVAILABLE_INSTANCES: 'No available service instances',
+    DISCOVERY_TIMEOUT: 'Service discovery timed out',
+    // Resilience errors
+    CIRCUIT_BREAKER_OPEN: 'Circuit breaker is open, request blocked',
+    CIRCUIT_BREAKER_ERROR: 'Circuit breaker encountered an error',
+    RETRY_EXHAUSTED: 'Retry attempts exhausted',
+    BULKHEAD_FULL: 'Bulkhead is full, request rejected',
+    TIMEOUT_EXHAUSTED: 'Operation timeout exceeded',
+    // Load balancing errors
+    LOAD_BALANCER_ERROR: 'Load balancing failed',
+    NO_HEALTHY_INSTANCES: 'No healthy instances available',
+    // Serialization errors
+    SERIALIZATION_ERROR: 'Serialization failed',
+    DESERIALIZATION_ERROR: 'Deserialization failed',
+    // Connection errors
+    CONNECTION_ERROR: 'Connection failed',
+    CONNECTION_TIMEOUT: 'Connection timeout',
+    CONNECTION_REFUSED: 'Connection refused',
+};

package/dist/cjs/errors/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMUNICATION_ERROR_CODES = exports.TimeoutError = exports.ServiceUnavailableError = exports.SerializationError = exports.RetryError = exports.ProtocolError = exports.LoadBalancerError = exports.DiscoveryError = exports.ConnectionError = exports.CommunicationError = exports.CircuitBreakerError = void 0;
+const errors_1 = require("@naman_deep_singh/errors");
+const communicationErrorCodes_js_1 = require("./communicationErrorCodes.js");
+// Register communication error messages with the global registry
+errors_1.errorMessageRegistry.register(communicationErrorCodes_js_1.COMMUNICATION_ERROR_CODES);
+// Export error classes
+var CircuitBreakerError_js_1 = require("./CircuitBreakerError.js");
+Object.defineProperty(exports, "CircuitBreakerError", { enumerable: true, get: function () { return CircuitBreakerError_js_1.CircuitBreakerError; } });
+var CommunicationError_js_1 = require("./CommunicationError.js");
+Object.defineProperty(exports, "CommunicationError", { enumerable: true, get: function () { return CommunicationError_js_1.CommunicationError; } });
+var ConnectionError_js_1 = require("./ConnectionError.js");
+Object.defineProperty(exports, "ConnectionError", { enumerable: true, get: function () { return ConnectionError_js_1.ConnectionError; } });
+var DiscoveryError_js_1 = require("./DiscoveryError.js");
+Object.defineProperty(exports, "DiscoveryError", { enumerable: true, get: function () { return DiscoveryError_js_1.DiscoveryError; } });
+var LoadBalancerError_js_1 = require("./LoadBalancerError.js");
+Object.defineProperty(exports, "LoadBalancerError", { enumerable: true, get: function () { return LoadBalancerError_js_1.LoadBalancerError; } });
+var ProtocolError_js_1 = require("./ProtocolError.js");
+Object.defineProperty(exports, "ProtocolError", { enumerable: true, get: function () { return ProtocolError_js_1.ProtocolError; } });
+var RetryError_js_1 = require("./RetryError.js");
+Object.defineProperty(exports, "RetryError", { enumerable: true, get: function () { return RetryError_js_1.RetryError; } });
+var SerializationError_js_1 = require("./SerializationError.js");
+Object.defineProperty(exports, "SerializationError", { enumerable: true, get: function () { return SerializationError_js_1.SerializationError; } });
+var ServiceUnavailableError_js_1 = require("./ServiceUnavailableError.js");
+Object.defineProperty(exports, "ServiceUnavailableError", { enumerable: true, get: function () { return ServiceUnavailableError_js_1.ServiceUnavailableError; } });
+var TimeoutError_js_1 = require("./TimeoutError.js");
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return TimeoutError_js_1.TimeoutError; } });
+// Also export error codes for convenience
+var communicationErrorCodes_js_2 = require("./communicationErrorCodes.js");
+Object.defineProperty(exports, "COMMUNICATION_ERROR_CODES", { enumerable: true, get: function () { return communicationErrorCodes_js_2.COMMUNICATION_ERROR_CODES; } });

package/dist/cjs/index.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Communication Core Package
+ * @packageDocumentation
+ *
+ * Core interfaces and abstract implementations for service-to-service communication.
+ * This package provides the foundation for communication protocols, resilience patterns,
+ * service discovery, load balancing, and interceptors.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionUtils = exports.ConnectionPoolUtils = exports.TimeoutUtils = void 0;
+// Core interfaces
+__exportStar(require("./interfaces/index.js"), exports);
+// Abstract base implementations
+__exportStar(require("./abstract/index.js"), exports);
+// Type definitions
+__exportStar(require("./types/index.js"), exports);
+// Error classes
+__exportStar(require("./errors/index.js"), exports);
+// Utilities (excluding ConnectionPoolConfig to avoid duplicate)
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "TimeoutUtils", { enumerable: true, get: function () { return utils_js_1.TimeoutUtils; } });
+Object.defineProperty(exports, "ConnectionPoolUtils", { enumerable: true, get: function () { return utils_js_1.ConnectionPoolUtils; } });
+Object.defineProperty(exports, "CompressionUtils", { enumerable: true, get: function () { return utils_js_1.CompressionUtils; } });

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

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

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });