@onlineapps/mq-client-core 1.0.14 → 1.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/mq-client-core",
-  "version": "1.0.14",
+  "version": "1.0.15",
   "description": "Core MQ client library for RabbitMQ - shared by infrastructure services and connectors",
   "main": "src/index.js",
   "scripts": {

package/src/config/queueConfig.js

@@ -0,0 +1,272 @@
+'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.
+ * 
+ * NOTE: This is part of mq-client-core (spodní vrstva) because it's used by both:
+ * - Infrastructure services (via mq-client-core)
+ * - Business services (via conn-infra-mq connector)
+ */
+
+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/utils/initInfrastructureQueues.js

@@ -21,12 +21,14 @@
 async function initInfrastructureQueues(channel, options = {}) {
   const logger = options.logger || console;
   
-  // Load queueConfig from @onlineapps/conn-infra-mq
-  let queueConfig;
-  try {
-    queueConfig = require('@onlineapps/conn-infra-mq/src/config/queueConfig');
-  } catch (requireError) {
-    throw new Error(`Cannot load queueConfig from @onlineapps/conn-infra-mq: ${requireError.message}. Make sure @onlineapps/conn-infra-mq is installed.`);
+  // Load queueConfig - either from options or try to load from @onlineapps/conn-infra-mq
+  let queueConfig = options.queueConfig;
+  if (!queueConfig) {
+    try {
+      queueConfig = require('@onlineapps/conn-infra-mq/src/config/queueConfig');
+    } catch (requireError) {
+      throw new Error(`Cannot load queueConfig. Either provide queueConfig in options, or ensure @onlineapps/conn-infra-mq is installed: ${requireError.message}`);
+    }
   }
 
   const queuesToCreate = options.queues || [