@onlineapps/conn-orch-registry 1.1.22 → 1.1.24

package/README.md

@@ -8,7 +8,7 @@
 
 ## 🚀 Features
 
-* Automatic queue management (`workflow`, `<serviceName>.registry`, `api_services_queuer`, `registry_office`)
+* Automatic queue management (`workflow`, `<serviceName>.registry`, `api_services_queuer`, `registry.register`)
 * Periodic heartbeat messages with metadata
 * API description request/response flow
 * Event-driven API using `EventEmitter`
@@ -64,7 +64,7 @@ Configuration can be provided via environment variables or constructor options:
 | `SERVICE_VERSION`    | Service version in SemVer format (required)   | —                    |
 | `HEARTBEAT_INTERVAL` | Interval in ms between heartbeats             | `10000`              |
 | `API_QUEUE`          | Queue name for heartbeat/API messages         | `api_services_queuer` |
-| `REGISTRY_QUEUE`     | Queue name for registry requests/descriptions | `registry_office`    |
+| `REGISTRY_QUEUE`     | Queue name for registry requests/descriptions | `registry.register`  |
 
 ## 📨 Message Formats
 

package/docs/REGISTRY_CLIENT_GUIDE.md

@@ -124,7 +124,7 @@ async function shutdown() {
 | `specificationEndpoint` | string | '/api/v1/specification' | Endpoint for API spec |
 | `heartbeatInterval` | number | 10000 | Heartbeat interval in ms |
 | `apiQueue` | string | 'api_services_queuer' | Queue for API traffic |
-| `registryQueue` | string | 'registry_office' | Registry queue name |
+| `registryQueue` | string | 'registry.register' | Registry queue name |
 
 ### Methods
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/conn-orch-registry",
-    "version": "1.1.22",
+  "version": "1.1.24",
   "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.
@@ -49,12 +41,44 @@ class QueueManager {
   /**
    * Initializes the connection and channel to RabbitMQ.
    * @returns {Promise<void>} 
+   * @throws {Error} If connection or channel creation fails or times out
    */
   async init() {
-    this.conn = await amqp.connect(this.amqpUrl);
+    const CONNECT_TIMEOUT = 10000; // 10 seconds
+    const connectPromise = amqp.connect(this.amqpUrl);
+    const connectTimeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`RabbitMQ connection timeout after ${CONNECT_TIMEOUT}ms. RabbitMQ may be unavailable at ${this.amqpUrl}`));
+      }, CONNECT_TIMEOUT);
+    });
+
+    try {
+      this.conn = await Promise.race([connectPromise, connectTimeoutPromise]);
+    } catch (error) {
+      throw new Error(`[QueueManager] Failed to connect to RabbitMQ: ${error.message}`);
+    }
+
     // Use regular channel instead of ConfirmChannel to avoid RPC reply queue issues
     // ConfirmChannel uses RPC pattern which requires reply queues that may not exist
