@naman_deep_singh/communication-core 1.0.0

package/dist/esm/abstract/BaseSerializer.js

@@ -0,0 +1,337 @@
+/**
+ * Abstract base serializer implementation
+ * @packageDocumentation
+ */
+import { CommunicationError } from '../errors/CommunicationError.js';
+import { COMMUNICATION_ERROR_CODES } from '../errors/communicationErrorCodes.js';
+/**
+ * Abstract base serializer implementation
+ * Provides common functionality for all serializer implementations
+ */
+export class BaseSerializer {
+    /**
+     * Create a new base serializer instance
+     * @param name Serializer name
+     * @param config Serializer configuration
+     */
+    constructor(name, config) {
+        /** Format handlers registry */
+        this.formatHandlers = new Map();
+        /** Serializer statistics */
+        this.stats = {
+            totalSerializations: 0,
+            totalDeserializations: 0,
+            serializationErrors: 0,
+            deserializationErrors: 0,
+            averageSerializationTime: 0,
+            averageDeserializationTime: 0,
+            formatUsage: {},
+        };
+        this.name = name;
+        this.config = { ...config };
+        this.supportedFormats = this.initializeSupportedFormats();
+        this.defaultFormat = this.supportedFormats[0] || 'json';
+        this.initialize();
+    }
+    /**
+     * Initialize serializer
+     */
+    initialize() {
+        // Register default format handlers
+        this.registerDefaultHandlers();
+    }
+    /**
+     * Perform serialization with timing and error handling
+     * @param data Data to serialize
+     * @param context Serialization context
+     * @param handler Serialization handler
+     * @returns Serialized data
+     */
+    performSerialization(data, context, handler) {
+        const startTime = Date.now();
+        const format = context.format;
+        try {
+            // Transform data if needed
+            const transformedData = this.transformData(data, 'serialize');
+            // Perform serialization
+            const result = handler(transformedData, context);
+            // Update statistics
+            this.updateSerializationStats(true, Date.now() - startTime, format);
+            return result;
+        }
+        catch (error) {
+            // Update error statistics
+            this.updateSerializationStats(false, Date.now() - startTime, format);
+            throw new CommunicationError(COMMUNICATION_ERROR_CODES.SERIALIZATION_ERROR, 500, {
+                message: `Serialization failed for format: ${format}`,
+                format,
+                originalError: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Perform deserialization with timing and error handling
+     * @param data Data to deserialize
+     * @param context Deserialization context
+     * @param handler Deserialization handler
+     * @returns Deserialized data
+     */
+    performDeserialization(data, context, handler) {
+        const startTime = Date.now();
+        const format = context.format;
+        try {
+            // Perform deserialization
+            const result = handler(data, context);
+            // Transform data if needed
+            const transformedResult = this.transformData(result, 'deserialize');
+            // Update statistics
+            this.updateDeserializationStats(true, Date.now() - startTime, format);
+            return transformedResult;
+        }
+        catch (error) {
+            // Update error statistics
+            this.updateDeserializationStats(false, Date.now() - startTime, format);
+            throw new CommunicationError(COMMUNICATION_ERROR_CODES.DESERIALIZATION_ERROR, 500, {
+                message: `Deserialization failed for format: ${format}`,
+                format,
+                originalError: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Transform data (e.g., date parsing, bigint handling)
+     * @param data Data to transform
+     * @param direction 'serialize' or 'deserialize'
+     */
+    transformData(data, direction) {
+        if (data === null || data === undefined) {
+            return data;
+        }
+        // Handle dates based on configuration
+        if (this.config.dateParsing) {
+            data = this.transformDates(data, direction);
+        }
+        // Handle bigints based on configuration
+        if (this.config.bigIntParsing) {
+            data = this.transformBigInts(data, direction);
+        }
+        // Apply custom transformations
+        data = this.applyCustomTransformations(data, direction);
+        return data;
+    }
+    /**
+     * Transform dates based on configuration
+     * @param data Data containing dates
+     * @param direction Transformation direction
+     */
+    transformDates(data, direction) {
+        if (data instanceof Date) {
+            switch (this.config.dateParsing) {
+                case 'string':
+                    return direction === 'serialize' ? data.toISOString() : data;
+                case 'timestamp':
+                    return direction === 'serialize' ? data.getTime() : data;
+                default:
+                    return data;
+            }
+        }
+        if (Array.isArray(data)) {
+            return data.map(item => this.transformDates(item, direction));
+        }
+        if (typeof data === 'object' && data !== null) {
+            const transformed = {};
+            for (const [key, value] of Object.entries(data)) {
+                transformed[key] = this.transformDates(value, direction);
+            }
+            return transformed;
+        }
+        return data;
+    }
+    /**
+     * Transform bigints based on configuration
+     * @param data Data containing bigints
+     * @param direction Transformation direction
+     */
+    transformBigInts(data, direction) {
+        if (typeof data === 'bigint') {
+            switch (this.config.bigIntParsing) {
+                case 'string':
+                    return direction === 'serialize' ? data.toString() : data;
+                case 'number':
+                    return direction === 'serialize' ? Number(data) : BigInt(data);
+                default:
+                    return data;
+            }
+        }
+        if (Array.isArray(data)) {
+            return data.map(item => this.transformBigInts(item, direction));
+        }
+        if (typeof data === 'object' && data !== null) {
+            const transformed = {};
+            for (const [key, value] of Object.entries(data)) {
+                transformed[key] = this.transformBigInts(value, direction);
+            }
+            return transformed;
+        }
+        return data;
+    }
+    /**
+     * Apply custom transformations
+     * @param data Data to transform
+     * @param direction Transformation direction
+     */
+    applyCustomTransformations(data, direction) {
+        // Can be overridden by subclasses
+        return data;
+    }
+    /**
+     * Update serialization statistics
+     * @param success Whether serialization succeeded
+     * @param duration Serialization duration in milliseconds
+     * @param format Format used
+     */
+    updateSerializationStats(success, duration, format) {
+        this.stats.totalSerializations++;
+        this.stats.averageSerializationTime = ((this.stats.averageSerializationTime * (this.stats.totalSerializations - 1) + duration) /
+            this.stats.totalSerializations);
+        if (!success) {
+            this.stats.serializationErrors++;
+        }
+        // Update format usage
+        this.stats.formatUsage[format] = (this.stats.formatUsage[format] || 0) + 1;
+    }
+    /**
+     * Update deserialization statistics
+     * @param success Whether deserialization succeeded
+     * @param duration Deserialization duration in milliseconds
+     * @param format Format used
+     */
+    updateDeserializationStats(success, duration, format) {
+        this.stats.totalDeserializations++;
+        this.stats.averageDeserializationTime = ((this.stats.averageDeserializationTime * (this.stats.totalDeserializations - 1) + duration) /
+            this.stats.totalDeserializations);
+        if (!success) {
+            this.stats.deserializationErrors++;
+        }
+        // Update format usage
+        this.stats.formatUsage[format] = (this.stats.formatUsage[format] || 0) + 1;
+    }
+    /**
+     * Check if a format is supported
+     * @param format Format to check
+     */
+    supportsFormat(format) {
+        return this.supportedFormats.includes(format);
+    }
+    /**
+     * Get content type for a format
+     * @param format Format
+     * @returns Content type string
+     */
+    getContentType(format) {
+        const handler = this.formatHandlers.get(format);
+        if (handler?.contentType) {
+            return handler.contentType;
+        }
+        // Default content types
+        switch (format) {
+            case 'json':
+                return 'application/json';
+            case 'xml':
+                return 'application/xml';
+            case 'yaml':
+                return 'application/yaml';
+            case 'protobuf':
+                return 'application/protobuf';
+            case 'msgpack':
+                return 'application/msgpack';
+            default:
+                return 'application/octet-stream';
+        }
+    }
+    /**
+     * Get format from content type
+     * @param contentType Content type
+     * @returns Format or undefined if not recognized
+     */
+    getFormatFromContentType(contentType) {
+        const normalized = contentType.toLowerCase().split(';')[0].trim();
+        for (const [format, handler] of this.formatHandlers.entries()) {
+            if (handler.contentType && handler.contentType.toLowerCase() === normalized) {
+                return format;
+            }
+        }
+        // Check common content types
+        if (normalized.includes('json')) {
+            return 'json';
+        }
+        else if (normalized.includes('xml')) {
+            return 'xml';
+        }
+        else if (normalized.includes('yaml') || normalized.includes('yml')) {
+            return 'yaml';
+        }
+        else if (normalized.includes('protobuf')) {
+            return 'protobuf';
+        }
+        else if (normalized.includes('msgpack')) {
+            return 'msgpack';
+        }
+        return undefined;
+    }
+    /**
+     * Register a custom format handler
+     * @param format Format name
+     * @param handler Serialization/deserialization functions
+     */
+    registerFormat(format, handler) {
+        this.formatHandlers.set(format, handler);
+        if (!this.supportedFormats.includes(format)) {
+            this.supportedFormats.push(format);
+        }
+    }
+    /**
+     * Update serializer configuration
+     * @param config New configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Get serializer statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Reset serializer statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalSerializations: 0,
+            totalDeserializations: 0,
+            serializationErrors: 0,
+            deserializationErrors: 0,
+            averageSerializationTime: 0,
+            averageDeserializationTime: 0,
+            formatUsage: {},
+        };
+    }
+    /**
+     * Health check for the serializer
+     */
+    healthCheck() {
+        const healthy = this.supportedFormats.length > 0;
+        return {
+            healthy,
+            message: healthy ? 'Serializer is operational' : 'No supported formats configured',
+            details: {
+                name: this.name,
+                supportedFormats: this.supportedFormats,
+                defaultFormat: this.defaultFormat,
+                registeredFormats: Array.from(this.formatHandlers.keys()),
+                statistics: this.getStats(),
+            },
+        };
+    }
+}

package/dist/esm/abstract/BaseServiceDiscoverer.js

@@ -0,0 +1,250 @@
+/**
+ * Abstract base service discoverer implementation
+ * @packageDocumentation
+ */
+/**
+ * Abstract base service discoverer implementation
+ * Provides common functionality for all service discovery implementations
+ */
+export class BaseServiceDiscoverer {
+    /**
+     * Create a new base service discoverer instance
+     * @param type Discovery type
+     * @param config Discovery configuration
+     */
+    constructor(type, config) {
+        /** Whether discovery is currently active */
+        this.isActive = false;
+        /** Total services discovered */
+        this.totalServicesDiscovered = 0;
+        /** Total instances discovered */
+        this.totalInstancesDiscovered = 0;
+        /** Service cache */
+        this.cache = new Map();
+        /** Cache timestamps */
+        this.cacheTimestamps = new Map();
+        /** Watch callbacks */
+        this.watchers = new Map();
+        /** Discovery statistics */
+        this.stats = {
+            totalResolves: 0,
+            totalWatches: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            cacheHitRate: 0,
+            averageResolveTime: 0,
+            totalResolveTime: 0,
+            uptime: 0,
+            startTime: Date.now(),
+        };
+        this.type = type;
+        this.config = { ...config };
+        this.initialize();
+    }
+    /**
+     * Initialize service discoverer
+     */
+    initialize() {
+        // Can be overridden by subclasses
+    }
+    /**
+     * Resolve all instances for multiple services
+     * @param serviceNames Array of service names
+     * @returns Promise resolving to map of service names to instances
+     */
+    async resolveAll(serviceNames) {
+        const results = new Map();
+        for (const serviceName of serviceNames) {
+            try {
+                const result = await this.resolve(serviceName);
+                results.set(serviceName, result.instances);
+            }
+            catch (error) {
+                results.set(serviceName, []);
+            }
+        }
+        return results;
+    }
+    /**
+     * Watch for changes to service instances
+     * @param serviceName Service name to watch
+     * @param callback Callback function for changes
+     * @returns Unwatch function
+     */
+    watch(serviceName, callback) {
+        let watchers = this.watchers.get(serviceName);
+        if (!watchers) {
+            watchers = new Set();
+            this.watchers.set(serviceName, watchers);
+        }
+        watchers.add(callback);
+        this.stats.totalWatches++;
+        return () => {
+            watchers?.delete(callback);
+            if (watchers?.size === 0) {
+                this.watchers.delete(serviceName);
+            }
+        };
+    }
+    /**
+     * Stop watching a service
+     * @param serviceName Service name to stop watching
+     */
+    unwatch(serviceName) {
+        this.watchers.delete(serviceName);
+    }
+    /**
+     * Stop watching all services
+     */
+    unwatchAll() {
+        this.watchers.clear();
+    }
+    /**
+     * Get cached service instances
+     * @param serviceName Service name
+     * @returns Cached instances or empty array
+     */
+    getCachedInstances(serviceName) {
+        return this.cache.get(serviceName) || [];
+    }
+    /**
+     * Clear cache for a service
+     * @param serviceName Service name
+     */
+    clearCache(serviceName) {
+        if (serviceName) {
+            this.cache.delete(serviceName);
+            this.cacheTimestamps.delete(serviceName);
+        }
+        else {
+            this.cache.clear();
+            this.cacheTimestamps.clear();
+        }
+    }
+    /**
+     * Refresh cache for a service
+     * @param serviceName Service name
+     * @returns Promise resolving when cache is refreshed
+     */
+    async refreshCache(serviceName) {
+        if (serviceName) {
+            this.clearCache(serviceName);
+            await this.resolve(serviceName);
+        }
+        else {
+            const serviceNames = Array.from(this.cache.keys());
+            this.clearCache();
+            await this.resolveAll(serviceNames);
+        }
+    }
+    /**
+     * Check if cache is valid for a service
+     * @param serviceName Service name
+     * @returns True if cache is valid
+     */
+    isCacheValid(serviceName) {
+        if (!this.config.cache?.enabled)
+            return false;
+        const timestamp = this.cacheTimestamps.get(serviceName);
+        if (!timestamp)
+            return false;
+        const ttl = this.config.cache.ttl;
+        return (Date.now() - timestamp) < ttl;
+    }
+    /**
+     * Update cache for a service
+     * @param serviceName Service name
+     * @param instances Service instances
+     */
+    updateCache(serviceName, instances) {
+        if (this.config.cache?.enabled) {
+            this.cache.set(serviceName, instances);
+            this.cacheTimestamps.set(serviceName, Date.now());
+        }
+    }
+    /**
+     * Notify watchers of service changes
+     * @param serviceName Service name
+     * @param instances Updated instances
+     */
+    notifyWatchers(serviceName, instances) {
+        const watchers = this.watchers.get(serviceName);
+        if (watchers) {
+            for (const callback of watchers) {
+                try {
+                    callback(instances);
+                }
+                catch (error) {
+                    // Log error but continue
+                }
+            }
+        }
+    }
+    /**
+     * Get service discovery statistics
+     */
+    getStats() {
+        this.stats.uptime = Date.now() - this.stats.startTime;
+        this.stats.cacheHitRate = this.stats.totalResolves > 0
+            ? this.stats.cacheHits / this.stats.totalResolves
+            : 0;
+        return { ...this.stats };
+    }
+    /**
+     * Reset service discovery statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalResolves: 0,
+            totalWatches: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            cacheHitRate: 0,
+            averageResolveTime: 0,
+            totalResolveTime: 0,
+            uptime: 0,
+            startTime: Date.now(),
+        };
+    }
+    /**
+     * Update service discovery configuration
+     * @param config New configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Health check for the service discoverer itself
+     */
+    async healthCheckSelf() {
+        const healthy = this.isActive;
+        return {
+            healthy,
+            message: healthy ? 'Service discoverer is operational' : 'Service discoverer is not active',
+            details: {
+                type: this.type,
+                isActive: this.isActive,
+                totalServices: this.totalServicesDiscovered,
+                totalInstances: this.totalInstancesDiscovered,
+                cacheSize: this.cache.size,
+                watchersCount: this.watchers.size,
+                stats: this.getStats(),
+            },
+        };
+    }
+    /**
+     * Close/cleanup service discovery resources
+     */
+    async close() {
+        this.isActive = false;
+        this.unwatchAll();
+        this.clearCache();
+        await this.onClose();
+    }
+    /**
+     * Hook for cleanup logic
+     */
+    async onClose() {
+        // Can be overridden by subclasses
+    }
+}