@onlineapps/service-common 1.0.7 → 1.0.9

package/package.json

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

package/src/config.js

@@ -23,16 +23,29 @@ const DEFAULTS = require('./defaults');
 const runtimeCfg = createRuntimeConfig({
   defaults: DEFAULTS,
   schema: {
-    // Redis defaults
-    redisHost: { env: 'REDIS_HOST', defaultKey: 'redisHost' },
-    redisPort: { env: 'REDIS_PORT', defaultKey: 'redisPort' },
-    redisUrl: { env: 'REDIS_URL', defaultKey: 'redisUrl' },
-
-    // RabbitMQ defaults
-    rabbitmqUrl: { env: 'RABBITMQ_URL', defaultKey: 'rabbitmqUrl' },
+    // Infrastructure topology (FAIL-FAST, no defaults)
+    redisUrl: { env: 'REDIS_URL', required: true },
+    rabbitmqUrl: { env: 'RABBITMQ_URL', required: true },
 
     // Infrastructure health
     infrastructureHealthQueueName: { env: 'INFRASTRUCTURE_HEALTH_QUEUE', defaultKey: 'infrastructureHealthQueueName' },
+    infrastructureHealthPublishIntervalMs: { env: 'INFRASTRUCTURE_HEALTH_PUBLISH_INTERVAL', defaultKey: 'infrastructureHealthPublishIntervalMs', type: 'number' },
+    infrastructureHealthWaitMaxTimeMs: { env: 'INFRASTRUCTURE_HEALTH_WAIT_MAX_TIME', defaultKey: 'infrastructureHealthWaitMaxTimeMs', type: 'number' },
+    infrastructureHealthWaitCheckIntervalMs: { env: 'INFRASTRUCTURE_HEALTH_WAIT_CHECK_INTERVAL', defaultKey: 'infrastructureHealthWaitCheckIntervalMs', type: 'number' },
+    infrastructureHealthTimeoutMs: { env: 'INFRASTRUCTURE_HEALTH_TIMEOUT', defaultKey: 'infrastructureHealthTimeoutMs', type: 'number' },
+    infrastructureHealthRedisTtlSeconds: { env: 'INFRASTRUCTURE_HEALTH_REDIS_TTL', defaultKey: 'infrastructureHealthRedisTtlSeconds', type: 'number' },
+    infrastructureHealthCleanupIntervalMs: { env: 'INFRASTRUCTURE_HEALTH_CLEANUP_INTERVAL', defaultKey: 'infrastructureHealthCleanupIntervalMs', type: 'number' },
+    infrastructureHealthQueueWaitMaxTimeMs: { env: 'INFRASTRUCTURE_HEALTH_QUEUE_WAIT_MAX_TIME', defaultKey: 'infrastructureHealthQueueWaitMaxTimeMs', type: 'number' },
+    infrastructureHealthQueueWaitCheckIntervalMs: { env: 'INFRASTRUCTURE_HEALTH_QUEUE_WAIT_CHECK_INTERVAL', defaultKey: 'infrastructureHealthQueueWaitCheckIntervalMs', type: 'number' },
+
+    // Optional reporting (no defaults; feature is disabled unless fully configured)
+    infraReportSmtpHost: { env: 'INFRA_REPORT_SMTP_HOST' },
+    infraReportSmtpPort: { env: 'INFRA_REPORT_SMTP_PORT', type: 'number' },
+    infraReportSmtpSecure: { env: 'INFRA_REPORT_SMTP_SECURE', type: 'boolean' },
+    infraReportSmtpUser: { env: 'INFRA_REPORT_SMTP_USER' },
+    infraReportSmtpPass: { env: 'INFRA_REPORT_SMTP_PASS' },
+    infraReportFrom: { env: 'INFRA_REPORT_FROM' },
+    infraReportTo: { env: 'INFRA_REPORT_TO' },
   }
 });
 

package/src/defaults.js

@@ -10,12 +10,16 @@
  */
 
 module.exports = {
-  redisHost: 'api_node_cache',
-  redisPort: '6379',
-  redisUrl: 'redis://api_node_cache:6379',
-
-  rabbitmqUrl: 'amqp://guest:guest@api_services_queuer:5672',
   infrastructureHealthQueueName: 'infrastructure.health.checks',
+  infrastructureHealthPublishIntervalMs: 5000,
+  infrastructureHealthWaitMaxTimeMs: 300000,
+  infrastructureHealthWaitCheckIntervalMs: 5000,
+  infrastructureHealthTimeoutMs: 15000,
+  infrastructureHealthRedisTtlSeconds: 30,
+  infrastructureHealthCleanupIntervalMs: 10000,
+
+  infrastructureHealthQueueWaitMaxTimeMs: 60000,
+  infrastructureHealthQueueWaitCheckIntervalMs: 2000,
 };
 
 

