@onlineapps/mq-client-core 1.0.22 → 1.0.25

package/package.json

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

package/src/BaseClient.js

@@ -32,6 +32,11 @@ class BaseClient {
 
     // Merge user config with defaults
     this._config = merge({}, defaultConfig, config || {});
+    this._config.heartbeat =
+      this._config.heartbeat ?? Number(process.env.RABBITMQ_HEARTBEAT || 30);
+    this._config.connectionName =
+      this._config.connectionName ||
+      `${process.env.SERVICE_NAME || 'oa-service'}:${process.pid}`;
 
     // Validate merged config
     const valid = validate(this._config);
@@ -46,6 +51,8 @@ class BaseClient {
     this._transport = null;
     this._connected = false;
     this._errorHandlers = [];
+
+    BaseClient._registerInstance(this);
   }
 
   /**
@@ -60,6 +67,11 @@ class BaseClient {
     console.log(`[BaseClient] Starting connect() with config:`, JSON.stringify({ type: this._config.type, host: this._config.host }));
     // Merge overrides into existing config
     this._config = merge({}, this._config, options);
+    this._config.heartbeat =
+      this._config.heartbeat ?? Number(process.env.RABBITMQ_HEARTBEAT || 30);
+    this._config.connectionName =
+      this._config.connectionName ||
+      `${process.env.SERVICE_NAME || 'oa-service'}:${process.pid}`;
 
     try {
       console.log(`[BaseClient] Creating transport...`);
@@ -90,6 +102,7 @@ class BaseClient {
       await this._transport.disconnect();
       this._connected = false;
       this._transport = null;
+      BaseClient._unregisterInstance(this);
     } catch (err) {
       throw new Error(`Error during disconnect: ${err.message}`);
     }
@@ -243,3 +256,44 @@ class BaseClient {
 
 module.exports = BaseClient;
 
+BaseClient._instances = new Set();
+BaseClient._cleanupRegistered = false;
+BaseClient._cleanupRunning = false;
+
+BaseClient._registerInstance = function registerInstance(instance) {
+  BaseClient._instances.add(instance);
+  if (!BaseClient._cleanupRegistered) {
+    BaseClient._registerCleanupHooks();
+  }
+};
+
+BaseClient._unregisterInstance = function unregisterInstance(instance) {
+  BaseClient._instances.delete(instance);
+};
+
+BaseClient._registerCleanupHooks = function registerCleanupHooks() {
+  const handler = async (signal) => {
+    if (BaseClient._cleanupRunning) return;
+    BaseClient._cleanupRunning = true;
+    const disconnects = Array.from(BaseClient._instances).map((instance) =>
+      instance
+        .disconnect()
+        .catch((err) =>
+          console.warn('[BaseClient] Failed to disconnect during shutdown:', err.message)
+        )
+    );
+    await Promise.allSettled(disconnects);
+    BaseClient._instances.clear();
+    BaseClient._cleanupRunning = false;
+    if (signal && signal !== 'beforeExit') {
+      process.exit(0); // eslint-disable-line no-process-exit
+    }
+  };
+
+  ['SIGINT', 'SIGTERM'].forEach((sig) => {
+    process.on(sig, () => handler(sig));
+  });
+  process.on('beforeExit', () => handler('beforeExit'));
+  BaseClient._cleanupRegistered = true;
+};
+

package/src/config/queueConfig.js

@@ -113,6 +113,22 @@ module.exports = {
     }
   },
 
+  /**
+   * Infrastructure health tracking queue configurations
+   */
+  infrastructure: {
+    /**
+     * infrastructure.health.checks - Health check messages from infrastructure services
+     */
+    'health.checks': {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 10000,       // 10 seconds TTL (prevent stale data)
+        'x-max-length': 1000
+      }
+    }
+  },
+
   /**
    * Registry infrastructure queue configurations
    */
