@onlineapps/mq-client-core 1.0.69 → 1.0.71

package/package.json

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

package/src/BaseClient.js

@@ -199,6 +199,99 @@ class BaseClient {
     }
   }
 
+  /**
+   * Assert queue existence (delegates to transport).
+   * @param {string} queue - Queue name
+   * @param {Object} [options]
+   * @returns {Promise<Object>}
+   */
+  async assertQueue(queue, options = {}) {
+    if (!this._connected || !this._transport) {
+      throw new ConnectionError('Cannot assertQueue: client is not connected');
+    }
+    if (typeof this._transport.assertQueue !== 'function') {
+      throw new Error('[BaseClient] Transport does not support assertQueue(queue, options)');
+    }
+    return await this._transport.assertQueue(queue, options);
+  }
+
+  /**
+   * Check queue existence (delegates to transport).
+   * @param {string} queue - Queue name
+   * @returns {Promise<Object>}
+   */
+  async checkQueue(queue) {
+    if (!this._connected || !this._transport) {
+      throw new ConnectionError('Cannot checkQueue: client is not connected');
+    }
+    if (typeof this._transport.checkQueue !== 'function') {
+      throw new Error('[BaseClient] Transport does not support checkQueue(queue)');
+    }
+    return await this._transport.checkQueue(queue);
+  }
+
+  /**
+   * Purge queue (delegates to transport).
+   * @param {string} queue - Queue name
+   * @returns {Promise<Object>}
+   */
+  async purgeQueue(queue) {
+    if (!this._connected || !this._transport) {
+      throw new ConnectionError('Cannot purgeQueue: client is not connected');
+    }
+    if (typeof this._transport.purgeQueue !== 'function') {
+      throw new Error('[BaseClient] Transport does not support purgeQueue(queue)');
+    }
+    return await this._transport.purgeQueue(queue);
+  }
+
+  /**
+   * Delete queue (delegates to transport).
+   * @param {string} queue - Queue name
+   * @param {Object} [options]
+   * @returns {Promise<Object>}
+   */
+  async deleteQueue(queue, options = {}) {
+    if (!this._connected || !this._transport) {
+      throw new ConnectionError('Cannot deleteQueue: client is not connected');
+    }
+    if (typeof this._transport.deleteQueue !== 'function') {
+      throw new Error('[BaseClient] Transport does not support deleteQueue(queue, options)');
+    }
+    return await this._transport.deleteQueue(queue, options);
+  }
+
+  /**
+   * Acknowledge a raw broker message (delegates to transport).
+   * @param {Object} msg - Broker message object
+   * @returns {Promise<void>}
+   */
+  async ack(msg) {
+    if (!this._connected || !this._transport) {
+      throw new ConnectionError('Cannot ack: client is not connected');
+    }
+    if (typeof this._transport.ack !== 'function') {
+      throw new Error('[BaseClient] Transport does not support ack(msg)');
+    }
+    return await this._transport.ack(msg);
+  }
+
+  /**
+   * Negative-acknowledge a raw broker message (delegates to transport).
+   * @param {Object} msg - Broker message object
+   * @param {Object} [options] - { requeue: boolean }
+   * @returns {Promise<void>}
+   */
+  async nack(msg, options = {}) {
+    if (!this._connected || !this._transport) {
+      throw new ConnectionError('Cannot nack: client is not connected');
+    }
+    if (typeof this._transport.nack !== 'function') {
+      throw new Error('[BaseClient] Transport does not support nack(msg, options)');
+    }
+    return await this._transport.nack(msg, options);
+  }
+
   /**
    * Acknowledges a RabbitMQ message.
    * @param {Object} msg - RabbitMQ message object.

package/src/transports/rabbitmqClient.js

@@ -419,6 +419,7 @@ class RabbitMQClient extends EventEmitter {
    * @throws {Error} If connection or channel creation fails.
    */
   async connect() {
+    let connectTimeoutTimer = null;
     try {
       const rawTarget = this._config.host || this._config.url;
       const heartbeat = this._config.heartbeat ?? 30;
@@ -433,9 +434,11 @@ class RabbitMQClient extends EventEmitter {
         : [{ ...rawTarget, heartbeat, clientProperties: { connection_name: connectionName } }];
 
       const connectPromise = amqp.connect(...connectArgs);
-      let connectTimeoutTimer = null;
       const timeoutPromise = new Promise((_, reject) => {
         connectTimeoutTimer = setTimeout(() => reject(new Error('Connection timeout after 10 seconds')), 10000);
+        if (connectTimeoutTimer && typeof connectTimeoutTimer.unref === 'function') {
+          connectTimeoutTimer.unref();
+        }
       });
       console.log('[RabbitMQClient] Starting connection race...');
       this._connection = await Promise.race([connectPromise, timeoutPromise]);
@@ -537,6 +540,11 @@ class RabbitMQClient extends EventEmitter {
         this._connection = null;
       }
       throw err;
+    } finally {
+      if (connectTimeoutTimer) {
+        clearTimeout(connectTimeoutTimer);
+        connectTimeoutTimer = null;
+      }
     }
   }
 
@@ -1084,6 +1092,92 @@ class RabbitMQClient extends EventEmitter {
     this._disconnecting = false;
   }
 
+  /**
+   * Ensure a queue exists with correct parameters (TTL/DLQ/etc).
+   * This is required by higher-level routing libraries (e.g. cookbook-router QueueManager).
+   *
+   * @param {string} queue - Queue name
+   * @param {Object} [options]
+   * @returns {Promise<Object>} amqplib assertQueue result
+   */
+  async assertQueue(queue, options = {}) {
+    await this._ensureQueueChannel();
+    if (!this._queueChannel) {
+      throw new Error('Cannot assertQueue: queue channel is not initialized');
+    }
+
+    let queueOptions = {
+      durable: options.durable !== false,
+      arguments: { ...(options.arguments || {}) }
+    };
+
+    // Prefer central queueConfig (fail-fast queue argument consistency)
+    try {
+      const queueConfig = require('../config/queueConfig');
+      const isInfraQueue = queueConfig ? queueConfig.isInfrastructureQueue(queue) : false;
+      const isBusinessQueue = queueConfig ? queueConfig.isBusinessQueue(queue) : false;
+
+      if (isInfraQueue) {
+        const infraConfig = queueConfig.getInfrastructureQueueConfig(queue);
+        queueOptions = {
+          durable: infraConfig.durable !== false,
+          arguments: { ...infraConfig.arguments }
+        };
+      } else if (isBusinessQueue) {
+        const parsed = queueConfig.parseBusinessQueue(queue);
+        if (parsed) {
+          const businessConfig = queueConfig.getBusinessQueueConfig(parsed.queueType, parsed.serviceName);
+          queueOptions = {
+            durable: businessConfig.durable !== false,
+            arguments: { ...businessConfig.arguments }
+          };
+        }
+      }
+    } catch (err) {
+      // If queueConfig cannot be loaded, keep caller-provided options (explicit).
+      // No fallbacks to "random defaults" here.
+    }
+
+    return await this._queueChannel.assertQueue(queue, queueOptions);
+  }
+
+  /**
+   * @param {string} queue - Queue name
+   * @returns {Promise<Object>} amqplib checkQueue result
+   */
+  async checkQueue(queue) {
+    await this._ensureQueueChannel();
+    if (!this._queueChannel) {
+      throw new Error('Cannot checkQueue: queue channel is not initialized');
+    }
+    return await this._queueChannel.checkQueue(queue);
+  }
+
+  /**
+   * @param {string} queue - Queue name
+   * @returns {Promise<Object>} amqplib purgeQueue result
+   */
+  async purgeQueue(queue) {
+    await this._ensureQueueChannel();
+    if (!this._queueChannel) {
+      throw new Error('Cannot purgeQueue: queue channel is not initialized');
+    }
+    return await this._queueChannel.purgeQueue(queue);
+  }
+
+  /**
+   * @param {string} queue - Queue name
+   * @param {Object} [options]
+   * @returns {Promise<Object>} amqplib deleteQueue result
+   */
+  async deleteQueue(queue, options = {}) {
+    await this._ensureQueueChannel();
+    if (!this._queueChannel) {
+      throw new Error('Cannot deleteQueue: queue channel is not initialized');
+    }
+    return await this._queueChannel.deleteQueue(queue, options);
+  }
+
   /**
    * Publishes a message buffer to the specified queue (or default queue) or exchange.
    * Implements systematic retry with exponential backoff for transient failures.
@@ -2034,11 +2128,11 @@ class RabbitMQClient extends EventEmitter {
    * @param {Object} msg - RabbitMQ message object.
    */
   async ack(msg) {
-    if (!this._channel) {
-      throw new Error('Cannot ack: channel is not initialized');
+    if (!this._consumerChannel) {
+      throw new Error('Cannot ack: consumer channel is not initialized');
     }
     try {
-      this._channel.ack(msg);
+      this._consumerChannel.ack(msg);
     } catch (err) {
       this.emit('error', err);
       throw err;
@@ -2051,12 +2145,12 @@ class RabbitMQClient extends EventEmitter {
    * @param {Object} [options] - { requeue: boolean }.
    */
   async nack(msg, options = {}) {
-    if (!this._channel) {
-      throw new Error('Cannot nack: channel is not initialized');
+    if (!this._consumerChannel) {
+      throw new Error('Cannot nack: consumer channel is not initialized');
     }
     const requeue = options.requeue !== undefined ? options.requeue : true;
     try {
-      this._channel.nack(msg, false, requeue);
+      this._consumerChannel.nack(msg, false, requeue);
     } catch (err) {
       this.emit('error', err);
       throw err;