@onlineapps/conn-infra-mq 1.1.20 → 1.1.22

package/package.json

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

package/src/layers/QueueManager.js

@@ -103,17 +103,40 @@ class QueueManager {
         throw new Error('Channel closed during checkQueue - cannot verify queue');
       }
       
-      // If queue doesn't exist (404), we'll let it be created lazily on first publish
-      // This avoids RPC reply queue issues with assertQueue()
+      // If queue doesn't exist (404), create it using assertQueue with proper error handling
+      // Business queues MUST be created with specific arguments (TTL, DLQ, max-length) from queueConfig
+      // Lazy creation via sendToQueue() is NOT suitable - it creates queue with default arguments
       if (checkErr.code === 404) {
-        // Queue doesn't exist - will be created on first sendToQueue()
-        // Return a mock queue info to indicate queue will be created lazily
-        console.info(`[QueueManager] Queue ${queueName} doesn't exist - will be created on first publish`);
-        return {
-          queue: queueName,
-          messageCount: 0,
-          consumerCount: 0
-        };
+        // CRITICAL: Business queues MUST be created explicitly with correct arguments
+        // Use assertQueue() on regular channel (queueChannel) - this should work without RPC issues
+        // If it fails, it's a real problem that needs to be fixed, not worked around
+        try {
+          if (!channel || channel.closed) {
+            throw new Error('Channel closed - cannot create queue');
+          }
+          
+          // For business queues: use assertQueue with queueOptions from queueConfig
+          // This ensures correct TTL, DLQ, max-length arguments
+          return await channel.assertQueue(queueName, queueOptions);
+        } catch (assertErr) {
+          // If channel closed during assertQueue, it's a real error
+          if (!channel || channel.closed) {
+            throw new Error(`Channel closed during assertQueue for ${queueName} - check channel management`);
+          }
+          
+          // If 406 PRECONDITION-FAILED, queue exists with different args
+          if (assertErr.code === 406) {
+            console.warn(`[QueueManager] Queue ${queueName} exists with different arguments:`, assertErr.message);
+            // Try to get queue info anyway
+            if (!channel || channel.closed) {
+              throw new Error('Channel closed - cannot check existing queue');
+            }
+            return await channel.checkQueue(queueName);
+          }
+          
+          // Other errors - rethrow
+          throw assertErr;
+        }
       } else {
         // Other error (including 406) - queue exists with different args
         // Log warning and return queue info without asserting
@@ -192,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
    */
@@ -200,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

package/src/transports/rabbitmqClient.js

@@ -222,23 +222,24 @@ class RabbitMQClient extends EventEmitter {
             throw checkErr;
           }
         } else {
-          // Business queue - may need to be created, but use unified config
+          // Business queue - should already be created by setupServiceQueues() BEFORE consume is called
           // Use queueChannel (regular channel) for queue operations to avoid RPC reply queue issues
-          const queueOptions = this._getQueueOptions(queue, { durable });
-          
-          // Try to assert queue with our config
-          // If it fails with 406 (PRECONDITION-FAILED), queue exists with different args - use it as-is
-          // IMPORTANT: Don't try to re-assert after 406, as it will close the channel
+          // Only check if it exists - don't try to create it here (that's setupServiceQueues() responsibility)
           try {
-            await this._queueChannel.assertQueue(queue, queueOptions);
-          } catch (assertErr) {
-            // If queue exists with different arguments (406), use it as-is without re-asserting
-            if (assertErr.code === 406) {
-              console.warn(`[RabbitMQClient] Queue ${queue} exists with different arguments, using as-is (skipping assert to avoid channel close):`, assertErr.message);
-              // Don't try to re-assert - just proceed to consume
+            await this._queueChannel.checkQueue(queue);
+            // Queue exists - proceed to consume
+          } catch (checkErr) {
+            if (checkErr.code === 404) {
+              // Queue doesn't exist - this is an error, queue should have been created by setupServiceQueues()
+              throw new Error(`Business queue '${queue}' not found. Queue should be created by setupServiceQueues() before consuming.`);
+            }
+            // Other error (including 406) - queue exists with different args, use it as-is
+            if (checkErr.code === 406) {
+              console.warn(`[RabbitMQClient] Queue ${queue} exists with different arguments, using as-is:`, checkErr.message);
+              // Proceed to consume - queue exists, just with different args
             } else {
               // Other error - rethrow
-              throw assertErr;
+              throw checkErr;
             }
           }
         }