rabbitmq-sdk 0.0.1-security → 1.2.0

package/src/components/DLQHandler.ts

@@ -0,0 +1,271 @@
+import { IDLQHandler } from '../interfaces/IDLQ';
+import { IConfiguration } from '../interfaces/IConfiguration';
+import { ConnectionManager } from './ConnectionManager';
+import { ResourceCreator } from './ResourceCreator';
+import { Logger } from './Logger';
+
+/**
+ * DLQHandler manages Dead Letter Queue functionality
+ * Handles DLQ setup, configuration, and failed message routing
+ */
+export class DLQHandler implements IDLQHandler {
+  private config: IConfiguration;
+  private connectionManager: ConnectionManager;
+  private resourceCreator: ResourceCreator;
+  private dlqSetupCache = new Set<string>();
+  private logger: Logger;
+
+  constructor(
+    config: IConfiguration,
+    connectionManager: ConnectionManager,
+    resourceCreator: ResourceCreator
+  ) {
+    this.config = config;
+    this.connectionManager = connectionManager;
+    this.resourceCreator = resourceCreator;
+    this.logger = Logger.createComponentLogger('DLQHandler', config.logging);
+  }
+
+  /**
+   * Check if DLQ is enabled in configuration
+   * @returns boolean indicating if DLQ is active
+   */
+  public isEnabled(): boolean {
+    return this.config.dlq.active;
+  }
+
+  /**
+   * Set up DLQ for a given original queue
+   * Creates DLQ exchange and queue following naming conventions
+   * @param originalQueue Original queue name
+   * @returns Promise<string> DLQ queue name
+   */
+  public async setupDLQ(originalQueue: string): Promise<string> {
+    if (!originalQueue) {
+      throw new Error('Original queue name is required for DLQ setup');
+    }
+
+    if (!this.isEnabled()) {
+      throw new Error('DLQ is not enabled in configuration');
+    }
+
+    // Check cache to avoid duplicate setup
+    if (this.dlqSetupCache.has(originalQueue)) {
+      return this.getDLQQueueName(originalQueue);
+    }
+
+    const dlqExchangeName = this.getDLQExchangeName(originalQueue);
+    const dlqQueueName = this.getDLQQueueName(originalQueue);
+
+    try {
+      // Create DLQ exchange
+      await this.resourceCreator.ensureExchange(dlqExchangeName, 'direct', {
+        durable: true,
+        autoDelete: false
+      });
+
+      // Create DLQ queue with TTL if configured
+      const queueOptions: any = {
+        durable: true,
+        exclusive: false,
+        autoDelete: false
+      };
+
+      // Add TTL if configured
+      if (this.config.dlq.ttl && this.config.dlq.ttl > 0) {
+        queueOptions.arguments = {
+          'x-message-ttl': this.config.dlq.ttl
+        };
+      }
+
+      await this.resourceCreator.ensureQueue(dlqQueueName, queueOptions);
+
+      // Bind DLQ queue to DLQ exchange
+      await this.resourceCreator.bindQueue(dlqQueueName, dlqExchangeName, originalQueue);
+
+      // Cache successful setup
+      this.dlqSetupCache.add(originalQueue);
+
+      this.logger.logOperation('setupDLQ', `DLQ setup completed`, {
+        originalQueue,
+        dlqExchange: dlqExchangeName,
+        dlqQueue: dlqQueueName,
+        ttl: this.config.dlq.ttl
+      });
+      
+      return dlqQueueName;
+    } catch (error) {
+      this.logger.logError(`Failed to setup DLQ`, error as Error, { originalQueue });
+      throw error;
+    }
+  }
+
+  /**
+   * Handle a failed message by routing to DLQ
+   * @param message Failed message object
+   * @param originalQueue Original queue name where message failed
+   */
+  public async handleFailedMessage(message: any, originalQueue: string): Promise<void> {
+    if (!originalQueue) {
+      throw new Error('Original queue name is required for failed message handling');
+    }
+
+    if (!message) {
+      throw new Error('Message is required for failed message handling');
+    }
+
+    if (!this.isEnabled()) {
+      this.logger.info(`DLQ is disabled. Acknowledging failed message without reprocessing`, { 
+        originalQueue 
+      });
+      return;
+    }
+
+    try {
+      // Ensure DLQ is set up for this queue
+      await this.setupDLQ(originalQueue);
+
+      const dlqExchangeName = this.getDLQExchangeName(originalQueue);
+      
+      // Prepare message for DLQ with original metadata
+      const dlqMessage = this.prepareDLQMessage(message, originalQueue);
+
+      // Route message to DLQ
+      await this.routeMessageToDLQ(dlqExchangeName, originalQueue, dlqMessage);
+
+      this.logger.logOperation('routeToDLQ', `Failed message routed to DLQ`, { 
+        originalQueue,
+        dlqExchange: dlqExchangeName
+      });
+    } catch (error) {
+      this.logger.logError(`Failed to handle failed message`, error as Error, { originalQueue });
+      throw error;
+    }
+  }
+
+  /**
+   * Get DLQ exchange name following naming convention
+   * @param originalQueue Original queue name
+   * @returns DLQ exchange name (original-queue.dlq)
+   */
+  private getDLQExchangeName(originalQueue: string): string {
+    return `${originalQueue}.dlq`;
+  }
+
+  /**
+   * Get DLQ queue name following naming convention
+   * @param originalQueue Original queue name
+   * @returns DLQ queue name (original-queue.dlq)
+   */
+  private getDLQQueueName(originalQueue: string): string {
+    return `${originalQueue}.dlq`;
+  }
+
+  /**
+   * Prepare message for DLQ with original metadata
+   * @param message Original message
+   * @param originalQueue Original queue name
+   * @returns Enhanced message with DLQ metadata
+   */
+  private prepareDLQMessage(message: any, originalQueue: string): any {
+    const now = new Date();
+    
+    // Extract original message content and metadata
+    const originalContent = message.content ? message.content : message;
+    const originalProperties = message.properties || {};
+    const originalFields = message.fields || {};
+
+    return {
+      originalMessage: originalContent,
+      dlqMetadata: {
+        originalQueue: originalQueue,
+        originalExchange: originalFields.exchange || '',
+        originalRoutingKey: originalFields.routingKey || '',
+        failedAt: now.toISOString(),
+        retryCount: this.getRetryCount(originalProperties) + 1,
+        maxRetries: this.config.dlq.maxRetries || 3,
+        retryDelay: this.config.dlq.retryDelay || 5000
+      },
+      originalProperties: originalProperties,
+      originalFields: originalFields
+    };
+  }
+
+  /**
+   * Route message to DLQ exchange
+   * @param dlqExchange DLQ exchange name
+   * @param routingKey Routing key (original queue name)
+   * @param message Message to route
+   */
+  private async routeMessageToDLQ(dlqExchange: string, routingKey: string, message: any): Promise<void> {
+    return this.connectionManager.executeOperation(async () => {
+      const connection = this.connectionManager.getConnection();
+      if (!connection) {
+        throw new Error('No active connection to RabbitMQ');
+      }
+
+      try {
+        const channel = await (connection as any).createChannel();
+        
+        // Publish message to DLQ exchange
+        const messageBuffer = Buffer.from(JSON.stringify(message));
+        const publishOptions = {
+          persistent: true,
+          timestamp: Date.now(),
+          headers: {
+            'x-dlq-routed': true,
+            'x-original-queue': routingKey
+          }
+        };
+
+        const published = channel.publish(dlqExchange, routingKey, messageBuffer, publishOptions);
+        
+        if (!published) {
+          throw new Error('Failed to publish message to DLQ - channel buffer full');
+        }
+
+        await channel.close();
+      } catch (error) {
+        const errorMessage = `Failed to route message to DLQ exchange '${dlqExchange}': ${error instanceof Error ? error.message : 'Unknown error'}`;
+        throw new Error(errorMessage);
+      }
+    });
+  }
+
+  /**
+   * Get retry count from message properties
+   * @param properties Message properties
+   * @returns Current retry count
+   */
+  private getRetryCount(properties: any): number {
+    if (!properties || !properties.headers) {
+      return 0;
+    }
+
+    return properties.headers['x-retry-count'] || 0;
+  }
+
+  /**
+   * Clear DLQ setup cache (useful for testing)
+   */
+  public clearCache(): void {
+    this.dlqSetupCache.clear();
+    this.logger.info('DLQHandler cache cleared');
+  }
+
+  /**
+   * Get cache statistics for monitoring
+   */
+  public getCacheStats(): { setupCache: number } {
+    return {
+      setupCache: this.dlqSetupCache.size
+    };
+  }
+
+  /**
+   * Get DLQ configuration
+   */
+  public getDLQConfig(): IConfiguration['dlq'] {
+    return this.config.dlq;
+  }
+}