@@ -197,7 +213,10 @@ module.exports = {
    * @returns {boolean} True if infrastructure queue
    */
   isInfrastructureQueue(queueName) {
-    return queueName.startsWith('workflow.') || queueName.startsWith('registry.');
+    return queueName.startsWith('workflow.') || 
+           queueName.startsWith('registry.') || 
+           queueName.startsWith('infrastructure.') ||
+           queueName.startsWith('validation.');
   },
 
   /**
@@ -255,9 +274,23 @@ module.exports = {
     return config;
   },
 
+  /**
+   * Get infrastructure health queue configuration
+   * @param {string} queueName - Queue name (e.g., 'infrastructure.health.checks')
+   * @returns {Object} Queue configuration
+   */
+  getInfrastructureHealthQueueConfig(queueName) {
+    const parts = queueName.split('.');
+    if (parts.length < 2 || parts[0] !== 'infrastructure') {
+      throw new Error(`Invalid infrastructure health queue name: ${queueName}. Expected format: infrastructure.{name}`);
+    }
+    const name = parts.slice(1).join('.');
+    return this.getQueueConfig('infrastructure', name);
+  },
+
   /**
    * Get infrastructure queue configuration by queue name (auto-detect type)
-   * @param {string} queueName - Full queue name (e.g., 'workflow.init', 'registry.register')
+   * @param {string} queueName - Full queue name (e.g., 'workflow.init', 'registry.register', 'infrastructure.health.checks')
    * @returns {Object} Queue configuration
    */
   getInfrastructureQueueConfig(queueName) {
@@ -265,8 +298,10 @@ module.exports = {
       return this.getWorkflowQueueConfig(queueName);
     } else if (queueName.startsWith('registry.')) {
       return this.getRegistryQueueConfig(queueName);
+    } else if (queueName.startsWith('infrastructure.')) {
+      return this.getInfrastructureHealthQueueConfig(queueName);
     } else {
-      throw new Error(`Queue ${queueName} is not an infrastructure queue. Infrastructure queues must start with 'workflow.' or 'registry.'`);
+      throw new Error(`Queue ${queueName} is not an infrastructure queue. Infrastructure queues must start with 'workflow.', 'registry.', or 'infrastructure.'`);
     }
   }
 };

package/src/index.js

@@ -5,6 +5,9 @@
  * 
  * Core MQ client library for RabbitMQ - shared by infrastructure services and connectors.
  * Provides basic publish/consume functionality without business-specific features.
+ * 
+ * NOTE: Infrastructure orchestration utilities (waitForInfrastructureReady, initInfrastructureQueues)
+ * have been moved to @onlineapps/infrastructure-tools to keep this library focused on core MQ operations.
  */
 
 const BaseClient = require('./BaseClient');
@@ -16,16 +19,14 @@ const {
   ConsumeError,
   SerializationError,
 } = require('./utils/errorHandler');
-const { initInfrastructureQueues } = require('./utils/initInfrastructureQueues');
 
 // Export BaseClient as default (constructor), with additional named exports
-// NOTE: When destructuring, use: const { initInfrastructureQueues } = require('@onlineapps/mq-client-core');
+// NOTE: When destructuring, use: const { BaseClient } = require('@onlineapps/mq-client-core');
 // When using default, use: const BaseClient = require('@onlineapps/mq-client-core');
 // BaseClient must be a constructor, so we export it directly and attach other exports as properties
 module.exports = BaseClient;
 module.exports.BaseClient = BaseClient;
 module.exports.RabbitMQClient = RabbitMQClient;
