@onlineapps/conn-orch-registry 1.1.22 → 1.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/conn-orch-registry",
-    "version": "1.1.22",
+    "version": "1.1.23",
   "license": "MIT",
   "description": "Connector-registry-client provides the core communication mechanism for microservices in this environment. It enables them to interact with a services_registry to receive and fulfill tasks by submitting heartbeats or their API descriptions.",
   "keywords": [
@@ -39,6 +39,7 @@
   },
   "dependencies": {
     "@onlineapps/conn-base-storage": "^1.0.0",
+    "@onlineapps/mq-client-core": "^1.0.26",
     "amqplib": "^0.10.9",
     "axios": "^1.12.2",
     "dotenv": "^16.6.1",

package/src/queueManager.js

@@ -19,15 +19,7 @@
  */
 
 const amqp = require('amqplib');
-// CRITICAL: Import queueConfig to ensure consistent queue parameters
-// This prevents 406 PRECONDITION-FAILED errors from TTL mismatches
-let queueConfig;
-try {
-  queueConfig = require('@onlineapps/conn-infra-mq/src/config/queueConfig');
-} catch (err) {
-  console.warn('[QueueManager] [REGISTRY] queueConfig not available, using defaults:', err.message);
-  queueConfig = null;
-}
+const queueConfig = require('@onlineapps/mq-client-core/src/config/queueConfig');
 
 /**
  * Queue manager for the microservice connector.
@@ -68,10 +60,7 @@ class QueueManager {
     }
 
     // Default queues for the registry client
-    const baseQueues = [
-      'workflow'
-      // Note: ${serviceName}.registry queue is created by RegistryEventConsumer when needed
-    ];
+    const baseQueues = [];
 
     const queuesToCreate = baseQueues.concat(additionalQueues);
 
@@ -101,34 +90,16 @@ class QueueManager {
         console.warn(`[QueueManager] [REGISTRY] [QUEUE] queueConfig not available, using default options for ${q}`);
       }
       
-      // Use checkQueue first to avoid 406 PRECONDITION-FAILED closing the channel
-      // If queue doesn't exist (404), then assertQueue to create it with correct options
+      // Directly assert queue with canonical configuration (idempotent)
       try {
-        const checkStartTime = Date.now();
-        await this.channel.checkQueue(q);
-        const checkEndTime = Date.now();
-        console.log(`[QueueManager] [REGISTRY] [QUEUE] ✓ Queue ${q} exists (checkQueue took ${checkEndTime - checkStartTime}ms)`);
-        // Queue exists - continue
-      } catch (checkErr) {
-        // If queue doesn't exist (404), create it with correct options from queueConfig
-        if (checkErr.code === 404) {
-          console.log(`[QueueManager] [REGISTRY] [QUEUE] Queue ${q} does not exist (404), creating with options:`, JSON.stringify(queueOptions));
-          const assertStartTime = Date.now();
-          try {
-            await this.channel.assertQueue(q, queueOptions);
-            const assertEndTime = Date.now();
-            console.log(`[QueueManager] [REGISTRY] [QUEUE] ✓ Created queue ${q} (assertQueue took ${assertEndTime - assertStartTime}ms)`);
-          } catch (assertErr) {
-            console.error(`[QueueManager] [REGISTRY] [QUEUE] ✗ Failed to create queue ${q}:`, assertErr.message);
-            console.error(`[QueueManager] [REGISTRY] [QUEUE] Error code: ${assertErr.code}`);
-            throw assertErr;
-          }
-        } else {
-          // Other error (including 406) - queue exists with different args
-          // Log warning and continue without asserting
-          console.warn(`[QueueManager] [REGISTRY] [QUEUE] Queue ${q} exists with different arguments, using as-is:`, checkErr.message);
-          console.warn(`[QueueManager] [REGISTRY] [QUEUE] Error code: ${checkErr.code}`);
-        }
+        const assertStartTime = Date.now();
+        await this.channel.assertQueue(q, queueOptions);
+        const assertEndTime = Date.now();
+        console.log(`[QueueManager] [REGISTRY] [QUEUE] ✓ Queue ${q} asserted (took ${assertEndTime - assertStartTime}ms)`);
+      } catch (assertErr) {
+        console.error(`[QueueManager] [REGISTRY] [QUEUE] ✗ Failed to assert queue ${q}:`, assertErr.message);
+        console.error(`[QueueManager] [REGISTRY] [QUEUE] Error code: ${assertErr.code}`);
+        throw assertErr;
       }
     }
   }

package/src/registryClient.js

@@ -19,46 +19,8 @@ const EventEmitter = require('events');
 const QueueManager = require('./queueManager');
 const RegistryEventConsumer = require('./registryEventConsumer');
 const { v4: uuidv4 } = require('uuid');
+const queueConfig = require('@onlineapps/mq-client-core/src/config/queueConfig');
 
-// CRITICAL: Import queueConfig to ensure consistent queue parameters
-// This prevents 406 PRECONDITION-FAILED errors from TTL mismatches
-let queueConfig;
-try {
-  queueConfig = require('@onlineapps/conn-infra-mq/src/config/queueConfig');
-} catch (err) {
-  console.warn('[RegistryClient] queueConfig not available, using defaults:', err.message);
-  queueConfig = null;
-}
-
-/**
- * Helper function to get queue options from queueConfig.js
- * @param {string} queueName - Queue name
- * @returns {Object} Queue options with correct parameters (TTL, max-length, etc.)
- */
-function getQueueOptions(queueName) {
-  let queueOptions = { durable: true };
-  
-  if (queueConfig) {
-    try {
-      if (queueConfig.isInfrastructureQueue(queueName)) {
-        const infraConfig = queueConfig.getInfrastructureQueueConfig(queueName);
-        queueOptions = {
-          durable: infraConfig.durable !== false,
-          arguments: { ...infraConfig.arguments }
-        };
-        console.log(`[RegistryClient] [QUEUE] Using infrastructure queue config for ${queueName}:`, JSON.stringify(queueOptions));
-      } else {
-        console.warn(`[RegistryClient] [QUEUE] Queue ${queueName} is not an infrastructure queue, using default options`);
-      }
-    } catch (configErr) {
-      console.warn(`[RegistryClient] [QUEUE] Failed to get config for ${queueName}, using defaults:`, configErr.message);
-    }
-  } else {
-    console.warn(`[RegistryClient] [QUEUE] queueConfig not available, using default options for ${queueName}`);
-  }
-  
-  return queueOptions;
-}
 
 class ServiceRegistryClient extends EventEmitter {
   /**
@@ -95,6 +57,7 @@ class ServiceRegistryClient extends EventEmitter {
 
     // Validation proof (injected via constructor - DEPENDENCY INJECTION)
     this.validationProof = validationProof;
+    this._verifiedInfraQueues = new Set();
   }
 
   /**
@@ -118,8 +81,8 @@ class ServiceRegistryClient extends EventEmitter {
     // Create service-specific registry event queue (for certificate delivery)
     this.serviceRegistryQueue = `${this.serviceName}.registry`;
 
-    // Ensure existence of API, registry and service response queues
-    await this.queueManager.ensureQueues([this.apiQueue, this.registryQueue, this.serviceResponseQueue, this.serviceRegistryQueue]);
+    // Ensure existence of service-specific queues only (infrastructure queues must already exist)
+    await this.queueManager.ensureQueues([this.serviceResponseQueue, this.serviceRegistryQueue]);
 
     // CRITICAL: Before consume(), we must assertQueue with correct parameters
     // amqplib's channel.consume() may internally call assertQueue() WITHOUT parameters
@@ -241,6 +204,49 @@ class ServiceRegistryClient extends EventEmitter {
     }
   }
 
+  /**
+   * Ensure an infrastructure queue exists without mutating it.
+   * Uses a temporary channel so failures don't kill the primary channel.
+   * @param {string} queueName
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _ensureInfrastructureQueue(queueName) {
+    if (!queueName) {
+      return;
+    }
+
+    if (!queueConfig?.isInfrastructureQueue(queueName)) {
+      return;
+    }
+
+    if (this._verifiedInfraQueues.has(queueName)) {
+      return;
+    }
+
+    if (!this.queueManager?.conn) {
+      console.warn(`[RegistryClient] ${this.serviceName}: MQ connection not ready, cannot verify infrastructure queue ${queueName}`);
+      return;
+    }
+
+    const verificationChannel = await this.queueManager.conn.createChannel();
+    try {
+      await verificationChannel.checkQueue(queueName);
+      this._verifiedInfraQueues.add(queueName);
+    } catch (error) {
+      if (error.code === 404) {
+        throw new Error(`[RegistryClient] Infrastructure queue '${queueName}' is missing. Ensure the responsible infrastructure service has initialized it.`);
+      }
+      throw error;
+    } finally {
+      try {
+        await verificationChannel.close();
+      } catch (closeErr) {
+        console.warn(`[RegistryClient] ${this.serviceName}: Failed to close verification channel for ${queueName}:`, closeErr.message);
+      }
+    }
+  }
+
   /**
    * Registers the service with the registry.
    * Registry will validate if the service is properly tested and valid.
@@ -317,36 +323,7 @@ class ServiceRegistryClient extends EventEmitter {
     // CRITICAL: Use queueConfig.js to get correct parameters (TTL, max-length, etc.)
     // This prevents 406 PRECONDITION-FAILED errors from TTL mismatches
     console.log(`[RegistryClient] [PUBLISH] Preparing to publish to ${this.registryQueue}`);
-    
-    let queueOptions = { durable: true };
-    try {
-      const queueConfig = require('@onlineapps/conn-infra-mq/src/config/queueConfig');
-      if (queueConfig.isInfrastructureQueue(this.registryQueue)) {
-        const infraConfig = queueConfig.getInfrastructureQueueConfig(this.registryQueue);
-        queueOptions = {
-          durable: infraConfig.durable !== false,
-          arguments: { ...infraConfig.arguments }
-        };
-        console.log(`[RegistryClient] [PUBLISH] Using infrastructure queue config for ${this.registryQueue}:`, JSON.stringify(queueOptions));
-      }
-    } catch (configErr) {
-      console.warn(`[RegistryClient] [PUBLISH] Failed to get config for ${this.registryQueue}, using defaults:`, configErr.message);
-    }
-    
-    // Use checkQueue to avoid 406 PRECONDITION-FAILED closing the channel
-    try {
-      await this.queueManager.channel.checkQueue(this.registryQueue);
-      console.log(`[RegistryClient] [PUBLISH] ✓ Queue ${this.registryQueue} exists`);
-    } catch (checkErr) {
-      if (checkErr.code === 404) {
-        console.log(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} does not exist (404), creating with options:`, JSON.stringify(queueOptions));
-        await this.queueManager.channel.assertQueue(this.registryQueue, queueOptions);
-        console.log(`[RegistryClient] [PUBLISH] ✓ Created queue ${this.registryQueue}`);
-      } else {
-        console.warn(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} exists with different arguments:`, checkErr.message);
-        // If 406 or other error, queue exists - proceed to publish
-      }
-    }
+    await this._ensureInfrastructureQueue(this.registryQueue);
     console.log(`[RegistryClient] ${this.serviceName}: Sending registration message to queue: ${this.registryQueue}`);
     console.log(`[RegistryClient] ${this.serviceName}: Message type: ${msg.type}, serviceName: ${msg.serviceName}, version: ${msg.version}`);
     this.queueManager.channel.sendToQueue(
@@ -388,21 +365,7 @@ class ServiceRegistryClient extends EventEmitter {
     // Send deregistration message to registry
     // CRITICAL: Use queueConfig.js to get correct parameters (TTL, max-length, etc.)
     console.log(`[RegistryClient] [PUBLISH] Preparing to publish to ${this.registryQueue} (deregister)`);
-    const queueOptions = getQueueOptions(this.registryQueue);
-    
-    // Use checkQueue to avoid 406 PRECONDITION-FAILED closing the channel
-    try {
-      await this.queueManager.channel.checkQueue(this.registryQueue);
-      console.log(`[RegistryClient] [PUBLISH] ✓ Queue ${this.registryQueue} exists`);
-    } catch (checkErr) {
-      if (checkErr.code === 404) {
-        console.log(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} does not exist (404), creating with options:`, JSON.stringify(queueOptions));
-        await this.queueManager.channel.assertQueue(this.registryQueue, queueOptions);
-        console.log(`[RegistryClient] [PUBLISH] ✓ Created queue ${this.registryQueue}`);
-      } else {
-        console.warn(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} exists with different arguments:`, checkErr.message);
-      }
-    }
+    await this._ensureInfrastructureQueue(this.registryQueue);
     this.queueManager.channel.sendToQueue(
       this.registryQueue,
       Buffer.from(JSON.stringify(msg)),
@@ -447,21 +410,7 @@ class ServiceRegistryClient extends EventEmitter {
     };
     // CRITICAL: Use queueConfig.js to get correct parameters (TTL, max-length, etc.)
     console.log(`[RegistryClient] [PUBLISH] Preparing to publish to ${this.registryQueue} (heartbeat)`);
-    const queueOptions = getQueueOptions(this.registryQueue);
-    
-    // Use checkQueue to avoid 406 PRECONDITION-FAILED closing the channel
-    try {
-      await this.queueManager.channel.checkQueue(this.registryQueue);
-      console.log(`[RegistryClient] [PUBLISH] ✓ Queue ${this.registryQueue} exists`);
-    } catch (checkErr) {
-      if (checkErr.code === 404) {
-        console.log(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} does not exist (404), creating with options:`, JSON.stringify(queueOptions));
-        await this.queueManager.channel.assertQueue(this.registryQueue, queueOptions);
-        console.log(`[RegistryClient] [PUBLISH] ✓ Created queue ${this.registryQueue}`);
-      } else {
-        console.warn(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} exists with different arguments:`, checkErr.message);
-      }
-    }
+    await this._ensureInfrastructureQueue(this.registryQueue);
     this.queueManager.channel.sendToQueue(
       this.registryQueue,
       Buffer.from(JSON.stringify(msg)),
@@ -507,21 +456,7 @@ class ServiceRegistryClient extends EventEmitter {
     };
     // CRITICAL: Use queueConfig.js to get correct parameters (TTL, max-length, etc.)
     console.log(`[RegistryClient] [PUBLISH] Preparing to publish to ${this.registryQueue} (apiDescription)`);
-    const queueOptions = getQueueOptions(this.registryQueue);
-    
-    // Use checkQueue to avoid 406 PRECONDITION-FAILED closing the channel
-    try {
-      await this.queueManager.channel.checkQueue(this.registryQueue);
-      console.log(`[RegistryClient] [PUBLISH] ✓ Queue ${this.registryQueue} exists`);
-    } catch (checkErr) {
-      if (checkErr.code === 404) {
-        console.log(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} does not exist (404), creating with options:`, JSON.stringify(queueOptions));
-        await this.queueManager.channel.assertQueue(this.registryQueue, queueOptions);
-        console.log(`[RegistryClient] [PUBLISH] ✓ Created queue ${this.registryQueue}`);
-      } else {
-        console.warn(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} exists with different arguments:`, checkErr.message);
-      }
-    }
+    await this._ensureInfrastructureQueue(this.registryQueue);
     this.queueManager.channel.sendToQueue(
       this.registryQueue,
       Buffer.from(JSON.stringify(msg)),