@onlineapps/mq-client-core 1.0.30 → 1.0.32

package/package.json

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

package/src/config/queueConfig.js

@@ -113,6 +113,72 @@ module.exports = {
     }
   },
 
+  /**
+   * Delivery infrastructure queue configurations
+   * Managed by API Delivery Dispatcher
+   */
+  delivery: {
+    /**
+     * delivery.retry - Retry queue for failed delivery attempts
+     * Used for delayed retries driven by Delivery Dispatcher
+     */
+    retry: {
+      durable: true,
+      arguments: {
+        'x-max-length': 10000 // Allow up to 10k pending retry messages
+      }
+    },
+
+    /**
+     * delivery.result - Final delivery status events for audits/monitoring
+     */
+    result: {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 86400000, // 24 hours TTL for audit traceability
+        'x-max-length': 50000
+      }
+    },
+
+    /**
+     * delivery.websocket.notify - Notifications for Gateway websocket hub
+     */
+    'websocket.notify': {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 60000, // Notifications older than 60s are irrelevant
+        'x-max-length': 10000
+      }
+    }
+  },
+
+  /**
+   * Validation infrastructure queue configurations
+   */
+  validation: {
+    /**
+     * validation.requests - Requests from Registry to Validator
+     */
+    requests: {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 300000, // 5 minutes TTL to avoid stale requests
+        'x-max-length': 10000
+      }
+    },
+
+    /**
+     * validation.responses - Responses from Validator back to Registry
+     */
+    responses: {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 300000,
+        'x-max-length': 10000
+      }
+    }
+  },
+
   /**
    * Infrastructure health tracking queue configurations
    */
@@ -269,7 +335,34 @@ module.exports = {
            queueName.startsWith('registry.') ||
            queueName.startsWith('infrastructure.') ||
            queueName.startsWith('validation.') ||
-           queueName.startsWith('monitoring.');
+           queueName.startsWith('monitoring.') ||
+           queueName.startsWith('delivery.');
+  },
+
+  /**
+   * Get delivery queue configuration
+   * @param {string} queueName - Queue name (e.g., 'delivery.retry')
+   * @returns {Object} Queue configuration
+   */
+  getDeliveryQueueConfig(queueName) {
+    if (!queueName.startsWith('delivery.')) {
+      throw new Error(`Queue ${queueName} is not a delivery queue`);
+    }
+    const name = queueName.replace('delivery.', '');
+    return this.getQueueConfig('delivery', name);
+  },
+
+  /**
+   * Get validation queue configuration
+   * @param {string} queueName - Queue name (e.g., 'validation.requests')
+   * @returns {Object} Queue configuration
+   */
+  getValidationQueueConfig(queueName) {
+    if (!queueName.startsWith('validation.')) {
+      throw new Error(`Queue ${queueName} is not a validation queue`);
+    }
+    const name = queueName.replace('validation.', '');
+    return this.getQueueConfig('validation', name);
   },
 
   /**
@@ -368,6 +461,10 @@ module.exports = {
       return this.getInfrastructureHealthQueueConfig(queueName);
     } else if (queueName.startsWith('monitoring.')) {
       return this.getMonitoringQueueConfig(queueName);
+    } else if (queueName.startsWith('validation.')) {
+      return this.getValidationQueueConfig(queueName);
+    } else if (queueName.startsWith('delivery.')) {
+      return this.getDeliveryQueueConfig(queueName);
     } else {
       throw new Error(`Queue ${queueName} is not an infrastructure queue. Infrastructure queues must start with 'workflow.', 'registry.', 'infrastructure.', or 'monitoring.'`);
     }

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
   }
 
   /**
@@ -109,6 +110,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 +141,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();
@@ -270,8 +291,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 +421,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 +444,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;

package/tests/unit/queueConfig-delivery.test.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const queueConfig = require('../../src/config/queueConfig');
+
+describe('queueConfig delivery infrastructure', () => {
+  test('delivery.retry configuration', () => {
+    const config = queueConfig.getInfrastructureQueueConfig('delivery.retry');
+    expect(config).toEqual({
+      durable: true,
+      arguments: {
+        'x-max-length': 10000
+      }
+    });
+  });
+
+  test('delivery.result configuration', () => {
+    const config = queueConfig.getInfrastructureQueueConfig('delivery.result');
+    expect(config).toEqual({
+      durable: true,
+      arguments: {
+        'x-message-ttl': 86400000,
+        'x-max-length': 50000
+      }
+    });
+  });
+
+  test('delivery.websocket.notify configuration', () => {
+    const config = queueConfig.getInfrastructureQueueConfig('delivery.websocket.notify');
+    expect(config).toEqual({
+      durable: true,
+      arguments: {
+        'x-message-ttl': 60000,
+        'x-max-length': 10000
+      }
+    });
+  });
+});
+

package/tests/unit/queueConfig-validation.test.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const queueConfig = require('../../src/config/queueConfig');
+
+describe('queueConfig validation infrastructure', () => {
+  test('validation.requests configuration', () => {
+    const config = queueConfig.getInfrastructureQueueConfig('validation.requests');
+    expect(config).toEqual({
+      durable: true,
+      arguments: {
+        'x-message-ttl': 300000,
+        'x-max-length': 10000
+      }
+    });
+  });
+
+  test('validation.responses configuration', () => {
+    const config = queueConfig.getInfrastructureQueueConfig('validation.responses');
+    expect(config).toEqual({
+      durable: true,
+      arguments: {
+        'x-message-ttl': 300000,
+        'x-max-length': 10000
+      }
+    });
+  });
+});
+