runmq 0.0.1 → 1.0.0

package/dist/index.js

@@ -0,0 +1,762 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/core/exceptions/RunMQException.ts
+var RunMQException = class extends Error {
+  constructor(exception, details) {
+    super(`RunMQ Exception: ${exception}`);
+    this.exception = exception;
+    this.details = details;
+  }
+};
+
+// src/core/clients/AmqplibClient.ts
+import * as amqp from "amqplib";
+
+// src/core/exceptions/Exceptions.ts
+var Exceptions = class {
+};
+Exceptions.EXCEEDING_CONNECTION_ATTEMPTS = "EXCEEDING_CONNECTION_ATTEMPTS";
+Exceptions.CONNECTION_NOT_ESTABLISHED = "CONNECTION_NOT_ESTABLISHED";
+Exceptions.NOT_INITIALIZED = "NOT_INITIALIZED";
+Exceptions.INVALID_MESSAGE_FORMAT = "MESSAGE_SHOULD_BE_VALID_RECORD";
+Exceptions.UNSUPPORTED_SCHEMA = "UNSUPPORTED_SCHEMA";
+
+// src/core/clients/AmqplibClient.ts
+var AmqplibClient = class {
+  constructor(config) {
+    this.config = config;
+    this.isConnected = false;
+    this.config = config;
+  }
+  async connect() {
+    try {
+      if (this.isConnected && this.channelModel) {
+        return this.channelModel;
+      }
+      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;
+        });
+      }
+      return this.channelModel;
+    } catch (error) {
+      this.isConnected = false;
+      throw new RunMQException(
+        Exceptions.CONNECTION_NOT_ESTABLISHED,
+        {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
+    }
+  }
+  async getChannel() {
+    return await (await this.connect()).createChannel();
+  }
+  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)
+        }
+      );
+    }
+  }
+  isActive() {
+    return this.isConnected && this.channelModel !== void 0;
+  }
+};
+
+// src/core/utils/Utils.ts
+import { randomUUID } from "crypto";
+var RunMQUtils = class {
+  static delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  static generateUUID() {
+    return randomUUID();
+  }
+  static assertRecord(message) {
+    if (typeof message !== "object" || message === null || Array.isArray(message)) {
+      throw new RunMQException(Exceptions.INVALID_MESSAGE_FORMAT, {});
+    }
+  }
+};
+
+// src/core/constants/index.ts
+var RUNMQ_PREFIX = "_runmq_";
+var Constants = {
+  ROUTER_EXCHANGE_NAME: RUNMQ_PREFIX + "router",
+  DEAD_LETTER_ROUTER_EXCHANGE_NAME: RUNMQ_PREFIX + "dead_letter_router",
+  RETRY_DELAY_QUEUE_PREFIX: RUNMQ_PREFIX + "retry_delay_",
+  DLQ_QUEUE_PREFIX: RUNMQ_PREFIX + "dlq_"
+};
+var DEFAULTS = {
+  RECONNECT_DELAY: 5e3,
+  MAX_RECONNECT_ATTEMPTS: 5,
+  PREFETCH_COUNT: 10,
+  PROCESSING_ATTEMPTS: 1,
+  PROCESSING_RETRY_DELAY: 1e3
+};
+
+// src/core/message/RabbitMQMessage.ts
+var RabbitMQMessage = class _RabbitMQMessage {
+  constructor(message, id = RunMQUtils.generateUUID(), correlationId = RunMQUtils.generateUUID(), channel, amqpMessage = null, headers = {}) {
+    this.message = message;
+    this.id = id;
+    this.correlationId = correlationId;
+    this.channel = channel;
+    this.amqpMessage = amqpMessage;
+    this.headers = headers;
+  }
+  static from(messageData, channel, props, amqpMessage = null) {
+    return new _RabbitMQMessage(
+      messageData,
+      props.id,
+      props.correlationId,
+      channel,
+      amqpMessage,
+      {}
+    );
+  }
+};
+
+// src/core/consumer/processors/RunMQSucceededMessageAcknowledgerProcessor.ts
+var RunMQSucceededMessageAcknowledgerProcessor = class {
+  constructor(consumer) {
+    this.consumer = consumer;
+  }
+  async consume(message) {
+    const result = await this.consumer.consume(message);
+    if (result) {
+      message.channel.ack(message.amqpMessage);
+    }
+    return result;
+  }
+};
+
+// src/core/consumer/processors/RunMQFailedMessageRejecterProcessor.ts
+var RunMQFailedMessageRejecterProcessor = class {
+  constructor(consumer) {
+    this.consumer = consumer;
+  }
+  async consume(message) {
+    try {
+      return await this.consumer.consume(message);
+    } catch (e) {
+      message.channel.nack(message.amqpMessage, false, false);
+      return false;
+    }
+  }
+};
+
+// src/core/consumer/ConsumerCreatorUtils.ts
+var ConsumerCreatorUtils = class {
+  static getDLQTopicName(topic) {
+    return Constants.DLQ_QUEUE_PREFIX + topic;
+  }
+  static getRetryDelayTopicName(topic) {
+    return Constants.RETRY_DELAY_QUEUE_PREFIX + topic;
+  }
+};
+
+// src/core/consumer/processors/RunMQRetriesCheckerProcessor.ts
+var _a;
+var RunMQRetriesCheckerProcessor = class {
+  constructor(consumer, config, DLQPublisher, logger) {
+    this.consumer = consumer;
+    this.config = config;
+    this.DLQPublisher = DLQPublisher;
+    this.logger = logger;
+    this.maxAttempts = (_a = this.config.attempts) != null ? _a : DEFAULTS.PROCESSING_ATTEMPTS;
+  }
+  async consume(message) {
+    try {
+      return await this.consumer.consume(message);
+    } catch (e) {
+      if (this.hasReachedMaxRetries(message)) {
+        this.logMaxRetriesReached(message);
+        this.moveToFinalDeadLetter(message);
+        this.acknowledgeMessage(message);
+        return false;
+      }
+      throw e;
+    }
+  }
+  hasReachedMaxRetries(message) {
+    const rejectedCount = this.getRejectionCount(message);
+    return rejectedCount >= this.maxAttempts;
+  }
+  logMaxRetriesReached(message) {
+    this.logger.error(
+      `Message reached maximum attempts. Moving to dead-letter queue.`,
+      {
+        message: message.message,
+        attempts: this.getRejectionCount(message),
+        max: this.maxAttempts
+      }
+    );
+  }
+  moveToFinalDeadLetter(message) {
+    this.DLQPublisher.publish(ConsumerCreatorUtils.getDLQTopicName(this.config.name), message);
+  }
+  acknowledgeMessage(message) {
+    try {
+      message.channel.ack(message.amqpMessage, false);
+    } 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) });
+      throw error;
+    }
+  }
+  getRejectionCount(message) {
+    var _a2;
+    const xDeath = (_a2 = message.headers) == null ? void 0 : _a2["x-death"];
+    if (!Array.isArray(xDeath)) return 1;
+    const deathRecord = xDeath.filter((entry) => entry && entry.reason == "rejected")[0];
+    return deathRecord ? deathRecord.count + 1 : 1;
+  }
+};
+
+// src/core/consumer/processors/RunMQFailureLoggerProcessor.ts
+var RunMQFailureLoggerProcessor = class {
+  constructor(consumer, logger) {
+    this.consumer = consumer;
+    this.logger = logger;
+  }
+  async consume(message) {
+    try {
+      return await this.consumer.consume(message);
+    } catch (e) {
+      this.logger.error(
+        "Message processing failed",
+        {
+          message: message.message
+        },
+        e instanceof Error ? e.stack : void 0
+      );
+      throw e;
+    }
+  }
+};
+
+// src/core/consumer/processors/RunMQBaseProcessor.ts
+var RunMQBaseProcessor = class {
+  constructor(handler, processorConfig, serializer) {
+    this.handler = handler;
+    this.processorConfig = processorConfig;
+    this.serializer = serializer;
+  }
+  async consume(message) {
+    const rabbitMQMessage = this.serializer.deserialize(message.message, this.processorConfig);
+    await this.handler(rabbitMQMessage);
+    return true;
+  }
+};
+
+// src/core/consumer/processors/RunMQExceptionLoggerProcessor.ts
+var RunMQExceptionLoggerProcessor = class {
+  constructor(consumer, logger) {
+    this.consumer = consumer;
+    this.logger = logger;
+  }
+  async consume(message) {
+    try {
+      return await this.consumer.consume(message);
+    } catch (e) {
+      if (e instanceof Error) {
+        this.logger.error(e.message, e.stack);
+        throw e;
+      } else {
+        const errorString = JSON.stringify(e);
+        this.logger.error(errorString);
+        throw new Error(errorString);
+      }
+    }
+  }
+};
+
+// src/core/message/RunMQMessage.ts
+var RunMQMessage = class {
+  static isValid(obj) {
+    if (typeof obj === "object" && obj !== null) {
+      return "message" in obj && "meta" in obj && typeof obj.message === "object" && obj.message !== null && Array.isArray(obj.message) === false && typeof obj.meta === "object" && obj.meta !== null && "id" in obj.meta && "correlationId" in obj.meta && "publishedAt" in obj.meta && typeof obj.meta.id === "string" && typeof obj.meta.correlationId === "string" && typeof obj.meta.publishedAt === "number";
+    }
+    return false;
+  }
+  constructor(message, meta) {
+    this.message = message;
+    this.meta = meta;
+  }
+};
+var RunMQMessageMeta = class {
+  constructor(id, publishedAt, correlationId) {
+    this.id = id;
+    this.correlationId = correlationId;
+    this.publishedAt = publishedAt;
+  }
+};
+
+// src/core/serializers/deserializer/validation/AjvSchemaValidator.ts
+import Ajv from "ajv";
+var AjvSchemaValidator = class {
+  constructor() {
+    this.lastValidator = null;
+    this.ajv = new Ajv({
+      allErrors: true,
+      verbose: true,
+      strict: true
+    });
+  }
+  validate(schema, data) {
+    this.lastValidator = this.ajv.compile(schema);
+    return this.lastValidator(data);
+  }
+  getError() {
+    if (!this.lastValidator || !this.lastValidator.errors) {
+      return null;
+    }
+    return JSON.stringify(this.lastValidator.errors);
+  }
+};
+
+// src/core/serializers/deserializer/validation/ValidatorFactory.ts
+var validatorCache = /* @__PURE__ */ new Map();
+function getValidator(schemaType) {
+  const cached = validatorCache.get(schemaType);
+  if (cached) {
+    return cached;
+  }
+  let validator;
+  switch (schemaType) {
+    case "ajv":
+      validator = new AjvSchemaValidator();
+      break;
+    default:
+      throw new RunMQException(Exceptions.UNSUPPORTED_SCHEMA, { schemaType });
+  }
+  validatorCache.set(schemaType, validator);
+  return validator;
+}
+
+// src/core/serializers/deserializer/DefaultDeserializer.ts
+var DeserializationError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "DeserializationError";
+  }
+};
+var RunMQSchemaValidationError = class extends Error {
+  constructor(message, error) {
+    super(message);
+    this.error = error;
+    this.name = "ValidationError";
+  }
+};
+var DefaultDeserializer = class {
+  deserialize(data, processorConfig) {
+    if (!data) {
+      throw new DeserializationError("Input must be a non-empty string");
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(data);
+    } catch (error) {
+      throw new DeserializationError(
+        `Failed to parse JSON: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+    if (!RunMQMessage.isValid(parsed)) {
+      throw new RunMQSchemaValidationError(
+        "Invalid message format: not valid RunMQMessage structure"
+      );
+    }
+    const typedParsed = parsed;
+    if (processorConfig.messageSchema) {
+      const { type, schema } = processorConfig.messageSchema;
+      const validator = getValidator(type);
+      if (!validator.validate(schema, typedParsed.message)) {
+        throw new RunMQSchemaValidationError(
+          "Message validation failed against schema",
+          validator.getError() || void 0
+        );
+      }
+    }
+    const message = typedParsed.message;
+    return new RunMQMessage(
+      message,
+      new RunMQMessageMeta(
+        typedParsed.meta.id,
+        typedParsed.meta.publishedAt,
+        typedParsed.meta.correlationId
+      )
+    );
+  }
+};
+
+// src/core/publisher/producers/RunMQFailureLoggerProducer.ts
+var RunMQFailureLoggerProducer = class {
+  constructor(producer, logger) {
+    this.producer = producer;
+    this.logger = logger;
+  }
+  publish(topic, message) {
+    try {
+      this.producer.publish(topic, message);
+    } catch (e) {
+      this.logger.error("Message publishing failed", {
+        message,
+        error: e instanceof Error ? e.message : JSON.stringify(e),
+        stack: e instanceof Error ? e.stack : void 0
+      });
+      throw e;
+    }
+  }
+};
+
+// src/core/publisher/producers/RunMQBaseProducer.ts
+var RunMQBaseProducer = class {
+  constructor(serializer, exchange = Constants.ROUTER_EXCHANGE_NAME) {
+    this.serializer = serializer;
+    this.exchange = exchange;
+  }
+  publish(topic, message) {
+    const runMQMessage = new RunMQMessage(
+      message.message,
+      new RunMQMessageMeta(
+        message.id,
+        Date.now(),
+        message.correlationId
+      )
+    );
+    const serialized = this.serializer.serialize(runMQMessage);
+    message.channel.publish(this.exchange, topic, Buffer.from(serialized), {
+      correlationId: message.correlationId,
+      messageId: message.id,
+      headers: message.headers
+    });
+  }
+};
+
+// src/core/serializers/DefaultSerializer.ts
+var SerializationError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "SerializationError";
+  }
+};
+var DefaultSerializer = class {
+  serialize(data) {
+    try {
+      return JSON.stringify(data);
+    } catch (error) {
+      throw new SerializationError(
+        `Failed to serialize message: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+};
+
+// src/core/publisher/RunMQPublisherCreator.ts
+var RunMQPublisherCreator = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  createPublisher(exchange = Constants.ROUTER_EXCHANGE_NAME) {
+    return new RunMQFailureLoggerProducer(
+      new RunMQBaseProducer(new DefaultSerializer(), exchange),
+      this.logger
+    );
+  }
+};
+
+// src/core/consumer/RunMQConsumerCreator.ts
+var RunMQConsumerCreator = class {
+  constructor(defaultChannel, client, logger) {
+    this.defaultChannel = defaultChannel;
+    this.client = client;
+    this.logger = logger;
+  }
+  async createConsumer(consumerConfiguration) {
+    await this.assertQueues(consumerConfiguration);
+    await this.bindQueues(consumerConfiguration);
+    for (let i = 0; i < consumerConfiguration.processorConfig.consumersCount; i++) {
+      await this.runProcessor(consumerConfiguration);
+    }
+  }
+  async runProcessor(consumerConfiguration) {
+    const consumerChannel = await this.getProcessorChannel();
+    const DLQPublisher = new RunMQPublisherCreator(this.logger).createPublisher(Constants.DEAD_LETTER_ROUTER_EXCHANGE_NAME);
+    await consumerChannel.prefetch(DEFAULTS.PREFETCH_COUNT);
+    await consumerChannel.consume(consumerConfiguration.processorConfig.name, async (msg) => {
+      if (msg) {
+        const rabbitmqMessage = new RabbitMQMessage(
+          msg.content.toString(),
+          msg.properties.messageId,
+          msg.properties.correlationId,
+          consumerChannel,
+          msg,
+          msg.properties.headers
+        );
+        return new RunMQExceptionLoggerProcessor(
+          new RunMQSucceededMessageAcknowledgerProcessor(
+            new RunMQFailedMessageRejecterProcessor(
+              new RunMQRetriesCheckerProcessor(
+                new RunMQFailureLoggerProcessor(
+                  new RunMQBaseProcessor(
+                    consumerConfiguration.processor,
+                    consumerConfiguration.processorConfig,
+                    new DefaultDeserializer()
+                  ),
+                  this.logger
+                ),
+                consumerConfiguration.processorConfig,
+                DLQPublisher,
+                this.logger
+              )
+            )
+          ),
+          this.logger
+        ).consume(rabbitmqMessage);
+      }
+    });
+  }
+  async assertQueues(consumerConfiguration) {
+    var _a2;
+    await this.defaultChannel.assertQueue(consumerConfiguration.processorConfig.name, {
+      durable: true,
+      deadLetterExchange: Constants.DEAD_LETTER_ROUTER_EXCHANGE_NAME,
+      deadLetterRoutingKey: consumerConfiguration.processorConfig.name
+    });
+    await this.defaultChannel.assertQueue(ConsumerCreatorUtils.getRetryDelayTopicName(consumerConfiguration.processorConfig.name), {
+      durable: true,
+      deadLetterExchange: Constants.ROUTER_EXCHANGE_NAME,
+      messageTtl: (_a2 = consumerConfiguration.processorConfig.attemptsDelay) != null ? _a2 : DEFAULTS.PROCESSING_RETRY_DELAY
+    });
+    await this.defaultChannel.assertQueue(ConsumerCreatorUtils.getDLQTopicName(consumerConfiguration.processorConfig.name), {
+      durable: true,
+      deadLetterExchange: Constants.ROUTER_EXCHANGE_NAME,
+      deadLetterRoutingKey: consumerConfiguration.processorConfig.name
+    });
+  }
+  async bindQueues(consumerConfiguration) {
+    await this.defaultChannel.bindQueue(
+      consumerConfiguration.processorConfig.name,
+      Constants.ROUTER_EXCHANGE_NAME,
+      consumerConfiguration.topic
+    );
+    await this.defaultChannel.bindQueue(
+      consumerConfiguration.processorConfig.name,
+      Constants.ROUTER_EXCHANGE_NAME,
+      consumerConfiguration.processorConfig.name
+    );
+    await this.defaultChannel.bindQueue(
+      ConsumerCreatorUtils.getRetryDelayTopicName(consumerConfiguration.processorConfig.name),
+      Constants.DEAD_LETTER_ROUTER_EXCHANGE_NAME,
+      consumerConfiguration.processorConfig.name
+    );
+    await this.defaultChannel.bindQueue(
+      ConsumerCreatorUtils.getDLQTopicName(consumerConfiguration.processorConfig.name),
+      Constants.DEAD_LETTER_ROUTER_EXCHANGE_NAME,
+      ConsumerCreatorUtils.getDLQTopicName(consumerConfiguration.processorConfig.name)
+    );
+  }
+  async getProcessorChannel() {
+    return await this.client.getChannel();
+  }
+};
+
+// src/core/consumer/ConsumerConfiguration.ts
+var ConsumerConfiguration = class {
+  constructor(topic, processorConfig, processor) {
+    this.topic = topic;
+    this.processorConfig = processorConfig;
+    this.processor = processor;
+  }
+};
+
+// src/core/logging/RunMQConsoleLogger.ts
+var RunMQConsoleLogger = class {
+  constructor() {
+    this.prefix = "[RunMQ] - ";
+  }
+  log(message) {
+    console.log(this.formatMessage(message));
+  }
+  error(message, ...optionalParams) {
+    console.error(this.formatMessage(message), ...optionalParams);
+  }
+  warn(message, ...optionalParams) {
+    console.warn(this.formatMessage(message), ...optionalParams);
+  }
+  info(message, ...optionalParams) {
+    console.info(this.formatMessage(message), ...optionalParams);
+  }
+  debug(message, ...optionalParams) {
+    console.debug(this.formatMessage(message), ...optionalParams);
+  }
+  verbose(message, ...optionalParams) {
+    console.debug(this.formatMessage(message), ...optionalParams);
+  }
+  formatMessage(message) {
+    return `${this.prefix} ${message}`;
+  }
+};
+
+// src/core/message/RabbitMQMessageProperties.ts
+var RabbitMQMessageProperties = class {
+  constructor(id, correlationId) {
+    this.id = id;
+    this.correlationId = correlationId;
+  }
+};
+
+// src/core/RunMQ.ts
+var RunMQ = class _RunMQ {
+  constructor(config, logger) {
+    this.retryAttempts = 0;
+    var _a2, _b;
+    this.logger = logger;
+    this.config = __spreadProps(__spreadValues({}, config), {
+      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);
+  }
+  /**
+   * Starts the RunMQ instance by establishing a connection to RabbitMQ and initializing necessary components.
+   * @param config The configuration for the RunMQ connection @see RunMQConnectionConfig
+   * @param logger (Optional) A custom logger implementing the RunMQLogger interface; if not provided, a default console logger will be used
+   * @returns A promise that resolves to the initialized RunMQ instance
+   */
+  static async start(config, logger = new RunMQConsoleLogger()) {
+    const instance = new _RunMQ(config, logger);
+    await instance.connectWithRetry();
+    await instance.initialize();
+    return instance;
+  }
+  /**
+   * Processes messages from the specified topic using the provided processor function and configuration.
+   * @param topic The name of the topic to process messages from, it should match the name used during publishing
+   * @param config The configuration for the message processor @see RunMQProcessorConfiguration
+   * @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);
+    await consumer.createConsumer(new ConsumerConfiguration(topic, config, processor));
+  }
+  /**
+   * Publishes a message to the specified topic with an optional correlation ID
+   * @param topic The name of the topic to publish the message to
+   * @param message The message payload to be published
+   * @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) {
+      throw new RunMQException(Exceptions.NOT_INITIALIZED, {});
+    }
+    RunMQUtils.assertRecord(message);
+    this.publisher.publish(
+      topic,
+      RabbitMQMessage.from(
+        message,
+        this.defaultChannel,
+        new RabbitMQMessageProperties(RunMQUtils.generateUUID(), correlationId)
+      )
+    );
+    this.logger.info(`Published message`, {
+      topic,
+      correlationId,
+      message
+    });
+  }
+  /**
+   * Disconnects from RabbitMQ, handling any errors that may occur during the disconnection process.
+   */
+  async disconnect() {
+    try {
+      await this.amqplibClient.disconnect();
+    } catch (error) {
+      throw new RunMQException(
+        Exceptions.CONNECTION_NOT_ESTABLISHED,
+        {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
+    }
+  }
+  /**
+   * Checks if the connection is currently active.
+   */
+  isActive() {
+    return this.amqplibClient.isActive();
+  }
+  async connectWithRetry() {
+    const maxAttempts = this.config.maxReconnectAttempts;
+    const delay = this.config.reconnectDelay;
+    while (this.retryAttempts < maxAttempts) {
+      try {
+        await this.amqplibClient.connect();
+        this.logger.log("Successfully connected to RabbitMQ");
+        this.retryAttempts = 0;
+        return;
+      } catch (error) {
+        this.retryAttempts++;
+        this.logger.error(`Connection attempt ${this.retryAttempts}/${maxAttempts} failed:`, error);
+        if (this.retryAttempts >= maxAttempts) {
+          throw new RunMQException(
+            Exceptions.EXCEEDING_CONNECTION_ATTEMPTS,
+            {
+              attempts: maxAttempts,
+              error: error instanceof Error ? error.message : String(error)
+            }
+          );
+        }
+        this.logger.error(`Retrying in ${delay}ms...`);
+        await RunMQUtils.delay(delay);
+      }
+    }
+  }
+  async initialize() {
+    this.defaultChannel = await this.amqplibClient.getChannel();
+    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();
+  }
+};
+export {
+  RunMQ
+};
+//# sourceMappingURL=index.js.map