@onlineapps/conn-infra-mq 1.1.51 → 1.1.53

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@onlineapps/conn-infra-mq",
-    "version": "1.1.51",
+    "version": "1.1.53",
     "description": "A promise-based, broker-agnostic client for sending and receiving messages via RabbitMQ",
     "main": "src/index.js",
     "repository": {

package/src/ConnectorMQClient.js

@@ -46,11 +46,60 @@ class ConnectorMQClient extends BaseClient {
    * });
    */
   constructor(config = {}) {
-    super(config);
+    // Setup queue creation callback for RecoveryWorker (delegates to QueueManager)
+    // This ensures RecoveryWorker uses QueueManager for queue creation instead of direct creation
+    // Note: We create a closure that will access this.queues after it's initialized
+    let queueManagerRef = null;
+    const queueCreationCallback = async (queueName, options = {}) => {
+      if (!queueManagerRef) {
+        throw new Error('QueueManager not initialized - cannot create queue via RecoveryWorker');
+      }
+      // Use ensureQueue for individual queues (RecoveryWorker handles single queue creation)
+      // Note: setupServiceQueues creates multiple queues, but RecoveryWorker only needs one
+      // However, ensureQueue throws for business queues, so we need to handle that
+      try {
+        await queueManagerRef.ensureQueue(queueName, options);
+      } catch (err) {
+        // If ensureQueue fails because it's a business queue, we can't create it via RecoveryWorker
+        // RecoveryWorker should only handle transient errors, not business queue creation
+        // Business queues must be created via setupServiceQueues() after registration
+        throw new Error(`Cannot create business queue '${queueName}' via RecoveryWorker. Business queues must be created via setupServiceQueues() after registration.`);
+      }
+    };
+
+    // Pass queueCreationCallback to config for RecoveryWorker
+    const enhancedConfig = {
+      ...config,
+      queueCreationCallback,
+      recoveryScope: config.recoveryScope || 'business', // Business services can create queues
+    };
+
+    super(enhancedConfig);
 
     // Initialize layers
     this.workflow = new WorkflowRouter(this, config);
     this.queues = new QueueManager(this, config);
+    
+    // Setup queue creation callback for RecoveryWorker (delegates to QueueManager)
+    // This ensures RecoveryWorker uses QueueManager for queue creation instead of direct creation
+    // Note: We create a closure that will access this.queues after it's initialized
+    let queueManagerRef = null;
+    const queueCreationCallback = async (queueName, options = {}) => {
+      if (!queueManagerRef) {
+        throw new Error('QueueManager not initialized - cannot create queue via RecoveryWorker');
+      }
+      // Use ensureQueue for individual queues (RecoveryWorker handles single queue creation)
+      // Note: setupServiceQueues creates multiple queues, but RecoveryWorker only needs one
+      // However, ensureQueue throws for business queues, so we need to handle that
+      try {
+        await queueManagerRef.ensureQueue(queueName, options);
+      } catch (err) {
+        // If ensureQueue fails because it's a business queue, we can't create it via RecoveryWorker
+        // RecoveryWorker should only handle transient errors, not business queue creation
+        // Business queues must be created via setupServiceQueues() after registration
+        throw new Error(`Cannot create business queue '${queueName}' via RecoveryWorker. Business queues must be created via setupServiceQueues() after registration.`);
+      }
+    };
     this.retry = new RetryHandler(this, config);
     this.forkJoin = new ForkJoinHandler(this, this.queues, config);
 

package/src/config/queueConfig.js

@@ -2,268 +2,15 @@
 
 /**
  * queueConfig.js
- *
- * Central configuration for INFRASTRUCTURE queues only.
- * Business queues ({service}.workflow, {service}.queue, {service}.dlq) are created
- * by individual services via QueueManager.setupServiceQueues().
- *
- * This ensures consistent configuration for infrastructure queues across all services.
+ * 
+ * Re-exports queueConfig from @onlineapps/mq-client-core.
+ * 
+ * NOTE: queueConfig is now part of mq-client-core (spodní vrstva) because it's used by both:
+ * - Infrastructure services (via mq-client-core)
+ * - Business services (via conn-infra-mq connector)
+ * 
+ * This file maintains backward compatibility for existing code that imports from conn-infra-mq.
  */
 
-module.exports = {
-  /**
-   * Workflow infrastructure queue configurations
-   * These are shared infrastructure queues used by all services
-   */
-  workflow: {
-    /**
-     * workflow.init - Entry point for all workflows
-     * All services listen as competing consumers
-     */
-    init: {
-      durable: true,
-      arguments: {
-        'x-message-ttl': 300000,      // 5 minutes TTL
-        'x-max-length': 10000          // Max 10k messages
-      }
-    },
-
-    /**
-     * workflow.completed - Completed workflows
-     */
-    completed: {
-      durable: true,
-      arguments: {
-        'x-message-ttl': 300000,      // 5 minutes TTL
-        'x-max-length': 10000
-      }
-    },
-
-    /**
-     * workflow.failed - Failed workflows
-     */
-    failed: {
-      durable: true,
-      arguments: {
-        'x-message-ttl': 300000,      // 5 minutes TTL
-        'x-max-length': 10000
-      }
-    },
-
-    /**
-     * workflow.dlq - Dead letter queue for workflows
-     */
-    dlq: {
-      durable: true,
-      arguments: {
-        // No TTL for DLQ - messages should persist
-        'x-max-length': 50000          // Higher limit for DLQ
-      }
-    }
-  },
-
-  /**
-   * Business queue templates
-   * These are templates for service-specific queues ({service}.workflow, {service}.queue, {service}.dlq)
-   * Used by QueueManager.setupServiceQueues() to ensure consistent configuration
-   */
-  business: {
-    /**
-     * {service}.workflow - Service-specific workflow queue
-     * Used for routing workflow steps to specific services
-     */
-    workflow: {
-      durable: true,
-      arguments: {
-        'x-message-ttl': 300000,      // 5 minutes TTL
-        'x-max-length': 10000,        // Max 10k messages
-        'x-dead-letter-exchange': 'dlx',
-        'x-dead-letter-routing-key': '{service}.dlq'  // Placeholder, replaced with actual service name
-      }
-    },
-
-    /**
-     * {service}.queue - Service main processing queue
-     * Used for direct service-to-service communication
-     */
-    queue: {
-      durable: true,
-      arguments: {
-        'x-message-ttl': 30000,       // 30 seconds TTL
-        'x-max-length': 10000,        // Max 10k messages
-        'x-dead-letter-exchange': 'dlx',
-        'x-dead-letter-routing-key': '{service}.dlq'  // Placeholder, replaced with actual service name
-      }
-    },
-
-    /**
-     * {service}.dlq - Service dead letter queue
-     * Receives failed messages from service.queue and service.workflow
-     */
-    dlq: {
-      durable: true,
-      arguments: {
-        // No TTL for DLQ - messages should persist
-        'x-max-length': 50000         // Higher limit for DLQ
-      }
-    }
-  },
-
-  /**
-   * Registry infrastructure queue configurations
-   */
-  registry: {
-    /**
-     * registry.register - Registration requests
-     */
-    register: {
-      durable: true,
-      arguments: {
-        'x-message-ttl': 60000,       // 1 minute TTL
-        'x-max-length': 1000
-      }
-    },
-
-    /**
-     * registry.heartbeats - Service heartbeats
-     */
-    heartbeats: {
-      durable: true,
-      arguments: {
-        'x-message-ttl': 120000,       // 2 minutes TTL
-        'x-max-length': 5000
-      }
-    },
-
-    /**
-     * registry.changes - Registry event fanout exchange
-     * (This is an exchange, not a queue, but included for reference)
-     */
-    changes: {
-      type: 'exchange',
-      durable: true
-    }
-  },
-
-  /**
-   * Get infrastructure queue configuration by type and name
-   * @param {string} type - Queue type: 'workflow', 'registry'
-   * @param {string} name - Queue name: 'init', 'completed', 'register', etc.
-   * @returns {Object} Queue configuration
-   */
-  getQueueConfig(type, name) {
-    const config = this[type]?.[name];
-    if (!config) {
-      throw new Error(`Infrastructure queue config not found: ${type}.${name}`);
-    }
-
-    // Deep clone to avoid modifying original
-    return JSON.parse(JSON.stringify(config));
-  },
-
-  /**
-   * Get workflow infrastructure queue configuration
-   * @param {string} queueName - Queue name (e.g., 'workflow.init', 'workflow.completed')
-   * @returns {Object} Queue configuration
-   */
-  getWorkflowQueueConfig(queueName) {
-    const parts = queueName.split('.');
-    if (parts.length !== 2 || parts[0] !== 'workflow') {
-      throw new Error(`Invalid workflow queue name: ${queueName}. Expected format: workflow.{name}`);
-    }
-    return this.getQueueConfig('workflow', parts[1]);
-  },
-
-  /**
-   * Get registry infrastructure queue configuration
-   * @param {string} queueName - Queue name (e.g., 'registry.register', 'registry.heartbeats')
-   * @returns {Object} Queue configuration
-   */
-  getRegistryQueueConfig(queueName) {
-    const parts = queueName.split('.');
-    if (parts.length !== 2 || parts[0] !== 'registry') {
-      throw new Error(`Invalid registry queue name: ${queueName}. Expected format: registry.{name}`);
-    }
-    return this.getQueueConfig('registry', parts[1]);
-  },
-
-  /**
-   * Check if queue name is an infrastructure queue
-   * @param {string} queueName - Queue name to check
-   * @returns {boolean} True if infrastructure queue
-   */
-  isInfrastructureQueue(queueName) {
-    return queueName.startsWith('workflow.') || queueName.startsWith('registry.');
-  },
-
-  /**
-   * Check if queue name is a business queue
-   * @param {string} queueName - Queue name to check
-   * @returns {boolean} True if business queue
-   */
-  isBusinessQueue(queueName) {
-    // Business queues follow pattern: {service}.{type}
-    // where type is: workflow, queue, dlq
-    const parts = queueName.split('.');
-    if (parts.length !== 2) return false;
-    return ['workflow', 'queue', 'dlq'].includes(parts[1]);
-  },
-
-  /**
-   * Parse business queue name to extract service name and queue type
-   * @param {string} queueName - Business queue name (e.g., 'hello-service.workflow')
-   * @returns {Object} { serviceName, queueType } or null if not a business queue
-   */
-  parseBusinessQueue(queueName) {
-    if (!this.isBusinessQueue(queueName)) {
-      return null;
-    }
-    const parts = queueName.split('.');
-    return {
-      serviceName: parts[0],
-      queueType: parts[1]
-    };
-  },
-
-  /**
-   * Get business queue configuration template
-   * @param {string} queueType - Queue type: 'workflow', 'queue', 'dlq'
-   * @param {string} serviceName - Service name (replaces {service} placeholder)
-   * @returns {Object} Queue configuration
-   */
-  getBusinessQueueConfig(queueType, serviceName) {
-    const template = this.business?.[queueType];
-    if (!template) {
-      throw new Error(`Business queue template not found: ${queueType}`);
-    }
-
-    // Deep clone to avoid modifying original
-    const config = JSON.parse(JSON.stringify(template));
-
-    // Replace {service} placeholder in routing keys
-    if (config.arguments && serviceName) {
-      const routingKey = config.arguments['x-dead-letter-routing-key'];
-      if (routingKey && typeof routingKey === 'string') {
-        config.arguments['x-dead-letter-routing-key'] = routingKey.replace('{service}', serviceName);
-      }
-    }
-
-    return config;
-  },
-
-  /**
-   * Get infrastructure queue configuration by queue name (auto-detect type)
-   * @param {string} queueName - Full queue name (e.g., 'workflow.init', 'registry.register')
-   * @returns {Object} Queue configuration
-   */
-  getInfrastructureQueueConfig(queueName) {
-    if (queueName.startsWith('workflow.')) {
-      return this.getWorkflowQueueConfig(queueName);
-    } else if (queueName.startsWith('registry.')) {
-      return this.getRegistryQueueConfig(queueName);
-    } else {
-      throw new Error(`Queue ${queueName} is not an infrastructure queue. Infrastructure queues must start with 'workflow.' or 'registry.'`);
-    }
-  }
-};
-
+// Re-export from mq-client-core
+module.exports = require('@onlineapps/mq-client-core/src/config/queueConfig');

package/src/layers/RetryHandler.js

@@ -13,6 +13,7 @@ class RetryHandler {
       maxDelay: config.maxDelay || 30000,
       backoffMultiplier: config.backoffMultiplier || 2,
       dlqSuffix: config.dlqSuffix || '.dlq',
+      emitMonitoringEvents: config.emitMonitoringEvents !== false, // Enable by default
       ...config
     };
     this.retryStats = {
@@ -22,6 +23,36 @@ class RetryHandler {
       dlqMessages: 0
     };
   }
+  
+  /**
+   * Emit retry event to monitoring (non-blocking)
+   * @private
+   */
+  async _emitRetryEvent(eventType, data) {
+    if (!this.config.emitMonitoringEvents) return;
+    
+    try {
+      const { publishToMonitoringWorkflow } = require('@onlineapps/mq-client-core').monitoring;
+      
+      await publishToMonitoringWorkflow(this.client, {
+        event_type: eventType,
+        workflow_id: data.workflow_id || data.message?.workflow_id || 'unknown',
+        timestamp: new Date().toISOString(),
+        retry_info: {
+          queue: data.queue,
+          retry_count: data.retryCount,
+          max_retries: data.maxRetries || this.config.maxRetries,
+          delay_ms: data.delay,
+          error_message: data.error?.message,
+          error_code: data.error?.code
+        }
+      }, null, { source: 'RetryHandler' });
+      
+    } catch (e) {
+      // Silent fail - don't break retry logic due to monitoring
+      console.warn('[RetryHandler] Failed to emit monitoring event:', e.message);
+    }
+  }
 
   /**
    * Process message with retry logic
@@ -75,12 +106,23 @@ class RetryHandler {
 
     if (retryCount < maxRetries) {
       // Retry the message
+      const delay = this.calculateDelay(retryCount + 1);
       await this.retryMessage(enrichedMessage, queueName, retryCount + 1, options);
 
       // Acknowledge original to remove from queue
       await this.client.ack(rawMsg);
 
       this.retryStats.totalRetries++;
+      
+      // Emit retry event to monitoring
+      this._emitRetryEvent('message_retry', {
+        workflow_id: message.workflow_id,
+        queue: queueName,
+        retryCount: retryCount + 1,
+        maxRetries,
+        delay,
+        error
+      });
 
       return { success: false, retried: true, retryCount: retryCount + 1 };
     } else {
@@ -92,6 +134,15 @@ class RetryHandler {
 
       this.retryStats.failedRetries++;
       this.retryStats.dlqMessages++;
+      
+      // Emit DLQ event to monitoring
+      this._emitRetryEvent('message_dlq', {
+        workflow_id: message.workflow_id,
+        queue: queueName,
+        retryCount,
+        maxRetries,
+        error
+      });
 
       return { success: false, retried: false, dlq: true, retryCount };
     }

package/src/transports/rabbitmqClient.js

@@ -197,6 +197,36 @@ class RabbitMQClient extends EventEmitter {
     }
   }
 
+  /**
+   * Emits structured PRECONDITION_FAILED events and invokes optional hooks.
+   * @param {Object} context - Details about the failing operation
+   * @param {Error} error - Original amqplib error
+   * @private
+   */
+  _handlePreconditionFailed(context, error) {
+    const event = {
+      timestamp: new Date().toISOString(),
+      serviceName: this._config.serviceName || this._config.clientId || 'unknown',
+      host: this._config.host,
+      ...context,
+      error: {
+        message: error?.message,
+        code: error?.code,
+        stack: error?.stack
+      }
+    };
+
+    this.emit('preconditionFailed', event);
+
+    if (typeof this._config.onPreconditionFailed === 'function') {
+      try {
+        this._config.onPreconditionFailed(event);
+      } catch (hookError) {
+        console.warn('[RabbitMQClient] onPreconditionFailed hook threw error:', hookError.message);
+      }
+    }
+  }
+
   /**
    * Publishes a message buffer to the specified queue (or default queue) or exchange.
    * @param {string} queue           - Target queue name.
@@ -265,6 +295,19 @@ class RabbitMQClient extends EventEmitter {
       // Wait for confirmation
       await this._channel.waitForConfirms();
     } catch (err) {
+      if (err?.code === 406) {
+        this._handlePreconditionFailed(
+          {
+            operation: 'publish',
+            queueName: queue,
+            routingKey,
+            payloadSample: buffer?.toString?.().slice(0, 512) || null,
+            persistent,
+            headers
+          },
+          err
+        );
+      }
       this.emit('error', err);
       throw err;
     }
@@ -336,44 +379,45 @@ class RabbitMQClient extends EventEmitter {
         const assertStartTime = Date.now();
         console.log(`[RabbitMQClient] [CONSUMER] Asserting queue ${queue} before consume() at ${new Date().toISOString()}`);
         console.log(`[RabbitMQClient] [CONSUMER] Queue options:`, JSON.stringify(queueOptions, null, 2));
+        console.log(`[RabbitMQClient] [CONSUMER] _queueChannel state: exists=${!!this._queueChannel}, closed=${this._queueChannel ? this._queueChannel.closed : 'N/A'}`);
         
-        // CRITICAL: Ensure _queueChannel is open before using it
-        // If it's closed (e.g., due to 406 error), recreate it
-        if (!this._queueChannel || this._queueChannel.closed) {
-          console.warn(`[RabbitMQClient] [CONSUMER] _queueChannel is closed or null, recreating...`);
-          try {
-            this._queueChannel = await this._connection.createChannel();
-            this._queueChannel._createdAt = new Date().toISOString();
-            this._queueChannel._closeReason = null;
-            this._queueChannel._lastOperation = null;
-            
-            // Re-attach event listeners
-            this._queueChannel.on('error', (err) => {
-              console.error('[RabbitMQClient] Queue channel error:', err.message);
-              console.error('[RabbitMQClient] Error code:', err.code);
-              console.error('[RabbitMQClient] Channel created at:', this._queueChannel._createdAt);
-              console.error('[RabbitMQClient] Last operation:', this._queueChannel._lastOperation);
-              this._queueChannel._closeReason = `Error: ${err.message} (code: ${err.code})`;
-            });
-            this._queueChannel.on('close', () => {
-              console.error('[RabbitMQClient] Queue channel closed');
-              console.error('[RabbitMQClient] Channel created at:', this._queueChannel._createdAt);
-              console.error('[RabbitMQClient] Close reason:', this._queueChannel._closeReason || 'Unknown');
-              console.error('[RabbitMQClient] Last operation:', this._queueChannel._lastOperation);
-            });
-            
-            console.log(`[RabbitMQClient] [CONSUMER] ✓ _queueChannel recreated`);
-          } catch (recreateErr) {
-            console.error(`[RabbitMQClient] [CONSUMER] ✗ Failed to recreate _queueChannel:`, recreateErr.message);
-            throw new Error(`Cannot assertQueue: _queueChannel is closed and recreation failed: ${recreateErr.message}`);
-          }
+        // CRITICAL: Check if _queueChannel is closed - if so, this indicates a previous 406 error
+        // The root cause is that assertQueue() was called without parameters somewhere else
+        // We should NOT recreate the channel - we should fix the root cause
+        if (this._queueChannel && this._queueChannel.closed) {
+          const errorMsg = `[RabbitMQClient] [CONSUMER] ✗ CRITICAL: _queueChannel is CLOSED (likely due to 406 PRECONDITION-FAILED). This means assertQueue() was called without parameters somewhere else. Root cause must be fixed - do NOT recreate channel!`;
+          console.error(errorMsg);
+          console.error(`[RabbitMQClient] [CONSUMER] Channel was created at: ${this._queueChannel._createdAt}`);
+          console.error(`[RabbitMQClient] [CONSUMER] Close reason: ${this._queueChannel._closeReason || 'Unknown'}`);
+          console.error(`[RabbitMQClient] [CONSUMER] Last operation: ${this._queueChannel._lastOperation || 'Unknown'}`);
+          throw new Error(`Cannot assertQueue: _queueChannel is closed due to 406 error. Root cause: assertQueue() was called without parameters. Fix the root cause instead of recreating channel.`);
+        }
+        
+        if (!this._queueChannel) {
+          throw new Error(`Cannot assertQueue: _queueChannel is null. Connection may not be established.`);
         }
         
         // Use queueChannel for assertQueue to avoid RPC reply queue issues
         const channelForAssert = this._queueChannel;
-        this._queueChannel._lastOperation = `About to assertQueue ${queue}`;
-        await channelForAssert.assertQueue(queue, queueOptions);
-        this._queueChannel._lastOperation = `assertQueue ${queue} succeeded`;
+        this._queueChannel._lastOperation = `About to assertQueue ${queue} with options: ${JSON.stringify(queueOptions)}`;
+        try {
+          await channelForAssert.assertQueue(queue, queueOptions);
+          this._queueChannel._lastOperation = `assertQueue ${queue} succeeded`;
+        } catch (assertErr) {
+          this._queueChannel._closeReason = `assertQueue failed: ${assertErr.message}`;
+          if (assertErr?.code === 406) {
+            this._handlePreconditionFailed(
+              {
+                operation: 'assertQueue',
+                phase: 'consume.setup',
+                queueName: queue,
+                queueOptions
+              },
+              assertErr
+            );
+          }
+          throw assertErr;
+        }
         
         const assertEndTime = Date.now();
         console.log(`[RabbitMQClient] [CONSUMER] ✓ Queue ${queue} asserted (took ${assertEndTime - assertStartTime}ms)`);

package/src/utils/initInfrastructureQueues.js

@@ -1,72 +0,0 @@
-'use strict';
-
-/**
- * initInfrastructureQueues.js
- * 
- * Unified tool for creating all infrastructure queues.
- * Used by ALL relevant services (infrastructure AND business) during startup.
- * 
- * Ensures consistent queue parameters across all services.
- */
-
-const queueConfig = require('../config/queueConfig');
-
-/**
- * Initialize all infrastructure queues
- * @param {Object} channel - RabbitMQ channel
- * @param {Object} options - Options
- * @param {Array<string>} [options.queues] - Specific queues to create (default: all infrastructure queues)
- * @param {Object} [options.logger] - Logger instance (default: console)
- * @returns {Promise<void>}
- */
-async function initInfrastructureQueues(channel, options = {}) {
-  const logger = options.logger || console;
-  const queuesToCreate = options.queues || [
-    // Workflow infrastructure queues
-    'workflow.init',
-    'workflow.completed',
-    'workflow.failed',
-    'workflow.dlq',
-    // Registry infrastructure queues
-    'registry.register',
-    'registry.heartbeats'
-  ];
-
-  logger.log(`[QueueInit] Initializing ${queuesToCreate.length} infrastructure queues...`);
-
-  for (const queueName of queuesToCreate) {
-    try {
-      // Verify it's an infrastructure queue
-      if (!queueConfig.isInfrastructureQueue(queueName)) {
-        logger.warn(`[QueueInit] Skipping ${queueName} - not an infrastructure queue`);
-        continue;
-      }
-
-      // Get unified configuration
-      const config = queueConfig.getInfrastructureQueueConfig(queueName);
-      
-      // Create queue with unified config
-      await channel.assertQueue(queueName, {
-        durable: config.durable !== false,
-        arguments: { ...config.arguments }
-      });
-
-      logger.log(`[QueueInit] ✓ Created infrastructure queue: ${queueName}`);
-    } catch (error) {
-      // If queue exists with different args (406), log warning but continue
-      if (error.code === 406) {
-        logger.warn(`[QueueInit] ⚠ Queue ${queueName} exists with different arguments - using as-is`);
-      } else {
-        logger.error(`[QueueInit] ✗ Failed to create ${queueName}:`, error.message);
-        throw error;
-      }
-    }
-  }
-
-  logger.log(`[QueueInit] Infrastructure queues initialization complete`);
-}
-
-module.exports = {
-  initInfrastructureQueues
-};
-