@onlineapps/conn-infra-mq 1.1.51 → 1.1.52

package/package.json

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

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/transports/rabbitmqClient.js

@@ -336,42 +336,27 @@ 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}`;
+        this._queueChannel._lastOperation = `About to assertQueue ${queue} with options: ${JSON.stringify(queueOptions)}`;
         await channelForAssert.assertQueue(queue, queueOptions);
         this._queueChannel._lastOperation = `assertQueue ${queue} succeeded`;
         

package/src/utils/initInfrastructureQueues.js

@@ -45,21 +45,41 @@ async function initInfrastructureQueues(channel, options = {}) {
       // 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;
+      // CRITICAL: Check if queue exists with different arguments (406 error)
+      // If so, delete it and recreate with correct parameters
+      try {
+        await channel.assertQueue(queueName, {
+          durable: config.durable !== false,
+          arguments: { ...config.arguments }
+        });
+        logger.log(`[QueueInit] ✓ Created/verified infrastructure queue: ${queueName}`);
+      } catch (assertError) {
+        if (assertError.code === 406) {
+          // Queue exists with different arguments - delete and recreate
+          logger.warn(`[QueueInit] ⚠ Queue ${queueName} exists with different arguments - deleting and recreating...`);
+          try {
+            await channel.deleteQueue(queueName);
+            logger.log(`[QueueInit] ✓ Deleted queue ${queueName} with incorrect parameters`);
+          } catch (deleteError) {
+            logger.error(`[QueueInit] ✗ Failed to delete queue ${queueName}:`, deleteError.message);
+            throw new Error(`Cannot delete queue ${queueName} with incorrect parameters: ${deleteError.message}`);
+          }
+          
+          // Recreate with correct parameters
+          await channel.assertQueue(queueName, {
+            durable: config.durable !== false,
+            arguments: { ...config.arguments }
+          });
+          logger.log(`[QueueInit] ✓ Recreated infrastructure queue: ${queueName} with correct parameters`);
+        } else {
+          // Other error - rethrow
+          logger.error(`[QueueInit] ✗ Failed to create ${queueName}:`, assertError.message);
+          throw assertError;
+        }
       }
+    } catch (error) {
+      logger.error(`[QueueInit] ✗ Failed to initialize queue ${queueName}:`, error.message);
+      throw error;
     }
   }