@onlineapps/cookbook-router 1.0.0

package/README.md

@@ -0,0 +1,215 @@
+# @onlineapps/cookbook-router
+
+Message routing for cookbook workflows - handles service discovery and queue routing.
+
+## Overview
+
+This package provides routing capabilities for cookbook workflows in a distributed microservices environment. It handles service discovery, queue management, and retry logic for reliable message delivery.
+
+## Installation
+
+```bash
+npm install @onlineapps/cookbook-router
+```
+
+## Features
+
+- **Service discovery** - Integration with service registry
+- **Queue management** - RabbitMQ operations and DLQ handling
+- **Workflow routing** - Route between services based on cookbook steps
+- **Retry logic** - Exponential backoff with jitter
+- **Health checking** - Service availability monitoring
+
+## Usage
+
+### Basic routing setup
+
+```javascript
+const { CookbookRouter } = require('@onlineapps/cookbook-router');
+const MQClient = require('@onlineapps/connector-mq-client');
+const RegistryClient = require('@onlineapps/connector-registry-client');
+
+const mqClient = new MQClient(mqConfig);
+const registryClient = new RegistryClient(registryConfig);
+
+const router = new CookbookRouter(mqClient, registryClient, {
+  defaultQueue: 'workflow.init',
+  completedQueue: 'workflow.completed',
+  maxRetries: 3
+});
+```
+
+### Route workflow to first service
+
+```javascript
+const cookbook = {
+  id: 'my-workflow',
+  steps: [
+    { id: 'step1', type: 'task', service: 'user-service', operation: 'getUser' },
+    { id: 'step2', type: 'task', service: 'email-service', operation: 'sendEmail' }
+  ]
+};
+
+const context = {
+  workflow_id: 'wf_123',
+  api_input: { userId: '456' }
+};
+
+await router.routeWorkflow(cookbook, context);
+```
+
+### Route to next service
+
+```javascript
+// After completing step1, route to next service
+await router.routeToNextService(cookbook, updatedContext, 'step1');
+```
+
+### Handle failures
+
+```javascript
+try {
+  await router.routeWorkflow(cookbook, context);
+} catch (error) {
+  // Route to dead letter queue
+  await router.routeToDLQ(cookbook, context, error, 'user-service');
+}
+```
+
+## Service Discovery
+
+```javascript
+const { ServiceDiscovery } = require('@onlineapps/cookbook-router');
+
+const discovery = new ServiceDiscovery(registryClient);
+
+// Check service availability
+const exists = await discovery.serviceExists('user-service');
+
+// Get service details
+const service = await discovery.getService('user-service');
+
+// Find services by capability
+const services = await discovery.findServicesByCapability('email');
+```
+
+## Queue Management
+
+```javascript
+const { QueueManager } = require('@onlineapps/cookbook-router');
+
+const queueManager = new QueueManager(mqClient);
+
+// Publish message
+await queueManager.publish('user.queue', { action: 'process' });
+
+// Subscribe to queue
+await queueManager.subscribe('user.queue', async (message) => {
+  console.log('Received:', message);
+});
+
+// Setup dead letter queue
+await queueManager.setupDLQ('user.queue', 'user.dlq');
+```
+
+## Retry Handling
+
+```javascript
+const { RetryHandler } = require('@onlineapps/cookbook-router');
+
+const retryHandler = new RetryHandler({
+  maxAttempts: 3,
+  initialDelay: 1000,
+  backoffFactor: 2
+});
+
+// Execute with retry
+const result = await retryHandler.execute(async () => {
+  return await unreliableOperation();
+});
+
+// Wrap function with retry
+const reliableOperation = retryHandler.wrap(unreliableOperation);
+await reliableOperation();
+```
+
+## Configuration Options
+
+### CookbookRouter Options
+
+```javascript
+{
+  defaultQueue: 'workflow.init',    // Default entry queue
+  completedQueue: 'workflow.completed', // Completion queue
+  dlqSuffix: '.dlq',               // Dead letter queue suffix
+  maxRetries: 3,                   // Max retry attempts
+  retryDelay: 2000,                // Base retry delay (ms)
+  logger: console                  // Logger instance
+}
+```
+
+### ServiceDiscovery Options
+
+```javascript
+{
+  cacheTTL: 60000,                 // Cache TTL in ms
+  logger: console                  // Logger instance
+}
+```
+
+### QueueManager Options
+
+```javascript
+{
+  defaultTTL: 30000,               // Message TTL
+  persistent: true,                // Persistent messages
+  logger: console                  // Logger instance
+}
+```
+
+### RetryHandler Options
+
+```javascript
+{
+  maxAttempts: 3,                  // Max retry attempts
+  initialDelay: 1000,              // Initial delay (ms)
+  maxDelay: 30000,                 // Max delay cap (ms)
+  backoffFactor: 2,                // Exponential factor
+  jitter: true,                    // Add random jitter
+  logger: console                  // Logger instance
+}
+```
+
+## Queue Naming Conventions
+
+- `{service}.workflow` - Workflow messages
+- `{service}.queue` - Direct messages
+- `{service}.dlq` - Dead letter queue
+- `workflow.init` - Entry point
+- `workflow.completed` - Completed workflows
+
+## Error Handling
+
+The router distinguishes between retryable and non-retryable errors:
+
+**Retryable:**
+- Network timeouts
+- Connection refused
+- Service temporarily unavailable
+
+**Non-retryable:**
+- Validation errors
+- Authentication failures
+- Not found errors
+- Bad requests
+
+## Related Packages
+
+- `@onlineapps/cookbook-core` - Core parsing and validation
+- `@onlineapps/cookbook-executor` - Workflow execution engine
+- `@onlineapps/cookbook-transformer` - OpenAPI mapping
+- `@onlineapps/connector-cookbook` - Full-featured wrapper
+
+## License
+
+PROPRIETARY - All rights reserved

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@onlineapps/cookbook-router",
+  "version": "1.0.0",
+  "description": "Message routing for cookbook workflows - handles service discovery and queue routing",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "docs": "jsdoc2md --files src/**/*.js > API.md"
+  },
+  "keywords": [
+    "cookbook",
+    "routing",
+    "queue",
+    "workflow",
+    "messaging"
+  ],
+  "author": "OnlineApps",
+  "license": "PROPRIETARY",
+  "dependencies": {
+    "@onlineapps/cookbook-core": "^1.0.0",
+    "@onlineapps/conn-infra-mq": "^1.1.0",
+    "@onlineapps/conn-orch-registry": "^1.1.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/index.js

@@ -0,0 +1,31 @@
+'use strict';
+
+/**
+ * @module @onlineapps/cookbook-router
+ *
+ * Message routing library for cookbook workflows.
+ * Handles service discovery, queue routing, and retry logic.
+ */
+
+const CookbookRouter = require('./router');
+const ServiceDiscovery = require('./serviceDiscovery');
+const QueueManager = require('./queueManager');
+const RetryHandler = require('./retryHandler');
+
+module.exports = {
+  // Main router class
+  CookbookRouter,
+
+  // Supporting classes
+  ServiceDiscovery,
+  QueueManager,
+  RetryHandler,
+
+  // Factory function
+  createRouter: (mqClient, registryClient, options = {}) => {
+    return new CookbookRouter(mqClient, registryClient, options);
+  },
+
+  // Utility exports
+  VERSION: '1.0.0'
+};

package/src/queueManager.js

@@ -0,0 +1,187 @@
+'use strict';
+
+/**
+ * QueueManager - Queue operations and management
+ */
+
+class QueueManager {
+  constructor(mqClient, options = {}) {
+    this.mqClient = mqClient;
+    this.options = {
+      ensureQueues: options.ensureQueues !== false,
+      defaultOptions: {
+        durable: true,
+        persistent: true,
+        ...options.defaultOptions
+      },
+      logger: options.logger || console,
+      ...options
+    };
+
+    this.ensuredQueues = new Set();
+  }
+
+  /**
+   * Publish message to queue
+   * @param {string} queueName - Target queue name
+   * @param {Object} message - Message to publish
+   * @param {Object} options - Publishing options
+   * @returns {Promise<boolean>}
+   */
+  async publish(queueName, message, options = {}) {
+    const { logger } = this.options;
+
+    try {
+      // Ensure queue exists if enabled
+      if (this.options.ensureQueues) {
+        await this.ensureQueue(queueName);
+      }
+
+      // Add timestamp to message
+      const messageWithTimestamp = {
+        ...message,
+        timestamp: new Date().toISOString()
+      };
+
+      // Merge publishing options
+      const publishOptions = {
+        ...this.options.defaultOptions,
+        ...options
+      };
+
+      logger.debug(`Publishing to ${queueName}`);
+
+      // Handle connection errors with retry
+      try {
+        await this.mqClient.publish(queueName, messageWithTimestamp, publishOptions);
+        return true;
+      } catch (error) {
+        // If connection lost, retry once
+        if (error.message.includes('Connection lost')) {
+          await this.mqClient.publish(queueName, messageWithTimestamp, publishOptions);
+          return true;
+        }
+        throw error;
+      }
+
+    } catch (error) {
+      logger.error(`Failed to publish to ${queueName}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Ensure queue exists
+   * @param {string} queueName - Queue name
+   * @param {Object} options - Queue options
+   * @returns {Promise<boolean>}
+   */
+  async ensureQueue(queueName, options = {}) {
+    // Check if already ensured
+    if (this.ensuredQueues.has(queueName)) {
+      return true;
+    }
+
+    const queueOptions = {
+      ...this.options.defaultOptions,
+      ...options
+    };
+
+    try {
+      await this.mqClient.assertQueue(queueName, queueOptions);
+      this.ensuredQueues.add(queueName);
+      return true;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Setup consumer for queue
+   * @param {string} queueName - Queue to consume from
+   * @param {Function} handler - Message handler
+   * @param {Object} options - Consumer options
+   * @returns {Promise<void>}
+   */
+  async consume(queueName, handler, options = {}) {
+    const { logger } = this.options;
+
+    // Ensure queue exists
+    if (this.options.ensureQueues) {
+      await this.ensureQueue(queueName);
+    }
+
+    const consumerOptions = {
+      noAck: false,
+      ...options
+    };
+
+    // Wrap handler with error handling
+    const wrappedHandler = async (message) => {
+      try {
+        // Parse message content
+        const content = JSON.parse(message.content.toString());
+
+        // Call user handler
+        await handler(content, message);
+
+        // Acknowledge message
+        this.mqClient.ack(message);
+      } catch (error) {
+        logger.error(`Error processing message from ${queueName}:`, error);
+        // Reject message without requeue
+        this.mqClient.nack(message, false, false);
+      }
+    };
+
+    await this.mqClient.consume(queueName, wrappedHandler, consumerOptions);
+  }
+
+  /**
+   * Get queue information
+   * @param {string} queueName - Queue name
+   * @returns {Promise<Object>}
+   */
+  async getQueueInfo(queueName) {
+    return await this.mqClient.checkQueue(queueName);
+  }
+
+  /**
+   * Purge queue (remove all messages)
+   * @param {string} queueName - Queue name
+   * @returns {Promise<Object>}
+   */
+  async purgeQueue(queueName) {
+    const { logger } = this.options;
+    const result = await this.mqClient.purgeQueue(queueName);
+    logger.warn(`Purged ${result.messageCount} messages from ${queueName}`);
+    return result;
+  }
+
+  /**
+   * Delete queue
+   * @param {string} queueName - Queue name
+   * @returns {Promise<boolean>}
+   */
+  async deleteQueue(queueName) {
+    const { logger } = this.options;
+    const result = await this.mqClient.deleteQueue(queueName);
+
+    // Remove from ensured queues cache
+    this.ensuredQueues.delete(queueName);
+
+    logger.warn(`Deleted queue ${queueName}`);
+    return result;
+  }
+
+  /**
+   * Reset connection and clear cache
+   */
+  resetConnection() {
+    const { logger } = this.options;
+    this.ensuredQueues.clear();
+    logger.info('Connection reset, cleared queue cache');
+  }
+}
+
+module.exports = QueueManager;

package/src/retryHandler.js

@@ -0,0 +1,186 @@
+'use strict';
+
+/**
+ * RetryHandler - Handles retry logic with exponential backoff
+ */
+
+class RetryHandler {
+  constructor(options = {}) {
+    this.options = {
+      maxAttempts: options.maxAttempts || 3,
+      baseDelay: options.baseDelay || 1000,
+      maxDelay: options.maxDelay || 30000,
+      backoffMultiplier: options.backoffMultiplier || 2,
+      logger: options.logger || console,
+      ...options
+    };
+
+    this.attempts = new Map();
+  }
+
+  /**
+   * Check if retry should be attempted
+   * @param {string} identifier - Unique identifier for the retry
+   * @param {Object} options - Override options
+   * @returns {boolean}
+   */
+  shouldRetry(identifier, options = {}) {
+    const { logger } = this.options;
+    const maxAttempts = options.maxAttempts || this.options.maxAttempts;
+
+    // Check for non-retryable error
+    if (options.error && options.error.retryable === false) {
+      return false;
+    }
+
+    // Get current attempt count
+    const record = this.attempts.get(identifier);
+    const currentAttempts = record ? record.count : 0;
+
+    const shouldRetry = currentAttempts < maxAttempts;
+
+    logger.debug(`Retry check for ${identifier}: attempts=${currentAttempts}, max=${maxAttempts}, shouldRetry=${shouldRetry}`);
+
+    return shouldRetry;
+  }
+
+  /**
+   * Get retry delay with exponential backoff
+   * @param {string} identifier - Unique identifier
+   * @param {Object} options - Override options
+   * @returns {number} Delay in milliseconds
+   */
+  getRetryDelay(identifier, options = {}) {
+    const baseDelay = options.baseDelay || this.options.baseDelay;
+    const maxDelay = this.options.maxDelay;
+    const backoffMultiplier = this.options.backoffMultiplier;
+    const jitter = options.jitter || false;
+
+    const record = this.attempts.get(identifier);
+    const attemptNumber = record ? record.count : 1;
+
+    // Calculate exponential backoff delay
+    let delay = baseDelay * Math.pow(backoffMultiplier, attemptNumber - 1);
+
+    // Cap at max delay
+    delay = Math.min(delay, maxDelay);
+
+    // Add jitter if requested
+    if (jitter) {
+      const jitterAmount = delay * 0.1 * Math.random();
+      delay = delay + jitterAmount;
+    }
+
+    return Math.floor(delay);
+  }
+
+  /**
+   * Record an attempt
+   * @param {string} identifier - Unique identifier
+   * @param {Object} context - Additional context
+   */
+  recordAttempt(identifier, context = {}) {
+    const { logger } = this.options;
+    const now = Date.now();
+
+    let record = this.attempts.get(identifier);
+    if (!record) {
+      record = { count: 0, firstAttempt: now, lastAttempt: now };
+    }
+
+    record.count += 1;
+    record.lastAttempt = now;
+
+    if (context.error) {
+      record.lastError = context.error;
+    }
+
+    this.attempts.set(identifier, record);
+
+    logger.debug(`Recording attempt ${record.count} for ${identifier}`);
+  }
+
+  /**
+   * Reset retry state for identifier
+   * @param {string} identifier - Unique identifier
+   */
+  reset(identifier) {
+    const { logger } = this.options;
+    this.attempts.delete(identifier);
+    logger.debug(`Reset retry state for ${identifier}`);
+  }
+
+  /**
+   * Reset all retry states
+   */
+  resetAll() {
+    const { logger } = this.options;
+    this.attempts.clear();
+    logger.info('Reset all retry states');
+  }
+
+  /**
+   * Get attempt count for identifier
+   * @param {string} identifier - Unique identifier
+   * @returns {number}
+   */
+  getAttemptCount(identifier) {
+    const record = this.attempts.get(identifier);
+    return record ? record.count : 0;
+  }
+
+  /**
+   * Execute function with retry logic
+   * @param {string} identifier - Unique identifier
+   * @param {Function} fn - Function to execute
+   * @param {Object} options - Override options
+   * @returns {Promise<*>}
+   */
+  async executeWithRetry(identifier, fn, options = {}) {
+    const { logger } = this.options;
+    const maxAttempts = options.maxAttempts || this.options.maxAttempts;
+
+    let lastError;
+    let attempts = 0;
+
+    while (attempts < maxAttempts) {
+      try {
+        const result = await fn();
+        return result;
+      } catch (error) {
+        attempts++;
+        lastError = error;
+        this.recordAttempt(identifier, { error });
+
+        if (attempts < maxAttempts) {
+          const delay = this.getRetryDelay(identifier, options);
+          logger.warn(`Retry attempt ${attempts + 1} for ${identifier} in ${delay}ms`);
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+      }
+    }
+
+    throw lastError;
+  }
+
+  /**
+   * Cleanup old attempts
+   * @param {number} maxAge - Maximum age in milliseconds
+   */
+  cleanup(maxAge = 3600000) { // Default 1 hour
+    const { logger } = this.options;
+    const now = Date.now();
+    let cleaned = 0;
+
+    for (const [identifier, record] of this.attempts.entries()) {
+      if (now - record.lastAttempt > maxAge) {
+        this.attempts.delete(identifier);
+        cleaned++;
+      }
+    }
+
+    logger.debug(`Cleaned up ${cleaned} old retry records`);
+  }
+}
+
+module.exports = RetryHandler;

package/src/router.js

@@ -0,0 +1,207 @@
+'use strict';
+
+/**
+ * CookbookRouter - Main routing class for workflow messages
+ */
+
+const ServiceDiscovery = require('./serviceDiscovery');
+const QueueManager = require('./queueManager');
+const RetryHandler = require('./retryHandler');
+
+class CookbookRouter {
+  constructor(mqClient, registryClient, options = {}) {
+    this.mqClient = mqClient;
+    this.registryClient = registryClient;
+    this.options = {
+      defaultQueue: 'workflow.init',
+      completedQueue: 'workflow.completed',
+      dlqSuffix: '.dlq',
+      maxRetries: 3,
+      retryDelay: 2000,
+      logger: console,
+      ...options
+    };
+
+    this.serviceDiscovery = new ServiceDiscovery(registryClient, options);
+    this.queueManager = new QueueManager(mqClient, options);
+    this.retryHandler = new RetryHandler(options);
+  }
+
+  /**
+   * Route workflow to the first service
+   * @param {Object} cookbook - Cookbook definition
+   * @param {Object} context - Workflow context
+   * @returns {Promise<void>}
+   */
+  async routeWorkflow(cookbook, context) {
+    const { logger } = this.options;
+
+    // Find first step
+    const firstStep = cookbook.steps?.[0];
+    if (!firstStep) {
+      throw new Error('No steps defined in cookbook');
+    }
+
+    // Determine target service
+    const targetService = await this.determineTargetService(firstStep);
+
+    // Build workflow message
+    const message = this.buildWorkflowMessage(cookbook, context, firstStep, targetService);
+
+    // Send to service queue
+    const queueName = `${targetService}.workflow`;
+    logger.info(`Routing workflow to ${queueName}`);
+
+    await this.queueManager.publish(queueName, message);
+  }
+
+  /**
+   * Route to next service in workflow
+   * @param {Object} cookbook - Cookbook definition
+   * @param {Object} context - Current context
+   * @param {string} currentStepId - Current step ID
+   * @returns {Promise<void>}
+   */
+  async routeToNextService(cookbook, context, currentStepId) {
+    const { logger } = this.options;
+
+    // Find current step index
+    const currentIndex = cookbook.steps.findIndex(s => s.id === currentStepId);
+    if (currentIndex === -1) {
+      throw new Error(`Step not found: ${currentStepId}`);
+    }
+
+    // Check if there's a next step
+    const nextStep = cookbook.steps[currentIndex + 1];
+    if (!nextStep) {
+      // Workflow completed
+      logger.info('Workflow completed, routing to completed queue');
+      return this.routeToCompleted(cookbook, context);
+    }
+
+    // Determine target service for next step
+    const targetService = await this.determineTargetService(nextStep);
+
+    // Build message for next step
+    const message = this.buildWorkflowMessage(cookbook, context, nextStep, targetService);
+
+    // Send to next service
+    const queueName = `${targetService}.workflow`;
+    logger.info(`Routing to next service: ${queueName}`);
+
+    await this.queueManager.publish(queueName, message);
+  }
+
+  /**
+   * Route completed workflow
+   * @param {Object} cookbook - Cookbook definition
+   * @param {Object} context - Final context
+   * @returns {Promise<void>}
+   */
+  async routeToCompleted(cookbook, context) {
+    const message = {
+      workflow_id: context.workflow_id,
+      cookbook_id: cookbook.id,
+      status: 'completed',
+      result: context.result || {},
+      trace: context.trace || [],
+      completed_at: new Date().toISOString()
+    };
+
+    await this.queueManager.publish(this.options.completedQueue, message);
+  }
+
+  /**
+   * Route failed workflow to DLQ
+   * @param {Object} cookbook - Cookbook definition
+   * @param {Object} context - Context at failure
+   * @param {Error} error - Error that caused failure
+   * @param {string} service - Service that failed
+   * @returns {Promise<void>}
+   */
+  async routeToDLQ(cookbook, context, error, service) {
+    const { logger } = this.options;
+
+    const dlqName = `${service}${this.options.dlqSuffix}`;
+    logger.error(`Routing to DLQ: ${dlqName}`, error);
+
+    const message = {
+      workflow_id: context.workflow_id,
+      cookbook_id: cookbook.id,
+      service,
+      error: {
+        message: error.message,
+        stack: error.stack,
+        code: error.code
+      },
+      context,
+      failed_at: new Date().toISOString()
+    };
+
+    await this.queueManager.publish(dlqName, message);
+  }
+
+  /**
+   * Determine target service for a step
+   * @private
+   */
+  async determineTargetService(step) {
+    if (step.type === 'task' && step.service) {
+      // Verify service is available
+      const isAvailable = await this.serviceDiscovery.isServiceAvailable(step.service);
+      if (!isAvailable) {
+        throw new Error(`Service not available: ${step.service}`);
+      }
+      return step.service;
+    }
+
+    // Control flow steps go to orchestrator
+    if (['foreach', 'switch', 'fork_join'].includes(step.type)) {
+      return 'workflow.orchestrator';
+    }
+
+    throw new Error(`Unknown step type: ${step.type}`);
+  }
+
+  /**
+   * Build workflow message
+   * @private
+   */
+  buildWorkflowMessage(cookbook, context, step, targetService) {
+    return {
+      workflow_id: context.workflow_id,
+      cookbook,
+      context,
+      step,
+      target_service: targetService,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Handle retry logic for steps
+   * @param {Object} step - Step to retry
+   * @param {Object} context - Current context
+   * @returns {Promise<boolean>}
+   */
+  async handleRetry(step, context) {
+    const stepId = step.id;
+    const attempts = context.attempts?.[stepId] || 0;
+
+    // Check if should retry
+    const shouldRetry = this.retryHandler.shouldRetry(stepId, { attempts });
+
+    if (shouldRetry) {
+      // Record attempt
+      this.retryHandler.recordAttempt(stepId);
+
+      // Apply delay
+      const delay = this.retryHandler.getRetryDelay(stepId);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+
+    return shouldRetry;
+  }
+}
+
+module.exports = CookbookRouter;

package/src/serviceDiscovery.js

@@ -0,0 +1,174 @@
+'use strict';
+
+/**
+ * ServiceDiscovery - Service discovery and health checking
+ */
+
+class ServiceDiscovery {
+  constructor(registryClient, options = {}) {
+    this.registryClient = registryClient;
+    this.options = {
+      cacheEnabled: options.cacheEnabled !== false,
+      cacheTTL: options.cacheTTL || 300000, // 5 minutes default
+      logger: options.logger || console,
+      ...options
+    };
+
+    this.cache = new Map();
+  }
+
+  /**
+   * Check if a service is available
+   * @param {string} serviceName - Service name
+   * @returns {Promise<boolean>}
+   */
+  async isServiceAvailable(serviceName) {
+    try {
+      // Check cache first if enabled
+      if (this.options.cacheEnabled) {
+        const cached = this.getCached(serviceName);
+        if (cached !== null) {
+          return cached.status === 'active';
+        }
+      }
+
+      const service = await this.registryClient.getService(serviceName);
+
+      if (service && this.options.cacheEnabled) {
+        this.setCached(serviceName, service);
+      }
+
+      return service && service.status === 'active';
+    } catch (error) {
+      // Handle specific error codes
+      if (error.code === 'ECONNREFUSED') {
+        this.options.logger.error('Registry connection failed', { serviceName, error });
+      } else {
+        this.options.logger.error(`Service discovery failed for ${serviceName}:`, error);
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Get service information
+   * @param {string} serviceName - Service name
+   * @returns {Promise<Object>}
+   */
+  async getServiceInfo(serviceName) {
+    this.options.logger.debug(`Getting service info for ${serviceName}`);
+
+    try {
+      // Check cache first if enabled
+      if (this.options.cacheEnabled) {
+        const cached = this.getCached(serviceName);
+        if (cached !== null) {
+          return cached;
+        }
+      }
+
+      const service = await this.registryClient.getService(serviceName);
+
+      if (!service) {
+        throw new Error(`Service not found: ${serviceName}`);
+      }
+
+      if (this.options.cacheEnabled) {
+        this.setCached(serviceName, service);
+      }
+
+      return service;
+    } catch (error) {
+      this.options.logger.error(`Failed to get service info for ${serviceName}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * List available services
+   * @returns {Promise<Array>}
+   */
+  async listAvailableServices() {
+    try {
+      const services = await this.registryClient.listServices();
+      return services
+        .filter(service => service.status === 'active')
+        .map(service => service.name);
+    } catch (error) {
+      this.options.logger.error('Failed to list services:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get service queue name
+   * @param {string} serviceName - Service name
+   * @param {Object} options - Options
+   * @returns {Promise<string>}
+   */
+  async getServiceQueue(serviceName, options = {}) {
+    const serviceInfo = await this.getServiceInfo(serviceName);
+
+    if (serviceInfo.endpoints && serviceInfo.endpoints.workflow) {
+      return serviceInfo.endpoints.workflow;
+    }
+
+    if (options.useDefault) {
+      return `${serviceName}.workflow`;
+    }
+
+    throw new Error(`No workflow queue defined for service: ${serviceName}`);
+  }
+
+  /**
+   * Invalidate cache
+   * @param {string} serviceName - Service name (optional)
+   */
+  invalidateCache(serviceName) {
+    if (serviceName) {
+      this.cache.delete(serviceName);
+      this.options.logger.debug(`Invalidating cache for ${serviceName}`);
+    } else {
+      this.cache.clear();
+      this.options.logger.debug('Invalidating entire cache');
+    }
+  }
+
+  /**
+   * Get cached service data
+   * @private
+   */
+  getCached(serviceName) {
+    if (!this.options.cacheEnabled) {
+      return null;
+    }
+
+    const cached = this.cache.get(serviceName);
+
+    if (!cached) {
+      return null;
+    }
+
+    const age = Date.now() - cached.timestamp;
+    if (age > this.options.cacheTTL) {
+      this.cache.delete(serviceName);
+      return null;
+    }
+
+    return cached.data;
+  }
+
+  /**
+   * Set cached service data
+   * @private
+   */
+  setCached(serviceName, data) {
+    this.cache.set(serviceName, {
+      data,
+      timestamp: Date.now()
+    });
+  }
+
+}
+
+module.exports = ServiceDiscovery;