@onlineapps/service-common 1.0.0 → 1.0.2

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@onlineapps/service-common",
-  "version": "1.0.0",
+  "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"
@@ -17,6 +19,7 @@
   "author": "OA Drive Team",
   "license": "MIT",
   "dependencies": {
+    "nodemailer": "^6.9.8",
     "redis": "^4.6.0"
   },
   "devDependencies": {
@@ -26,4 +29,3 @@
     "node": ">=14.0.0"
   }
 }
-

package/src/index.js

@@ -2,17 +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
+  waitForInfrastructureReady,
+  waitForHealthCheckQueueReady,
+
+  // Redis utilities (shared between services and tests)
+  buildRedisUrl,
+  createRedisClient,
+  connectRedis,
+
+  // Reporting utilities
+  sendMonitoringFailFallbackEmail
 };
 
+

package/src/infrastructure/waitForHealthCheckQueueReady.js

@@ -0,0 +1,106 @@
+'use strict';
+
+/**
+ * waitForHealthCheckQueueReady.js
+ * 
+ * Waits for Registry to create the infrastructure.health.checks queue.
+ * Used by infrastructure services to know when they can start publishing health checks.
+ * 
+ * This is different from waitForInfrastructureReady - this only checks if the queue exists,
+ * not if all services are healthy.
+ * 
+ * **How it works:**
+ * 1. Connects to Redis
+ * 2. Checks `infrastructure:health:queue:ready` key every 2 seconds
+ * 3. If key is `"true"` → queue is ready → return success
+ * 4. If key is missing → wait and retry
+ * 5. If timeout reached → throw error
+ * 
+ * **Usage:**
+ * - Infrastructure services: Wait before starting health check publisher
+ */
+
+/**
+ * Wait for health check queue to be ready
+ * @param {Object} options - Options
+ * @param {string} [options.redisUrl] - Redis URL (default: REDIS_URL env or redis://api_node_cache:6379)
+ * @param {number} [options.maxWait] - Maximum wait time in ms (default: 60000 = 1 minute)
+ * @param {number} [options.checkInterval] - Check interval in ms (default: 2000 = 2 seconds)
+ * @param {Object} [options.logger] - Logger instance (default: console)
+ * @returns {Promise<boolean>} - True if queue is ready
+ * @throws {Error} - If timeout is reached
+ */
+async function waitForHealthCheckQueueReady(options = {}) {
+  const redisUrl = options.redisUrl || process.env.REDIS_URL || 'redis://api_node_cache: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;
+  
+  const log = (msg) => {
+    if (logger && typeof logger.info === 'function') {
+      logger.info(msg);
+    } else if (logger && typeof logger.log === 'function') {
+      logger.log(msg);
+    } else {
+      console.log(msg);
+    }
+  };
+
+  let redis = null;
+  const startTime = Date.now();
+  let attemptCount = 0;
+
+  log(`[HealthCheckQueueReady] Waiting for health check queue to be ready...`);
+  log(`[HealthCheckQueueReady] Redis URL: ${redisUrl}`);
+  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}`);
+    });
+    
+    await redis.connect();
+    log('[HealthCheckQueueReady] Connected to Redis');
+
+    while (Date.now() - startTime < maxWait) {
+      attemptCount++;
+      
+      try {
+        // Check Redis key: infrastructure:health:queue:ready
+        const queueReady = await redis.get('infrastructure:health:queue:ready');
+        
+        if (queueReady === 'true') {
+          // Queue is ready, we can proceed
+          const elapsed = Date.now() - startTime;
+          log(`[HealthCheckQueueReady] ✓ Health check queue is ready (took ${elapsed}ms, ${attemptCount} attempts)`);
+          return true;
+        }
+
+        log(`[HealthCheckQueueReady] Attempt ${attemptCount}: Queue not ready yet (current status: ${queueReady || 'unknown'}). Waiting ${checkInterval}ms...`);
+
+      } catch (error) {
+        log(`[HealthCheckQueueReady] Attempt ${attemptCount}: Failed to get queue ready status from Redis (${error.message}). Waiting ${checkInterval}ms...`);
+      }
+
+      await new Promise(resolve => setTimeout(resolve, checkInterval));
+    }
+
+    const elapsed = Date.now() - startTime;
+    throw new Error(
+      `Health check queue not ready within ${maxWait}ms (${elapsed}ms elapsed, ${attemptCount} attempts). ` +
+      `Check Redis key 'infrastructure:health:queue:ready' and ensure Registry has started.`
+    );
+  } finally {
+    if (redis && redis.isReady) {
+      await redis.quit();
+      log('[HealthCheckQueueReady] Disconnected from Redis.');
+    }
+  }
+}
+
+module.exports = { waitForHealthCheckQueueReady };
+

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

package/src/reporting/monitoringFallbackEmail.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const nodemailer = require('nodemailer');
+
+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
+  };
+}
+
+function createTransportIfNeeded(config) {
+  const signature = JSON.stringify(config);
+  if (transporter && cachedConfigSignature === signature) {
+    return transporter;
+  }
+
+  if (!config.host || !config.port || !config.user || !config.pass || !config.from || !config.to) {
+    return null;
+  }
+
+  transporter = nodemailer.createTransport({
+    host: config.host,
+    port: config.port,
+    secure: config.secure,
+    auth: {
+      user: config.user,
+      pass: config.pass
+    }
+  });
+  cachedConfigSignature = signature;
+  return transporter;
+}
+
+async function sendMonitoringFailFallbackEmail(subject, text, html) {
+  const config = loadConfig();
+  const mailer = createTransportIfNeeded(config);
+
+  if (!mailer) {
+    console.warn('[MonitoringFallbackEmail] SMTP configuration missing, skipping email send');
+    return false;
+  }
+
+  const recipients = config.to.split(',').map(addr => addr.trim()).filter(Boolean);
+  if (recipients.length === 0) {
+    console.warn('[MonitoringFallbackEmail] No recipients configured in INFRA_REPORT_TO');
+    return false;
+  }
+
+  try {
+    const result = await mailer.sendMail({
+      from: config.from,
+      to: recipients,
+      subject,
+      text,
+      html
+    });
+    console.log('[MonitoringFallbackEmail] Email sent successfully', {
+      messageId: result.messageId,
+      response: result.response,
+      accepted: result.accepted,
+      rejected: result.rejected
+    });
+    return true;
+  } catch (error) {
+    console.error('[MonitoringFallbackEmail] Failed to send email:', {
+      message: error.message,
+      code: error.code,
+      command: error.command,
+      response: error.response,
+      responseCode: error.responseCode
+    });
+    return false;
+  }
+}
+
+module.exports = {
+  sendMonitoringFailFallbackEmail
+};
+
+

package/tests/unit/monitoringFallbackEmail.test.js

@@ -0,0 +1,57 @@
+'use strict';
+
+jest.mock('nodemailer', () => {
+  return {
+    createTransport: jest.fn(() => ({
+      sendMail: jest.fn().mockResolvedValue(true)
+    }))
+  };
+});
+
+describe('monitoringFallbackEmail', () => {
+  const ORIGINAL_ENV = process.env;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...ORIGINAL_ENV };
+  });
+
+  afterEach(() => {
+    process.env = ORIGINAL_ENV;
+  });
+
+  function loadReporter() {
+    return require('../../src/reporting/monitoringFallbackEmail');
+  }
+
+  test('returns false when SMTP config missing', async () => {
+    delete process.env.INFRA_REPORT_SMTP_HOST;
+    const { sendMonitoringFailFallbackEmail } = loadReporter();
+    const result = await sendMonitoringFailFallbackEmail('t', 't', '<p>t</p>');
+    expect(result).toBe(false);
+  });
+
+  test('sends email when SMTP config provided', async () => {
+    process.env.INFRA_REPORT_SMTP_HOST = 'smtp.example.com';
+    process.env.INFRA_REPORT_SMTP_PORT = '587';
+    process.env.INFRA_REPORT_SMTP_SECURE = 'false';
+    process.env.INFRA_REPORT_SMTP_USER = 'user@example.com';
+    process.env.INFRA_REPORT_SMTP_PASS = 'secret';
+    process.env.INFRA_REPORT_FROM = 'infra@example.com';
+    process.env.INFRA_REPORT_TO = 'ops@example.com';
+
+    const nodemailer = require('nodemailer');
+    const transportMock = {
+      sendMail: jest.fn().mockResolvedValue(true)
+    };
+    nodemailer.createTransport.mockReturnValue(transportMock);
+
+    const { sendMonitoringFailFallbackEmail } = loadReporter();
+    const result = await sendMonitoringFailFallbackEmail('Subject', 'Body', '<p>Body</p>');
+
+    expect(result).toBe(true);
+    expect(transportMock.sendMail).toHaveBeenCalledTimes(1);
+  });
+});
+
+