@naman_deep_singh/communication-core 1.0.0

package/dist/cjs/abstract/BaseInterceptor.js

@@ -0,0 +1,235 @@
+"use strict";
+/**
+ * Abstract base interceptor implementation
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseInterceptor = void 0;
+/**
+ * Abstract base interceptor implementation
+ * Provides common functionality for all interceptor implementations
+ */
+class BaseInterceptor {
+    /**
+     * Create a new base interceptor instance
+     * @param name Interceptor name
+     * @param options Interceptor options
+     */
+    constructor(name, options) {
+        /** Whether interceptor is enabled */
+        this.enabled = true;
+        /** Interceptor statistics */
+        this.stats = {
+            totalRequests: 0,
+            totalResponses: 0,
+            totalErrors: 0,
+            modifications: 0,
+            totalProcessingTime: 0,
+            averageProcessingTime: 0,
+        };
+        /** Configuration */
+        this.config = {};
+        this.name = name;
+        this.version = options?.version || '1.0.0';
+        this.description = options?.description;
+        this.enabled = options?.enabled ?? true;
+        // Set default order if not provided
+        this.order = options?.order || {
+            request: 0,
+            response: 0,
+            error: 0
+        };
+        this.config = { ...options };
+        // Call setup instead of initialize to avoid confusion with interface method
+        this.setup(options);
+    }
+    /**
+     * Setup interceptor (internal initialization)
+     * @param options Initialization options
+     */
+    setup(options) {
+        // Can be overridden by subclasses
+    }
+    /**
+     * Initialize interceptor (called when added to client/protocol)
+     * @param options Initialization options
+     */
+    initialize(options) {
+        // Can be overridden by subclasses
+        this.config = { ...this.config, ...options };
+    }
+    /**
+     * Cleanup interceptor (called when removed from client/protocol)
+     */
+    cleanup() {
+        // Can be overridden by subclasses
+    }
+    /**
+     * Get interceptor configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update interceptor configuration
+     * @param config New configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Health check for the interceptor
+     */
+    healthCheck() {
+        const healthy = this.enabled && !this.stats.lastError;
+        return {
+            healthy,
+            message: healthy ? 'Interceptor is operational' : 'Interceptor has errors',
+            details: {
+                name: this.name,
+                enabled: this.enabled,
+                lastError: this.stats.lastError,
+                statistics: this.getStats(),
+            },
+        };
+    }
+    /**
+     * Get interceptor statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Reset interceptor statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalRequests: 0,
+            totalResponses: 0,
+            totalErrors: 0,
+            modifications: 0,
+            totalProcessingTime: 0,
+            averageProcessingTime: 0,
+        };
+        this.lastProcessingTime = undefined;
+    }
+    /**
+     * Execute request interception with timing and error handling
+     * @param request Original request
+     * @param context Request context
+     * @returns Modified request or original if not modified
+     */
+    async executeOnRequest(request, context) {
+        if (!this.enabled || !this.onRequest) {
+            return request;
+        }
+        const startTime = Date.now();
+        try {
+            const result = await this.onRequest(request, context);
+            const processingTime = Date.now() - startTime;
+            this.updateRequestStats(processingTime, result !== undefined);
+            this.lastProcessingTime = processingTime;
+            return result !== undefined ? result : request;
+        }
+        catch (error) {
+            this.stats.lastError = error instanceof Error ? error.message : String(error);
+            this.stats.totalErrors++;
+            throw error;
+        }
+    }
+    /**
+     * Execute response interception with timing and error handling
+     * @param response Original response
+     * @param context Request context
+     * @returns Modified response or original if not modified
+     */
+    async executeOnResponse(response, context) {
+        if (!this.enabled || !this.onResponse) {
+            return response;
+        }
+        const startTime = Date.now();
+        try {
+            const result = await this.onResponse(response, context);
+            const processingTime = Date.now() - startTime;
+            this.updateResponseStats(processingTime, result !== undefined);
+            this.lastProcessingTime = processingTime;
+            return result !== undefined ? result : response;
+        }
+        catch (error) {
+            this.stats.lastError = error instanceof Error ? error.message : String(error);
+            this.stats.totalErrors++;
+            throw error;
+        }
+    }
+    /**
+     * 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
+     */
+    async executeOnError(error, context) {
+        if (!this.enabled || !this.onError) {
+            return error;
+        }
+        const startTime = Date.now();
+        try {
+            const result = await this.onError(error, context);
+            const processingTime = Date.now() - startTime;
+            this.updateErrorStats(processingTime, result !== undefined);
+            this.lastProcessingTime = processingTime;
+            if (result === undefined) {
+                return error;
+            }
+            return result;
+        }
+        catch (interceptorError) {
+            this.stats.lastError = interceptorError instanceof Error ? interceptorError.message : String(interceptorError);
+            this.stats.totalErrors++;
+            // If interceptor itself fails, return the original error
+            return error;
+        }
+    }
+    /**
+     * Update request statistics
+     * @param processingTime Processing time in milliseconds
+     * @param modified Whether request was modified
+     */
+    updateRequestStats(processingTime, modified) {
+        this.stats.totalRequests++;
+        this.stats.totalProcessingTime += processingTime;
+        this.stats.averageProcessingTime = this.stats.totalProcessingTime /
+            (this.stats.totalRequests + this.stats.totalResponses + this.stats.totalErrors);
+        if (modified) {
+            this.stats.modifications++;
+        }
+    }
+    /**
+     * Update response statistics
+     * @param processingTime Processing time in milliseconds
+     * @param modified Whether response was modified
+     */
+    updateResponseStats(processingTime, modified) {
+        this.stats.totalResponses++;
+        this.stats.totalProcessingTime += processingTime;
+        this.stats.averageProcessingTime = this.stats.totalProcessingTime /
+            (this.stats.totalRequests + this.stats.totalResponses + this.stats.totalErrors);
+        if (modified) {
+            this.stats.modifications++;
+        }
+    }
+    /**
+     * Update error statistics
+     * @param processingTime Processing time in milliseconds
+     * @param modified Whether error was modified
+     */
+    updateErrorStats(processingTime, modified) {
+        this.stats.totalErrors++;
+        this.stats.totalProcessingTime += processingTime;
+        this.stats.averageProcessingTime = this.stats.totalProcessingTime /
+            (this.stats.totalRequests + this.stats.totalResponses + this.stats.totalErrors);
+        if (modified) {
+            this.stats.modifications++;
+        }
+    }
+}
+exports.BaseInterceptor = BaseInterceptor;