package/src/index.js

@@ -28,8 +28,6 @@ const {
   optionalNumberEnv,
   getCriticalConfig,
   getCriticalConfigWithFallbacks,
-  getOptionalInfraConfig,
-  getServiceConfig,
   getInfrastructureHealthConfig
 } = require('./runtime-config');
 
@@ -53,9 +51,7 @@ module.exports = {
   optionalEnv,
   optionalNumberEnv,
   getCriticalConfig,
-  getCriticalConfigWithFallbacks, // EXCEPTION: Fallbacks allowed ONLY for infrastructure clients
-  getOptionalInfraConfig,
-  getServiceConfig,
+  getCriticalConfigWithFallbacks,
   getInfrastructureHealthConfig,
 
   // Reporting utilities

package/src/infrastructure/waitForHealthCheckQueueReady.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { connectRedis, buildRedisUrl } = require('../redisClient');
+const runtimeCfg = require('../config');
 
 /**
  * waitForHealthCheckQueueReady.js
@@ -33,11 +34,9 @@ const { connectRedis, buildRedisUrl } = require('../redisClient');
  * @throws {Error} - If timeout is reached
  */
 async function waitForHealthCheckQueueReady(options = {}) {
-  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 redisUrl = buildRedisUrl({ redisUrl: options.redisUrl });
+  const maxWait = runtimeCfg.get('infrastructureHealthQueueWaitMaxTimeMs', options.maxWait);
+  const checkInterval = runtimeCfg.get('infrastructureHealthQueueWaitCheckIntervalMs', options.checkInterval);
   const logger = options.logger || console;
   
   const log = (msg) => {
@@ -73,8 +72,7 @@ async function waitForHealthCheckQueueReady(options = {}) {
         }
       },
       timeoutMs: 10000,
-      env: process.env,
-      defaults: { host: 'api_node_cache', port: '6379' }
+      redisUrl
     });
     log('[HealthCheckQueueReady] Connected to Redis');
 

package/src/infrastructure/waitForInfrastructureReady.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { connectRedis, buildRedisUrl } = require('../redisClient');
+const runtimeCfg = require('../config');
 
 /**
  * waitForInfrastructureReady.js
@@ -44,11 +45,9 @@ const { connectRedis, buildRedisUrl } = require('../redisClient');
  * Registry config (config.infrastructureHealth) is the source of truth for these defaults.
  */
 async function waitForInfrastructureReady(options = {}) {
-  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 redisUrl = buildRedisUrl({ redisUrl: options.redisUrl });
+  const maxWait = runtimeCfg.get('infrastructureHealthWaitMaxTimeMs', options.maxWait);
+  const checkInterval = runtimeCfg.get('infrastructureHealthWaitCheckIntervalMs', options.checkInterval);
   const logger = options.logger || console;
 
   // Helper to log messages (compatible with both console and winston)
@@ -90,8 +89,7 @@ async function waitForInfrastructureReady(options = {}) {
         }
       },
       timeoutMs: 10000,
-      env: process.env,
-      defaults: { host: 'api_node_cache', port: '6379' }
+      redisUrl
     });
     log('[InfrastructureReady] Connected to Redis');
 

package/src/redisClient.js

@@ -13,39 +13,38 @@
  */
 
 const { createClient } = require('redis');
