@onlineapps/conn-infra-mq 1.1.21 → 1.1.23

package/package.json

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

package/src/layers/QueueManager.js

@@ -215,6 +215,7 @@ class QueueManager {
 
   /**
    * Setup service queues (main + DLQ + optional workflow queue)
+   * CRITICAL: All queues MUST be created together - if one fails, all fail
    * @param {string} serviceName - Name of the service
    * @param {Object} options - Configuration options
    */
@@ -223,67 +224,110 @@ class QueueManager {
     if (!transport || !transport.channel) {
       throw new Error('MQ client not connected');
     }
-    // Use queueChannel for queue operations to avoid RPC reply queue issues
-    const channel = transport.queueChannel || transport.channel;
-
-    const queues = {};
-
-    // Create main processing queue
-    // Handle PRECONDITION-FAILED gracefully - queue may exist with different args
-    try {
-      await this.ensureQueue(`${serviceName}.queue`, {
-        ttl: options.ttl || this.config.defaultTTL,
-        dlq: true,
-        durable: true,
-        maxRetries: this.config.maxRetries
-      });
-    } catch (error) {
-      if (error.code === 406) {
-        // Queue exists with different arguments - use it as-is
-        console.warn(`[QueueManager] Queue ${serviceName}.queue exists with different arguments, using as-is`);
-        // Verify queue exists
-        await channel.checkQueue(`${serviceName}.queue`);
-      } else {
-        throw error;
-      }
+    
+    // CRITICAL: Use queueChannel for queue operations
+    // If channel is closed, we cannot continue - this is a critical error
+    let channel = transport.queueChannel || transport.channel;
+    
+    if (!channel || channel.closed) {
+      throw new Error('Queue channel is not available or closed - cannot create business queues');
     }
-    queues.main = `${serviceName}.queue`;
 
-    // Create dead letter queue
-    try {
-      await this.ensureQueue(`${serviceName}.dlq`, {
-        ttl: null, // No TTL for DLQ
-        dlq: false,
-        durable: true,
-        autoDelete: false
-      });
-    } catch (error) {
-      if (error.code === 406) {
-        console.warn(`[QueueManager] Queue ${serviceName}.dlq exists with different arguments, using as-is`);
-        await channel.checkQueue(`${serviceName}.dlq`);
-      } else {
-        throw error;
-      }
+    const queues = {};
+    const queueNames = [];
+    
+    // Collect all queue names that need to be created
+    queueNames.push({ name: `${serviceName}.queue`, type: 'main' });
+    queueNames.push({ name: `${serviceName}.dlq`, type: 'dlq' });
+    if (options.includeWorkflow !== false) {
+      queueNames.push({ name: `${serviceName}.workflow`, type: 'workflow' });
     }
-    queues.dlq = `${serviceName}.dlq`;
 
-    // Create workflow queue if requested
-    if (options.includeWorkflow !== false) {
-      try {
-        await this.ensureQueue(`${serviceName}.workflow`, {
+    // CRITICAL: Create ALL queues using assertQueue directly (no checkQueue first to avoid channel closure)
+    // This ensures all queues are created atomically
+    for (const queueInfo of queueNames) {
+      const queueName = queueInfo.name;
+      let queueOptions;
+      
+      if (queueInfo.type === 'main') {
+        queueOptions = this._buildQueueOptions(queueName, {
+          ttl: options.ttl || this.config.defaultTTL,
+          dlq: true,
+          durable: true,
+          maxRetries: this.config.maxRetries
+        });
+      } else if (queueInfo.type === 'dlq') {
+        queueOptions = this._buildQueueOptions(queueName, {
+          ttl: null,
+          dlq: false,
+          durable: true,
+          autoDelete: false
+        });
+      } else if (queueInfo.type === 'workflow') {
+        queueOptions = this._buildQueueOptions(queueName, {
           ttl: options.workflowTTL || this.config.defaultTTL,
           dlq: true,
           durable: true
         });
-      } catch (error) {
-        if (error.code === 406) {
-          console.warn(`[QueueManager] Queue ${serviceName}.workflow exists with different arguments, using as-is`);
-          await channel.checkQueue(`${serviceName}.workflow`);
+      }
+      
+      // Use business queue config from queueConfig if available
+      if (queueConfig.isBusinessQueue(queueName)) {
+        try {
+          const parsed = queueConfig.parseBusinessQueue(queueName);
+          if (parsed) {
+            const businessConfig = queueConfig.getBusinessQueueConfig(parsed.queueType, parsed.serviceName);
+            queueOptions = {
+              durable: businessConfig.durable !== false,
+              arguments: { ...businessConfig.arguments }
+            };
+            // Replace placeholder {service} with actual service name
+            if (queueOptions.arguments['x-dead-letter-routing-key']) {
+              queueOptions.arguments['x-dead-letter-routing-key'] = 
+                queueOptions.arguments['x-dead-letter-routing-key'].replace('{service}', serviceName);
+            }
+          }
+        } catch (error) {
+          // If config not found, use built options
+          console.warn(`[QueueManager] Business queue config not found for ${queueName}, using provided options:`, error.message);
+        }
+      }
+      
+      // CRITICAL: Use assertQueue directly - if queue exists with different args (406), that's OK
+      // We'll handle it gracefully, but channel should NOT close
+      try {
+        // Check if channel is still open before each operation
+        if (!channel || channel.closed) {
+          throw new Error(`Channel closed before creating ${queueName} - cannot continue`);
+        }
+        
+        await channel.assertQueue(queueName, queueOptions);
+        queues[queueInfo.type] = queueName;
+        console.info(`[QueueManager] ✓ Created business queue: ${queueName}`);
+      } catch (assertErr) {
+        // If channel closed, this is a critical error
+        if (!channel || channel.closed) {
+          throw new Error(`Channel closed during assertQueue for ${queueName} - cannot create remaining queues`);
+        }
+        
+        // If 406 PRECONDITION-FAILED, queue exists with different args - use it as-is
+        if (assertErr.code === 406) {
+          console.warn(`[QueueManager] Queue ${queueName} exists with different arguments, using as-is:`, assertErr.message);
+          // Verify queue exists
+          if (!channel || channel.closed) {
+            throw new Error(`Channel closed after 406 error for ${queueName}`);
+          }
+          try {
+            await channel.checkQueue(queueName);
+            queues[queueInfo.type] = queueName;
+          } catch (checkErr) {
+            throw new Error(`Failed to verify existing queue ${queueName}: ${checkErr.message}`);
+          }
         } else {
-          throw error;
+          // Other error - critical, cannot continue
+          throw new Error(`Failed to create business queue ${queueName}: ${assertErr.message}`);
         }
       }
-      queues.workflow = `${serviceName}.workflow`;
     }
 
     // Setup DLQ exchange and bindings