@onlineapps/service-common 1.0.1 → 1.0.2

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@onlineapps/service-common",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Common utilities for both infrastructure services and business services",
   "main": "src/index.js",
   "scripts": {
+    "prepublishOnly": "../../scripts/pre-publish-compatibility-check.sh",
+    "postpublish": "../../scripts/update-manifest-from-npm.sh && ../../scripts/update-all-services.sh",
     "test": "jest",
     "test:unit": "jest tests/unit",
     "test:integration": "jest tests/integration"
@@ -27,4 +29,3 @@
     "node": ">=14.0.0"
   }
 }
-

package/src/index.js

@@ -2,22 +2,34 @@
 
 /**
  * @onlineapps/service-common
- * 
+ *
  * Common utilities for both infrastructure services and business services.
  * Provides shared functionality that is used across the entire system.
- * 
+ *
  * This library is for ALL services (infrastructure and business).
  */
 
 const { waitForInfrastructureReady } = require('./infrastructure/waitForInfrastructureReady');
 const { waitForHealthCheckQueueReady } = require('./infrastructure/waitForHealthCheckQueueReady');
 const { sendMonitoringFailFallbackEmail } = require('./reporting/monitoringFallbackEmail');
+const {
+  buildRedisUrl,
+  createRedisClient,
+  connectRedis
+} = require('./redisClient');
 
 module.exports = {
   // Infrastructure readiness utilities (used by both infrastructure and business services)
   waitForInfrastructureReady,
   waitForHealthCheckQueueReady,
+
+  // Redis utilities (shared between services and tests)
+  buildRedisUrl,
+  createRedisClient,
+  connectRedis,
+
   // Reporting utilities
   sendMonitoringFailFallbackEmail
 };
 
+

package/src/infrastructure/waitForInfrastructureReady.js

