rabbitmq-sdk 0.0.1-security → 1.2.0

package/scripts/run-dynamic-routing-test.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env ts-node
+
+/**
+ * Script para executar o teste de fluxo de roteamento dinâmico
+ * 
+ * Uso:
+ * npm run build && npx ts-node scripts/run-dynamic-routing-test.ts
+ * 
+ * Ou compile primeiro:
+ * npm run build && node dist/examples/test-dynamic-routing-flow.js
+ */
+
+import { testDynamicRoutingFlow } from '../examples/test-dynamic-routing-flow';
+
+async function main(): Promise<void> {
+  console.log('🚀 Executando teste de fluxo de roteamento dinâmico...\n');
+  
+  try {
+    await testDynamicRoutingFlow();
+    console.log('\n✅ Teste executado com sucesso!');
+    process.exit(0);
+  } catch (error) {
+    console.error('\n❌ Erro durante a execução do teste:', error);
+    process.exit(1);
+  }
+}
+
+// Executar apenas se este arquivo for chamado diretamente
+if (require.main === module) {
+  main();
+}

package/src/.gitkeep

@@ -0,0 +1 @@
+# This file ensures the src directory is tracked by git

package/src/components/.gitkeep

@@ -0,0 +1 @@
+# This file ensures the components directory is tracked by git

package/src/components/ConfigurationManager.ts