package/src/components/Logger.ts

@@ -0,0 +1,224 @@
+import { ILogger } from '../interfaces/ILogger';
+import { IConfiguration } from '../interfaces/IConfiguration';
+
+/**
+ * Log levels with numeric values for comparison
+ */
+export enum LogLevel {
+  ERROR = 0,
+  WARN = 1,
+  INFO = 2,
+  DEBUG = 3
+}
+
+/**
+ * Log entry structure for JSON formatting
+ */
+interface LogEntry {
+  timestamp: string;
+  level: string;
+  message: string;
+  context?: any;
+  component?: string;
+  operation?: string;
+}
+
+/**
+ * Logger class that provides structured logging with configurable levels and formats
+ */
+export class Logger implements ILogger {
+  private static instance: Logger | null = null;
+  private logLevel: LogLevel;
+  private format: 'json' | 'text';
+  private component?: string;
+
+  /**
+   * Private constructor to enforce singleton pattern
+   */
+  private constructor(config?: IConfiguration['logging'], component?: string) {
+    this.logLevel = this.parseLogLevel(config?.level || 'info');
+    this.format = config?.format || 'text';
+    if (component) {
+      this.component = component;
+    }
+  }
+
+  /**
+   * Get singleton instance of Logger
+   */
+  public static getInstance(config?: IConfiguration['logging'], component?: string): Logger {
+    if (!Logger.instance) {
+      Logger.instance = new Logger(config, component);
+    }
+    return Logger.instance;
+  }
+
+  /**
+   * Create a new logger instance for a specific component
+   */
+  public static createComponentLogger(component: string, config?: IConfiguration['logging']): Logger {
+    return new Logger(config, component);
+  }
+
+  /**
+   * Log error message with optional context
+   */
+  public error(message: string, context?: any): void {
+    this.log(LogLevel.ERROR, 'ERROR', message, context);
+  }
+
+  /**
+   * Log warning message with optional context
+   */
+  public warn(message: string, context?: any): void {
+    this.log(LogLevel.WARN, 'WARN', message, context);
+  }
+
+  /**
+   * Log info message with optional context
+   */
+  public info(message: string, context?: any): void {
+    this.log(LogLevel.INFO, 'INFO', message, context);
+  }
+
+  /**
+   * Log debug message with optional context
+   */
+  public debug(message: string, context?: any): void {
+    this.log(LogLevel.DEBUG, 'DEBUG', message, context);
+  }
+
+  /**
+   * Log operation with context (for operation tracking)
+   */
+  public logOperation(operation: string, message: string, context?: any): void {
+    const operationContext = {
+      operation,
+      ...context
+    };
+    this.info(message, operationContext);
+  }
+
+  /**
+   * Log error with stack trace
+   */
+  public logError(message: string, error: Error, context?: any): void {
+    const errorContext = {
+      error: {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+      },
+      ...context
+    };
+    this.error(message, errorContext);
+  }
+
+  /**
+   * Log connection state changes
+   */
+  public logConnectionState(state: string, context?: any): void {
+    const connectionContext = {
+      connectionState: state,
+      ...context
+    };
+    this.info(`Connection state changed to: ${state}`, connectionContext);
+  }
+
+  /**
+   * Internal logging method
+   */
+  private log(level: LogLevel, levelName: string, message: string, context?: any): void {
+    // Check if this log level should be output
+    if (level > this.logLevel) {
+      return;
+    }
+
+    const timestamp = new Date().toISOString();
+    
+    if (this.format === 'json') {
+      const logEntry: LogEntry = {
+        timestamp,
+        level: levelName,
+        message
+      };
+      
+      if (context) {
+        try {
+          // Test if context can be serialized
+          JSON.stringify(context);
+          logEntry.context = context;
+        } catch (error) {
+          logEntry.context = '[Circular Reference]';
+        }
+      }
+      
+      if (this.component) {
+        logEntry.component = this.component;
+      }
+      
+      console.log(JSON.stringify(logEntry));
+    } else {
+      // Text format
+      const componentPrefix = this.component ? `[${this.component}] ` : '';
+      let contextSuffix = '';
+      if (context) {
+        try {
+          contextSuffix = ` | Context: ${JSON.stringify(context)}`;
+        } catch (error) {
+          contextSuffix = ` | Context: [Circular Reference]`;
+        }
+      }
+      
+      const logMessage = `${timestamp} [${levelName}] ${componentPrefix}${message}${contextSuffix}`;
+      
+      // Use appropriate console method based on level
+      switch (level) {
+        case LogLevel.ERROR:
+          console.error(logMessage);
+          break;
+        case LogLevel.WARN:
+          console.warn(logMessage);
+          break;
+        case LogLevel.DEBUG:
+          console.debug(logMessage);
+          break;
+        default:
+          console.log(logMessage);
+      }
+    }
+  }
+
+  /**
+   * Parse log level string to enum value
+   */
+  private parseLogLevel(level: string): LogLevel {
+    switch (level.toLowerCase()) {
+      case 'error':
+        return LogLevel.ERROR;
+      case 'warn':
+        return LogLevel.WARN;
+      case 'info':
+        return LogLevel.INFO;
+      case 'debug':
+        return LogLevel.DEBUG;
+      default:
+        return LogLevel.INFO;
+    }
+  }
+
+  /**
+   * Update logger configuration
+   */
+  public updateConfig(config: IConfiguration['logging']): void {
+    this.logLevel = this.parseLogLevel(config?.level || 'info');
+    this.format = config?.format || 'text';
+  }
+
+  /**
+   * Reset singleton instance (for testing purposes)
+   */
+  public static resetInstance(): void {
+    Logger.instance = null;
+  }
+}