-    this.channel = await this.conn.createChannel();
+    const CHANNEL_TIMEOUT = 5000; // 5 seconds
+    const channelPromise = this.conn.createChannel();
+    const channelTimeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Channel creation timeout after ${CHANNEL_TIMEOUT}ms`));
+      }, CHANNEL_TIMEOUT);
+    });
+
+    try {
+      this.channel = await Promise.race([channelPromise, channelTimeoutPromise]);
+    } catch (error) {
+      // Clean up connection on channel creation failure
+      try {
+        await this.conn.close();
+      } catch (closeErr) {
+        // Ignore close errors
+      }
+      throw new Error(`[QueueManager] Failed to create channel: ${error.message}`);
+    }
   }
 
   /**
@@ -68,10 +92,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);
 
@@ -81,19 +102,20 @@ class QueueManager {
       // CRITICAL: Use queueConfig.js to get correct parameters (TTL, max-length, etc.)
       // This prevents 406 PRECONDITION-FAILED errors from TTL mismatches
       let queueOptions = { durable: true };
+      const isInfrastructureQueue = queueConfig?.isInfrastructureQueue
+        ? queueConfig.isInfrastructureQueue(q)
+        : ['workflow.', 'registry.', 'infrastructure.', 'validation.', 'monitoring.', 'delivery.'].some(prefix => q.startsWith(prefix));
+
+      if (isInfrastructureQueue) {
+        const message = `[QueueManager] [REGISTRY] Refusing to assert infrastructure queue '${q}'. ` +
+          'These queues are owned by infrastructure services and must be created before business services start.';
+        console.error(message);
+        throw new Error(message);
+      }
       
       if (queueConfig) {
         try {
-          if (queueConfig.isInfrastructureQueue(q)) {
-            const infraConfig = queueConfig.getInfrastructureQueueConfig(q);
-            queueOptions = {
-              durable: infraConfig.durable !== false,
-              arguments: { ...infraConfig.arguments }
-            };
-            console.log(`[QueueManager] [REGISTRY] [QUEUE] Using infrastructure queue config for ${q}:`, JSON.stringify(queueOptions));
-          } else {
-            console.warn(`[QueueManager] [REGISTRY] [QUEUE] Queue ${q} is not an infrastructure queue, using default options`);
-          }
+          console.warn(`[QueueManager] [REGISTRY] [QUEUE] Queue ${q} is not an infrastructure queue, using default options`);
         } catch (configErr) {
           console.warn(`[QueueManager] [REGISTRY] [QUEUE] Failed to get config for ${q}, using defaults:`, configErr.message);
         }
@@ -101,34 +123,25 @@ 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();
+        const ASSERT_TIMEOUT = 5000; // 5 seconds
+        const assertPromise = this.channel.assertQueue(q, queueOptions);
+        const assertTimeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(new Error(`assertQueue timeout after ${ASSERT_TIMEOUT}ms`));
+          }, ASSERT_TIMEOUT);
+        });
+        
+        await Promise.race([assertPromise, assertTimeoutPromise]);
+        const assertEndTime = Date.now();
+        console.log(`[QueueManager] [REGISTRY] [QUEUE] ✓ Queue ${q} asserted (took ${assertEndTime - assertStartTime}ms)`);
+      } catch (assertErr) {
+        const errorMsg = assertErr.message || String(assertErr);
+        console.error(`[QueueManager] [REGISTRY] [QUEUE] ✗ Failed to assert queue ${q}: ${errorMsg}`);
+        console.error(`[QueueManager] [REGISTRY] [QUEUE] Error code: ${assertErr.code || 'N/A'}`);
+        throw new Error(`[QueueManager] Failed to assert queue ${q}: ${errorMsg}`);
       }
     }
   }

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
@@ -129,7 +92,8 @@ class ServiceRegistryClient extends EventEmitter {
     console.log(`[RegistryClient] [CONSUMER] ⚠ WARNING: Queue should already be asserted by ensureQueues() above with correct parameters from queueConfig.js`);
     
     // Start consuming service response queue for registry responses
-    await this.queueManager.channel.consume(
+    const CONSUME_TIMEOUT = 5000; // 5 seconds
+    const consumeResponsePromise = this.queueManager.channel.consume(
       this.serviceResponseQueue,
       msg => {
         // Handle null message (queue deleted, connection closed, consumer canceled)
@@ -137,17 +101,38 @@ class ServiceRegistryClient extends EventEmitter {
           console.warn(`[RegistryClient] ${this.serviceName}: Received null message from ${this.serviceResponseQueue} (queue may be deleted or connection closed)`);
           return;
         }
-        this._handleRegistryMessage(msg);
+        try {
+          this._handleRegistryMessage(msg);
+        } catch (error) {
+          console.error(`[RegistryClient] ${this.serviceName}: Error in consume callback:`, error);
+          // Nack message on error
+          try {
+            this.queueManager.channel.nack(msg, false, false);
+          } catch (nackErr) {
+            console.error(`[RegistryClient] ${this.serviceName}: Failed to nack message:`, nackErr);
+          }
+        }
       },
       { noAck: false }
     );
+    const consumeResponseTimeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`consume() timeout for ${this.serviceResponseQueue} after ${CONSUME_TIMEOUT}ms`));
+      }, CONSUME_TIMEOUT);
+    });
+
+    try {
+      await Promise.race([consumeResponsePromise, consumeResponseTimeoutPromise]);
+    } catch (consumeErr) {
+      throw new Error(`[RegistryClient] ${this.serviceName}: Failed to start consumer on ${this.serviceResponseQueue}: ${consumeErr.message}`);
+    }
 
     // CRITICAL: Also listen on registry event queue for certificate delivery
     console.log(`[RegistryClient] [CONSUMER] About to consume from ${this.serviceRegistryQueue}`);
     console.log(`[RegistryClient] [CONSUMER] ⚠ WARNING: amqplib's channel.consume() may internally call assertQueue() WITHOUT parameters`);
     console.log(`[RegistryClient] [CONSUMER] ⚠ WARNING: Queue should already be asserted by ensureQueues() above with correct parameters from queueConfig.js`);
     
