runmq 1.3.0 → 1.4.2

package/dist/index.js

@@ -27,8 +27,8 @@ var RunMQException = class extends Error {
   }
 };
 
-// src/core/clients/RabbitMQClientAdapter.ts
-import { Connection } from "rabbitmq-client";
+// src/core/clients/AmqplibClientAdapter.ts
+import amqplib from "amqplib";
 
 // src/core/exceptions/Exceptions.ts
 var Exceptions = class {
@@ -40,8 +40,8 @@ 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/RabbitMQClientChannel.ts
-var RabbitMQClientChannel = class {
+// src/core/clients/AmqplibChannel.ts
+var AmqplibChannel = class {
   constructor(channel) {
     this.channel = channel;
   }
@@ -51,8 +51,7 @@ var RabbitMQClientChannel = class {
     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,
+    const result = await this.channel.assertQueue(queue, {
       durable: options == null ? void 0 : options.durable,
       exclusive: options == null ? void 0 : options.exclusive,
       autoDelete: options == null ? void 0 : options.autoDelete,
@@ -65,10 +64,7 @@ var RabbitMQClientChannel = class {
     };
   }
   async checkQueue(queue) {
-    const result = await this.channel.queueDeclare({
-      queue,
-      passive: true
-    });
+    const result = await this.channel.checkQueue(queue);
     return {
       queue: result.queue,
       messageCount: result.messageCount,
@@ -76,8 +72,7 @@ var RabbitMQClientChannel = class {
     };
   }
   async deleteQueue(queue, options) {
-    const result = await this.channel.queueDelete({
-      queue,
+    const result = await this.channel.deleteQueue(queue, {
       ifUnused: options == null ? void 0 : options.ifUnused,
       ifEmpty: options == null ? void 0 : options.ifEmpty
     });
@@ -89,9 +84,7 @@ var RabbitMQClientChannel = class {
     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,
+    await this.channel.assertExchange(exchange, type, {
       durable: options == null ? void 0 : options.durable,
       internal: options == null ? void 0 : options.internal,
       autoDelete: options == null ? void 0 : options.autoDelete,
@@ -102,37 +95,26 @@ var RabbitMQClientChannel = class {
     };
   }
   async checkExchange(exchange) {
-    await this.channel.exchangeDeclare({
-      exchange,
-      passive: true
-    });
+    await this.channel.checkExchange(exchange);
     return {
       exchange
     };
   }
   async deleteExchange(exchange, options) {
-    await this.channel.exchangeDelete({
-      exchange,
+    await this.channel.deleteExchange(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
-    });
+    await this.channel.bindQueue(queue, source, pattern, args);
   }
   publish(exchange, routingKey, content, options) {
     var _a2;
-    this.channel.basicPublish({
-      exchange,
-      routingKey,
+    return this.channel.publish(exchange, routingKey, content, {
       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,
+      persistent: 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,
@@ -142,79 +124,106 @@ var RabbitMQClientChannel = class {
       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 result = await this.channel.consume(queue, (msg) => {
+      if (msg === null) {
+        onMessage(null);
+        return;
+      }
       const consumeMessage = {
-        content,
+        content: msg.content,
         fields: {
-          consumerTag: msg.consumerTag,
-          deliveryTag: msg.deliveryTag,
-          redelivered: msg.redelivered,
-          exchange: msg.exchange,
-          routingKey: msg.routingKey
+          consumerTag: msg.fields.consumerTag,
+          deliveryTag: msg.fields.deliveryTag,
+          redelivered: msg.fields.redelivered,
+          exchange: msg.fields.exchange,
+          routingKey: msg.fields.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
+          contentType: msg.properties.contentType || void 0,
+          contentEncoding: msg.properties.contentEncoding || void 0,
+          headers: msg.properties.headers || {},
+          deliveryMode: msg.properties.deliveryMode,
+          priority: msg.properties.priority,
+          correlationId: msg.properties.correlationId || void 0,
+          replyTo: msg.properties.replyTo || void 0,
+          expiration: msg.properties.expiration || void 0,
+          messageId: msg.properties.messageId || void 0,
+          timestamp: msg.properties.timestamp,
+          type: msg.properties.type || void 0,
+          userId: msg.properties.userId || void 0,
+          appId: msg.properties.appId || void 0
         }
       };
       onMessage(consumeMessage);
+    }, {
+      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,
+      priority: options == null ? void 0 : options.priority,
+      arguments: options == null ? void 0 : options.arguments
     });
     return {
       consumerTag: result.consumerTag
     };
   }
   ack(message, allUpTo) {
-    this.channel.basicAck({
-      deliveryTag: message.fields.deliveryTag,
-      multiple: allUpTo
-    });
+    this.channel.ack(
+      { fields: message.fields, content: message.content, properties: message.properties },
+      allUpTo
+    );
   }
   nack(message, allUpTo, requeue) {
-    this.channel.basicNack({
-      deliveryTag: message.fields.deliveryTag,
-      multiple: allUpTo,
+    this.channel.nack(
+      { fields: message.fields, content: message.content, properties: message.properties },
+      allUpTo,
       requeue
-    });
+    );
   }
   async prefetch(count, global) {
-    await this.channel.basicQos({
-      prefetchCount: count,
-      global
-    });
+    await this.channel.prefetch(count, global);
   }
   async close() {
     await this.channel.close();
   }
 };
 
-// src/core/clients/RabbitMQClientAdapter.ts
-var RabbitMQClientAdapter = class {
-  constructor(config) {
+// 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/clients/AmqplibClientAdapter.ts
+var AmqplibClientAdapter = class {
+  constructor(config, logger = new RunMQConsoleLogger()) {
     this.config = config;
+    this.logger = logger;
     this.isConnected = false;
     this.acquiredChannels = [];
   }
@@ -230,38 +239,20 @@ var RabbitMQClientAdapter = class {
         }
         this.connection = void 0;
       }
-      this.connection = new Connection({
-        url: this.config.url,
-        // Disable automatic retries - we handle retries at RunMQ level
-        retryLow: 100,
-        retryHigh: 200,
-        connectionTimeout: 5e3
-      });
+      const connection = await amqplib.connect(this.config.url);
+      this.connection = connection;
       this.connection.on("error", (err) => {
-        console.error("RabbitMQ connection error:", err);
+        this.logger.error("RabbitMQ connection error:", { 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");
+      this.connection.on("close", () => {
+        this.isConnected = false;
       });
-      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;
-      }
+      this.connection = void 0;
       throw new RunMQException(
         Exceptions.CONNECTION_NOT_ESTABLISHED,
         {
@@ -272,9 +263,9 @@ var RabbitMQClientAdapter = class {
   }
   async getChannel() {
     const connection = await this.connect();
-    const rawChannel = await connection.acquire();
+    const rawChannel = await connection.createChannel();
     this.acquiredChannels.push(rawChannel);
-    return new RabbitMQClientChannel(rawChannel);
+    return new AmqplibChannel(rawChannel);
   }
   async getDefaultChannel() {
     if (!this.defaultChannel) {
@@ -291,9 +282,7 @@ var RabbitMQClientAdapter = class {
     this.acquiredChannels = [];
     for (const channel of channels) {
       try {
-        if (channel.active) {
-          await channel.close();
-        }
+        await channel.close();
       } catch (e) {
       }
     }
@@ -335,7 +324,8 @@ var Constants = {
   DEAD_LETTER_ROUTER_EXCHANGE_NAME: RUNMQ_PREFIX + "dead_letter_router",
   RETRY_DELAY_QUEUE_PREFIX: RUNMQ_PREFIX + "retry_delay_",
   DLQ_QUEUE_PREFIX: RUNMQ_PREFIX + "dlq_",
-  MESSAGE_TTL_OPERATOR_POLICY_PREFIX: RUNMQ_PREFIX + "message_ttl_operator_policy"
+  MESSAGE_TTL_OPERATOR_POLICY_PREFIX: RUNMQ_PREFIX + "message_ttl_operator_policy",
+  METADATA_STORE_PREFIX: RUNMQ_PREFIX + "metadata_"
 };
 var DEFAULTS = {
   RECONNECT_DELAY: 5e3,
@@ -413,6 +403,27 @@ var RunMQFailedMessageRejecterProcessor = class {
   }
 };
 
+// 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/consumer/ConsumerCreatorUtils.ts
 var ConsumerCreatorUtils = class {
   static getDLQTopicName(topic) {
@@ -464,7 +475,28 @@ var RunMQRetriesCheckerProcessor = class {
     );
   }
   moveToFinalDeadLetter(message) {
-    this.DLQPublisher.publish(ConsumerCreatorUtils.getDLQTopicName(this.config.name), message);
+    const originalPayload = this.extractOriginalPayload(message);
+    const dlqMessage = new RabbitMQMessage(
+      originalPayload,
+      message.id,
+      message.correlationId,
+      message.channel,
+      message.amqpMessage,
+      message.headers
+    );
+    this.DLQPublisher.publish(ConsumerCreatorUtils.getDLQTopicName(this.config.name), dlqMessage);
+  }
+  extractOriginalPayload(message) {
+    if (typeof message.message === "string") {
+      try {
+        const parsed = JSON.parse(message.message);
+        if (RunMQMessage.isValid(parsed)) {
+          return parsed.message;
+        }
+      } catch (e) {
+      }
+    }
+    return message.message;
   }
   acknowledgeMessage(message) {
     try {
@@ -542,27 +574,6 @@ var RunMQExceptionLoggerProcessor = class {
   }
 };
 
-// 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 {
@@ -837,6 +848,91 @@ var RabbitMQManagementClient = class {
       return false;
     }
   }
+  /**
+   * Creates or updates a RabbitMQ parameter.
+   * Parameters are custom key-value stores that can hold any JSON data.
+   *
+   * @param name - The parameter name
+   * @param value - The parameter value (any JSON-serializable object)
+   */
+  async setParameter(name, value) {
+    try {
+      const url = `${this.config.url}/api/global-parameters/${encodeURIComponent(name)}`;
+      const response = await fetch(url, {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": this.getAuthHeader()
+        },
+        body: JSON.stringify({ value })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        this.logger.error(`Failed to set parameter ${name}: ${response.status} - ${error}`);
+        return false;
+      }
+      this.logger.info(`Successfully set parameter: ${name}`);
+      return true;
+    } catch (error) {
+      this.logger.error(`Error setting parameter: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * Gets a RabbitMQ parameter.
+   *
+   * @param name - The parameter name
+   */
+  async getParameter(name) {
+    try {
+      const url = `${this.config.url}/api/global-parameters/${encodeURIComponent(name)}`;
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "Authorization": this.getAuthHeader()
+        }
+      });
+      if (!response.ok) {
+        if (response.status === 404) {
+          return null;
+        }
+        const error = await response.text();
+        this.logger.error(`Failed to get parameter ${name}: ${response.status} - ${error}`);
+        return null;
+      }
+      const data = await response.json();
+      return data.value;
+    } catch (error) {
+      this.logger.error(`Error getting parameter: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Deletes a RabbitMQ parameter.
+   *
+   * @param name - The parameter name
+   */
+  async deleteParameter(name) {
+    try {
+      const url = `${this.config.url}/api/global-parameters/${encodeURIComponent(name)}`;
+      const response = await fetch(url, {
+        method: "DELETE",
+        headers: {
+          "Authorization": this.getAuthHeader()
+        }
+      });
+      if (!response.ok && response.status !== 404) {
+        const error = await response.text();
+        this.logger.error(`Failed to delete parameter ${name}: ${response.status} - ${error}`);
+        return false;
+      }
+      this.logger.info(`Successfully deleted parameter: ${name}`);
+      return true;
+    } catch (error) {
+      this.logger.error(`Error deleting parameter: ${error}`);
+      return false;
+    }
+  }
 };
 
 // src/core/management/Policies/RabbitMQMessageTTLPolicy.ts
@@ -866,6 +962,9 @@ var RunMQTTLPolicyManager = class {
     }
   }
   async initialize() {
+    if (this.isManagementPluginEnabled) {
+      return;
+    }
     if (!this.managementClient) {
       this.logger.warn("Management client not configured");
       return;
@@ -898,21 +997,166 @@ var RunMQTTLPolicyManager = class {
   }
 };
 
+// src/core/management/Policies/RunMQQueueMetadata.ts
+var METADATA_SCHEMA_VERSION = 0;
+
+// src/core/management/Policies/RabbitMQMetadata.ts
+var RabbitMQMetadata = class {
+  /**
+   * Creates metadata for a queue.
+   * @param maxRetries - Maximum retry attempts configured for the queue
+   * @param existingMetadata - Optional existing metadata to preserve createdAt
+   * @returns RunMQQueueMetadata object
+   */
+  static createMetadataFor(maxRetries, existingMetadata) {
+    var _a2;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return __spreadValues({
+      version: METADATA_SCHEMA_VERSION,
+      maxRetries,
+      createdAt: (_a2 = existingMetadata == null ? void 0 : existingMetadata.createdAt) != null ? _a2 : now
+    }, existingMetadata ? { updatedAt: now } : {});
+  }
+  /**
+   * Gets the parameter name for a given queue.
+   */
+  static getParameterName(queueName) {
+    return Constants.METADATA_STORE_PREFIX + queueName;
+  }
+};
+
+// src/core/management/Policies/RunMQMetadataManager.ts
+var RunMQMetadataManager = class {
+  constructor(logger, managementConfig) {
+    this.logger = logger;
+    this.managementConfig = managementConfig;
+    this.managementClient = null;
+    this.isManagementPluginEnabled = false;
+    if (this.managementConfig) {
+      this.managementClient = new RabbitMQManagementClient(this.managementConfig, this.logger);
+    }
+  }
+  /**
+   * Initialize the manager by checking if management plugin is available.
+   */
+  async initialize() {
+    if (this.isManagementPluginEnabled) {
+      return;
+    }
+    if (!this.managementClient) {
+      this.logger.warn("Management client not configured - metadata storage disabled");
+      return;
+    }
+    this.isManagementPluginEnabled = await this.managementClient.checkManagementPluginEnabled();
+    if (!this.isManagementPluginEnabled) {
+      this.logger.warn("RabbitMQ management plugin is not enabled - metadata storage disabled");
+    } else {
+      this.logger.info("RunMQ metadata storage initialized");
+    }
+  }
+  /**
+   * Store or update metadata for a queue.
+   * If metadata already exists, preserves createdAt and sets updatedAt.
+   *
+   * @param queueName - The name of the queue
+   * @param maxRetries - Maximum retry attempts
+   * @returns true if metadata was stored successfully, false otherwise
+   */
+  async apply(queueName, maxRetries) {
+    if (!this.isManagementPluginEnabled || !this.managementClient) {
+      this.logger.warn(`Cannot store metadata for queue '${queueName}' - management plugin not available`);
+      return false;
+    }
+    try {
+      const existingMetadata = await this.getMetadata(queueName);
+      const metadata = RabbitMQMetadata.createMetadataFor(
+        maxRetries,
+        existingMetadata != null ? existingMetadata : void 0
+      );
+      const paramName = RabbitMQMetadata.getParameterName(queueName);
+      const success = await this.managementClient.setParameter(
+        paramName,
+        metadata
+      );
+      if (success) {
+        const action = existingMetadata ? "Updated" : "Created";
+        this.logger.info(`${action} metadata for queue: ${queueName}`);
+        return true;
+      }
+      this.logger.error(`Failed to store metadata for queue: ${queueName}`);
+      return false;
+    } catch (error) {
+      this.logger.error(`Error storing metadata for queue ${queueName}: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * Get metadata for a queue.
+   *
+   * @param queueName - The name of the queue
+   * @returns The queue metadata or null if not found
+   */
+  async getMetadata(queueName) {
+    if (!this.isManagementPluginEnabled || !this.managementClient) {
+      return null;
+    }
+    try {
+      const paramName = RabbitMQMetadata.getParameterName(queueName);
+      return await this.managementClient.getParameter(
+        paramName
+      );
+    } catch (error) {
+      this.logger.warn(`Failed to get metadata for queue ${queueName}: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Delete metadata for a queue.
+   *
+   * @param queueName - The name of the queue
+   */
+  async cleanup(queueName) {
+    if (!this.isManagementPluginEnabled || !this.managementClient) {
+      return;
+    }
+    const paramName = RabbitMQMetadata.getParameterName(queueName);
+    await this.managementClient.deleteParameter(paramName);
+    this.logger.info(`Deleted metadata for queue: ${queueName}`);
+  }
+  /**
+   * Check if management plugin is enabled and metadata storage is available.
+   */
+  isEnabled() {
+    return this.isManagementPluginEnabled;
+  }
+};
+
 // src/core/consumer/RunMQConsumerCreator.ts
 var RunMQConsumerCreator = class {
   constructor(client, logger, managementConfig) {
     this.client = client;
     this.logger = logger;
     this.ttlPolicyManager = new RunMQTTLPolicyManager(logger, managementConfig);
+    this.metadataManager = new RunMQMetadataManager(logger, managementConfig);
   }
   async createConsumer(consumerConfiguration) {
     await this.ttlPolicyManager.initialize();
+    await this.metadataManager.initialize();
     await this.assertQueues(consumerConfiguration);
     await this.bindQueues(consumerConfiguration);
+    await this.storeMetadata(consumerConfiguration);
     for (let i = 0; i < consumerConfiguration.processorConfig.consumersCount; i++) {
       await this.runProcessor(consumerConfiguration);
     }
   }
+  async storeMetadata(consumerConfiguration) {
+    var _a2;
+    const maxRetries = (_a2 = consumerConfiguration.processorConfig.attempts) != null ? _a2 : DEFAULTS.PROCESSING_ATTEMPTS;
+    await this.metadataManager.apply(
+      consumerConfiguration.processorConfig.name,
+      maxRetries
+    );
+  }
   async runProcessor(consumerConfiguration) {
     const consumerChannel = await this.getProcessorChannel();
     const DLQPublisher = new RunMQPublisherCreator(this.logger).createPublisher(Constants.DEAD_LETTER_ROUTER_EXCHANGE_NAME);
@@ -1029,34 +1273,6 @@ var ConsumerConfiguration = class {
   }
 };
 
-// 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) {
@@ -1075,7 +1291,8 @@ var RunMQ = class _RunMQ {
       reconnectDelay: (_a2 = config.reconnectDelay) != null ? _a2 : DEFAULTS.RECONNECT_DELAY,
       maxReconnectAttempts: (_b = config.maxReconnectAttempts) != null ? _b : DEFAULTS.MAX_RECONNECT_ATTEMPTS
     });
-    this.client = new RabbitMQClientAdapter(this.config);
+    this.client = new AmqplibClientAdapter(this.config, this.logger);
+    this.consumer = new RunMQConsumerCreator(this.client, this.logger, this.config.management);
   }
   /**
    * Starts the RunMQ instance by establishing a connection to RabbitMQ and initializing necessary components.
@@ -1096,8 +1313,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.client, this.logger, this.config.management);
-    await consumer.createConsumer(new ConsumerConfiguration(topic, config, processor));
+    await this.consumer.createConsumer(new ConsumerConfiguration(topic, config, processor));
   }
   /**
    * Publishes a message to the specified topic with an optional correlation ID
@@ -1156,7 +1372,6 @@ var RunMQ = class _RunMQ {
         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(