package/src/components/MessagePublisher.ts

@@ -0,0 +1,180 @@
+// amqplib types are used via ConnectionManager
+import { IMessagePublisher } from '../interfaces/IMessage';
+import { PublishError } from '../interfaces/IErrors';
+import { ConnectionManager } from './ConnectionManager';
+import { ResourceCreator } from './ResourceCreator';
+import { Logger } from './Logger';
+import { IConfiguration } from '../interfaces/IConfiguration';
+
+/**
+ * MessagePublisher handles message publishing to RabbitMQ exchanges
+ * Implements parameter validation, JSON serialization, and automatic exchange creation
+ */
+export class MessagePublisher implements IMessagePublisher {
+  private connectionManager: ConnectionManager;
+  private resourceCreator: ResourceCreator;
+  private logger: Logger;
+
+  constructor(connectionManager: ConnectionManager, resourceCreator: ResourceCreator, config?: IConfiguration['logging']) {
+    this.connectionManager = connectionManager;
+    this.resourceCreator = resourceCreator;
+    this.logger = Logger.createComponentLogger('MessagePublisher', config);
+  }
+
+  /**
+   * Publish a message to an exchange
+   * @param exchange Exchange name (required)
+   * @param routingKey Routing key for message routing (required)
+   * @param payload Message payload to be JSON serialized (required)
+   * @returns Promise<boolean> - true for success, false for failure
+   */
+  public async publish(exchange: string, routingKey: string, payload: any): Promise<boolean> {
+    // Parameter validation - all parameters are required
+    this.validatePublishParameters(exchange, routingKey, payload);
+
+    try {
+      // JSON serialization for all payloads
+      const serializedPayload = this.serializePayload(payload);
+
+      // Automatic exchange creation before publishing
+      await this.ensureExchangeExists(exchange);
+
+      return await this.connectionManager.executeOperation(async () => {
+        const connection = this.connectionManager.getConnection();
+        if (!connection) {
+          throw new PublishError('No active connection to RabbitMQ', {
+            exchange,
+            routingKey,
+            payload: typeof payload
+          });
+        }
+
+        const channel = await (connection as any).createChannel();
+        
+        try {
+          // Publish message with JSON content type
+          const published = channel.publish(
+            exchange,
+            routingKey,
+            Buffer.from(serializedPayload),
+            {
+              contentType: 'application/json',
+              timestamp: Date.now(),
+              persistent: true // Make messages persistent by default
+            }
+          );
+
+          await channel.close();
+          
+          // Log successful publish
+          this.logger.logOperation('publish', `Message published successfully`, {
+            exchange,
+            routingKey,
+            payloadType: typeof payload,
+            payloadSize: serializedPayload.length
+          });
+          
+          return published;
+        } catch (error) {
+          await channel.close();
+          throw error;
+        }
+      });
+    } catch (error) {
+      // Detailed error logging with context
+      this.logPublishError(error, exchange, routingKey, payload);
+      
+      // Return false for failure as per requirements
+      return false;
+    }
+  }
+
+  /**
+   * Validate publish method parameters
+   * @param exchange Exchange name
+   * @param routingKey Routing key
+   * @param payload Message payload
+   */
+  private validatePublishParameters(exchange: string, routingKey: string, payload: any): void {
+    if (!exchange || typeof exchange !== 'string') {
+      throw new PublishError('Exchange parameter is required and must be a non-empty string', {
+        exchange,
+        routingKey,
+        payload: typeof payload
+      });
+    }
+
+    if (!routingKey || typeof routingKey !== 'string') {
+      throw new PublishError('RoutingKey parameter is required and must be a non-empty string', {
+        exchange,
+        routingKey,
+        payload: typeof payload
+      });
+    }
+
+    if (payload === undefined || payload === null) {
+      throw new PublishError('Payload parameter is required and cannot be null or undefined', {
+        exchange,
+        routingKey,
+        payload
+      });
+    }
+  }
+
+  /**
+   * Serialize payload to JSON string
+   * @param payload Payload to serialize
+   * @returns JSON string representation
+   */
+  private serializePayload(payload: any): string {
+    try {
+      return JSON.stringify(payload);
+    } catch (error) {
+      throw new PublishError('Failed to serialize payload to JSON', {
+        payload: typeof payload,
+        error: error instanceof Error ? error.message : 'Unknown serialization error'
+      });
+    }
+  }
+
+  /**
+   * Ensure exchange exists before publishing
+   * @param exchange Exchange name
+   */
+  private async ensureExchangeExists(exchange: string): Promise<void> {
+    try {
+      // Use ResourceCreator to automatically create exchange if it doesn't exist
+      // Always use topic type by default
+      await this.resourceCreator.ensureExchange(exchange, 'topic');
+    } catch (error) {
+      throw new PublishError(`Failed to ensure exchange '${exchange}' exists`, {
+        exchange,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      });
+    }
+  }
+
+  /**
+   * Log publish errors with detailed context
+   * @param error The error that occurred
+   * @param exchange Exchange name
+   * @param routingKey Routing key
+   * @param payload Original payload
+   */
+  private logPublishError(error: unknown, exchange: string, routingKey: string, payload: any): void {
+    let payloadSize = 0;
+    try {
+      payloadSize = JSON.stringify(payload).length;
+    } catch {
+      payloadSize = -1; // Indicate serialization failed
+    }
+
+    this.logger.logError('Message publish failed', error as Error, {
+      exchange,
+      routingKey,
+      payloadType: typeof payload,
+      payloadSize,
+      operation: 'publish'
+    });
+  }
+}