@onlineapps/service-common 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-common",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Common utilities for both infrastructure services and business services",
   "main": "src/index.js",
   "scripts": {

package/src/index.js

@@ -17,6 +17,15 @@ const {
   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)
@@ -28,6 +37,15 @@ module.exports = {
   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,35 +76,24 @@ async function waitForInfrastructureReady(options = {}) {
   log(`[InfrastructureReady] Max wait: ${maxWait}ms, Check interval: ${checkInterval}ms`);
 
   try {
-    // Connect to Redis with timeout
-    const { createClient } = require('redis');
-    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}`);
-    });
-    
-    // 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);
+    // 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' }
     });
-    
-    try {
-      await Promise.race([connectPromise, connectTimeoutPromise]);
-      log('[InfrastructureReady] Connected to Redis');
-    } catch (connectError) {
-      throw new Error(`[InfrastructureReady] Failed to connect to Redis: ${connectError.message}`);
-    }
+    log('[InfrastructureReady] Connected to Redis');
 
     while (Date.now() - startTime < maxWait) {
       attemptCount++;

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
+};
+