@@ -72,23 +72,50 @@ async function waitForInfrastructureReady(options = {}) {
   log(`[InfrastructureReady] Max wait: ${maxWait}ms, Check interval: ${checkInterval}ms`);
 
   try {
-    // Connect to Redis
+    // Connect to Redis with timeout
     const { createClient } = require('redis');
-    redis = createClient({ url: redisUrl });
+    redis = createClient({ 
+      url: redisUrl,
+      socket: {
+        connectTimeout: 5000, // 5 seconds timeout for connection
+        reconnectStrategy: false // Don't auto-reconnect - fail fast
+      }
+    });
     
     redis.on('error', (err) => {
       log(`[InfrastructureReady] Redis error: ${err.message}`);
     });
     
-    await redis.connect();
-    log('[InfrastructureReady] Connected to Redis');
+    // Add timeout for Redis connection
+    const CONNECT_TIMEOUT = 10000; // 10 seconds
+    const connectPromise = redis.connect();
+    const connectTimeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Redis connection timeout after ${CONNECT_TIMEOUT}ms. Redis may be unavailable at ${redisUrl}`));
+      }, CONNECT_TIMEOUT);
+    });
+    
+    try {
+      await Promise.race([connectPromise, connectTimeoutPromise]);
+      log('[InfrastructureReady] Connected to Redis');
+    } catch (connectError) {
+      throw new Error(`[InfrastructureReady] Failed to connect to Redis: ${connectError.message}`);
+    }
 
     while (Date.now() - startTime < maxWait) {
       attemptCount++;
       
       try {
-        // Check Redis key: infrastructure:health:all
-        const allHealthy = await redis.get('infrastructure:health:all');
+        // Check Redis key: infrastructure:health:all with timeout to prevent hanging
+        const REDIS_OPERATION_TIMEOUT = 5000; // 5 seconds per operation
+        const getPromise = redis.get('infrastructure:health:all');
+        const getTimeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(new Error(`Redis get() operation timeout after ${REDIS_OPERATION_TIMEOUT}ms`));
+          }, REDIS_OPERATION_TIMEOUT);
+        });
+        
+        const allHealthy = await Promise.race([getPromise, getTimeoutPromise]);
         
         if (allHealthy === 'true') {
           // All services are UP, we can proceed
@@ -100,9 +127,18 @@ async function waitForInfrastructureReady(options = {}) {
           const serviceKeys = ['gateway', 'registry', 'validator', 'delivery', 'monitoring'];
           const statuses = {};
           for (const serviceName of serviceKeys) {
-            const status = await redis.get(`infrastructure:health:${serviceName}`);
-            if (status) {
-              statuses[serviceName] = JSON.parse(status);
+            try {
+              const statusPromise = redis.get(`infrastructure:health:${serviceName}`);
+              const statusTimeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error('timeout')), REDIS_OPERATION_TIMEOUT);
+              });
+              const status = await Promise.race([statusPromise, statusTimeoutPromise]);
+              if (status) {
+                statuses[serviceName] = JSON.parse(status);
+              }
+            } catch (statusError) {
+              // Ignore individual service status errors
+              log(`[InfrastructureReady] Could not get status for ${serviceName}: ${statusError.message}`);
             }
           }
           if (Object.keys(statuses).length > 0) {
@@ -115,7 +151,13 @@ async function waitForInfrastructureReady(options = {}) {
         log(`[InfrastructureReady] Attempt ${attemptCount}: Not all services ready (current status: ${allHealthy || 'unknown'}). Waiting ${checkInterval}ms...`);
 
       } catch (error) {
-        log(`[InfrastructureReady] Attempt ${attemptCount}: Failed to get infrastructure health from Redis (${error.message}). Waiting ${checkInterval}ms...`);
+        const errorMsg = error.message || String(error);
+        log(`[InfrastructureReady] Attempt ${attemptCount}: Failed to get infrastructure health from Redis (${errorMsg}). Waiting ${checkInterval}ms...`);
+        
+        // If Redis connection is lost, throw error immediately instead of retrying
+        if (errorMsg.includes('timeout') || errorMsg.includes('ECONNREFUSED') || errorMsg.includes('ENOTFOUND')) {
+          throw new Error(`[InfrastructureReady] Redis connection lost: ${errorMsg}. Cannot continue waiting for infrastructure ready.`);
+        }
       }
 
       await new Promise(resolve => setTimeout(resolve, checkInterval));

package/src/redisClient.js

@@ -0,0 +1,134 @@
+'use strict';
+
+/**
+ * Shared Redis client utilities for services and tests.
+ *
+ * Responsibility:
+ * - Build Redis connection URL from environment in a consistent way
+ * - Create a configured redis client with unified error logging
+ * - (Optionally) connect with a hard timeout for tests / tools
+ *
+ * This module is intentionally small and framework-agnostic so it can be used
+ * both in infrastructure services, business services and in test utilities.
+ */
+
+const { createClient } = require('redis');
+
+/**
+ * Build a Redis connection URL from environment.
+ *
+ * Precedence:
+ * 1. REDIS_URL (full URL, e.g. redis://host:port/db)
+ * 2. REDIS_HOST + REDIS_PORT
+ * 3. Defaults (host/port) or localhost:6379
+ */
+function buildRedisUrl(options = {}) {
+  const env = options.env || process.env || {};
+  const defaults = options.defaults || {};
+
+  if (env.REDIS_URL && typeof env.REDIS_URL === 'string' && env.REDIS_URL.length > 0) {
+    return env.REDIS_URL;
+  }
+
+  const host = env.REDIS_HOST || defaults.host || 'localhost';
+  const port = env.REDIS_PORT || defaults.port || '6379';
+
+  return `redis://${host}:${port}`;
+}
+
+/**
+ * Create a Redis client with unified error logging and optional test settings.
+ *
+ * @param {Object} options
+ * @param {string} [options.purpose] - Logical purpose (for log context)
+ * @param {boolean} [options.forTests=false] - If true, disables automatic reconnect loops
+ * @param {Object} [options.logger=console] - Logger with .error/.info methods
+ * @param {Object} [options.env=process.env] - Optional env override (for tests)
+ * @param {Object} [options.defaults] - Optional default host/port overrides
+ * @returns {{ client: import('redis').RedisClientType, url: string }}
+ */
+function createRedisClient(options = {}) {
+  const {
+    purpose = 'default',
+    forTests = false,
+    logger = console,
+    env,
+    defaults
+  } = options;
+
+  const url = buildRedisUrl({ env, defaults });
+
+  const socketOptions = forTests
+    ? {
+        // In tests we typically want fail-fast behaviour, not infinite reconnect loops
+        reconnectStrategy: false
+      }
+    : {};
+
+  const client = createClient({
+    url,
+    socket: socketOptions
+  });
+
+  const log = logger && typeof logger.error === 'function' ? logger : console;
+
+  client.on('error', (err) => {
+    try {
+      log.error('[Redis] Error', {
+        purpose,
+        url,
+        message: err && err.message ? err.message : String(err)
+      });
+    } catch {
+      // Last-resort fallback to avoid throwing in error handler
+      // eslint-disable-next-line no-console
+      console.error('[Redis] Error', err);
+    }
+  });
+
+  return { client, url };
+}
+
+/**
+ * Create and connect a Redis client with a hard timeout (useful for tests/tools).
+ *
+ * @param {Object} options - Same as createRedisClient plus:
+ * @param {number} [options.timeoutMs=15000] - Max time to wait for connect()
+ * @returns {Promise<import('redis').RedisClientType>}
+ */
+async function connectRedis(options = {}) {
+  const { timeoutMs = 15000, logger = console } = options;
+  const { client, url } = createRedisClient(options);
+
+  if (!timeoutMs || timeoutMs <= 0) {
+    await client.connect();
+    if (logger && typeof logger.info === 'function') {
+      logger.info('[Redis] Connected', { url });
+    }
+    return client;
+  }
+
+  const connectPromise = client.connect();
+  const timeoutPromise = new Promise((_, reject) => {
+    setTimeout(
+      () => reject(new Error(`Redis connection timeout after ${timeoutMs}ms to ${url}`)),
+      timeoutMs
+    );
+  });
+
+  await Promise.race([connectPromise, timeoutPromise]);
+
+  if (logger && typeof logger.info === 'function') {
+    logger.info('[Redis] Connected', { url });
+  }
+
+  return client;
+}
+
+module.exports = {
+  buildRedisUrl,
+  createRedisClient,
+  connectRedis
+};
+
+