@onlineapps/service-common 1.0.1 → 1.0.3

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@onlineapps/service-common",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "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,52 @@
 
 /**
  * @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');
+const {
+  requireEnv,
+  optionalEnv,
+  optionalNumberEnv,
+  getCriticalConfig,
+  getOptionalInfraConfig,
+  getServiceConfig,
+  getInfrastructureHealthConfig
+} = require('./runtime-config');
 
 module.exports = {
   // Infrastructure readiness utilities (used by both infrastructure and business services)
   waitForInfrastructureReady,
   waitForHealthCheckQueueReady,
+
+  // Redis utilities (shared between services and tests)
+  buildRedisUrl,
+  createRedisClient,
+  connectRedis,
+
+  // Configuration helpers (NO FALLBACKS for critical infrastructure)
+  requireEnv,
+  optionalEnv,
+  optionalNumberEnv,
+  getCriticalConfig,
+  getOptionalInfraConfig,
+  getServiceConfig,
+  getInfrastructureHealthConfig,
+
   // Reporting utilities
   sendMonitoringFailFallbackEmail
 };
 
+

package/src/infrastructure/waitForHealthCheckQueueReady.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { connectRedis, buildRedisUrl } = require('../redisClient');
+
 /**
  * waitForHealthCheckQueueReady.js
  * 
@@ -31,7 +33,9 @@
  * @throws {Error} - If timeout is reached
  */
 async function waitForHealthCheckQueueReady(options = {}) {
-  const redisUrl = options.redisUrl || process.env.REDIS_URL || 'redis://api_node_cache:6379';
+  const redisUrl =
+    options.redisUrl ||
+    buildRedisUrl({ env: process.env, defaults: { host: 'api_node_cache', port: '6379' } });
   const maxWait = options.maxWait || parseInt(process.env.INFRASTRUCTURE_HEALTH_QUEUE_WAIT_MAX_TIME) || 60000; // 1 minute
   const checkInterval = options.checkInterval || parseInt(process.env.INFRASTRUCTURE_HEALTH_QUEUE_WAIT_CHECK_INTERVAL) || 2000; // 2 seconds
   const logger = options.logger || console;
@@ -55,15 +59,23 @@ async function waitForHealthCheckQueueReady(options = {}) {
   log(`[HealthCheckQueueReady] Max wait: ${maxWait}ms, Check interval: ${checkInterval}ms`);
 
   try {
-    // Connect to Redis
-    const { createClient } = require('redis');
-    redis = createClient({ url: redisUrl });
-    
-    redis.on('error', (err) => {
-      log(`[HealthCheckQueueReady] Redis error: ${err.message}`);
+    // Connect to Redis using shared helper (consistent config + fail-fast behaviour)
+    redis = await connectRedis({
+      purpose: 'wait-for-health-check-queue-ready',
+      logger: {
+        info: (message, meta = {}) => {
+          const suffix = meta && meta.url ? ` (${meta.url})` : '';
+          log(`[HealthCheckQueueReady] ${message}${suffix}`);
+        },
+        error: (message, meta = {}) => {
+          const detail = meta && meta.error ? ` ${meta.error}` : '';
+          log(`[HealthCheckQueueReady] ${message}${detail}`);
+        }
+      },
+      timeoutMs: 10000,
+      env: process.env,
+      defaults: { host: 'api_node_cache', port: '6379' }
     });
-    
-    await redis.connect();
     log('[HealthCheckQueueReady] Connected to Redis');
 
     while (Date.now() - startTime < maxWait) {

package/src/infrastructure/waitForInfrastructureReady.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { connectRedis, buildRedisUrl } = require('../redisClient');
+
 /**
  * waitForInfrastructureReady.js
  * 
@@ -42,7 +44,9 @@
  * Registry config (config.infrastructureHealth) is the source of truth for these defaults.
  */
 async function waitForInfrastructureReady(options = {}) {
-  const redisUrl = options.redisUrl || process.env.REDIS_URL || 'redis://api_node_cache:6379';
+  const redisUrl =
+    options.redisUrl ||
+    buildRedisUrl({ env: process.env, defaults: { host: 'api_node_cache', port: '6379' } });
   const maxWait = options.maxWait || parseInt(process.env.INFRASTRUCTURE_HEALTH_WAIT_MAX_TIME) || 300000; // 5 minutes
   const checkInterval = options.checkInterval || parseInt(process.env.INFRASTRUCTURE_HEALTH_WAIT_CHECK_INTERVAL) || 5000; // 5 seconds
   const logger = options.logger || console;
@@ -72,23 +76,39 @@ async function waitForInfrastructureReady(options = {}) {
   log(`[InfrastructureReady] Max wait: ${maxWait}ms, Check interval: ${checkInterval}ms`);
 
   try {
-    // Connect to Redis
-    const { createClient } = require('redis');
-    redis = createClient({ url: redisUrl });
-    
-    redis.on('error', (err) => {
-      log(`[InfrastructureReady] Redis error: ${err.message}`);
+    // Connect to Redis with timeout using shared helper (fail-fast, no infinite reconnect loops)
+    redis = await connectRedis({
+      purpose: 'wait-for-infrastructure-ready',
+      logger: {
+        error: (message, meta = {}) => {
+          const msg = meta && meta.error ? `${message} ${meta.error}` : message;
+          log(`[InfrastructureReady] ${msg}`);
+        },
+        info: (message, meta = {}) => {
+          const suffix = meta && meta.url ? ` (${meta.url})` : '';
+          log(`[InfrastructureReady] ${message}${suffix}`);
+        }
+      },
+      timeoutMs: 10000,
+      env: process.env,
+      defaults: { host: 'api_node_cache', port: '6379' }
     });
-    
-    await redis.connect();
     log('[InfrastructureReady] Connected to Redis');
 
     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 +120,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 +144,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
+};
+
+

package/src/runtime-config.js

@@ -0,0 +1,134 @@
+'use strict';
+
+/**
+ * Runtime Configuration Helper
+ * 
+ * NO FALLBACKS for critical infrastructure connections.
+ * Services must fail fast if critical config is missing.
+ * 
+ * This ensures:
+ * - Services don't silently connect to wrong infrastructure
+ * - Configuration problems are detected immediately
+ * - No hidden dependencies on hardcoded values
+ */
+
+/**
+ * Get required environment variable or throw error
+ * @param {string} name - Environment variable name
+ * @param {string} description - Description for error message
+ * @returns {string} Environment variable value
+ * @throws {Error} If variable is not set
+ */
+function requireEnv(name, description) {
+  const value = process.env[name];
+  if (!value || value.trim() === '') {
+    throw new Error(
+      `Service configuration error: ${name} is required but not set. ${description || ''}\n` +
+      `Please set ${name} environment variable in .env file or environment.\n` +
+      `Example: ${name}=value`
+    );
+  }
+  return value;
+}
+
+/**
+ * Get optional environment variable with default
+ * Use ONLY for non-critical values (ports, timeouts, log levels)
+ * @param {string} name - Environment variable name
+ * @param {any} defaultValue - Default value if not set
+ * @returns {any} Environment variable value or default
+ */
+function optionalEnv(name, defaultValue) {
+  const value = process.env[name];
+  if (value === undefined || value === null || value === '') {
+    return defaultValue;
+  }
+  return value;
+}
+
+/**
+ * Get optional number from environment with default
+ * @param {string} name - Environment variable name
+ * @param {number} defaultValue - Default value if not set or invalid
+ * @returns {number} Parsed number or default
+ */
+function optionalNumberEnv(name, defaultValue) {
+  const value = process.env[name];
+  if (!value || value.trim() === '') {
+    return defaultValue;
+  }
+  const parsed = parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : defaultValue;
+}
+
+/**
+ * Get critical infrastructure configuration
+ * These MUST be set - no fallbacks allowed
+ * @returns {Object} Critical infrastructure config
+ */
+function getCriticalConfig() {
+  return {
+    REDIS_URL: requireEnv('REDIS_URL', 'Redis connection URL (e.g., redis://api_node_cache:6379)'),
+    RABBITMQ_URL: requireEnv('RABBITMQ_URL', 'RabbitMQ connection URL (e.g., amqp://guest:guest@api_services_queuer:5672)')
+  };
+}
+
+/**
+ * Get optional infrastructure configuration
+ * These have sensible defaults for development
+ * @returns {Object} Optional infrastructure config
+ */
+function getOptionalInfraConfig() {
+  return {
+    POSTGRES_URL: optionalEnv('POSTGRES_URL', null), // Optional - only for services that need it
+    RABBITMQ_MGMT_URL: optionalEnv('RABBITMQ_MGMT_URL', null),
+    RABBITMQ_DEFAULT_USER: optionalEnv('RABBITMQ_DEFAULT_USER', 'guest'),
+    RABBITMQ_DEFAULT_PASS: optionalEnv('RABBITMQ_DEFAULT_PASS', 'guest'),
+    RABBITMQ_VHOST: optionalEnv('RABBITMQ_VHOST', '/')
+  };
+}
+
+/**
+ * Get service configuration with defaults
+ * @param {Object} options - Options
+ * @param {string} [options.defaultPort] - Default port if PORT not set
+ * @param {string} [options.defaultLogLevel] - Default log level
+ * @returns {Object} Service config
+ */
+function getServiceConfig(options = {}) {
+  const { defaultPort = 3000, defaultLogLevel = 'info' } = options;
+  
+  return {
+    PORT: optionalNumberEnv('PORT', defaultPort),
+    LOG_LEVEL: optionalEnv('LOG_LEVEL', defaultLogLevel),
+    SERVICE_NAME: optionalEnv('SERVICE_NAME', 'unknown-service'),
+    NODE_ENV: optionalEnv('NODE_ENV', 'development')
+  };
+}
+
+/**
+ * Get infrastructure health configuration with defaults
+ * @returns {Object} Infrastructure health config
+ */
+function getInfrastructureHealthConfig() {
+  return {
+    queueName: optionalEnv('INFRASTRUCTURE_HEALTH_QUEUE', 'infrastructure.health.checks'),
+    publishInterval: optionalNumberEnv('INFRASTRUCTURE_HEALTH_PUBLISH_INTERVAL', 5000),
+    waitMaxTime: optionalNumberEnv('INFRASTRUCTURE_HEALTH_WAIT_MAX_TIME', 300000),
+    waitCheckInterval: optionalNumberEnv('INFRASTRUCTURE_HEALTH_WAIT_CHECK_INTERVAL', 5000),
+    healthCheckTimeout: optionalNumberEnv('INFRASTRUCTURE_HEALTH_TIMEOUT', 15000),
+    redisKeyTTL: optionalNumberEnv('INFRASTRUCTURE_HEALTH_REDIS_TTL', 30),
+    cleanupInterval: optionalNumberEnv('INFRASTRUCTURE_HEALTH_CLEANUP_INTERVAL', 10000)
+  };
+}
+
+module.exports = {
+  requireEnv,
+  optionalEnv,
+  optionalNumberEnv,
+  getCriticalConfig,
+  getOptionalInfraConfig,
+  getServiceConfig,
+  getInfrastructureHealthConfig
+};
+