package/dist/cjs/abstract/BaseLoadBalancer.js

@@ -0,0 +1,269 @@
+"use strict";
+/**
+ * Abstract base load balancer implementation
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseLoadBalancer = void 0;
+/**
+ * Abstract base load balancer implementation
+ * Provides common functionality for all load balancing strategy implementations
+ */
+class BaseLoadBalancer {
+    /**
+     * Create a new base load balancer instance
+     * @param name Load balancer name
+     * @param config Load balancer configuration
+     */
+    constructor(name, config) {
+        /** Total selections made */
+        this.totalSelections = 0;
+        /** Instance statistics */
+        this.instanceStats = new Map();
+        /** Load balancer statistics */
+        this.stats = {
+            totalSelections: 0,
+            successfulSelections: 0,
+            failedSelections: 0,
+            averageSelectionTime: 0,
+            instanceStats: {},
+        };
+        this.name = name;
+        this.config = { ...config };
+        this.initialize();
+    }
+    /**
+     * Initialize load balancer
+     */
+    initialize() {
+        // Can be overridden by subclasses
+    }
+    /**
+     * Select multiple service instances
+     * @param instances Available service instances
+     * @param count Number of instances to select
+     * @param context Selection context
+     * @returns Selected service instances
+     */
+    selectMultiple(instances, count, context) {
+        const selected = [];
+        const available = [...instances];
+        for (let i = 0; i < count && available.length > 0; i++) {
+            const instance = this.select(available, context);
+            selected.push(instance);
+            // Remove selected instance from available pool
+            const index = available.findIndex(inst => inst.id === instance.id);
+            if (index !== -1) {
+                available.splice(index, 1);
+            }
+        }
+        return selected;
+    }
+    /**
+     * Update instance statistics (for adaptive strategies)
+     * @param instance Service instance
+     * @param success Whether the request was successful
+     * @param responseTime Response time in milliseconds
+     */
+    updateStats(instance, success, responseTime) {
+        const instanceId = instance.id;
+        const now = Date.now();
+        let stats = this.instanceStats.get(instanceId);
+        if (!stats) {
+            stats = {
+                selections: 0,
+                successes: 0,
+                failures: 0,
+                totalResponseTime: 0,
+                averageResponseTime: undefined,
+                lastSelected: undefined,
+            };
+            this.instanceStats.set(instanceId, stats);
+        }
+        stats.selections++;
+        stats.lastSelected = now;
+        if (success) {
+            stats.successes++;
+            if (responseTime !== undefined) {
+                stats.totalResponseTime += responseTime;
+                stats.averageResponseTime = stats.totalResponseTime / stats.selections;
+            }
+        }
+        else {
+            stats.failures++;
+        }
+        // Update aggregate stats
+        this.updateAggregateStats(instanceId, stats);
+    }
+    /**
+     * Update aggregate statistics
+     * @param instanceId Instance ID
+     * @param instanceStats Instance statistics
+     */
+    updateAggregateStats(instanceId, instanceStats) {
+        this.stats.instanceStats[instanceId] = {
+            selections: instanceStats.selections,
+            successes: instanceStats.successes,
+            failures: instanceStats.failures,
+            averageResponseTime: instanceStats.averageResponseTime,
+        };
+    }
+    /**
+     * Reset instance statistics
+     * @param instanceId Optional instance ID to reset, or reset all
+     */
+    resetStats(instanceId) {
+        if (instanceId) {
+            this.instanceStats.delete(instanceId);
+            delete this.stats.instanceStats[instanceId];
+        }
+        else {
+            this.instanceStats.clear();
+            this.stats.instanceStats = {};
+            this.totalSelections = 0;
+            this.lastSelectionTime = undefined;
+            this.stats.totalSelections = 0;
+            this.stats.successfulSelections = 0;
+            this.stats.failedSelections = 0;
+            this.stats.averageSelectionTime = 0;
+        }
+    }
+    /**
+     * Get instance statistics
+     * @param instanceId Optional instance ID to get stats for
+     */
+    getStats(instanceId) {
+        if (instanceId) {
+            const stats = this.instanceStats.get(instanceId);
+            return stats ? { ...stats, instanceId } : {};
+        }
+        return {
+            ...this.stats,
+            totalSelections: this.totalSelections,
+            lastSelectionTime: this.lastSelectionTime,
+        };
+    }
+    /**
+     * Check if an instance is currently eligible for selection
+     * @param instance Service instance to check
+     */
+    isEligible(instance) {
+        // Default eligibility: instance must be healthy
+        if (instance.status !== 'healthy') {
+            return false;
+        }
+        // Check if instance is within weight limits (if weighted strategy)
+        if (this.config.weights) {
+            const weight = this.config.weights[instance.id];
+            if (weight !== undefined && weight <= 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Filter instances based on eligibility
+     * @param instances Instances to filter
+     */
+    filterEligible(instances) {
+        return instances.filter(instance => this.isEligible(instance));
+    }
+    /**
+     * Sort instances by selection priority
+     * @param instances Instances to sort
+     */
+    sortByPriority(instances) {
+        // Default: no sorting, return as-is
+        return [...instances];
+    }
+    /**
+     * Get instance weight
+     * @param instance Service instance
+     * @returns Instance weight
+     */
+    getInstanceWeight(instance) {
+        if (this.config.weights && this.config.weights[instance.id]) {
+            return this.config.weights[instance.id];
+        }
+        if (instance.weight !== undefined) {
+            return instance.weight;
+        }
+        return 1; // Default weight
+    }
+    /**
+     * Record selection
+     * @param instance Selected instance
+     * @param selectionTime Selection time in milliseconds
+     */
+    recordSelection(instance, selectionTime) {
+        this.totalSelections++;
+        this.lastSelectionTime = Date.now();
+        this.stats.totalSelections++;
+        // Update average selection time
+        this.stats.averageSelectionTime = ((this.stats.averageSelectionTime * (this.stats.totalSelections - 1) + selectionTime) /
+            this.stats.totalSelections);
+        // Update instance stats
+        this.updateStats(instance, true);
+    }
+    /**
+     * Create selection result
+     * @param instance Selected instance
+     * @param instances Available instances
+     * @param selectionTime Selection time in milliseconds
+     * @returns Selection result
+     */
+    createSelectionResult(instance, instances, selectionTime) {
+        return {
+            selectedInstance: instance,
+            availableInstances: instances,
+            timestamp: Date.now(),
+            selectionDuration: selectionTime,
+            metadata: {
+                strategy: this.name,
+                totalSelections: this.totalSelections,
+            },
+        };
+    }
+    /**
+     * Update load balancer configuration
+     * @param config New configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Get load balancer statistics
+     */
+    getStrategyStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Reset load balancer statistics
+     */
+    resetStrategyStats() {
+        this.stats = {
+            totalSelections: 0,
+            successfulSelections: 0,
+            failedSelections: 0,
+            averageSelectionTime: 0,
+            instanceStats: {},
+        };
+    }
+    /**
+     * Health check for the load balancer
+     */
+    healthCheck() {
+        const healthy = true; // Load balancer is always healthy
+        return {
+            healthy,
+            message: 'Load balancer is operational',
+            details: {
+                name: this.name,
+                totalSelections: this.totalSelections,
+                instanceCount: this.instanceStats.size,
+                config: this.config,
+            },
+        };
+    }
+}
+exports.BaseLoadBalancer = BaseLoadBalancer;