@onlineapps/mq-client-core 1.0.8 → 1.0.11

package/package.json

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

package/src/transports/rabbitmqClient.js

@@ -151,16 +151,26 @@ class RabbitMQClient extends EventEmitter {
     try {
       // Ensure queue exists if publishing directly to queue and using default exchange
       if (!exchange) {
-        // For infrastructure queues, they should already exist with specific arguments
+        // CRITICAL: For infrastructure queues, they should already exist with specific arguments from queueConfig
         // 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
+        // If queue doesn't exist (404), we should NOT auto-create it - infrastructure queues must be created explicitly
+        // This prevents creating queues with wrong arguments (no TTL) which causes 406 errors later
         try {
           await this._queueChannel.checkQueue(queue);
           // Queue exists - proceed to publish
         } catch (checkErr) {
-          // If queue doesn't exist (404), create it with default options
+          // If queue doesn't exist (404), this is an ERROR for infrastructure queues
+          // Infrastructure queues (workflow.*, registry.*) must be created explicitly with correct arguments
+          // We should NOT auto-create them here, as we don't have access to queueConfig in mq-client-core
           if (checkErr.code === 404) {
+            // Check if this is an infrastructure queue
+            const isInfraQueue = queue.startsWith('workflow.') || queue.startsWith('registry.');
+            if (isInfraQueue) {
+              throw new Error(`Cannot publish to infrastructure queue ${queue}: queue does not exist. Infrastructure queues must be created explicitly with correct arguments (TTL, max-length, etc.) before publishing.`);
+            }
+            // For non-infrastructure queues, allow auto-creation with default options
             const queueOptions = options.queueOptions || { durable: this._config.durable };
+            console.warn(`[RabbitMQClient] [mq-client-core] [PUBLISH] Auto-creating non-infrastructure queue ${queue} with default options (no TTL). This should be avoided for production.`);
             await this._queueChannel.assertQueue(queue, queueOptions);
           } else {
             // Other error - rethrow
@@ -300,6 +310,19 @@ class RabbitMQClient extends EventEmitter {
       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(
         queue,
         async (msg) => {

package/src/utils/initInfrastructureQueues.js

@@ -0,0 +1,100 @@
+'use strict';
+
+/**
+ * initInfrastructureQueues.js
+ * 
+ * Utility for infrastructure services to initialize infrastructure queues.
+ * Uses queueConfig from @onlineapps/conn-infra-mq for configuration.
+ * 
+ * NOTE: This is for infrastructure services (gateway, monitoring, etc.)
+ * Business services should use @onlineapps/conn-infra-mq connector instead.
+ */
+
+/**
+ * Initialize all infrastructure queues
+ * @param {Object} channel - RabbitMQ channel
+ * @param {Object} options - Options
+ * @param {Array<string>} [options.queues] - Specific queues to create (default: all infrastructure queues)
+ * @param {Object} [options.logger] - Logger instance (default: console)
+ * @returns {Promise<void>}
+ */
+async function initInfrastructureQueues(channel, options = {}) {
+  const logger = options.logger || console;
+  
+  // Load queueConfig from @onlineapps/conn-infra-mq
+  let queueConfig;
+  try {
+    queueConfig = require('@onlineapps/conn-infra-mq/src/config/queueConfig');
+  } catch (requireError) {
+    throw new Error(`Cannot load queueConfig from @onlineapps/conn-infra-mq: ${requireError.message}. Make sure @onlineapps/conn-infra-mq is installed.`);
+  }
+
+  const queuesToCreate = options.queues || [
+    // Workflow infrastructure queues
+    'workflow.init',
+    'workflow.completed',
+    'workflow.failed',
+    'workflow.dlq',
+    // Registry infrastructure queues
+    'registry.register',
+    'registry.heartbeats'
+  ];
+
+  logger.log(`[QueueInit] Initializing ${queuesToCreate.length} infrastructure queues...`);
+
+  for (const queueName of queuesToCreate) {
+    try {
+      // Verify it's an infrastructure queue
+      if (!queueConfig.isInfrastructureQueue(queueName)) {
+        logger.warn(`[QueueInit] Skipping ${queueName} - not an infrastructure queue`);
+        continue;
+      }
+
+      // Get unified configuration
+      const config = queueConfig.getInfrastructureQueueConfig(queueName);
+      
+      // CRITICAL: Check if queue exists with different arguments (406 error)
+      // If so, delete it and recreate with correct parameters
+      try {
+        await channel.assertQueue(queueName, {
+          durable: config.durable !== false,
+          arguments: { ...config.arguments }
+        });
+        logger.log(`[QueueInit] ✓ Created/verified infrastructure queue: ${queueName}`);
+      } catch (assertError) {
+        if (assertError.code === 406) {
+          // Queue exists with different arguments - delete and recreate
+          logger.warn(`[QueueInit] ⚠ Queue ${queueName} exists with different arguments - deleting and recreating...`);
+          try {
+            await channel.deleteQueue(queueName);
+            logger.log(`[QueueInit] ✓ Deleted queue ${queueName} with incorrect parameters`);
+          } catch (deleteError) {
+            logger.error(`[QueueInit] ✗ Failed to delete queue ${queueName}:`, deleteError.message);
+            throw new Error(`Cannot delete queue ${queueName} with incorrect parameters: ${deleteError.message}`);
+          }
+          
+          // Recreate with correct parameters
+          await channel.assertQueue(queueName, {
+            durable: config.durable !== false,
+            arguments: { ...config.arguments }
+          });
+          logger.log(`[QueueInit] ✓ Recreated infrastructure queue: ${queueName} with correct parameters`);
+        } else {
+          // Other error - rethrow
+          logger.error(`[QueueInit] ✗ Failed to create ${queueName}:`, assertError.message);
+          throw assertError;
+        }
+      }
+    } catch (error) {
+      logger.error(`[QueueInit] ✗ Failed to initialize queue ${queueName}:`, error.message);
+      throw error;
+    }
+  }
+
+  logger.log(`[QueueInit] Infrastructure queues initialization complete`);
+}
+
+module.exports = {
+  initInfrastructureQueues
+};
+