@onlineapps/service-common 1.0.0

package/README.md

@@ -0,0 +1,77 @@
+# @onlineapps/service-common
+
+Common utilities for both infrastructure services and business services in OA Drive.
+
+## Purpose
+
+This library provides shared functionality that is used across the entire system, by both infrastructure services (Gateway, Registry, Validator, etc.) and business services (hello-service, etc.).
+
+## Installation
+
+```bash
+npm install @onlineapps/service-common
+```
+
+## Usage
+
+### Wait for Infrastructure Ready
+
+Wait for all infrastructure services to be ready before creating queues:
+
+**Infrastructure Services:**
+```javascript
+const { waitForInfrastructureReady } = require('@onlineapps/service-common');
+
+await waitForInfrastructureReady({
+  redisUrl: 'redis://api_node_cache:6379',
+  maxWait: 300000, // 5 minutes
+  checkInterval: 5000, // 5 seconds
+  logger: logger
+});
+
+// Now safe to create infrastructure queues
+```
+
+**Business Services:**
+```javascript
+const { waitForInfrastructureReady } = require('@onlineapps/service-common');
+
+await waitForInfrastructureReady({
+  redisUrl: process.env.REDIS_URL,
+  maxWait: 60000, // 1 minute
+  checkInterval: 5000, // 5 seconds
+  logger: logger
+});
+
+// Now safe to create business queues
+```
+
+## API
+
+### `waitForInfrastructureReady(options)`
+
+Waits for all infrastructure services to be reported as healthy by Registry.
+
+**Options:**
+- `redisUrl` (string): Redis URL (default: from ENV or `redis://api_node_cache:6379`)
+- `maxWait` (number): Maximum wait time in ms (default: 300000 = 5 minutes)
+- `checkInterval` (number): Check interval in ms (default: 5000 = 5 seconds)
+- `logger` (Object): Logger instance (default: console)
+
+**Returns:** `Promise<boolean>` - True if all infrastructure services are ready
+
+**Throws:** `Error` - If timeout is reached
+
+**Environment Variables:**
+- `REDIS_URL` - Redis connection URL
+- `INFRASTRUCTURE_HEALTH_WAIT_MAX_TIME` - Maximum wait time in ms
+- `INFRASTRUCTURE_HEALTH_WAIT_CHECK_INTERVAL` - Check interval in ms
+
+## Architecture
+
+This library is used by:
+- **Infrastructure services** (via `@onlineapps/infrastructure-tools` which re-exports from here)
+- **Business services** (via `@onlineapps/service-wrapper` or directly)
+
+This ensures no duplication and consistent behavior across all services.
+

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@onlineapps/service-common",
+  "version": "1.0.0",
+  "description": "Common utilities for both infrastructure services and business services",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "jest",
+    "test:unit": "jest tests/unit",
+    "test:integration": "jest tests/integration"
+  },
+  "keywords": [
+    "microservices",
+    "infrastructure",
+    "common",
+    "utilities"
+  ],
+  "author": "OA Drive Team",
+  "license": "MIT",
+  "dependencies": {
+    "redis": "^4.6.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}
+

package/src/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+/**
+ * @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');
+
+module.exports = {
+  // Infrastructure readiness utilities (used by both infrastructure and business services)
+  waitForInfrastructureReady
+};
+

package/src/infrastructure/waitForInfrastructureReady.js

@@ -0,0 +1,138 @@
+'use strict';
+
+/**
+ * waitForInfrastructureReady.js
+ * 
+ * Waits for all infrastructure services to be verified as running and healthy.
+ * Used by BOTH infrastructure services and business services before creating queues
+ * to ensure system consistency.
+ * 
+ * This prevents race conditions where queues are created before all services are ready.
+ * 
+ * **How it works:**
+ * 1. Connects to Redis (where Registry stores infrastructure health status)
+ * 2. Checks `infrastructure:health:all` key every 5 seconds
+ * 3. If key is `"true"` → all infrastructure services are UP → return success
+ * 4. If key is `"false"` or missing → wait and retry
+ * 5. If timeout reached → throw error
+ * 
+ * **Why Redis (not HTTP):**
+ * - Fast: In-memory lookup, no network overhead
+ * - Reliable: Redis is already required infrastructure
+ * - Low latency: Direct key lookup, no HTTP parsing
+ * - Consistent: Same data source as Registry uses
+ * - No single point of failure: Redis can be clustered
+ * 
+ * **Usage:**
+ * - Infrastructure services: Wait before creating infrastructure queues
+ * - Business services: Wait before creating business queues
+ */
+
+/**
+ * Wait for all infrastructure services 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: INFRASTRUCTURE_HEALTH_WAIT_MAX_TIME env or 300000 = 5 minutes)
+ * @param {number} [options.checkInterval] - Check interval in ms (default: INFRASTRUCTURE_HEALTH_WAIT_CHECK_INTERVAL env or 5000 = 5 seconds)
+ * @param {Object} [options.logger] - Logger instance (default: console)
+ * @returns {Promise<boolean>} - True if all infrastructure services are ready
+ * @throws {Error} - If timeout is reached
+ * 
+ * Note: Default values can be overridden via ENV variables or options parameter.
+ * 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 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;
+
+  // Helper to log messages (compatible with both console and winston)
+  const log = (messageStr) => {
+    if (logger && typeof logger.log === 'function') {
+      // Winston-style logger
+      logger.log({ message: messageStr, level: 'info' });
+    } else if (logger && typeof logger.info === 'function') {
+      // Standard logger
+      logger.info(messageStr);
+    } else if (logger && typeof logger === 'function') {
+      // console.log or similar
+      logger(messageStr);
+    } else {
+      console.log(messageStr);
+    }
+  };
+
+  const startTime = Date.now();
+  let attemptCount = 0;
+  let redis = null;
+
+  log('[InfrastructureReady] Waiting for all infrastructure services to be ready...');
+  log(`[InfrastructureReady] Redis URL: ${redisUrl}`);
+  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}`);
+    });
+    
+    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');
+        
+        if (allHealthy === 'true') {
+          // All services are UP, we can proceed
+          const elapsed = Date.now() - startTime;
+          log(`[InfrastructureReady] ✓ All infrastructure services are ready (took ${elapsed}ms, ${attemptCount} attempts)`);
+          
+          // Optionally log individual service status
+          // Note: Service names should match config.infrastructureServices in Registry
+          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);
+            }
+          }
+          if (Object.keys(statuses).length > 0) {
+            log(`[InfrastructureReady] Individual service status: ${JSON.stringify(statuses, null, 2)}`);
+          }
+          
+          return true;
+        }
+
+        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...`);
+      }
+
+      await new Promise(resolve => setTimeout(resolve, checkInterval));
+    }
+
+    const elapsed = Date.now() - startTime;
+    throw new Error(
+      `Infrastructure services not ready within ${maxWait}ms (${elapsed}ms elapsed, ${attemptCount} attempts). ` +
+      `Check Redis key 'infrastructure:health:all' and individual service health keys.`
+    );
+  } finally {
+    if (redis && redis.isReady) {
+      await redis.quit();
+      log('[InfrastructureReady] Disconnected from Redis.');
+    }
+  }
+}
+
+module.exports = { waitForInfrastructureReady };
+