-    await this.queueManager.channel.consume(
+    const consumeRegistryPromise = this.queueManager.channel.consume(
       this.serviceRegistryQueue,
       msg => {
         // Handle null message (queue deleted, connection closed, consumer canceled)
@@ -155,10 +140,31 @@ class ServiceRegistryClient extends EventEmitter {
           console.warn(`[RegistryClient] ${this.serviceName}: Received null message from ${this.serviceRegistryQueue} (queue may be deleted or connection closed)`);
           return;
         }
-        this._handleRegistryMessage(msg);
+        try {
+          this._handleRegistryMessage(msg);
+        } catch (error) {
+          console.error(`[RegistryClient] ${this.serviceName}: Error in consume callback:`, error);
+          // Nack message on error
+          try {
+            this.queueManager.channel.nack(msg, false, false);
+          } catch (nackErr) {
+            console.error(`[RegistryClient] ${this.serviceName}: Failed to nack message:`, nackErr);
+          }
+        }
       },
       { noAck: false }
     );
+    const consumeRegistryTimeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`consume() timeout for ${this.serviceRegistryQueue} after ${CONSUME_TIMEOUT}ms`));
+      }, CONSUME_TIMEOUT);
+    });
+
+    try {
+      await Promise.race([consumeRegistryPromise, consumeRegistryTimeoutPromise]);
+    } catch (consumeErr) {
+      throw new Error(`[RegistryClient] ${this.serviceName}: Failed to start consumer on ${this.serviceRegistryQueue}: ${consumeErr.message}`);
+    }
   }
 
   /**
@@ -175,10 +181,16 @@ class ServiceRegistryClient extends EventEmitter {
       return; // Don't try to parse or ack null message
     }
     
+    // Log which queue this message came from (if available in msg properties)
+    const queueName = msg.fields?.routingKey || msg.fields?.exchange || 'unknown';
+    console.log(`[RegistryClient] ${this.serviceName}: [MESSAGE] Processing message from queue: ${queueName}`);
+    
     let payload;
     try {
       payload = JSON.parse(msg.content.toString());
+      console.log(`[RegistryClient] ${this.serviceName}: [MESSAGE] Parsed payload type: ${payload.type}, requestId: ${payload.requestId}`);
     } catch (err) {
+      console.error(`[RegistryClient] ${this.serviceName}: [MESSAGE] Failed to parse message:`, err);
       this.emit('error', err);
       // Only nack if message is not null
       if (msg) {
@@ -202,22 +214,34 @@ class ServiceRegistryClient extends EventEmitter {
     // Handle registration response from registry
     // Registry sends 'register.confirmed' after validation
     if ((payload.type === 'registerResponse' || payload.type === 'register.confirmed') && payload.requestId) {
-      console.log(`[RegistryClient] ${this.serviceName}: Received ${payload.type} message`, {
+      console.log(`[RegistryClient] ${this.serviceName}: [REGISTRATION] Received ${payload.type} message`, {
         requestId: payload.requestId,
         hasPendingRegistrations: !!(this.pendingRegistrations),
         pendingCount: this.pendingRegistrations ? this.pendingRegistrations.size : 0,
         hasMatchingRequest: !!(this.pendingRegistrations && this.pendingRegistrations.has(payload.requestId)),
-        pendingKeys: this.pendingRegistrations ? Array.from(this.pendingRegistrations.keys()) : []
+        pendingKeys: this.pendingRegistrations ? Array.from(this.pendingRegistrations.keys()) : [],
+        queueName
       });
 
       if (this.pendingRegistrations && this.pendingRegistrations.has(payload.requestId)) {
+        console.log(`[RegistryClient] ${this.serviceName}: [REGISTRATION] Found matching pending registration, extracting resolve function...`);
         const { resolve } = this.pendingRegistrations.get(payload.requestId);
         this.pendingRegistrations.delete(payload.requestId);
-
-        console.log(`[RegistryClient] ${this.serviceName}: ✓ Resolving registration promise for requestId: ${payload.requestId}`);
+        console.log(`[RegistryClient] ${this.serviceName}: [REGISTRATION] ✓ Resolve function extracted, pending registration removed`);
+
+        // CRITICAL: Resolve promise synchronously to ensure it's called before any async operations
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Starting resolve process for requestId: ${payload.requestId}`);
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Payload keys:`, Object.keys(payload));
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Payload.success:`, payload.success);
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Payload.validated:`, payload.validated);
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Payload.hasCertificate:`, !!payload.certificate);
+        if (payload.certificate) {
+          console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Payload.certificate.id:`, payload.certificate.id);
+          console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Payload.certificate.serviceName:`, payload.certificate.serviceName);
+        }
 
         // Resolve the registration promise with the response
-        resolve({
+        const registrationResult = {
           success: payload.success || false,
           message: payload.message || 'Registration processed',
           serviceName: this.serviceName,
@@ -225,7 +249,31 @@ class ServiceRegistryClient extends EventEmitter {
           registrationId: payload.registrationId,
           validated: payload.validated || payload.success, // Consider successful registration as validated
           certificate: payload.certificate || null // Include certificate from Registry
-        });
+        };
+        
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Created registrationResult:`, JSON.stringify({
+          success: registrationResult.success,
+          validated: registrationResult.validated,
+          hasCertificate: !!registrationResult.certificate,
+          certificateId: registrationResult.certificate?.id || 'none',
+          serviceName: registrationResult.serviceName,
+          version: registrationResult.version
+        }));
+        
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] About to call resolve() function...`);
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] resolve function type:`, typeof resolve);
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] resolve function exists:`, !!resolve);
+        
+        try {
+          // CRITICAL: Call resolve synchronously - this must happen immediately
+          resolve(registrationResult);
+          console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] ✓ resolve() called successfully`);
+          console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Promise should now be resolved`);
+        } catch (resolveError) {
+          console.error(`[RegistryClient] ${this.serviceName}: [RESOLVE] ✗ Error calling resolve():`, resolveError);
+          console.error(`[RegistryClient] ${this.serviceName}: [RESOLVE] Error stack:`, resolveError.stack);
+          throw resolveError;
+        }
       } else {
         console.warn(`[RegistryClient] ${this.serviceName}: ⚠️  Received ${payload.type} with requestId ${payload.requestId}, but no matching pending registration found`);
       }
@@ -241,6 +289,66 @@ 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) {
+      throw new Error(`[RegistryClient] ${this.serviceName}: MQ connection not ready, cannot verify infrastructure queue ${queueName}. Ensure RabbitMQ is accessible.`);
+    }
+
+    // Add timeout to prevent hanging
+    const QUEUE_VERIFY_TIMEOUT = 10000; // 10 seconds
+    const verifyPromise = (async () => {
+      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);
+        }
+      }
+    })();
+
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`[RegistryClient] ${this.serviceName}: Timeout verifying infrastructure queue '${queueName}' after ${QUEUE_VERIFY_TIMEOUT}ms. Queue may not exist or RabbitMQ is unresponsive.`));
+      }, QUEUE_VERIFY_TIMEOUT);
+    });
+
+    try {
+      await Promise.race([verifyPromise, timeoutPromise]);
+    } catch (error) {
+      // Clear verification cache on error so we can retry
+      this._verifiedInfraQueues.delete(queueName);
+      throw error;
+    }
+  }
+
   /**
    * Registers the service with the registry.
    * Registry will validate if the service is properly tested and valid.
@@ -318,49 +426,56 @@ class ServiceRegistryClient extends EventEmitter {
     // 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);
+      await this._ensureInfrastructureQueue(this.registryQueue);
+    } catch (queueError) {
+      const errorMsg = `[RegistryClient] ${this.serviceName}: Cannot register - infrastructure queue verification failed: ${queueError.message}`;
+      console.error(errorMsg);
+      throw new Error(errorMsg);
+    }
+
+    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}`);
+    
+    // Send message synchronously (sendToQueue is synchronous, returns boolean)
+    // But check channel state first to fail fast
+    if (!this.queueManager.channel) {
+      throw new Error(`[RegistryClient] ${this.serviceName}: Cannot publish - channel not initialized. Ensure MQ connection is established.`);
     }
     
-    // Use checkQueue to avoid 406 PRECONDITION-FAILED closing the channel
+    if (this.queueManager.channel.closed) {
+      throw new Error(`[RegistryClient] ${this.serviceName}: Cannot publish - channel is closed. MQ connection may be lost.`);
+    }
+
     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
+      const sent = this.queueManager.channel.sendToQueue(
+        this.registryQueue,
+        Buffer.from(JSON.stringify(msg)),
+        { persistent: true }
+      );
+      if (!sent) {
+        throw new Error(`[RegistryClient] ${this.serviceName}: sendToQueue returned false - queue may be full or channel backpressure active.`);
       }
+      console.log(`[RegistryClient] ${this.serviceName}: ✓ Registration message sent, waiting for response...`);
+    } catch (sendError) {
+      const errorMsg = `[RegistryClient] ${this.serviceName}: Failed to send registration message: ${sendError.message}`;
+      console.error(errorMsg);
+      throw new Error(errorMsg);
     }
-    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(
-      this.registryQueue,
-      Buffer.from(JSON.stringify(msg)),
-      { persistent: true }
-    );
-    console.log(`[RegistryClient] ${this.serviceName}: ✓ Registration message sent, waiting for response...`);
 
     this.emit('registerSent', msg);
 
     // Wait for registration response from registry
     try {
+      console.log(`[RegistryClient] ${this.serviceName}: [AWAIT] Waiting for registration response promise...`);
       const response = await responsePromise;
+      console.log(`[RegistryClient] ${this.serviceName}: [AWAIT] ✓ Promise resolved, response received:`, {
+        hasResponse: !!response,
+        responseType: typeof response,
+        responseKeys: response ? Object.keys(response) : [],
+        hasSuccess: !!response?.success,
+        hasCertificate: !!response?.certificate
+      });
       return response;
     } catch (error) {
       return {
@@ -388,21 +503,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 +548,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 +594,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)),