@onlineapps/mq-client-core 1.0.31 → 1.0.33

package/package.json

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

package/src/transports/rabbitmqClient.js

@@ -32,8 +32,9 @@ class RabbitMQClient extends EventEmitter {
     );
 
     this._connection = null;
-    this._channel = null;
-    this._queueChannel = null;
+    this._channel = null; // ConfirmChannel for publish operations
+    this._queueChannel = null; // Regular channel for queue operations (assertQueue, checkQueue)
+    this._consumerChannel = null; // Dedicated channel for consume operations
   }
 
   /**
@@ -93,11 +94,20 @@ class RabbitMQClient extends EventEmitter {
 
       // Use ConfirmChannel to enable publisher confirms for publish operations
       this._channel = await this._connection.createConfirmChannel();
-      this._channel.on('error', (err) => this.emit('error', err));
+      // Enable publisher confirms explicitly
+      this._channel.on('error', (err) => {
+        console.error('[RabbitMQClient] [mq-client-core] Publisher channel error:', err.message);
+        this.emit('error', err);
+      });
       this._channel.on('close', () => {
+        console.warn('[RabbitMQClient] [mq-client-core] Publisher channel closed');
         // Emit a channel close error
         this.emit('error', new Error('RabbitMQ channel closed unexpectedly'));
       });
+      // Set up publisher confirms callback
+      this._channel.on('drain', () => {
+        console.log('[RabbitMQClient] [mq-client-core] Publisher channel drained');
+      });
       
       // Create a separate regular channel for queue operations (assertQueue, checkQueue)
       // This avoids RPC reply queue issues with ConfirmChannel.assertQueue()
@@ -109,6 +119,18 @@ class RabbitMQClient extends EventEmitter {
       this._queueChannel.on('close', () => {
         console.warn('[RabbitMQClient] Queue channel closed');
       });
+      
+      // Create a dedicated channel for consume operations
+      // This prevents channel conflicts between publish (ConfirmChannel) and consume operations
+      this._consumerChannel = await this._connection.createChannel();
+      this._consumerChannel.on('error', (err) => {
+        console.warn('[RabbitMQClient] Consumer channel error:', err.message);
+        this.emit('error', err);
+      });
+      this._consumerChannel.on('close', () => {
+        console.warn('[RabbitMQClient] Consumer channel closed');
+        this.emit('error', new Error('RabbitMQ consumer channel closed unexpectedly'));
+      });
     } catch (err) {
       // Cleanup partially created resources
       if (this._connection) {
@@ -128,6 +150,14 @@ class RabbitMQClient extends EventEmitter {
    * @returns {Promise<void>}
    */
   async disconnect() {
+    try {
+      if (this._consumerChannel) {
+        await this._consumerChannel.close();
+        this._consumerChannel = null;
+      }
+    } catch (err) {
+      console.warn('[RabbitMQClient] Error closing consumer channel:', err.message);
+    }
     try {
       if (this._queueChannel) {
         await this._queueChannel.close();
@@ -166,8 +196,13 @@ class RabbitMQClient extends EventEmitter {
   async publish(queue, buffer, options = {}) {
     // Check channel state before publish
     if (!this._channel || this._channel.closed) {
-      throw new Error('Cannot publish: channel is not initialized or closed');
+      const errorMsg = `Cannot publish to queue "${queue}": channel is not initialized or closed (channel: ${!!this._channel}, closed: ${this._channel?.closed})`;
+      console.error('[RabbitMQClient] [mq-client-core] [PUBLISH]', errorMsg);
+      throw new Error(errorMsg);
     }
+    
+    // Log publish attempt for debugging
+    console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Attempting to publish to queue "${queue}" (channel open: ${!this._channel.closed})`);
 
     const exchange = this._config.exchange || '';
     const routingKey = options.routingKey || queue;
@@ -233,23 +268,90 @@ class RabbitMQClient extends EventEmitter {
         // Publish to queue using ConfirmChannel (for publisher confirms)
         // Check channel state again before sendToQueue
         if (this._channel.closed) {
-          throw new Error('Cannot publish: channel closed during operation');
+          throw new Error(`Cannot publish to queue "${queue}": channel closed during operation (after queue check)`);
+        }
+        
+        console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Sending message to queue "${queue}" (size: ${buffer.length} bytes)`);
+        
+        // Use callback-based confirmation for more reliable error handling
+        const confirmPromise = new Promise((resolve, reject) => {
+          // Set up timeout
+          const timeout = setTimeout(() => {
+            reject(new Error(`Publisher confirm timeout after 5 seconds for queue "${queue}"`));
+          }, 5000);
+          
+          // Send message with callback
+          const sent = this._channel.sendToQueue(queue, buffer, { persistent, headers }, (err, ok) => {
+            clearTimeout(timeout);
+            if (err) {
+              console.error(`[RabbitMQClient] [mq-client-core] [PUBLISH] Send callback error for queue "${queue}":`, err.message);
+              reject(err);
+            } else {
+              console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] ✓ Message confirmed for queue "${queue}"`);
+              resolve();
+            }
+          });
+          
+          // If sendToQueue returns false, channel is full - wait for drain
+          if (!sent) {
+            console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Channel full, waiting for drain for queue "${queue}"`);
+            this._channel.once('drain', () => {
+              console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Channel drained for queue "${queue}"`);
+            });
+          }
+        });
+        
+        try {
+          await confirmPromise;
+        } catch (confirmErr) {
+          // Check if channel was closed during confirmation
+          if (this._channel.closed) {
+            const errorMsg = `Publisher confirm failed for queue "${queue}": channel closed during confirmation. Original error: ${confirmErr.message}`;
+            console.error('[RabbitMQClient] [mq-client-core] [PUBLISH]', errorMsg);
+            throw new Error(errorMsg);
+          }
+          throw confirmErr;
         }
-        this._channel.sendToQueue(queue, buffer, { persistent, headers });
       } else {
         // If exchange is specified, assert exchange and publish to it
         if (this._channel.closed) {
           throw new Error('Cannot publish: channel closed during operation');
         }
         await this._channel.assertExchange(exchange, 'direct', { durable: this._config.durable });
-        this._channel.publish(exchange, routingKey, buffer, { persistent, headers });
+        
+        // Use callback-based confirmation for exchange publish
+        const confirmPromise = new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            reject(new Error(`Publisher confirm timeout after 5 seconds for exchange "${exchange}"`));
+          }, 5000);
+          
+          const sent = this._channel.publish(exchange, routingKey, buffer, { persistent, headers }, (err, ok) => {
+            clearTimeout(timeout);
+            if (err) {
+              console.error(`[RabbitMQClient] [mq-client-core] [PUBLISH] Exchange publish callback error:`, err.message);
+              reject(err);
+            } else {
+              console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] ✓ Exchange publish confirmed`);
+              resolve();
+            }
+          });
+          
+          if (!sent) {
+            this._channel.once('drain', () => {
+              console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Channel drained for exchange "${exchange}"`);
+            });
+          }
+        });
+        
+        try {
+          await confirmPromise;
+        } catch (confirmErr) {
+          if (this._channel.closed) {
+            throw new Error(`Publisher confirm failed for exchange "${exchange}": channel closed during confirmation. Original error: ${confirmErr.message}`);
+          }
+          throw confirmErr;
+        }
       }
-      // Wait for confirmation (with timeout to prevent hanging)
-      const confirmPromise = this._channel.waitForConfirms();
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => reject(new Error('Publisher confirm timeout after 5 seconds')), 5000);
-      });
-      await Promise.race([confirmPromise, timeoutPromise]);
     } catch (err) {
       // If channel was closed, mark it for recreation
       if (err.message && (err.message.includes('Channel closed') || err.message.includes('channel is closed') || this._channel?.closed)) {
@@ -270,8 +372,40 @@ class RabbitMQClient extends EventEmitter {
    * @throws {Error} If consume setup fails or channel is not available.
    */
   async consume(queue, onMessage, options = {}) {
-    if (!this._channel) {
-      throw new Error('Cannot consume: channel is not initialized');
+    // Use dedicated consumer channel instead of ConfirmChannel
+    // ConfirmChannel is optimized for publish operations, not consume
+    if (!this._consumerChannel) {
+      // Recreate consumer channel if closed
+      if (this._connection && !this._connection.closed) {
+        this._consumerChannel = await this._connection.createChannel();
+        this._consumerChannel.on('error', (err) => {
+          console.warn('[RabbitMQClient] Consumer channel error:', err.message);
+          this.emit('error', err);
+        });
+        this._consumerChannel.on('close', () => {
+          console.warn('[RabbitMQClient] Consumer channel closed');
+          this.emit('error', new Error('RabbitMQ consumer channel closed unexpectedly'));
+        });
+      } else {
+        throw new Error('Cannot consume: consumer channel is not initialized and connection is closed');
+      }
+    }
+    
+    if (this._consumerChannel.closed) {
+      // Recreate consumer channel if closed
+      if (this._connection && !this._connection.closed) {
+        this._consumerChannel = await this._connection.createChannel();
+        this._consumerChannel.on('error', (err) => {
+          console.warn('[RabbitMQClient] Consumer channel error:', err.message);
+          this.emit('error', err);
+        });
+        this._consumerChannel.on('close', () => {
+          console.warn('[RabbitMQClient] Consumer channel closed');
+          this.emit('error', new Error('RabbitMQ consumer channel closed unexpectedly'));
+        });
+      } else {
+        throw new Error('Cannot consume: consumer channel is closed and connection is closed');
+      }
     }
 
     const durable = options.durable !== undefined ? options.durable : this._config.durable;
@@ -368,32 +502,21 @@ class RabbitMQClient extends EventEmitter {
         }
       }
       }
-      // Set prefetch if provided
+      // Set prefetch if provided (on consumer channel)
       if (typeof prefetch === 'number') {
-        this._channel.prefetch(prefetch);
+        this._consumerChannel.prefetch(prefetch);
       }
 
       // CRITICAL: Log before calling amqplib's consume()
       // amqplib's consume() may internally call assertQueue() without parameters if queue doesn't exist
       // This would create queue with default arguments (no TTL), causing 406 errors later
-      console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] About to call amqplib's channel.consume(${queue})`);
+      console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] About to call amqplib's consumerChannel.consume(${queue})`);
       console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] ⚠ WARNING: amqplib's consume() may internally call assertQueue() WITHOUT parameters if queue doesn't exist`);
       console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] ⚠ WARNING: We already asserted queue with correct parameters above - this should prevent auto-creation`);
       
-      // CRITICAL: Wrap amqplib's channel.consume() to intercept any internal assertQueue() calls
-      // This will help us identify if amqplib is creating the queue without TTL
-      const originalConsume = this._channel.consume.bind(this._channel);
-      const originalAssertQueue = this._channel.assertQueue.bind(this._channel);
-      
-      // Intercept assertQueue() calls to log them
-      this._channel.assertQueue = async function(queueName, options) {
-        console.log(`[RabbitMQClient] [mq-client-core] [INTERCEPT] assertQueue() called for: ${queueName}`);
-        console.log(`[RabbitMQClient] [mq-client-core] [INTERCEPT] Options:`, JSON.stringify(options || {}, null, 2));
-        console.log(`[RabbitMQClient] [mq-client-core] [INTERCEPT] Stack trace:`, new Error().stack.split('\n').slice(1, 10).join('\n'));
-        return originalAssertQueue.call(this, queueName, options);
-      };
-      
-      await this._channel.consume(
+      // Use dedicated consumer channel for consume operations
+      // This prevents conflicts with ConfirmChannel used for publish operations
+      const consumeResult = await this._consumerChannel.consume(
         queue,
         async (msg) => {
           if (msg === null) {
@@ -402,15 +525,18 @@ class RabbitMQClient extends EventEmitter {
           try {
             await onMessage(msg);
             if (!noAck) {
-              this._channel.ack(msg);
+              this._consumerChannel.ack(msg);
             }
           } catch (handlerErr) {
             // Negative acknowledge and requeue by default
-            this._channel.nack(msg, false, true);
+            this._consumerChannel.nack(msg, false, true);
           }
         },
         { noAck }
       );
+      
+      // Return consumer tag for cancellation
+      return consumeResult.consumerTag;
     } catch (err) {
       this.emit('error', err);
       throw err;