-const DEFAULTS = require('./defaults');
+const runtimeCfg = require('./config');
+const { createRuntimeConfig } = require('@onlineapps/runtime-config');
 
 /**
  * Build a Redis 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. 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)
+ * Strict rules:
+ * - No topology defaults (FAIL-FAST).
+ * - Priority: explicit redisUrl > env REDIS_URL.
  *
  * @param {Object} options - Options
- * @param {Object} [options.env=process.env] - Environment variables
- * @param {Object} [options.defaults] - Default host/port overrides
+ * @param {Object} [options.env] - Optional env override (tests/tools)
+ * @param {string} [options.redisUrl] - Explicit Redis URL override
  * @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 { env, redisUrl } = options;
+
+  if (env) {
+    const cfg = createRuntimeConfig({
+      defaults: {},
+      env,
+      schema: {
+        redisUrl: { env: 'REDIS_URL', required: true },
+      },
+    });
+    return cfg.get('redisUrl', redisUrl);
   }
 
-  // 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 || DEFAULTS.redisHost;
-  const port = env.REDIS_PORT || defaults.port || DEFAULTS.redisPort;
-
-  return `redis://${host}:${port}`;
+  // Default env source is the runtime-config resolver's env (process.env),
+  // but we never access process.env directly here.
+  return runtimeCfg.get('redisUrl', redisUrl);
 }
 
 /**
@@ -65,10 +64,10 @@ function createRedisClient(options = {}) {
     forTests = false,
     logger = console,
     env,
-    defaults
+    redisUrl
   } = options;
 
-  const url = buildRedisUrl({ env, defaults });
+  const url = buildRedisUrl({ env, redisUrl });
 
   const socketOptions = forTests
     ? {

package/src/reporting/monitoringFallbackEmail.js

@@ -1,19 +1,20 @@
 'use strict';
 
 const nodemailer = require('nodemailer');
+const runtimeCfg = require('../config');
 
 let transporter = null;
 let cachedConfigSignature = null;
 
 function loadConfig() {
   return {
-    host: process.env.INFRA_REPORT_SMTP_HOST,
-    port: process.env.INFRA_REPORT_SMTP_PORT ? parseInt(process.env.INFRA_REPORT_SMTP_PORT, 10) : undefined,
-    secure: process.env.INFRA_REPORT_SMTP_SECURE === 'true',
-    user: process.env.INFRA_REPORT_SMTP_USER,
-    pass: process.env.INFRA_REPORT_SMTP_PASS,
-    from: process.env.INFRA_REPORT_FROM,
-    to: process.env.INFRA_REPORT_TO
+    host: runtimeCfg.get('infraReportSmtpHost'),
+    port: runtimeCfg.get('infraReportSmtpPort'),
+    secure: runtimeCfg.get('infraReportSmtpSecure'),
+    user: runtimeCfg.get('infraReportSmtpUser'),
+    pass: runtimeCfg.get('infraReportSmtpPass'),
+    from: runtimeCfg.get('infraReportFrom'),
+    to: runtimeCfg.get('infraReportTo')
   };
 }
 

package/src/runtime-config.js

@@ -2,35 +2,31 @@
 
 /**
  * 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
+ *
+ * Rules:
+ * - No inline process.env usage in implementation code (use runtime-config resolver).
+ * - No topology defaults (Redis/RabbitMQ URLs must be provided via explicit config or ENV).
+ * - Module-owned defaults are allowed only for non-topology behavior (intervals/timeouts).
  */
 
 const runtimeCfg = require('./config');
