@onlineapps/conn-infra-mq 1.1.3 → 1.1.5

package/README.md

@@ -1,8 +1,8 @@
-# @onlineapps/connector-mq-client
+# @onlineapps/conn-infra-mq
 
-[![Build Status](https://img.shields.io/github/actions/workflow/status/onlineapps/connector-mq-client/nodejs.yml?branch=main)](https://github.com/onlineapps/connector-mq-client/actions)
-[![Coverage Status](https://codecov.io/gh/onlineapps/connector-mq-client/branch/main/graph/badge.svg)](https://codecov.io/gh/onlineapps/connector-mq-client)
-[![npm version](https://img.shields.io/npm/v/@onlineapps/connector-mq-client)](https://www.npmjs.com/package/@onlineapps/connector-mq-client)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/onlineapps/conn-infra-mq/nodejs.yml?branch=main)](https://github.com/onlineapps/conn-infra-mq/actions)
+[![Coverage Status](https://codecov.io/gh/onlineapps/conn-infra-mq/branch/main/graph/badge.svg)](https://codecov.io/gh/onlineapps/conn-infra-mq)
+[![npm version](https://img.shields.io/npm/v/@onlineapps/conn-infra-mq)](https://www.npmjs.com/package/@onlineapps/conn-infra-mq)
 
 > Message queue connector with **layered architecture** for workflow orchestration, RPC, fork-join, and retry patterns. Built on top of RabbitMQ with clean separation of concerns.
 
@@ -26,9 +26,9 @@
 ## 📦 Installation
 
 ```bash
-npm install @onlineapps/connector-mq-client
+npm install @onlineapps/conn-infra-mq
 # or
-yarn add @onlineapps/connector-mq-client
+yarn add @onlineapps/conn-infra-mq
 ````
 
 > Requires Node.js ≥12. For RabbitMQ usage, ensure an accessible AMQP server.
@@ -52,7 +52,7 @@ ConnectorMQClient (main orchestrator)
 ```js
 'use strict';
 
-const ConnectorMQClient = require('@onlineapps/connector-mq-client');
+const ConnectorMQClient = require('@onlineapps/conn-infra-mq');
 
 (async () => {
   // 1. Create client with configuration

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@onlineapps/conn-infra-mq",
-    "version": "1.1.3",
+    "version": "1.1.5",
     "description": "A promise-based, broker-agnostic client for sending and receiving messages via RabbitMQ",
     "main": "src/index.js",
     "repository": {
@@ -21,9 +21,9 @@
         "test:integration:required": "REQUIRE_SERVICES=true jest --config=jest.integration.config.js",
         "test:watch": "jest --watch",
         "test:coverage": "jest --coverage --coverageReporters=text-lcov html",
-        "lint": "eslint \"src/**/*.js\" \"test/**/*.js\"",
-        "prettier:check": "prettier --check \"src/**/*.js\" \"test/**/*.js\"",
-        "prettier:fix": "prettier --write \"src/**/*.js\" \"test/**/*.js\""
+        "lint": "eslint \"src/**/*.js\" \"tests/**/*.js\"",
+        "prettier:check": "prettier --check \"src/**/*.js\" \"tests/**/*.js\"",
+        "prettier:fix": "prettier --write \"src/**/*.js\" \"tests/**/*.js\""
     },
     "keywords": [
         "connector",

package/src/config/queueConfig.js

@@ -0,0 +1,269 @@
+'use strict';
+
+/**
+ * queueConfig.js
+ *
+ * Central configuration for INFRASTRUCTURE queues only.
+ * Business queues ({service}.workflow, {service}.queue, {service}.dlq) are created
+ * by individual services via QueueManager.setupServiceQueues().
+ *
+ * This ensures consistent configuration for infrastructure queues across all services.
+ */
+
+module.exports = {
+  /**
+   * Workflow infrastructure queue configurations
+   * These are shared infrastructure queues used by all services
+   */
+  workflow: {
+    /**
+     * workflow.init - Entry point for all workflows
+     * All services listen as competing consumers
+     */
+    init: {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 300000,      // 5 minutes TTL
+        'x-max-length': 10000          // Max 10k messages
+      }
+    },
+
+    /**
+     * workflow.completed - Completed workflows
+     */
+    completed: {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 300000,      // 5 minutes TTL
+        'x-max-length': 10000
+      }
+    },
+
+    /**
+     * workflow.failed - Failed workflows
+     */
+    failed: {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 300000,      // 5 minutes TTL
+        'x-max-length': 10000
+      }
+    },
+
+    /**
+     * workflow.dlq - Dead letter queue for workflows
+     */
+    dlq: {
+      durable: true,
+      arguments: {
+        // No TTL for DLQ - messages should persist
+        'x-max-length': 50000          // Higher limit for DLQ
+      }
+    }
+  },
+
+  /**
+   * Business queue templates
+   * These are templates for service-specific queues ({service}.workflow, {service}.queue, {service}.dlq)
+   * Used by QueueManager.setupServiceQueues() to ensure consistent configuration
+   */
+  business: {
+    /**
+     * {service}.workflow - Service-specific workflow queue
+     * Used for routing workflow steps to specific services
+     */
+    workflow: {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 300000,      // 5 minutes TTL
+        'x-max-length': 10000,        // Max 10k messages
+        'x-dead-letter-exchange': 'dlx',
+        'x-dead-letter-routing-key': '{service}.dlq'  // Placeholder, replaced with actual service name
+      }
+    },
+
+    /**
+     * {service}.queue - Service main processing queue
+     * Used for direct service-to-service communication
+     */
+    queue: {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 30000,       // 30 seconds TTL
+        'x-max-length': 10000,        // Max 10k messages
+        'x-dead-letter-exchange': 'dlx',
+        'x-dead-letter-routing-key': '{service}.dlq'  // Placeholder, replaced with actual service name
+      }
+    },
+
+    /**
+     * {service}.dlq - Service dead letter queue
+     * Receives failed messages from service.queue and service.workflow
+     */
+    dlq: {
+      durable: true,
+      arguments: {
+        // No TTL for DLQ - messages should persist
+        'x-max-length': 50000         // Higher limit for DLQ
+      }
+    }
+  },
+
+  /**
+   * Registry infrastructure queue configurations
+   */
+  registry: {
+    /**
+     * registry.register - Registration requests
+     */
+    register: {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 60000,       // 1 minute TTL
+        'x-max-length': 1000
+      }
+    },
+
+    /**
+     * registry.heartbeats - Service heartbeats
+     */
+    heartbeats: {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 120000,       // 2 minutes TTL
+        'x-max-length': 5000
+      }
+    },
+
+    /**
+     * registry.changes - Registry event fanout exchange
+     * (This is an exchange, not a queue, but included for reference)
+     */
+    changes: {
+      type: 'exchange',
+      durable: true
+    }
+  },
+
+  /**
+   * Get infrastructure queue configuration by type and name
+   * @param {string} type - Queue type: 'workflow', 'registry'
+   * @param {string} name - Queue name: 'init', 'completed', 'register', etc.
+   * @returns {Object} Queue configuration
+   */
+  getQueueConfig(type, name) {
+    const config = this[type]?.[name];
+    if (!config) {
+      throw new Error(`Infrastructure queue config not found: ${type}.${name}`);
+    }
+
+    // Deep clone to avoid modifying original
+    return JSON.parse(JSON.stringify(config));
+  },
+
+  /**
+   * Get workflow infrastructure queue configuration
+   * @param {string} queueName - Queue name (e.g., 'workflow.init', 'workflow.completed')
+   * @returns {Object} Queue configuration
+   */
+  getWorkflowQueueConfig(queueName) {
+    const parts = queueName.split('.');
+    if (parts.length !== 2 || parts[0] !== 'workflow') {
+      throw new Error(`Invalid workflow queue name: ${queueName}. Expected format: workflow.{name}`);
+    }
+    return this.getQueueConfig('workflow', parts[1]);
+  },
+
+  /**
+   * Get registry infrastructure queue configuration
+   * @param {string} queueName - Queue name (e.g., 'registry.register', 'registry.heartbeats')
+   * @returns {Object} Queue configuration
+   */
+  getRegistryQueueConfig(queueName) {
+    const parts = queueName.split('.');
+    if (parts.length !== 2 || parts[0] !== 'registry') {
+      throw new Error(`Invalid registry queue name: ${queueName}. Expected format: registry.{name}`);
+    }
+    return this.getQueueConfig('registry', parts[1]);
+  },
+
+  /**
+   * Check if queue name is an infrastructure queue
+   * @param {string} queueName - Queue name to check
+   * @returns {boolean} True if infrastructure queue
+   */
+  isInfrastructureQueue(queueName) {
+    return queueName.startsWith('workflow.') || queueName.startsWith('registry.');
+  },
+
+  /**
+   * Check if queue name is a business queue
+   * @param {string} queueName - Queue name to check
+   * @returns {boolean} True if business queue
+   */
+  isBusinessQueue(queueName) {
+    // Business queues follow pattern: {service}.{type}
+    // where type is: workflow, queue, dlq
+    const parts = queueName.split('.');
+    if (parts.length !== 2) return false;
+    return ['workflow', 'queue', 'dlq'].includes(parts[1]);
+  },
+
+  /**
+   * Parse business queue name to extract service name and queue type
+   * @param {string} queueName - Business queue name (e.g., 'hello-service.workflow')
+   * @returns {Object} { serviceName, queueType } or null if not a business queue
+   */
+  parseBusinessQueue(queueName) {
+    if (!this.isBusinessQueue(queueName)) {
+      return null;
+    }
+    const parts = queueName.split('.');
+    return {
+      serviceName: parts[0],
+      queueType: parts[1]
+    };
+  },
+
+  /**
+   * Get business queue configuration template
+   * @param {string} queueType - Queue type: 'workflow', 'queue', 'dlq'
+   * @param {string} serviceName - Service name (replaces {service} placeholder)
+   * @returns {Object} Queue configuration
+   */
+  getBusinessQueueConfig(queueType, serviceName) {
+    const template = this.business?.[queueType];
+    if (!template) {
+      throw new Error(`Business queue template not found: ${queueType}`);
+    }
+
+    // Deep clone to avoid modifying original
+    const config = JSON.parse(JSON.stringify(template));
+
+    // Replace {service} placeholder in routing keys
+    if (config.arguments && serviceName) {
+      const routingKey = config.arguments['x-dead-letter-routing-key'];
+      if (routingKey && typeof routingKey === 'string') {
+        config.arguments['x-dead-letter-routing-key'] = routingKey.replace('{service}', serviceName);
+      }
+    }
+
+    return config;
+  },
+
+  /**
+   * Get infrastructure queue configuration by queue name (auto-detect type)
+   * @param {string} queueName - Full queue name (e.g., 'workflow.init', 'registry.register')
+   * @returns {Object} Queue configuration
+   */
+  getInfrastructureQueueConfig(queueName) {
+    if (queueName.startsWith('workflow.')) {
+      return this.getWorkflowQueueConfig(queueName);
+    } else if (queueName.startsWith('registry.')) {
+      return this.getRegistryQueueConfig(queueName);
+    } else {
+      throw new Error(`Queue ${queueName} is not an infrastructure queue. Infrastructure queues must start with 'workflow.' or 'registry.'`);
+    }
+  }
+};
+

package/src/layers/QueueManager.js

@@ -1,8 +1,13 @@
 'use strict';
 
+const queueConfig = require('../config/queueConfig');
+
 /**
  * QueueManager - Manages queue creation, configuration, and lifecycle
  * Handles TTL, DLQ, auto-delete, and other queue properties
+ * 
+ * For infrastructure queues (workflow.*, registry.*), uses central configuration.
+ * For business queues ({service}.*), uses service-specific configuration.
  */
 class QueueManager {
   constructor(mqClient, config = {}) {
@@ -19,8 +24,11 @@ class QueueManager {
 
   /**
    * Create or ensure queue exists with specific configuration
+   * For infrastructure queues (workflow.*, registry.*), uses central configuration.
+   * For business queues, uses provided options.
+   * 
    * @param {string} queueName - Name of the queue
-   * @param {Object} options - Queue configuration options
+   * @param {Object} options - Queue configuration options (ignored for infrastructure queues)
    */
   async ensureQueue(queueName, options = {}) {
     // Get channel from client's transport
@@ -30,6 +38,57 @@ class QueueManager {
     }
     const channel = transport.channel;
 
+    let queueOptions;
+
+    // Check if this is an infrastructure queue - use central config
+    if (queueConfig.isInfrastructureQueue(queueName)) {
+      try {
+        const infraConfig = queueConfig.getInfrastructureQueueConfig(queueName);
+        queueOptions = {
+          durable: infraConfig.durable !== false,
+          arguments: { ...infraConfig.arguments }
+        };
+      } catch (error) {
+        // If config not found, fall back to provided options
+        console.warn(`[QueueManager] Infrastructure queue config not found for ${queueName}, using provided options:`, error.message);
+        queueOptions = this._buildQueueOptions(queueName, options);
+      }
+    } else if (queueConfig.isBusinessQueue(queueName)) {
+      // Business queue - use central business queue config
+      try {
+        const parsed = queueConfig.parseBusinessQueue(queueName);
+        if (parsed) {
+          const businessConfig = queueConfig.getBusinessQueueConfig(parsed.queueType, parsed.serviceName);
+          queueOptions = {
+            durable: businessConfig.durable !== false,
+            arguments: { ...businessConfig.arguments }
+          };
+        } else {
+          // Fallback to provided options
+          queueOptions = this._buildQueueOptions(queueName, options);
+        }
+      } catch (error) {
+        // If config not found, fall back to provided options
+        console.warn(`[QueueManager] Business queue config not found for ${queueName}, using provided options:`, error.message);
+        queueOptions = this._buildQueueOptions(queueName, options);
+      }
+    } else {
+      // Unknown queue type - use provided options
+      queueOptions = this._buildQueueOptions(queueName, options);
+    }
+
+    // Track managed queue
+    this.managedQueues.add(queueName);
+
+    // Assert the queue
+    return channel.assertQueue(queueName, queueOptions);
+  }
+
+  /**
+   * Build queue options from provided configuration
+   * @private
+   */
+  _buildQueueOptions(queueName, options) {
     const queueOptions = {
       durable: options.durable !== false,
       arguments: {
@@ -63,11 +122,21 @@ class QueueManager {
       queueOptions.arguments['x-max-priority'] = options.maxPriority;
     }
 
-    // Track managed queue
-    this.managedQueues.add(queueName);
+    return queueOptions;
+  }
 
-    // Assert the queue
-    return channel.assertQueue(queueName, queueOptions);
+  /**
+   * Ensure infrastructure queue exists (workflow.*, registry.*)
+   * Uses central configuration from queueConfig
+   * 
+   * @param {string} queueName - Infrastructure queue name (e.g., 'workflow.init', 'registry.register')
+   * @returns {Promise<Object>} Queue assertion result
+   */
+  async ensureInfrastructureQueue(queueName) {
+    if (!queueConfig.isInfrastructureQueue(queueName)) {
+      throw new Error(`Queue ${queueName} is not an infrastructure queue. Use ensureQueue() for business queues.`);
+    }
+    return this.ensureQueue(queueName);
   }
 
   /**

package/src/transports/rabbitmqClient.js

@@ -7,6 +7,7 @@
 
 const amqp = require('amqplib');
 const EventEmitter = require('events');
+const queueConfig = require('../config/queueConfig');
 
 class RabbitMQClient extends EventEmitter {
   /**
@@ -121,7 +122,9 @@ class RabbitMQClient extends EventEmitter {
     try {
       // Ensure queue exists if publishing directly to queue and using default exchange
       if (!exchange) {
-        await this._channel.assertQueue(queue, { durable: this._config.durable });
+        // Use central config for infrastructure queues
+        const queueOptions = this._getQueueOptions(queue);
+        await this._channel.assertQueue(queue, queueOptions);
         this._channel.sendToQueue(queue, buffer, { persistent, headers, routingKey });
       } else {
         // If exchange is specified, assert exchange and publish to it
@@ -157,8 +160,32 @@ class RabbitMQClient extends EventEmitter {
       // Skip assertQueue for reply queues (they're already created with specific settings)
       // Reply queues start with 'rpc.reply.' and are created as non-durable
       if (!queue.startsWith('rpc.reply.')) {
-        // Ensure queue exists
-        await this._channel.assertQueue(queue, { durable });
+        // Use central config for infrastructure queues
+        const queueOptions = this._getQueueOptions(queue, { durable });
+        
+        // Try to assert queue with our config
+        // If it fails with 406 (PRECONDITION-FAILED), queue exists with different args - use it as-is
+        try {
+          await this._channel.assertQueue(queue, queueOptions);
+        } catch (assertErr) {
+          // If queue exists with different arguments (406), use it as-is
+          if (assertErr.code === 406) {
+            console.warn(`[RabbitMQClient] Queue ${queue} exists with different arguments, using as-is:`, assertErr.message);
+            // Try to assert with minimal options (just durable) to verify queue exists
+            try {
+              await this._channel.assertQueue(queue, { durable: durable !== false });
+            } catch (minErr) {
+              // If even minimal assert fails, queue might not exist - log and proceed
+              console.warn(`[RabbitMQClient] Could not assert queue ${queue} with minimal options:`, minErr.message);
+            }
+          } else if (assertErr.code === 404) {
+            // Queue doesn't exist - this shouldn't happen with assertQueue, but handle it
+            throw assertErr;
+          } else {
+            // Other error - rethrow
+            throw assertErr;
+          }
+        }
       }
       // Set prefetch if provided
       if (typeof prefetch === 'number') {
@@ -189,6 +216,56 @@ class RabbitMQClient extends EventEmitter {
     }
   }
 
+  /**
+   * Get queue options - uses central config for infrastructure and business queues
+   * @private
+   * @param {string} queueName - Queue name
+   * @param {Object} [defaultOptions] - Default options if config not found
+   * @returns {Object} Queue options
+   */
+  _getQueueOptions(queueName, defaultOptions = {}) {
+    // Check if this is an infrastructure queue - use central config
+    if (queueConfig.isInfrastructureQueue(queueName)) {
+      try {
+        const infraConfig = queueConfig.getInfrastructureQueueConfig(queueName);
+        return {
+          durable: infraConfig.durable !== false,
+          arguments: { ...infraConfig.arguments }
+        };
+      } catch (error) {
+        // If config not found, fall back to default options
+        console.warn(`[RabbitMQClient] Infrastructure queue config not found for ${queueName}, using default options:`, error.message);
+        return {
+          durable: defaultOptions.durable !== false,
+          ...defaultOptions
+        };
+      }
+    }
+    
+    // Check if this is a business queue - use central business queue config
+    if (queueConfig.isBusinessQueue(queueName)) {
+      try {
+        const parsed = queueConfig.parseBusinessQueue(queueName);
+        if (parsed) {
+          const businessConfig = queueConfig.getBusinessQueueConfig(parsed.queueType, parsed.serviceName);
+          return {
+            durable: businessConfig.durable !== false,
+            arguments: { ...businessConfig.arguments }
+          };
+        }
+      } catch (error) {
+        // If config not found, fall back to default options
+        console.warn(`[RabbitMQClient] Business queue config not found for ${queueName}, using default options:`, error.message);
+      }
+    }
+    
+    // Unknown queue type - use default options
+    return {
+      durable: defaultOptions.durable !== false,
+      ...defaultOptions
+    };
+  }
+
   /**
    * Acknowledges a message.
    * @param {Object} msg - RabbitMQ message object.