@onlineapps/service-common 1.0.2 → 1.0.4

package/package.json

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

package/src/index.js

@@ -17,6 +17,21 @@ const {
   createRedisClient,
   connectRedis
 } = require('./redisClient');
+const {
+  buildPostgresUrl,
+  createPostgresPool,
+  connectPostgres
+} = require('./postgresClient');
+const {
+  requireEnv,
+  optionalEnv,
+  optionalNumberEnv,
+  getCriticalConfig,
+  getCriticalConfigWithFallbacks,
+  getOptionalInfraConfig,
+  getServiceConfig,
+  getInfrastructureHealthConfig
+} = require('./runtime-config');
 
 module.exports = {
   // Infrastructure readiness utilities (used by both infrastructure and business services)
@@ -28,6 +43,21 @@ module.exports = {
   createRedisClient,
   connectRedis,
 
+  // PostgreSQL utilities (shared between services and tests)
+  buildPostgresUrl,
+  createPostgresPool,
+  connectPostgres,
+
+  // Configuration helpers (NO FALLBACKS for critical infrastructure)
+  requireEnv,
+  optionalEnv,
+  optionalNumberEnv,
+  getCriticalConfig,
+  getCriticalConfigWithFallbacks, // EXCEPTION: Fallbacks allowed ONLY for infrastructure clients
+  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/postgresClient.js

@@ -0,0 +1,104 @@
+'use strict';
+
+/**
+ * PostgreSQL Client Utilities
+ * 
+ * Provides helper functions for building PostgreSQL connection URLs
+ * with fallback support for infrastructure client configuration.
+ * 
+ * EXCEPTION: Fallbacks are allowed ONLY for infrastructure client configuration.
+ * This is the ONLY place where fallbacks are acceptable.
+ */
+
+/**
+ * Build a PostgreSQL connection URL from environment.
+ *
+ * EXCEPTION: Fallbacks are allowed ONLY for infrastructure client configuration.
+ * This is the ONLY place where fallbacks are acceptable.
+ *
+ * Environment variable precedence (checked in order):
+ * 1. POSTGRES_URL (full URL, e.g. postgres://monitoring:monitoring_pass@api_monitoring_postgres:5432/monitoring) - ENV variable name
+ * 2. POSTGRES_HOST + POSTGRES_PORT + POSTGRES_USER + POSTGRES_PASSWORD + POSTGRES_DB (if POSTGRES_URL not set)
+ * 3. Fallback: postgres://monitoring:monitoring_pass@api_monitoring_postgres:5432/monitoring (docker-compose default)
+ *
+ * @param {Object} options - Options
+ * @param {Object} [options.env=process.env] - Environment variables
+ * @param {Object} [options.defaults] - Default host/port/user/password/db overrides
+ * @returns {string} PostgreSQL connection URL
+ */
+function buildPostgresUrl(options = {}) {
+  const env = options.env || process.env || {};
+  const defaults = options.defaults || {};
+
+  // Priority 1: POSTGRES_URL from environment (ENV variable name: POSTGRES_URL)
+  if (env.POSTGRES_URL && typeof env.POSTGRES_URL === 'string' && env.POSTGRES_URL.length > 0) {
+    return env.POSTGRES_URL;
+  }
+
+  // Priority 2: POSTGRES_HOST + POSTGRES_PORT + POSTGRES_USER + POSTGRES_PASSWORD + POSTGRES_DB (if POSTGRES_URL not set)
+  // Fallback for docker-compose environment (defined in library, not in docker-compose.yml)
+  const host = env.POSTGRES_HOST || defaults.host || 'api_monitoring_postgres';
+  const port = env.POSTGRES_PORT || defaults.port || '5432';
+  const user = env.POSTGRES_USER || defaults.user || 'monitoring';
+  const password = env.POSTGRES_PASSWORD || defaults.password || 'monitoring_pass';
+  const database = env.POSTGRES_DB || defaults.database || 'monitoring';
+
+  return `postgres://${user}:${password}@${host}:${port}/${database}`;
+}
+
+/**
+ * Create a PostgreSQL connection pool
+ * 
+ * @param {Object} options - Options
+ * @param {Object} [options.env=process.env] - Environment variables
+ * @param {Object} [options.defaults] - Default connection parameters
+ * @param {Object} [options.poolConfig] - Additional pool configuration (max, idleTimeoutMillis, etc.)
+ * @returns {Object} PostgreSQL Pool instance
+ */
+function createPostgresPool(options = {}) {
+  const { Pool } = require('pg');
+  
+  const connectionString = buildPostgresUrl({
+    env: options.env,
+    defaults: options.defaults
+  });
+
+  const poolConfig = {
+    connectionString,
+    max: options.poolConfig?.max || 10,
+    idleTimeoutMillis: options.poolConfig?.idleTimeoutMillis || 30000,
+    connectionTimeoutMillis: options.poolConfig?.connectionTimeoutMillis || 2000,
+    ...options.poolConfig
+  };
+
+  return new Pool(poolConfig);
+}
+
+/**
+ * Connect to PostgreSQL and test connection
+ * 
+ * @param {Object} pool - PostgreSQL Pool instance
+ * @param {Object} logger - Logger object with info/error methods
+ * @returns {Promise<void>}
+ */
+async function connectPostgres(pool, logger = console) {
+  try {
+    await pool.query('SELECT NOW()');
+    if (logger && logger.info) {
+      logger.info('[PostgreSQL] Connected');
+    }
+    return true;
+  } catch (error) {
+    if (logger && logger.error) {
+      logger.error('[PostgreSQL] Connection failed:', error);
+    }
+    throw error;
+  }
+}
+
+module.exports = {
+  buildPostgresUrl,
+  createPostgresPool,
+  connectPostgres
+};
+

package/src/redisClient.js

@@ -17,20 +17,31 @@ 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
+ * EXCEPTION: Fallbacks are allowed ONLY for infrastructure client configuration.
+ * This is the ONLY place where fallbacks are acceptable.
+ *
+ * Environment variable precedence (checked in order):
+ * 1. REDIS_URL (full URL, e.g. redis://api_node_cache:6379) - ENV variable name
+ * 2. REDIS_HOST + REDIS_PORT (if REDIS_URL not set)
+ * 3. Fallback: redis://api_node_cache:6379 (docker-compose default)
+ *
+ * @param {Object} options - Options
+ * @param {Object} [options.env=process.env] - Environment variables
+ * @param {Object} [options.defaults] - Default host/port overrides
+ * @returns {string} Redis connection URL
  */
 function buildRedisUrl(options = {}) {
   const env = options.env || process.env || {};
   const defaults = options.defaults || {};
 
+  // Priority 1: REDIS_URL from environment (ENV variable name: REDIS_URL)
   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';
+  // Priority 2: REDIS_HOST + REDIS_PORT (if REDIS_URL not set)
+  // Fallback for docker-compose environment (defined in library, not in docker-compose.yml)
+  const host = env.REDIS_HOST || defaults.host || 'api_node_cache';
   const port = env.REDIS_PORT || defaults.port || '6379';
 
   return `redis://${host}:${port}`;

package/src/runtime-config.js

@@ -0,0 +1,167 @@
+'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
+ * 
+ * NOTE: This function is DEPRECATED - use getCriticalConfigWithFallbacks() instead.
+ * This function requires ENV variables and fails fast (NO FALLBACKS).
+ * 
+ * @returns {Object} Critical infrastructure config
+ * @throws {Error} If REDIS_URL or RABBITMQ_URL are not set
+ */
+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 critical infrastructure configuration with fallbacks
+ * 
+ * EXCEPTION: Fallbacks are allowed ONLY for infrastructure client configuration.
+ * This is the ONLY place where fallbacks are acceptable.
+ * 
+ * Environment variables (checked in order):
+ * - REDIS_URL: Full Redis URL (e.g., redis://api_node_cache:6379)
+ * - RABBITMQ_URL: Full RabbitMQ URL (e.g., amqp://guest:guest@api_services_queuer:5672)
+ * 
+ * Fallbacks (used only if ENV is not set):
+ * - Redis: redis://api_node_cache:6379 (docker-compose default)
+ * - RabbitMQ: amqp://guest:guest@api_services_queuer:5672 (docker-compose default)
+ * 
+ * @returns {Object} Critical infrastructure config with fallbacks
+ */
+function getCriticalConfigWithFallbacks() {
+  // Fallback URLs for docker-compose environment (defined in library, not in docker-compose.yml)
+  // These are used ONLY if ENV variables are not set
+  const redisFallback = 'redis://api_node_cache:6379';
+  const rabbitmqFallback = 'amqp://guest:guest@api_services_queuer:5672';
+  
+  return {
+    REDIS_URL: optionalEnv('REDIS_URL', redisFallback),
+    RABBITMQ_URL: optionalEnv('RABBITMQ_URL', rabbitmqFallback)
+  };
+}
+
+/**
+ * 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,
+  getCriticalConfigWithFallbacks,
+  getOptionalInfraConfig,
+  getServiceConfig,
+  getInfrastructureHealthConfig
+};
+