@onlineapps/infrastructure-tools 1.0.17 → 1.0.19

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@onlineapps/infrastructure-tools",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "Infrastructure orchestration utilities for OA Drive infrastructure services (health tracking, queue initialization, service discovery)",
   "main": "src/index.js",
   "scripts": {
     "test": "jest",
     "test:unit": "jest --testPathPattern=tests/unit",
     "test:component": "jest --testPathPattern=tests/component",
-    "test:integration": "jest --testPathPattern=tests/integration"
+    "test:integration": "jest --testPathPattern=tests/integration",
+    "prepublishOnly": "cd $(git rev-parse --show-toplevel) && bash scripts/pre-publish-compatibility-check.sh shared/infrastructure-tools",
+    "postpublish": "cd $(git rev-parse --show-toplevel) && bash scripts/update-manifest-from-npm.sh && bash scripts/update-all-services.sh"
   },
   "keywords": [
     "infrastructure",
@@ -19,7 +21,7 @@
   "license": "MIT",
   "dependencies": {
     "@onlineapps/mq-client-core": "^1.0.38",
-    "@onlineapps/service-common": "^1.0.1",
+    "@onlineapps/service-common": "^1.0.3",
     "uuid": "^9.0.1"
   },
   "devDependencies": {

package/src/health/healthPublisher.js

@@ -56,6 +56,11 @@ function createHealthPublisher(options) {
 
   const queueName = config.queueName || config.infrastructureHealth?.queueName || process.env.INFRASTRUCTURE_HEALTH_QUEUE || 'infrastructure.health.checks';
   const publishInterval = config.publishInterval || config.infrastructureHealth?.publishInterval || parseInt(process.env.INFRASTRUCTURE_HEALTH_PUBLISH_INTERVAL) || 5000;
+  
+  // Support for disabling health checks via environment variable (useful for library updates)
+  const healthChecksDisabled = process.env.DISABLE_HEALTH_CHECKS === 'true' || 
+                                process.env.DISABLE_HEALTH_CHECKS === '1' ||
+                                config.disableHealthChecks === true;
 
   /**
    * Publish health check to infrastructure.health.checks queue
@@ -125,11 +130,25 @@ function createHealthPublisher(options) {
       return;
     }
 
+    // Check if health checks are disabled (useful for library updates/maintenance)
+    if (healthChecksDisabled) {
+      logger.warn(`[InfrastructureHealth:${serviceName}] Health checks are disabled (DISABLE_HEALTH_CHECKS=true). Skipping start.`, {
+        reason: 'health_checks_disabled',
+        serviceName
+      });
+      return;
+    }
+
     // Publish initial health check immediately
     await publishHealthCheck();
     
     // Then publish periodically
     healthCheckInterval = setInterval(() => {
+      // Double-check disabled flag on each interval (allows runtime changes)
+      if (healthChecksDisabled) {
+        stop();
+        return;
+      }
       publishHealthCheck().catch(err => {
         logger.error(`[InfrastructureHealth:${serviceName}] Error in health check publisher interval`, {
           error: err.message
@@ -166,7 +185,8 @@ function createHealthPublisher(options) {
     start,
     stop,
     publishNow,
-    isRunning: () => healthCheckInterval !== null
+    isRunning: () => healthCheckInterval !== null,
+    isDisabled: () => healthChecksDisabled
   };
 }
 

package/src/index.js

@@ -10,8 +10,25 @@
  * Business services should NOT use this library.
  */
 
-// Re-export infrastructure readiness utilities from service-common (no duplication)
-const { waitForInfrastructureReady, waitForHealthCheckQueueReady, sendMonitoringFailFallbackEmail } = require('@onlineapps/service-common');
+// Re-export all utilities from service-common (infrastructure services should use infrastructure-tools, not service-common directly)
+const {
+  // Infrastructure readiness utilities
+  waitForInfrastructureReady,
+  waitForHealthCheckQueueReady,
+  sendMonitoringFailFallbackEmail,
+  // Redis utilities
+  buildRedisUrl,
+  createRedisClient,
+  connectRedis,
+  // Runtime configuration helpers (NO FALLBACKS for critical infrastructure)
+  requireEnv,
+  optionalEnv,
+  optionalNumberEnv,
+  getCriticalConfig,
+  getOptionalInfraConfig,
+  getServiceConfig,
+  getInfrastructureHealthConfig
+} = require('@onlineapps/service-common');
 
 // Re-export MQ client core utilities
 const BaseClient = require('@onlineapps/mq-client-core');
@@ -32,10 +49,23 @@ module.exports = {
   MQClient: BaseClient, // Alias for compatibility
   queueConfig,
   
-  // Service Common utilities (re-exported for convenience)
+  // Service Common utilities (re-exported - infrastructure services should use infrastructure-tools, not service-common directly)
+  // Infrastructure readiness
   waitForInfrastructureReady,
   waitForHealthCheckQueueReady,
   sendMonitoringFailFallbackEmail,
+  // Redis utilities
+  buildRedisUrl,
+  createRedisClient,
+  connectRedis,
+  // Runtime configuration helpers (NO FALLBACKS for critical infrastructure)
+  requireEnv,
+  optionalEnv,
+  optionalNumberEnv,
+  getCriticalConfig,
+  getOptionalInfraConfig,
+  getServiceConfig,
+  getInfrastructureHealthConfig,
   
   // Orchestration utilities
   initInfrastructureQueues,

package/src/orchestration/initInfrastructureQueues.js

@@ -96,8 +96,98 @@ async function initInfrastructureQueues(channel, options = {}) {
       // 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
+      // CRITICAL: First check if queue exists and what parameters it has
+      // This prevents 406 errors by proactively deleting queues with wrong parameters
+      // Use a separate channel for checkQueue to avoid channel closure issues
+      // NOTE: checkQueue() does NOT create queue - it only checks if it exists
+      let queueExists = false;
+      let queueNeedsRecreation = false;
+      let checkChannelForDelete = null;
+      
+      try {
+        // Use a separate channel for checking queue (to avoid closing workingChannel)
+        // CRITICAL: checkQueue() does NOT create queue - it only checks existence
+        checkChannelForDelete = await connection.createChannel();
+        const queueInfo = await checkChannelForDelete.checkQueue(queueName);
+        queueExists = true;
+        
+        // Check if queue has correct arguments
+        const currentArgs = queueInfo.arguments || {};
+        const expectedArgs = config.arguments || {};
+        
+        // Compare arguments (TTL, max-length, etc.)
+        const argsMatch = Object.keys(expectedArgs).every(key => {
+          return currentArgs[key] === expectedArgs[key];
+        }) && Object.keys(currentArgs).every(key => {
+          // Allow extra args in current queue, but required args must match
+          return expectedArgs[key] === undefined || currentArgs[key] === expectedArgs[key];
+        });
+        
+        if (!argsMatch) {
+          logger.warn(`[QueueInit] ⚠ Queue ${queueName} exists with different arguments - will delete and recreate`, {
+            current: currentArgs,
+            expected: expectedArgs
+          });
+          queueNeedsRecreation = true;
+        } else {
+          logger.log(`[QueueInit] ✓ Queue ${queueName} exists with correct parameters`);
+          // Close check channel if queue is OK
+          try {
+            await checkChannelForDelete.close();
+            checkChannelForDelete = null;
+          } catch (closeErr) {
+            // Ignore
+          }
+        }
+      } catch (checkError) {
+        // Queue doesn't exist - will be created
+        queueExists = false;
+        logger.log(`[QueueInit] Queue ${queueName} does not exist - will be created`);
+        // Close check channel if queue doesn't exist
+        if (checkChannelForDelete) {
+          try {
+            await checkChannelForDelete.close();
+            checkChannelForDelete = null;
+          } catch (closeErr) {
+            // Ignore
+          }
+        }
+      }
+      
+      // CRITICAL: If queue exists with wrong parameters, delete it first
+      // This must be done BEFORE assertQueue to avoid 406 errors
+      if (queueNeedsRecreation) {
+        try {
+          // Use the check channel for deletion (or create new one if check failed)
+          const deleteChannel = checkChannelForDelete || await connection.createChannel();
+          await deleteChannel.deleteQueue(queueName, { ifEmpty: false });
+          logger.log(`[QueueInit] ✓ Deleted queue ${queueName} with incorrect parameters`);
+          // Close delete channel after use
+          try {
+            await deleteChannel.close();
+          } catch (closeErr) {
+            // Ignore close errors
+          }
+          checkChannelForDelete = null;
+          
+          // Wait to ensure deletion is processed and no frames are pending
+          await new Promise(resolve => setTimeout(resolve, 300));
+          queueExists = false; // Queue no longer exists, will be created
+        } catch (deleteError) {
+          logger.error(`[QueueInit] ✗ Failed to delete queue ${queueName}:`, deleteError.message);
+          // Clean up check channel if still open
+          if (checkChannelForDelete) {
+            try {
+              await checkChannelForDelete.close();
+            } catch (closeErr) {
+              // Ignore
+            }
+          }
+          throw new Error(`Cannot delete queue ${queueName} with incorrect parameters: ${deleteError.message}`);
+        }
+      }
+      
+      // CRITICAL: Now create/verify queue with correct parameters
       const ensureQueue = async () => {
         const activeChannel = await getChannel();
         return activeChannel.assertQueue(queueName, {
@@ -129,9 +219,26 @@ async function initInfrastructureQueues(channel, options = {}) {
             `[QueueInit] ⚠ Queue ${queueName} exists with different arguments - deleting and recreating...`
           );
           try {
+            // CRITICAL: Use a fresh channel for delete operation to avoid closed channel errors
+            // Close the current channel first to prevent it from receiving frames during deletion
+            if (workingChannel && !workingChannel.__queueInitClosed) {
+              try {
+                await workingChannel.close();
+                workingChannel.__queueInitClosed = true;
+              } catch (closeErr) {
+                // Ignore - channel may already be closed
+              }
+            }
+            
             const deleteChannel = await getChannel(true);
-            await deleteChannel.deleteQueue(queueName);
+            await deleteChannel.deleteQueue(queueName, { ifEmpty: false });
             logger.log(`[QueueInit] ✓ Deleted queue ${queueName} with incorrect parameters`);
+            // Close delete channel after use to avoid channel leaks
+            try {
+              await deleteChannel.close();
+            } catch (closeErr) {
+              // Ignore close errors - channel may already be closed
+            }
           } catch (deleteError) {
             logger.error(
               `[QueueInit] ✗ Failed to delete queue ${queueName}:`,
@@ -142,12 +249,24 @@ async function initInfrastructureQueues(channel, options = {}) {
             );
           }
 
-          // Recreate with correct parameters (force fresh channel to avoid closed state)
-          await getChannel(true);
-          await ensureQueue();
-          logger.log(
-            `[QueueInit] ✓ Recreated infrastructure queue: ${queueName} with correct parameters`
-          );
+          // CRITICAL: Recreate with correct parameters using a fresh channel
+          // Wait a brief moment to ensure queue deletion is fully processed and no frames are pending
+          await new Promise(resolve => setTimeout(resolve, 200));
+          const recreateChannel = await getChannel(true);
+          try {
+            await recreateChannel.assertQueue(queueName, {
+              durable: config.durable !== false,
+              arguments: { ...config.arguments }
+            });
+            logger.log(
+              `[QueueInit] ✓ Recreated infrastructure queue: ${queueName} with correct parameters`
+            );
+            // Update workingChannel to the new channel for subsequent operations
+            workingChannel = recreateChannel;
+          } catch (recreateError) {
+            logger.error(`[QueueInit] ✗ Failed to recreate ${queueName}:`, recreateError.message);
+            throw recreateError;
+          }
         } else {
           logger.error(`[QueueInit] ✗ Failed to create ${queueName}:`, assertError.message);
           throw assertError;