@onlineapps/mq-client-core 1.0.22 → 1.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/mq-client-core",
-  "version": "1.0.22",
+  "version": "1.0.23",
   "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/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

@@ -19,7 +19,12 @@
  * @returns {Promise<void>}
  */
 async function initInfrastructureQueues(channel, options = {}) {
+  if (!channel) {
+    throw new Error('initInfrastructureQueues requires a valid channel');
+  }
+
   const logger = options.logger || console;
+  const connection = options.connection || channel.connection;
   
   // Load queueConfig from mq-client-core (spodní vrstva)
   // NOTE: queueConfig is part of mq-client-core because it's used by both:
@@ -38,6 +43,35 @@ async function initInfrastructureQueues(channel, options = {}) {
     'registry.heartbeats'
   ];
 
+  const watchChannel = (ch) => {
+    if (!ch) return ch;
+    if (!ch.__queueInitLinked) {
+      ch.__queueInitLinked = true;
+      ch.once('close', () => {
+        ch.__queueInitClosed = true;
+        logger.warn('[QueueInit] Queue channel closed');
+      });
+      ch.on('error', (err) => {
+        ch.__queueInitClosed = true;
+        logger.warn(`[QueueInit] Queue channel error: ${err.message}`);
+      });
+    }
+    return ch;
+  };
+
+  let workingChannel = watchChannel(channel);
+
+  const getChannel = async (forceNew = false) => {
+    if (!forceNew && workingChannel && !workingChannel.__queueInitClosed) {
+      return workingChannel;
+    }
+    if (!connection) {
+      throw new Error('Queue channel closed and no connection reference available to recreate it');
+    }
+    workingChannel = watchChannel(await connection.createChannel());
+    return workingChannel;
+  };
+
   logger.log(`[QueueInit] Initializing ${queuesToCreate.length} infrastructure queues...`);
 
   for (const queueName of queuesToCreate) {
@@ -53,32 +87,43 @@ async function initInfrastructureQueues(channel, options = {}) {
       
       // CRITICAL: Check if queue exists with different arguments (406 error)
       // If so, delete it and recreate with correct parameters
-      try {
-        await channel.assertQueue(queueName, {
+      const ensureQueue = async () => {
+        const activeChannel = await getChannel();
+        return activeChannel.assertQueue(queueName, {
           durable: config.durable !== false,
           arguments: { ...config.arguments }
         });
+      };
+
+      try {
+        await ensureQueue();
         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...`);
+          logger.warn(
+            `[QueueInit] ⚠ Queue ${queueName} exists with different arguments - deleting and recreating...`
+          );
           try {
-            await channel.deleteQueue(queueName);
+            const deleteChannel = await getChannel(true);
+            await deleteChannel.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}`);
+            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`);
+
+          // Recreate with correct parameters (force fresh channel to avoid closed state)
+          await getChannel(true);
+          await ensureQueue();
+          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;
         }