@onlineapps/service-common 1.0.3 → 1.0.5

package/package.json

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

package/src/index.js

@@ -17,15 +17,27 @@ const {
   createRedisClient,
   connectRedis
 } = require('./redisClient');
+const {
+  buildPostgresUrl,
+  createPostgresPool,
+  connectPostgres
+} = require('./postgresClient');
 const {
   requireEnv,
   optionalEnv,
   optionalNumberEnv,
   getCriticalConfig,
+  getCriticalConfigWithFallbacks,
   getOptionalInfraConfig,
   getServiceConfig,
   getInfrastructureHealthConfig
 } = require('./runtime-config');
+const {
+  publishToMonitoringResilient,
+  publishToMonitoringWorkflow,
+  publishToMonitoringServices,
+  isQueueUnavailableError
+} = require('./monitoring-publish');
 
 module.exports = {
   // Infrastructure readiness utilities (used by both infrastructure and business services)
@@ -37,17 +49,29 @@ 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
+  sendMonitoringFailFallbackEmail,
+
+  // Resilient monitoring publish utilities
+  publishToMonitoringResilient,
+  publishToMonitoringWorkflow,
+  publishToMonitoringServices,
+  isQueueUnavailableError
 };
 
 

package/src/monitoring-publish.js

@@ -0,0 +1,133 @@
+/**
+ * Resilient monitoring publish helper
+ * 
+ * Publishes to monitoring queues (monitoring.workflow, monitoring.services) with fail-safe behavior.
+ * If the queue doesn't exist or RabbitMQ is unavailable, logs the error and continues without failing.
+ * 
+ * This ensures services can start and operate even if monitoring queues aren't ready yet.
+ * Monitoring queues are created when health:all is true, so this is a temporary state during startup.
+ */
+
+/**
+ * Check if error indicates queue doesn't exist or RabbitMQ is unavailable
+ */
+function isQueueUnavailableError(error) {
+  if (!error) return false;
+  
+  const errorMessage = error.message || String(error);
+  const errorCode = error.code || '';
+  
+  // RabbitMQ connection errors
+  if (errorCode === 'ECONNREFUSED' || errorCode === 'ENOTFOUND' || errorCode === 'ETIMEDOUT') {
+    return true;
+  }
+  
+  // Queue doesn't exist errors (from RabbitMQ)
+  if (errorMessage.includes('NOT_FOUND') || 
+      errorMessage.includes('404') ||
+      errorMessage.includes('no queue') ||
+      errorMessage.includes('queue does not exist') ||
+      errorMessage.includes('Channel closed') ||
+      errorMessage.includes('Connection closed')) {
+    return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Resilient publish to monitoring queue
+ * 
+ * @param {Object} mqClient - MQ client instance (must have publish method)
+ * @param {string} queueName - Queue name (e.g., 'monitoring.workflow', 'monitoring.services')
+ * @param {Object} message - Message to publish
+ * @param {Object} logger - Logger instance (optional, for logging)
+ * @param {Object} context - Additional context for logging (optional)
+ * @returns {Promise<boolean>} - true if published successfully, false otherwise
+ */
+async function publishToMonitoringResilient(mqClient, queueName, message, logger = null, context = {}) {
+  if (!mqClient || typeof mqClient.publish !== 'function') {
+    if (logger) {
+      logger.warn('Monitoring publish skipped: mqClient not available', context);
+    }
+    return false;
+  }
+
+  try {
+    await mqClient.publish(queueName, message);
+    
+    if (logger) {
+      logger.debug(`Published to ${queueName}`, {
+        ...context,
+        event_type: message.event_type,
+        workflow_id: message.workflow_id,
+        service_name: message.service_name
+      });
+    }
+    
+    return true;
+  } catch (error) {
+    // Check if this is a queue unavailable error
+    if (isQueueUnavailableError(error)) {
+      // Queue doesn't exist yet or RabbitMQ is unavailable - log but don't fail
+      if (logger) {
+        logger.warn(`Monitoring queue ${queueName} not available (queue may not exist yet or RabbitMQ unavailable)`, {
+          ...context,
+          error: error.message,
+          event_type: message.event_type,
+          workflow_id: message.workflow_id,
+          service_name: message.service_name
+        });
+      }
+      return false;
+    }
+    
+    // Other errors - log as warning but don't fail
+    if (logger) {
+      logger.warn(`Failed to publish to monitoring queue ${queueName}`, {
+        ...context,
+        error: error.message,
+        errorCode: error.code,
+        event_type: message.event_type,
+        workflow_id: message.workflow_id,
+        service_name: message.service_name
+      });
+    }
+    
+    return false;
+  }
+}
+
+/**
+ * Resilient publish to monitoring.workflow queue
+ * 
+ * @param {Object} mqClient - MQ client instance
+ * @param {Object} message - Message with event_type, workflow_id, etc.
+ * @param {Object} logger - Logger instance (optional)
+ * @param {Object} context - Additional context for logging (optional)
+ * @returns {Promise<boolean>}
+ */
+async function publishToMonitoringWorkflow(mqClient, message, logger = null, context = {}) {
+  return publishToMonitoringResilient(mqClient, 'monitoring.workflow', message, logger, context);
+}
+
+/**
+ * Resilient publish to monitoring.services queue
+ * 
+ * @param {Object} mqClient - MQ client instance
+ * @param {Object} message - Message with event_type, service_name, etc.
+ * @param {Object} logger - Logger instance (optional)
+ * @param {Object} context - Additional context for logging (optional)
+ * @returns {Promise<boolean>}
+ */
+async function publishToMonitoringServices(mqClient, message, logger = null, context = {}) {
+  return publishToMonitoringResilient(mqClient, 'monitoring.services', message, logger, context);
+}
+
+module.exports = {
+  publishToMonitoringResilient,
+  publishToMonitoringWorkflow,
+  publishToMonitoringServices,
+  isQueueUnavailableError
+};
+

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

@@ -63,8 +63,12 @@ function optionalNumberEnv(name, defaultValue) {
 
 /**
  * Get critical infrastructure configuration
- * These MUST be set - no fallbacks allowed
+ * 
+ * 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 {
@@ -73,6 +77,34 @@ function getCriticalConfig() {
   };
 }
 
+/**
+ * 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
@@ -127,6 +159,7 @@ module.exports = {
   optionalEnv,
   optionalNumberEnv,
   getCriticalConfig,
+  getCriticalConfigWithFallbacks,
   getOptionalInfraConfig,
   getServiceConfig,
   getInfrastructureHealthConfig