@@ -0,0 +1,104 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { IConfiguration, IConfigurationManager } from '../interfaces/IConfiguration';
+import { ConfigurationError } from '../interfaces/IErrors';
+import { validateConfigurationSchema } from '../utils/configSchema';
+
+/**
+ * Configuration manager that handles loading and validating configuration from config.json
+ */
+export class ConfigurationManager implements IConfigurationManager {
+  private static instance: ConfigurationManager;
+  private cachedConfig: IConfiguration | null = null;
+  private readonly configPath: string;
+
+  private constructor() {
+    // Config file should be at project root
+    this.configPath = path.join(process.cwd(), 'config.json');
+  }
+
+  /**
+   * Get singleton instance of ConfigurationManager
+   */
+  public static getInstance(): ConfigurationManager {
+    if (!ConfigurationManager.instance) {
+      ConfigurationManager.instance = new ConfigurationManager();
+    }
+    return ConfigurationManager.instance;
+  }
+
+  /**
+   * Load configuration from config.json file
+   * @returns Validated configuration object
+   * @throws ConfigurationError if file doesn't exist or is invalid
+   */
+  public loadConfig(): IConfiguration {
+    // Return cached config if available
+    if (this.cachedConfig) {
+      return this.cachedConfig;
+    }
+
+    try {
+      // Check if config file exists
+      if (!fs.existsSync(this.configPath)) {
+        throw new ConfigurationError(
+          `Configuration file not found at ${this.configPath}. Please create a config.json file in your project root.`,
+          { configPath: this.configPath }
+        );
+      }
+
+      // Read and parse config file
+      const configContent = fs.readFileSync(this.configPath, 'utf-8');
+      let parsedConfig: any;
+
+      try {
+        parsedConfig = JSON.parse(configContent);
+      } catch (parseError) {
+        throw new ConfigurationError(
+          `Invalid JSON in configuration file: ${parseError instanceof Error ? parseError.message : 'Unknown parsing error'}`,
+          { configPath: this.configPath, parseError }
+        );
+      }
+
+      // Validate configuration schema
+      this.validateConfig(parsedConfig);
+
+      // Cache the validated configuration
+      this.cachedConfig = parsedConfig as IConfiguration;
+      
+      return this.cachedConfig;
+    } catch (error) {
+      if (error instanceof ConfigurationError) {
+        throw error;
+      }
+      
+      throw new ConfigurationError(
+        `Failed to load configuration: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        { configPath: this.configPath, originalError: error }
+      );
+    }
+  }
+
+  /**
+   * Validate configuration schema
+   * @param config - Configuration object to validate
+   * @throws ConfigurationError if validation fails
+   */
+  public validateConfig(config: any): void {
+    validateConfigurationSchema(config);
+  }
+
+  /**
+   * Clear cached configuration (useful for testing)
+   */
+  public clearCache(): void {
+    this.cachedConfig = null;
+  }
+
+  /**
+   * Get the configuration file path
+   */
+  public getConfigPath(): string {
+    return this.configPath;
+  }
+}

package/src/components/ConnectionManager.ts

@@ -0,0 +1,357 @@
+import * as amqp from 'amqplib';
+import { IConnectionManager } from '../interfaces/IConnection';
+import { IConfiguration } from '../interfaces/IConfiguration';
+import { Logger } from './Logger';
+
+/**
+ * Connection states for tracking connection status
+ */
+export enum ConnectionState {
+  DISCONNECTED = 'disconnected',
+  CONNECTING = 'connecting',
+  CONNECTED = 'connected',
+  RECONNECTING = 'reconnecting',
+  FAILED = 'failed'
+}
+
+/**
+ * ConnectionManager implements singleton pattern for RabbitMQ connections
+ * Manages connection state and provides auto-reconnection capabilities
+ */
+export class ConnectionManager implements IConnectionManager {
+  private static instance: ConnectionManager | null = null;
+  private connection: amqp.Connection | null = null;
+  private connectionState: ConnectionState = ConnectionState.DISCONNECTED;
+  private config: IConfiguration;
+  private connectionLostCallbacks: (() => void)[] = [];
+  private operationQueue: (() => Promise<void>)[] = [];
+  private reconnectAttempts = 0;
+  private maxReconnectAttempts = 10;
+  private baseRetryDelay = 1000; // 1 second
+  private maxRetryDelay = 30000; // 30 seconds
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private logger: Logger;
+
+  /**
+   * Private constructor to enforce singleton pattern
+   */
+  private constructor(config: IConfiguration) {
+    this.config = config;
+    this.logger = Logger.createComponentLogger('ConnectionManager', config.logging);
+  }
+
+  /**
+   * Get singleton instance of ConnectionManager
+   */
+  public static getInstance(config: IConfiguration): ConnectionManager {
+    if (!ConnectionManager.instance) {
+      ConnectionManager.instance = new ConnectionManager(config);
+    }
+    return ConnectionManager.instance;
+  }
+
+  /**
+   * Establish connection to RabbitMQ
+   */
+  public async connect(): Promise<amqp.Connection> {
+    if (this.connection && this.connectionState === ConnectionState.CONNECTED) {
+      return this.connection;
+    }
+
+    if (this.connectionState === ConnectionState.CONNECTING || 
+        this.connectionState === ConnectionState.RECONNECTING) {
+      // Wait for existing connection attempt
+      return new Promise<amqp.Connection>((resolve, reject) => {
+        const checkConnection = (): void => {
+          if (this.connection && this.connectionState === ConnectionState.CONNECTED) {
+            resolve(this.connection);
+          } else if (this.connectionState === ConnectionState.FAILED) {
+            reject(new Error('Connection failed'));
+          } else {
+            setTimeout(checkConnection, 100);
+          }
+        };
+        checkConnection();
+      });
+    }
+
+    this.connectionState = ConnectionState.CONNECTING;
+
+    try {
+      this.connection = await amqp.connect(this.config.url) as unknown as amqp.Connection;
+      this.connectionState = ConnectionState.CONNECTED;
+      this.reconnectAttempts = 0;
+
+      this.logger.logConnectionState(ConnectionState.CONNECTED, { url: this.config.url });
+
+      // Set up connection event handlers
+      this.setupConnectionEventHandlers();
+
+      // Process queued operations
+      await this.processQueuedOperations();
+
+      return this.connection;
+    } catch (error) {
+      this.connectionState = ConnectionState.FAILED;
+      this.logger.logError('Failed to connect to RabbitMQ', error as Error, { url: this.config.url });
+      throw new Error(`Failed to connect to RabbitMQ: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Get current connection instance
+   */
+  public getConnection(): amqp.Connection | null {
+    return this.connection;
+  }
+
+  /**
+   * Check if currently connected
+   */
+  public isConnected(): boolean {
+    return this.connectionState === ConnectionState.CONNECTED && this.connection !== null;
+  }
+
+  /**
+   * Disconnect from RabbitMQ
+   */
+  public async disconnect(): Promise<void> {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+
+    if (this.connection) {
+      try {
+        await (this.connection as any).close();
+      } catch (error) {
+        // Ignore errors during disconnect
+      }
+      this.connection = null;
+    }
+
+    this.connectionState = ConnectionState.DISCONNECTED;
+    this.reconnectAttempts = 0;
+    this.operationQueue = [];
+    
+    this.logger.logConnectionState(ConnectionState.DISCONNECTED);
+  }
+
+  /**
+   * Register callback for connection lost events
+   */
+  public onConnectionLost(callback: () => void): void {
+    this.connectionLostCallbacks.push(callback);
+  }
+
+  /**
+   * Get current connection state
+   */
+  public getConnectionState(): ConnectionState {
+    return this.connectionState;
+  }
+
+  /**
+   * Queue operation to be executed after reconnection
+   */
+  public queueOperation(operation: () => Promise<void>): void {
+    if (this.connectionState === ConnectionState.RECONNECTING || 
+        this.connectionState === ConnectionState.CONNECTING) {
+      this.operationQueue.push(operation);
+    } else if (this.connectionState === ConnectionState.CONNECTED) {
+      // Execute immediately if connected
+      operation().catch(error => {
+        this.logger.logError('Error executing queued operation', error as Error);
+      });
+    } else {
+      // Queue for later if disconnected
+      this.operationQueue.push(operation);
+    }
+  }
+
+  /**
+   * Execute operation with automatic queuing during reconnection
+   */
+  public async executeOperation<T>(operation: () => Promise<T>): Promise<T> {
+    if (this.connectionState === ConnectionState.CONNECTED && this.connection) {
+      return await operation();
+    }
+
+    // Queue operation and wait for reconnection
+    return new Promise<T>((resolve, reject) => {
+      const wrappedOperation = async (): Promise<void> => {
+        try {
+          const result = await operation();
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        }
+      };
+      this.queueOperation(wrappedOperation);
+    });
+  }
+
+  /**
+   * Set up event handlers for connection
+   */
+  private setupConnectionEventHandlers(): void {
+    if (!this.connection) return;
+
+    this.connection.on('error', (error: Error) => {
+      this.logger.logError('RabbitMQ connection error', error);
+      this.handleConnectionLoss();
+    });
+
+    this.connection.on('close', () => {
+      this.logger.warn('RabbitMQ connection closed');
+      this.handleConnectionLoss();
+    });
+
+    this.connection.on('blocked', (reason: string) => {
+      this.logger.warn('RabbitMQ connection blocked', { reason });
+    });
+
+    this.connection.on('unblocked', () => {
+      this.logger.info('RabbitMQ connection unblocked');
+    });
+  }
+
+  /**
+   * Handle connection loss and initiate reconnection
+   */
+  private handleConnectionLoss(): void {
+    if (this.connectionState === ConnectionState.RECONNECTING || 
+        this.connectionState === ConnectionState.DISCONNECTED) {
+      return; // Already handling reconnection or intentionally disconnected
+    }
+
+    this.connection = null;
+    this.connectionState = ConnectionState.RECONNECTING;
+
+    this.logger.logConnectionState(ConnectionState.RECONNECTING, { 
+      queuedOperations: this.operationQueue.length 
+    });
+
+    // Notify callbacks about connection loss
+    this.connectionLostCallbacks.forEach(callback => {
+      try {
+        callback();
+      } catch (error) {
+        this.logger.logError('Error in connection lost callback', error as Error);
+      }
+    });
+
+    // Start reconnection process
+    this.startReconnection();
+  }
+
+  /**
+   * Start reconnection process with exponential backoff
+   * Implements exponential backoff: 1s, 2s, 4s, 8s, 16s, 30s (max)
+   */
+  private startReconnection(): void {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.logger.error('Max reconnection attempts reached. Connection failed permanently.', {
+        maxAttempts: this.maxReconnectAttempts,
+        queuedOperations: this.operationQueue.length
+      });
+      this.connectionState = ConnectionState.FAILED;
+      this.logger.logConnectionState(ConnectionState.FAILED);
+      
+      // Reject all queued operations
+      this.operationQueue.forEach(operation => {
+        operation().catch(() => {
+          // Operations will fail, but we need to clear the queue
+        });
+      });
+      this.operationQueue = [];
+      return;
+    }
+
+    // Calculate exponential backoff delay: 1s, 2s, 4s, 8s, 16s, max 30s
+    const delay = Math.min(
+      this.baseRetryDelay * Math.pow(2, this.reconnectAttempts),
+      this.maxRetryDelay
+    );
+
+    this.logger.info('Connection lost. Starting reconnection process', {
+      queuedOperations: this.operationQueue.length,
+      delayMs: delay,
+      attempt: this.reconnectAttempts + 1,
+      maxAttempts: this.maxReconnectAttempts
+    });
+
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectAttempts++;
+      
+      try {
+        this.logger.logOperation('reconnect', `Attempting reconnection ${this.reconnectAttempts}/${this.maxReconnectAttempts}`);
+        
+        // Set state to connecting before attempting connection
+        this.connectionState = ConnectionState.CONNECTING;
+        this.connection = await amqp.connect(this.config.url) as unknown as amqp.Connection;
+        this.connectionState = ConnectionState.CONNECTED;
+
+        this.logger.logConnectionState(ConnectionState.CONNECTED, { url: this.config.url });
+
+        // Set up connection event handlers
+        this.setupConnectionEventHandlers();
+
+        // Process queued operations
+        await this.processQueuedOperations();
+
+        this.logger.info('Successfully reconnected to RabbitMQ', {
+          queuedOperations: this.operationQueue.length,
+          attempt: this.reconnectAttempts
+        });
+      } catch (error) {
+        this.connectionState = ConnectionState.RECONNECTING;
+        this.logger.logError(`Reconnection attempt ${this.reconnectAttempts} failed`, error as Error, {
+          attempt: this.reconnectAttempts,
+          maxAttempts: this.maxReconnectAttempts
+        });
+        this.startReconnection(); // Try again with increased delay
+      }
+    }, delay);
+  }
+
+  /**
+   * Process operations that were queued during reconnection
+   */
+  private async processQueuedOperations(): Promise<void> {
+    if (this.operationQueue.length === 0) {
+      return;
+    }
+
+    this.logger.logOperation('processQueue', `Processing ${this.operationQueue.length} queued operations after reconnection`);
+    
+    const operations = [...this.operationQueue];
+    this.operationQueue = [];
+
+    let successCount = 0;
+    let errorCount = 0;
+
+    for (const operation of operations) {
+      try {
+        await operation();
+        successCount++;
+      } catch (error) {
+        errorCount++;
+        this.logger.logError('Error processing queued operation', error as Error);
+      }
+    }
+
+    this.logger.info('Processed queued operations', {
+      successful: successCount,
+      failed: errorCount,
+      total: operations.length
+    });
+  }
+
+  /**
+   * Reset singleton instance (for testing purposes)
+   */
+  public static resetInstance(): void {
+    ConnectionManager.instance = null;
+  }
+}