runmq 1.1.1 → 1.2.0

package/README.md

@@ -15,7 +15,6 @@ It combines RabbitMQ’s proven reliability with a modern developer experience
 
 Whether you’re running <b>background jobs</b>, designing an <b>event-driven architecture</b>, or managing a <b>pub/sub event bus</b>, RunMQ provides everything you need — all in a <b>lightweight package</b> with a <b>simple DX</b>, <b>without the hassle of managing everything on your own</b>.
 
-
 ## Features
 
 - **Reliable Message Processing with Retries**: Automatically retries failed messages with configurable delays and retry limits.

package/dist/index.cjs

@@ -60,8 +60,8 @@ var RunMQException = class extends Error {
   }
 };
 
-// src/core/clients/AmqplibClient.ts
-var amqp = __toESM(require("amqplib"), 1);
+// src/core/clients/RabbitMQClientAdapter.ts
+var import_rabbitmq_client = require("rabbitmq-client");
 
 // src/core/exceptions/Exceptions.ts
 var Exceptions = class {
@@ -73,31 +73,228 @@ Exceptions.INVALID_MESSAGE_FORMAT = "MESSAGE_SHOULD_BE_VALID_RECORD";
 Exceptions.UNSUPPORTED_SCHEMA = "UNSUPPORTED_SCHEMA";
 Exceptions.FAILURE_TO_DEFINE_TTL_POLICY = "FAILURE_TO_DEFINE_TTL_POLICY";
 
-// src/core/clients/AmqplibClient.ts
-var AmqplibClient = class {
+// src/core/clients/RabbitMQClientChannel.ts
+var RabbitMQClientChannel = class {
+  constructor(channel) {
+    this.channel = channel;
+  }
+  async assertQueue(queue, options) {
+    const args = {};
+    if (options == null ? void 0 : options.deadLetterExchange) args["x-dead-letter-exchange"] = options.deadLetterExchange;
+    if (options == null ? void 0 : options.deadLetterRoutingKey) args["x-dead-letter-routing-key"] = options.deadLetterRoutingKey;
+    if (options == null ? void 0 : options.messageTtl) args["x-message-ttl"] = options.messageTtl;
+    if (options == null ? void 0 : options.arguments) Object.assign(args, options.arguments);
+    const result = await this.channel.queueDeclare({
+      queue,
+      durable: options == null ? void 0 : options.durable,
+      exclusive: options == null ? void 0 : options.exclusive,
+      autoDelete: options == null ? void 0 : options.autoDelete,
+      arguments: Object.keys(args).length > 0 ? args : void 0
+    });
+    return {
+      queue: result.queue,
+      messageCount: result.messageCount,
+      consumerCount: result.consumerCount
+    };
+  }
+  async checkQueue(queue) {
+    const result = await this.channel.queueDeclare({
+      queue,
+      passive: true
+    });
+    return {
+      queue: result.queue,
+      messageCount: result.messageCount,
+      consumerCount: result.consumerCount
+    };
+  }
+  async deleteQueue(queue, options) {
+    const result = await this.channel.queueDelete({
+      queue,
+      ifUnused: options == null ? void 0 : options.ifUnused,
+      ifEmpty: options == null ? void 0 : options.ifEmpty
+    });
+    return {
+      messageCount: result.messageCount
+    };
+  }
+  async assertExchange(exchange, type, options) {
+    const args = {};
+    if (options == null ? void 0 : options.alternateExchange) args["alternate-exchange"] = options.alternateExchange;
+    if (options == null ? void 0 : options.arguments) Object.assign(args, options.arguments);
+    await this.channel.exchangeDeclare({
+      exchange,
+      type,
+      durable: options == null ? void 0 : options.durable,
+      internal: options == null ? void 0 : options.internal,
+      autoDelete: options == null ? void 0 : options.autoDelete,
+      arguments: Object.keys(args).length > 0 ? args : void 0
+    });
+    return {
+      exchange
+    };
+  }
+  async checkExchange(exchange) {
+    await this.channel.exchangeDeclare({
+      exchange,
+      passive: true
+    });
+    return {
+      exchange
+    };
+  }
+  async deleteExchange(exchange, options) {
+    await this.channel.exchangeDelete({
+      exchange,
+      ifUnused: options == null ? void 0 : options.ifUnused
+    });
+  }
+  async bindQueue(queue, source, pattern, args) {
+    await this.channel.queueBind({
+      queue,
+      exchange: source,
+      routingKey: pattern,
+      arguments: args
+    });
+  }
+  publish(exchange, routingKey, content, options) {
+    var _a2;
+    this.channel.basicPublish({
+      exchange,
+      routingKey,
+      correlationId: options == null ? void 0 : options.correlationId,
+      messageId: options == null ? void 0 : options.messageId,
+      headers: options == null ? void 0 : options.headers,
+      durable: options == null ? void 0 : options.persistent,
+      expiration: (_a2 = options == null ? void 0 : options.expiration) == null ? void 0 : _a2.toString(),
+      contentType: options == null ? void 0 : options.contentType,
+      contentEncoding: options == null ? void 0 : options.contentEncoding,
+      priority: options == null ? void 0 : options.priority,
+      replyTo: options == null ? void 0 : options.replyTo,
+      timestamp: options == null ? void 0 : options.timestamp,
+      type: options == null ? void 0 : options.type,
+      userId: options == null ? void 0 : options.userId,
+      appId: options == null ? void 0 : options.appId
+    }, content);
+    return true;
+  }
+  async consume(queue, onMessage, options) {
+    const result = await this.channel.basicConsume({
+      queue,
+      consumerTag: options == null ? void 0 : options.consumerTag,
+      noLocal: options == null ? void 0 : options.noLocal,
+      noAck: options == null ? void 0 : options.noAck,
+      exclusive: options == null ? void 0 : options.exclusive,
+      arguments: options == null ? void 0 : options.arguments
+    }, (msg) => {
+      const body = msg.body;
+      const content = Buffer.isBuffer(body) ? body : typeof body === "string" ? Buffer.from(body) : Buffer.from(JSON.stringify(body));
+      const consumeMessage = {
+        content,
+        fields: {
+          consumerTag: msg.consumerTag,
+          deliveryTag: msg.deliveryTag,
+          redelivered: msg.redelivered,
+          exchange: msg.exchange,
+          routingKey: msg.routingKey
+        },
+        properties: {
+          contentType: msg.contentType,
+          contentEncoding: msg.contentEncoding,
+          headers: msg.headers || {},
+          deliveryMode: msg.durable ? 2 : 1,
+          priority: msg.priority,
+          correlationId: msg.correlationId,
+          replyTo: msg.replyTo,
+          expiration: msg.expiration,
+          messageId: msg.messageId,
+          timestamp: msg.timestamp,
+          type: msg.type,
+          userId: msg.userId,
+          appId: msg.appId
+        }
+      };
+      onMessage(consumeMessage);
+    });
+    return {
+      consumerTag: result.consumerTag
+    };
+  }
+  ack(message, allUpTo) {
+    this.channel.basicAck({
+      deliveryTag: message.fields.deliveryTag,
+      multiple: allUpTo
+    });
+  }
+  nack(message, allUpTo, requeue) {
+    this.channel.basicNack({
+      deliveryTag: message.fields.deliveryTag,
+      multiple: allUpTo,
+      requeue
+    });
+  }
+  async prefetch(count, global) {
+    await this.channel.basicQos({
+      prefetchCount: count,
+      global
+    });
+  }
+  async close() {
+    await this.channel.close();
+  }
+};
+
+// src/core/clients/RabbitMQClientAdapter.ts
+var RabbitMQClientAdapter = class {
   constructor(config) {
     this.config = config;
     this.isConnected = false;
-    this.config = config;
+    this.acquiredChannels = [];
   }
   async connect() {
     try {
-      if (this.isConnected && this.channelModel) {
-        return this.channelModel;
+      if (this.connection && this.isConnected) {
+        return this.connection;
       }
-      this.channelModel = await amqp.connect(this.config.url);
-      this.isConnected = true;
-      if (this.isConnected) {
-        this.channelModel.on("error", () => {
-          this.isConnected = false;
-        });
-        this.channelModel.on("close", () => {
-          this.isConnected = false;
-        });
+      if (this.connection) {
+        try {
+          await this.connection.close();
+        } catch (e) {
+        }
+        this.connection = void 0;
       }
-      return this.channelModel;
+      this.connection = new import_rabbitmq_client.Connection({
+        url: this.config.url,
+        // Disable automatic retries - we handle retries at RunMQ level
+        retryLow: 100,
+        retryHigh: 200,
+        connectionTimeout: 5e3
+      });
+      this.connection.on("error", (err) => {
+        console.error("RabbitMQ connection error:", err);
+        this.isConnected = false;
+      });
+      this.connection.on("connection", () => {
+        this.isConnected = true;
+      });
+      this.connection.on("connection.blocked", (reason) => {
+        console.warn("RabbitMQ connection blocked:", reason);
+      });
+      this.connection.on("connection.unblocked", () => {
+        console.info("RabbitMQ connection unblocked");
+      });
+      await this.connection.onConnect(5e3, true);
+      this.isConnected = true;
+      return this.connection;
     } catch (error) {
       this.isConnected = false;
+      if (this.connection) {
+        try {
+          this.connection.close();
+        } catch (e) {
+        }
+        this.connection = void 0;
+      }
       throw new RunMQException(
         Exceptions.CONNECTION_NOT_ESTABLISHED,
         {
@@ -107,25 +304,41 @@ var AmqplibClient = class {
     }
   }
   async getChannel() {
-    return await (await this.connect()).createChannel();
+    const connection = await this.connect();
+    const rawChannel = await connection.acquire();
+    this.acquiredChannels.push(rawChannel);
+    return new RabbitMQClientChannel(rawChannel);
+  }
+  async getDefaultChannel() {
+    if (!this.defaultChannel) {
+      this.defaultChannel = await this.getChannel();
+    }
+    return this.defaultChannel;
   }
   async disconnect() {
-    try {
-      if (this.channelModel && this.isConnected) {
-        await this.channelModel.close();
-        this.isConnected = false;
-      }
-    } catch (error) {
-      throw new RunMQException(
-        Exceptions.CONNECTION_NOT_ESTABLISHED,
-        {
-          error: error instanceof Error ? error.message : String(error)
+    const conn = this.connection;
+    const channels = this.acquiredChannels;
+    this.connection = void 0;
+    this.defaultChannel = void 0;
+    this.isConnected = false;
+    this.acquiredChannels = [];
+    for (const channel of channels) {
+      try {
+        if (channel.active) {
+          await channel.close();
         }
-      );
+      } catch (e) {
+      }
+    }
+    if (conn) {
+      try {
+        await conn.close();
+      } catch (e) {
+      }
     }
   }
   isActive() {
-    return this.isConnected && this.channelModel !== void 0;
+    return this.connection !== void 0 && this.isConnected;
   }
 };
 
@@ -175,6 +388,23 @@ var RabbitMQMessage = class _RabbitMQMessage {
     this.amqpMessage = amqpMessage;
     this.headers = headers;
   }
+  /**
+   * Acknowledges the message.
+   */
+  ack() {
+    if (this.amqpMessage) {
+      this.channel.ack(this.amqpMessage);
+    }
+  }
+  /**
+   * Negatively acknowledges the message.
+   * @param requeue - Whether to requeue the message (default: false)
+   */
+  nack(requeue = false) {
+    if (this.amqpMessage) {
+      this.channel.nack(this.amqpMessage, false, requeue);
+    }
+  }
   static from(messageData, channel, props, amqpMessage = null) {
     return new _RabbitMQMessage(
       messageData,
@@ -195,7 +425,7 @@ var RunMQSucceededMessageAcknowledgerProcessor = class {
   async consume(message) {
     const result = await this.consumer.consume(message);
     if (result) {
-      message.channel.ack(message.amqpMessage);
+      message.ack();
     }
     return result;
   }
@@ -210,7 +440,7 @@ var RunMQFailedMessageRejecterProcessor = class {
     try {
       return await this.consumer.consume(message);
     } catch (e) {
-      message.channel.nack(message.amqpMessage, false, false);
+      message.nack(false);
       return false;
     }
   }
@@ -271,7 +501,7 @@ var RunMQRetriesCheckerProcessor = class {
   }
   acknowledgeMessage(message) {
     try {
-      message.channel.ack(message.amqpMessage, false);
+      message.ack();
     } catch (e) {
       const error = new Error("A message acknowledge failed after publishing to final dead letter");
       this.logger.error(error.message, { cause: e instanceof Error ? e.message : String(e) });
@@ -703,8 +933,7 @@ var RunMQTTLPolicyManager = class {
 
 // src/core/consumer/RunMQConsumerCreator.ts
 var RunMQConsumerCreator = class {
-  constructor(defaultChannel, client, logger, managementConfig) {
-    this.defaultChannel = defaultChannel;
+  constructor(client, logger, managementConfig) {
     this.client = client;
     this.logger = logger;
     this.ttlPolicyManager = new RunMQTTLPolicyManager(logger, managementConfig);
@@ -756,12 +985,13 @@ var RunMQConsumerCreator = class {
   }
   async assertQueues(consumerConfiguration) {
     var _a2, _b;
-    await this.defaultChannel.assertQueue(consumerConfiguration.processorConfig.name, {
+    const defaultChannel = await this.client.getDefaultChannel();
+    await defaultChannel.assertQueue(consumerConfiguration.processorConfig.name, {
       durable: true,
       deadLetterExchange: Constants.DEAD_LETTER_ROUTER_EXCHANGE_NAME,
       deadLetterRoutingKey: consumerConfiguration.processorConfig.name
     });
-    await this.defaultChannel.assertQueue(ConsumerCreatorUtils.getDLQTopicName(consumerConfiguration.processorConfig.name), {
+    await defaultChannel.assertQueue(ConsumerCreatorUtils.getDLQTopicName(consumerConfiguration.processorConfig.name), {
       durable: true,
       deadLetterExchange: Constants.ROUTER_EXCHANGE_NAME,
       deadLetterRoutingKey: consumerConfiguration.processorConfig.name
@@ -770,7 +1000,7 @@ var RunMQConsumerCreator = class {
     const messageDelay = (_a2 = consumerConfiguration.processorConfig.attemptsDelay) != null ? _a2 : DEFAULTS.PROCESSING_RETRY_DELAY;
     const policiesForTTL = (_b = consumerConfiguration.processorConfig.usePoliciesForDelay) != null ? _b : false;
     if (!policiesForTTL) {
-      await this.defaultChannel.assertQueue(retryDelayQueueName, {
+      await defaultChannel.assertQueue(retryDelayQueueName, {
         durable: true,
         deadLetterExchange: Constants.ROUTER_EXCHANGE_NAME,
         messageTtl: messageDelay
@@ -782,7 +1012,7 @@ var RunMQConsumerCreator = class {
       messageDelay
     );
     if (result) {
-      await this.defaultChannel.assertQueue(retryDelayQueueName, {
+      await defaultChannel.assertQueue(retryDelayQueueName, {
         durable: true,
         deadLetterExchange: Constants.ROUTER_EXCHANGE_NAME
       });
@@ -796,22 +1026,23 @@ var RunMQConsumerCreator = class {
     );
   }
   async bindQueues(consumerConfiguration) {
-    await this.defaultChannel.bindQueue(
+    const defaultChannel = await this.client.getDefaultChannel();
+    await defaultChannel.bindQueue(
       consumerConfiguration.processorConfig.name,
       Constants.ROUTER_EXCHANGE_NAME,
       consumerConfiguration.topic
     );
-    await this.defaultChannel.bindQueue(
+    await defaultChannel.bindQueue(
       consumerConfiguration.processorConfig.name,
       Constants.ROUTER_EXCHANGE_NAME,
       consumerConfiguration.processorConfig.name
     );
-    await this.defaultChannel.bindQueue(
+    await defaultChannel.bindQueue(
       ConsumerCreatorUtils.getRetryDelayTopicName(consumerConfiguration.processorConfig.name),
       Constants.DEAD_LETTER_ROUTER_EXCHANGE_NAME,
       consumerConfiguration.processorConfig.name
     );
-    await this.defaultChannel.bindQueue(
+    await defaultChannel.bindQueue(
       ConsumerCreatorUtils.getDLQTopicName(consumerConfiguration.processorConfig.name),
       Constants.DEAD_LETTER_ROUTER_EXCHANGE_NAME,
       ConsumerCreatorUtils.getDLQTopicName(consumerConfiguration.processorConfig.name)
@@ -877,7 +1108,7 @@ var RunMQ = class _RunMQ {
       reconnectDelay: (_a2 = config.reconnectDelay) != null ? _a2 : DEFAULTS.RECONNECT_DELAY,
       maxReconnectAttempts: (_b = config.maxReconnectAttempts) != null ? _b : DEFAULTS.MAX_RECONNECT_ATTEMPTS
     });
-    this.amqplibClient = new AmqplibClient(this.config);
+    this.client = new RabbitMQClientAdapter(this.config);
   }
   /**
    * Starts the RunMQ instance by establishing a connection to RabbitMQ and initializing necessary components.
@@ -898,7 +1129,7 @@ var RunMQ = class _RunMQ {
    * @param processor The function that will process the incoming messages
    */
   async process(topic, config, processor) {
-    const consumer = new RunMQConsumerCreator(this.defaultChannel, this.amqplibClient, this.logger, this.config.management);
+    const consumer = new RunMQConsumerCreator(this.client, this.logger, this.config.management);
     await consumer.createConsumer(new ConsumerConfiguration(topic, config, processor));
   }
   /**
@@ -908,7 +1139,7 @@ var RunMQ = class _RunMQ {
    * @param correlationId (Optional) A unique identifier for correlating messages; if not provided, a new UUID will be generated
    */
   publish(topic, message, correlationId = RunMQUtils.generateUUID()) {
-    if (!this.publisher) {
+    if (!this.publisher || !this.defaultChannel) {
       throw new RunMQException(Exceptions.NOT_INITIALIZED, {});
     }
     RunMQUtils.assertRecord(message);
@@ -931,7 +1162,7 @@ var RunMQ = class _RunMQ {
    */
   async disconnect() {
     try {
-      await this.amqplibClient.disconnect();
+      await this.client.disconnect();
     } catch (error) {
       throw new RunMQException(
         Exceptions.CONNECTION_NOT_ESTABLISHED,
@@ -945,19 +1176,20 @@ var RunMQ = class _RunMQ {
    * Checks if the connection is currently active.
    */
   isActive() {
-    return this.amqplibClient.isActive();
+    return this.client.isActive();
   }
   async connectWithRetry() {
     const maxAttempts = this.config.maxReconnectAttempts;
     const delay = this.config.reconnectDelay;
     while (this.retryAttempts < maxAttempts) {
       try {
-        await this.amqplibClient.connect();
+        await this.client.connect();
         this.logger.log("Successfully connected to RabbitMQ");
         this.retryAttempts = 0;
         return;
       } catch (error) {
         this.retryAttempts++;
+        console.log(this.logger);
         this.logger.error(`Connection attempt ${this.retryAttempts}/${maxAttempts} failed:`, error);
         if (this.retryAttempts >= maxAttempts) {
           throw new RunMQException(
@@ -974,7 +1206,7 @@ var RunMQ = class _RunMQ {
     }
   }
   async initialize() {
-    this.defaultChannel = await this.amqplibClient.getChannel();
+    this.defaultChannel = await this.client.getDefaultChannel();
     await this.defaultChannel.assertExchange(Constants.ROUTER_EXCHANGE_NAME, "direct", { durable: true });
     await this.defaultChannel.assertExchange(Constants.DEAD_LETTER_ROUTER_EXCHANGE_NAME, "direct", { durable: true });
     this.publisher = new RunMQPublisherCreator(this.logger).createPublisher();