@onlineapps/mq-client-core 1.0.5 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/mq-client-core",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Core MQ client library for RabbitMQ - shared by infrastructure services and connectors",
   "main": "src/index.js",
   "scripts": {

package/src/BaseClient.js

@@ -146,7 +146,14 @@ class BaseClient {
     if (typeof noAck === 'boolean') consumeOptions.noAck = noAck;
     if (options.queueOptions) consumeOptions.queueOptions = options.queueOptions;
 
+    // CRITICAL: Log all consume() calls for transparency
+    console.log(`[BaseClient] [CONSUMER] Starting consume() for queue: ${queue} at ${new Date().toISOString()}`);
+    console.log(`[BaseClient] [CONSUMER] Options:`, JSON.stringify(consumeOptions, null, 2));
+    console.log(`[BaseClient] [CONSUMER] Transport type: ${this._transport?.constructor?.name || 'unknown'}`);
+    console.log(`[BaseClient] [CONSUMER] Connected: ${this._connected}`);
+
     try {
+      const consumeStartTime = Date.now();
       await this._transport.consume(
         queue,
         async (msg) => {
@@ -162,7 +169,10 @@ class BaseClient {
         },
         consumeOptions
       );
+      const consumeEndTime = Date.now();
+      console.log(`[BaseClient] [CONSUMER] ✓ consume() completed for queue: ${queue} (took ${consumeEndTime - consumeStartTime}ms)`);
     } catch (err) {
+      console.error(`[BaseClient] [CONSUMER] ✗ consume() failed for queue: ${queue}`, err.message);
       throw new ConsumeError(`Failed to start consumer for queue "${queue}"`, queue, err);
     }
   }

package/src/transports/rabbitmqClient.js

@@ -33,14 +33,24 @@ class RabbitMQClient extends EventEmitter {
 
     this._connection = null;
     this._channel = null;
+    this._queueChannel = null;
   }
 
   /**
    * Getter for channel - provides compatibility with QueueManager
+   * Returns ConfirmChannel for publish operations
    */
   get channel() {
     return this._channel;
   }
+  
+  /**
+   * Getter for queue channel - regular channel for queue operations
+   * Use this for assertQueue, checkQueue to avoid RPC reply queue issues
+   */
+  get queueChannel() {
+    return this._queueChannel || this._channel; // Fallback to main channel if queueChannel not available
+  }
 
   /**
    * Connects to RabbitMQ server and creates a confirm channel.
@@ -56,13 +66,24 @@ class RabbitMQClient extends EventEmitter {
         this.emit('error', new Error('RabbitMQ connection closed unexpectedly'));
       });
 
-      // Use ConfirmChannel to enable publisher confirms
+      // Use ConfirmChannel to enable publisher confirms for publish operations
       this._channel = await this._connection.createConfirmChannel();
       this._channel.on('error', (err) => this.emit('error', err));
       this._channel.on('close', () => {
         // Emit a channel close error
         this.emit('error', new Error('RabbitMQ channel closed unexpectedly'));
       });
+      
+      // Create a separate regular channel for queue operations (assertQueue, checkQueue)
+      // This avoids RPC reply queue issues with ConfirmChannel.assertQueue()
+      this._queueChannel = await this._connection.createChannel();
+      this._queueChannel.on('error', (err) => {
+        // Log but don't emit - queue channel errors are less critical
+        console.warn('[RabbitMQClient] Queue channel error:', err.message);
+      });
+      this._queueChannel.on('close', () => {
+        console.warn('[RabbitMQClient] Queue channel closed');
+      });
     } catch (err) {
       // Cleanup partially created resources
       if (this._connection) {
@@ -82,6 +103,15 @@ class RabbitMQClient extends EventEmitter {
    * @returns {Promise<void>}
    */
   async disconnect() {
+    try {
+      if (this._queueChannel) {
+        await this._queueChannel.close();
+        this._queueChannel = null;
+      }
+    } catch (err) {
+      // Log but don't emit - queue channel errors are less critical
+      console.warn('[RabbitMQClient] Error closing queue channel:', err.message);
+    }
     try {
       if (this._channel) {
         await this._channel.close();
@@ -122,22 +152,22 @@ class RabbitMQClient extends EventEmitter {
       // Ensure queue exists if publishing directly to queue and using default exchange
       if (!exchange) {
         // For infrastructure queues, they should already exist with specific arguments
-        // Use checkQueue instead of assertQueue to avoid 406 PRECONDITION-FAILED
+        // Use queueChannel (regular channel) for checkQueue/assertQueue to avoid RPC reply queue issues
         // If queue doesn't exist (404), try to create it with default options
         try {
-          await this._channel.checkQueue(queue);
+          await this._queueChannel.checkQueue(queue);
           // Queue exists - proceed to publish
         } catch (checkErr) {
           // If queue doesn't exist (404), create it with default options
           if (checkErr.code === 404) {
             const queueOptions = options.queueOptions || { durable: this._config.durable };
-            await this._channel.assertQueue(queue, queueOptions);
+            await this._queueChannel.assertQueue(queue, queueOptions);
           } else {
             // Other error - rethrow
             throw checkErr;
           }
         }
-        // Publish to queue (works even if queue has different arguments)
+        // Publish to queue using ConfirmChannel (for publisher confirms)
         this._channel.sendToQueue(queue, buffer, { persistent, headers });
       } else {
         // If exchange is specified, assert exchange and publish to it
@@ -173,23 +203,74 @@ class RabbitMQClient extends EventEmitter {
       // Skip assertQueue for reply queues (they're already created with specific settings)
       // Reply queues start with 'rpc.reply.' and are created as non-durable
       if (!queue.startsWith('rpc.reply.')) {
-        // Simple queue assertion - infrastructure services should ensure queues exist
-        // If queue doesn't exist, assertQueue will create it with default options
-        // If it exists with different args (406), log warning and proceed
-        const queueOptions = options.queueOptions || { durable };
-        try {
-          await this._channel.assertQueue(queue, queueOptions);
-        } catch (assertErr) {
-          // If queue exists with different arguments (406), use it as-is
-          if (assertErr.code === 406) {
-            console.warn(`[RabbitMQClient] Queue ${queue} exists with different arguments, using as-is:`, assertErr.message);
-            // Don't try to re-assert - just proceed to consume
-          } else {
-            // Other error - rethrow
-            throw assertErr;
+      // CRITICAL: Use queueConfig.js to get correct parameters (TTL, max-length, etc.)
+      // This prevents 406 PRECONDITION-FAILED errors from TTL mismatches
+      // Note: mq-client-core is for infrastructure services, but we need queueConfig from conn-infra-mq
+      // Try to load it - if it fails, we'll use defaults
+      let queueConfig = null;
+      try {
+        queueConfig = require('@onlineapps/conn-infra-mq/src/config/queueConfig');
+      } catch (requireErr) {
+        console.warn(`[RabbitMQClient] [mq-client-core] [CONSUMER] Cannot load queueConfig from @onlineapps/conn-infra-mq:`, requireErr.message);
+        console.warn(`[RabbitMQClient] [mq-client-core] [CONSUMER] Using default queue options (this may cause 406 errors if queue exists with different args)`);
+      }
+      const isInfraQueue = queueConfig.isInfrastructureQueue(queue);
+      const isBusinessQueue = queueConfig.isBusinessQueue(queue);
+      
+      let queueOptions = options.queueOptions || { durable };
+      
+      if (queueConfig) {
+        if (isInfraQueue) {
+          // Infrastructure queue - use central config
+          try {
+            const infraConfig = queueConfig.getInfrastructureQueueConfig(queue);
+            queueOptions = {
+              durable: infraConfig.durable !== false,
+              arguments: { ...infraConfig.arguments }
+            };
+            console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] Asserting infrastructure queue ${queue} with config from queueConfig`);
+          } catch (configErr) {
+            console.warn(`[RabbitMQClient] [mq-client-core] [CONSUMER] Infrastructure queue config not found for ${queue}, using default:`, configErr.message);
+          }
+        } else if (isBusinessQueue) {
+          // Business queue - use central config
+          try {
+            const parsed = queueConfig.parseBusinessQueue(queue);
+            if (parsed) {
+              const businessConfig = queueConfig.getBusinessQueueConfig(parsed.queueType, parsed.serviceName);
+              queueOptions = {
+                durable: businessConfig.durable !== false,
+                arguments: { ...businessConfig.arguments }
+              };
+              console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] Asserting business queue ${queue} with config from queueConfig`);
+            }
+          } catch (configErr) {
+            console.warn(`[RabbitMQClient] [mq-client-core] [CONSUMER] Business queue config not found for ${queue}, using default:`, configErr.message);
           }
         }
       }
+      
+      console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] Asserting queue ${queue} before consume() at ${new Date().toISOString()}`);
+      console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] Queue options:`, JSON.stringify(queueOptions, null, 2));
+      
+      try {
+        await this._queueChannel.assertQueue(queue, queueOptions);
+        console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] ✓ Queue ${queue} asserted successfully`);
+      } catch (assertErr) {
+        // If queue exists with different arguments (406), this is a CRITICAL ERROR
+        // We should NOT proceed - the root cause must be fixed
+        if (assertErr.code === 406) {
+          console.error(`[RabbitMQClient] [mq-client-core] [CONSUMER] ✗ CRITICAL: Queue ${queue} exists with different arguments!`);
+          console.error(`[RabbitMQClient] [mq-client-core] [CONSUMER] Error:`, assertErr.message);
+          console.error(`[RabbitMQClient] [mq-client-core] [CONSUMER] Expected options:`, JSON.stringify(queueOptions, null, 2));
+          console.error(`[RabbitMQClient] [mq-client-core] [CONSUMER] This means assertQueue() was called without parameters somewhere else. Root cause must be fixed!`);
+          throw new Error(`Cannot assertQueue ${queue}: queue exists with different arguments. Root cause: assertQueue() was called without parameters. Fix the root cause instead of proceeding.`);
+        } else {
+          // Other error - rethrow
+          throw assertErr;
+        }
+      }
+      }
       // Set prefetch if provided
       if (typeof prefetch === 'number') {
         this._channel.prefetch(prefetch);