-module.exports.initInfrastructureQueues = initInfrastructureQueues;
 module.exports.errors = {
   ValidationError,
   ConnectionError,

package/src/transports/rabbitmqClient.js

@@ -43,6 +43,13 @@ class RabbitMQClient extends EventEmitter {
   get channel() {
     return this._channel;
   }
+
+  /**
+   * Getter for underlying connection
+   */
+  get connection() {
+    return this._connection;
+  }
   
   /**
    * Getter for queue channel - regular channel for queue operations
@@ -59,15 +66,25 @@ class RabbitMQClient extends EventEmitter {
    */
   async connect() {
     try {
-      console.log(`[RabbitMQClient] Attempting to connect to: ${this._config.host}`);
-      // Add connection timeout to prevent hanging
-      const connectPromise = amqp.connect(this._config.host);
+      const rawTarget = this._config.host || this._config.url;
+      const heartbeat = this._config.heartbeat ?? 30;
+      const connectionName =
+        this._config.connectionName ||
+        this._config.clientName ||
+        `oa-client:${process.env.SERVICE_NAME || 'unknown'}:${process.pid}`;
+
+      console.log(`[RabbitMQClient] Attempting to connect to: ${rawTarget}`);
+      const connectArgs = typeof rawTarget === 'string'
+        ? [rawTarget, { heartbeat, clientProperties: { connection_name: connectionName } }]
+        : [{ ...rawTarget, heartbeat, clientProperties: { connection_name: connectionName } }];
+
+      const connectPromise = amqp.connect(...connectArgs);
       const timeoutPromise = new Promise((_, reject) => {
         setTimeout(() => reject(new Error('Connection timeout after 10 seconds')), 10000);
       });
-      console.log(`[RabbitMQClient] Starting connection race...`);
+      console.log('[RabbitMQClient] Starting connection race...');
       this._connection = await Promise.race([connectPromise, timeoutPromise]);
-      console.log(`[RabbitMQClient] Connection established`);
+      console.log('[RabbitMQClient] Connection established');
       this._connection.on('error', (err) => this.emit('error', err));
       this._connection.on('close', () => {
         // Emit a connection close error to notify listeners

package/src/utils/initInfrastructureQueues.js

@@ -1,98 +0,0 @@
-'use strict';
-
-/**
- * initInfrastructureQueues.js
- * 
- * Utility for infrastructure services to initialize infrastructure queues.
- * Uses queueConfig from @onlineapps/conn-infra-mq for configuration.
- * 
- * NOTE: This is for infrastructure services (gateway, monitoring, etc.)
- * Business services should use @onlineapps/conn-infra-mq connector instead.
- */
-
-/**
- * Initialize all infrastructure queues
- * @param {Object} channel - RabbitMQ channel
- * @param {Object} options - Options
- * @param {Array<string>} [options.queues] - Specific queues to create (default: all infrastructure queues)
- * @param {Object} [options.logger] - Logger instance (default: console)
- * @returns {Promise<void>}
- */
-async function initInfrastructureQueues(channel, options = {}) {
-  const logger = options.logger || console;
-  
-  // Load queueConfig from mq-client-core (spodní vrstva)
-  // NOTE: queueConfig is part of mq-client-core because it's used by both:
-  // - Infrastructure services (via mq-client-core)
-  // - Business services (via conn-infra-mq connector)
-  const queueConfig = options.queueConfig || require('../config/queueConfig');
-
-  const queuesToCreate = options.queues || [
-    // Workflow infrastructure queues
-    'workflow.init',
-    'workflow.completed',
-    'workflow.failed',
-    'workflow.dlq',
-    // Registry infrastructure queues
-    'registry.register',
-    'registry.heartbeats'
-  ];
-
-  logger.log(`[QueueInit] Initializing ${queuesToCreate.length} infrastructure queues...`);
-
-  for (const queueName of queuesToCreate) {
-    try {
-      // Verify it's an infrastructure queue
-      if (!queueConfig.isInfrastructureQueue(queueName)) {
-        logger.warn(`[QueueInit] Skipping ${queueName} - not an infrastructure queue`);
-        continue;
-      }
-
-      // Get unified configuration
-      const config = queueConfig.getInfrastructureQueueConfig(queueName);
-      
-      // CRITICAL: Check if queue exists with different arguments (406 error)
-      // If so, delete it and recreate with correct parameters
-      try {
-        await channel.assertQueue(queueName, {
-          durable: config.durable !== false,
-          arguments: { ...config.arguments }
-        });
-        logger.log(`[QueueInit] ✓ Created/verified infrastructure queue: ${queueName}`);
-      } catch (assertError) {
-        if (assertError.code === 406) {
-          // Queue exists with different arguments - delete and recreate
-          logger.warn(`[QueueInit] ⚠ Queue ${queueName} exists with different arguments - deleting and recreating...`);
-          try {
-            await channel.deleteQueue(queueName);
-            logger.log(`[QueueInit] ✓ Deleted queue ${queueName} with incorrect parameters`);
-          } catch (deleteError) {
-            logger.error(`[QueueInit] ✗ Failed to delete queue ${queueName}:`, deleteError.message);
-            throw new Error(`Cannot delete queue ${queueName} with incorrect parameters: ${deleteError.message}`);
-          }
-          
-          // Recreate with correct parameters
-          await channel.assertQueue(queueName, {
-            durable: config.durable !== false,
-            arguments: { ...config.arguments }
-          });
-          logger.log(`[QueueInit] ✓ Recreated infrastructure queue: ${queueName} with correct parameters`);
-        } else {
-          // Other error - rethrow
-          logger.error(`[QueueInit] ✗ Failed to create ${queueName}:`, assertError.message);
-          throw assertError;
-        }
-      }
-    } catch (error) {
-      logger.error(`[QueueInit] ✗ Failed to initialize queue ${queueName}:`, error.message);
-      throw error;
-    }
-  }
-
-  logger.log(`[QueueInit] Infrastructure queues initialization complete`);
-}
-
-module.exports = {
-  initInfrastructureQueues
-};
-