+const { createRuntimeConfig } = require('@onlineapps/runtime-config');
 
 /**
- * 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
+ * Resolve arbitrary environment variables through runtime-config (no direct process.env access).
+ * Note: Prefer module schema keys (runtimeCfg.get) over these generic helpers.
  */
 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`
-    );
+  const cfg = createRuntimeConfig({
+    defaults: {},
+    schema: { value: { env: name, required: true } },
+  });
+  try {
+    return cfg.get('value');
+  } catch (err) {
+    const hint = description ? ` ${description}` : '';
+    throw new Error(`[ServiceConfig] Missing environment variable - ${name} is required.${hint}`.trim());
   }
-  return value;
 }
 
 /**
@@ -41,11 +37,11 @@ function requireEnv(name, description) {
  * @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;
+  const cfg = createRuntimeConfig({
+    defaults: {},
+    schema: { value: { env: name, default: defaultValue } },
+  });
+  return cfg.get('value');
 }
 
 /**
@@ -55,86 +51,36 @@ function optionalEnv(name, defaultValue) {
  * @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;
+  const cfg = createRuntimeConfig({
+    defaults: {},
+    schema: { value: { env: name, default: defaultValue, type: 'number' } },
+  });
+  return cfg.get('value');
 }
 
 /**
  * Get critical infrastructure configuration
- * 
- * NOTE: This function is DEPRECATED - use getCriticalConfigWithFallbacks() instead.
- * This function requires ENV variables and fails fast (NO FALLBACKS).
- * 
+ *
+ * This function is FAIL-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)')
+    REDIS_URL: runtimeCfg.get('redisUrl'),
+    RABBITMQ_URL: runtimeCfg.get('rabbitmqUrl'),
   };
 }
 
 /**
  * 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)
- * 
+ *
+ * Strict mode: This function is kept for compatibility but DOES NOT provide fallbacks.
+ * Topology is FAIL-FAST (no defaults).
  * @returns {Object} Critical infrastructure config with fallbacks
  */
 function getCriticalConfigWithFallbacks() {
-  // Uses runtime-config for unified priority: ENV → owner defaults
-  // Fallbacks are defined in ./defaults.js (module-owned)
-  return {
-    REDIS_URL: runtimeCfg.get('redisUrl'),
-    RABBITMQ_URL: runtimeCfg.get('rabbitmqUrl')
-  };
-}
-
-/**
- * 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')
-  };
+  return getCriticalConfig();
 }
 
 /**
@@ -144,12 +90,14 @@ function getServiceConfig(options = {}) {
 function getInfrastructureHealthConfig() {
   return {
     queueName: runtimeCfg.get('infrastructureHealthQueueName'),
-    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)
+    publishInterval: runtimeCfg.get('infrastructureHealthPublishIntervalMs'),
+    waitMaxTime: runtimeCfg.get('infrastructureHealthWaitMaxTimeMs'),
+    waitCheckInterval: runtimeCfg.get('infrastructureHealthWaitCheckIntervalMs'),
+    healthCheckTimeout: runtimeCfg.get('infrastructureHealthTimeoutMs'),
+    redisKeyTTL: runtimeCfg.get('infrastructureHealthRedisTtlSeconds'),
+    cleanupInterval: runtimeCfg.get('infrastructureHealthCleanupIntervalMs'),
+    queueWaitMaxTime: runtimeCfg.get('infrastructureHealthQueueWaitMaxTimeMs'),
+    queueWaitCheckInterval: runtimeCfg.get('infrastructureHealthQueueWaitCheckIntervalMs'),
   };
 }
 
@@ -159,8 +107,6 @@ module.exports = {
   optionalNumberEnv,
   getCriticalConfig,
   getCriticalConfigWithFallbacks,
-  getOptionalInfraConfig,
-  getServiceConfig,
   getInfrastructureHealthConfig
 };
 

package/tests/unit/defaults.test.js

@@ -6,20 +6,24 @@ const { buildRedisUrl } = require('../../src/redisClient');
 
 describe('@onlineapps/service-common defaults @unit', () => {
   test('should export stable module-owned defaults', () => {
-    expect(defaults.redisUrl).toBe('redis://api_node_cache:6379');
-    expect(defaults.rabbitmqUrl).toBe('amqp://guest:guest@api_services_queuer:5672');
     expect(defaults.infrastructureHealthQueueName).toBe('infrastructure.health.checks');
+    expect(defaults.infrastructureHealthPublishIntervalMs).toBe(5000);
+    expect(defaults.infrastructureHealthWaitMaxTimeMs).toBe(300000);
+    expect(defaults.infrastructureHealthWaitCheckIntervalMs).toBe(5000);
+    expect(defaults.infrastructureHealthTimeoutMs).toBe(15000);
+    expect(defaults.infrastructureHealthRedisTtlSeconds).toBe(30);
+    expect(defaults.infrastructureHealthCleanupIntervalMs).toBe(10000);
+    expect(defaults.infrastructureHealthQueueWaitMaxTimeMs).toBe(60000);
+    expect(defaults.infrastructureHealthQueueWaitCheckIntervalMs).toBe(2000);
   });
 
-  test('getCriticalConfigWithFallbacks should use module defaults when env is missing', () => {
+  test('getCriticalConfigWithFallbacks should fail-fast when env is missing (no topology defaults)', () => {
     const oldRedis = process.env.REDIS_URL;
     const oldRabbit = process.env.RABBITMQ_URL;
     delete process.env.REDIS_URL;
     delete process.env.RABBITMQ_URL;
 
-    const cfg = getCriticalConfigWithFallbacks();
-    expect(cfg.REDIS_URL).toBe(defaults.redisUrl);
-    expect(cfg.RABBITMQ_URL).toBe(defaults.rabbitmqUrl);
+    expect(() => getCriticalConfigWithFallbacks()).toThrow(/Missing required config/i);
 
     if (oldRedis !== undefined) process.env.REDIS_URL = oldRedis;
     if (oldRabbit !== undefined) process.env.RABBITMQ_URL = oldRabbit;
@@ -36,8 +40,7 @@ describe('@onlineapps/service-common defaults @unit', () => {
   });
 
   test('buildRedisUrl should fall back to module defaults host/port', () => {
-    const url = buildRedisUrl({ env: {}, defaults: {} });
-    expect(url).toBe(defaults.redisUrl);
+    expect(() => buildRedisUrl({ env: {}, defaults: {} })).toThrow(/Missing required config/i);
   });
 });