@onlineapps/mq-client-core 1.0.32 → 1.0.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/mq-client-core",
-  "version": "1.0.32",
+  "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

@@ -94,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()
@@ -187,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;
@@ -254,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)) {