runmq 1.5.1 → 2.0.0

package/dist/index.js

@@ -124,9 +124,9 @@ var RabbitMQClientChannel = class {
       arguments: args
     });
   }
-  publish(exchange, routingKey, content, options) {
+  async publish(exchange, routingKey, content, options) {
     var _a2;
-    this.channel.basicPublish({
+    await this.channel.basicPublish({
       exchange,
       routingKey,
       correlationId: options == null ? void 0 : options.correlationId,
@@ -143,7 +143,9 @@ var RabbitMQClientChannel = class {
       userId: options == null ? void 0 : options.userId,
       appId: options == null ? void 0 : options.appId
     }, content);
-    return true;
+  }
+  async confirmSelect() {
+    await this.channel.confirmSelect();
   }
   async consume(queue, onMessage, options) {
     const result = await this.channel.basicConsume({
@@ -246,12 +248,14 @@ var RabbitMQClientAdapter = class {
     this.logger = logger;
     this.isConnected = false;
     this.acquiredChannels = [];
+    this.isShuttingDown = false;
   }
   async connect() {
     try {
       if (this.connection && this.isConnected) {
         return this.connection;
       }
+      this.isShuttingDown = false;
       if (this.connection) {
         try {
           await this.connection.close();
@@ -300,21 +304,52 @@ var RabbitMQClientAdapter = class {
       );
     }
   }
-  async getChannel() {
+  async getChannel(callbacks) {
     const connection = await this.connect();
     const rawChannel = await connection.acquire();
+    const channelId = rawChannel.id;
+    rawChannel.on("error", (err) => {
+      var _a2;
+      this.logger.error("RabbitMQ channel error:", { channelId, error: err });
+      try {
+        (_a2 = callbacks == null ? void 0 : callbacks.onError) == null ? void 0 : _a2.call(callbacks, err);
+      } catch (cbErr) {
+        this.logger.error("RabbitMQ channel onError callback threw:", { channelId, error: cbErr });
+      }
+    });
+    rawChannel.on("close", () => {
+      var _a2;
+      this.logger.warn("RabbitMQ channel closed", { channelId });
+      const idx = this.acquiredChannels.indexOf(rawChannel);
+      if (idx >= 0) {
+        this.acquiredChannels.splice(idx, 1);
+      }
+      if (this.isShuttingDown) {
+        return;
+      }
+      try {
+        (_a2 = callbacks == null ? void 0 : callbacks.onClose) == null ? void 0 : _a2.call(callbacks);
+      } catch (cbErr) {
+        this.logger.error("RabbitMQ channel onClose callback threw:", { channelId, error: cbErr });
+      }
+    });
     this.acquiredChannels.push(rawChannel);
     return new RabbitMQClientChannel(rawChannel);
   }
   async getDefaultChannel() {
     if (!this.defaultChannel) {
-      this.defaultChannel = await this.getChannel();
+      this.defaultChannel = await this.getChannel({
+        onClose: () => {
+          this.defaultChannel = void 0;
+        }
+      });
     }
     return this.defaultChannel;
   }
   async disconnect() {
     const conn = this.connection;
     const channels = this.acquiredChannels;
+    this.isShuttingDown = true;
     this.connection = void 0;
     this.defaultChannel = void 0;
     this.isConnected = false;
@@ -387,20 +422,33 @@ var RabbitMQMessage = class _RabbitMQMessage {
     this.headers = headers;
   }
   /**
-   * Acknowledges the message.
+   * Acknowledges the message. Returns true on success, false if the
+   * underlying channel rejected the call (e.g. closed mid-flight).
+   * Plumbing errors are intentionally swallowed: the broker will redeliver
+   * unacked messages on channel close, so escalating here only crashes
+   * the consumer for no recovery benefit.
    */
   ack() {
-    if (this.amqpMessage) {
+    if (!this.amqpMessage) return false;
+    try {
       this.channel.ack(this.amqpMessage);
+      return true;
+    } catch (e) {
+      return false;
     }
   }
   /**
-   * Negatively acknowledges the message.
+   * Negatively acknowledges the message. Returns true on success, false if
+   * the underlying channel rejected the call. See `ack()` for rationale.
    * @param requeue - Whether to requeue the message (default: false)
    */
   nack(requeue = false) {
-    if (this.amqpMessage) {
+    if (!this.amqpMessage) return false;
+    try {
       this.channel.nack(this.amqpMessage, false, requeue);
+      return true;
+    } catch (e) {
+      return false;
     }
   }
   static from(messageData, channel, props, amqpMessage = null) {
@@ -417,13 +465,20 @@ var RabbitMQMessage = class _RabbitMQMessage {
 
 // src/core/consumer/processors/RunMQSucceededMessageAcknowledgerProcessor.ts
 var RunMQSucceededMessageAcknowledgerProcessor = class {
-  constructor(consumer) {
+  constructor(consumer, logger) {
     this.consumer = consumer;
+    this.logger = logger;
   }
   async consume(message) {
+    var _a2;
     const result = await this.consumer.consume(message);
     if (result) {
-      message.ack();
+      const acked = message.ack();
+      if (!acked) {
+        (_a2 = this.logger) == null ? void 0 : _a2.warn("Failed to ack message \u2014 channel likely closed. Broker will redeliver.", {
+          correlationId: message.correlationId
+        });
+      }
     }
     return result;
   }
@@ -431,40 +486,26 @@ var RunMQSucceededMessageAcknowledgerProcessor = class {
 
 // src/core/consumer/processors/RunMQFailedMessageRejecterProcessor.ts
 var RunMQFailedMessageRejecterProcessor = class {
-  constructor(consumer) {
+  constructor(consumer, logger) {
     this.consumer = consumer;
+    this.logger = logger;
   }
   async consume(message) {
+    var _a2;
     try {
       return await this.consumer.consume(message);
     } catch (e) {
-      message.nack(false);
+      const nacked = message.nack(false);
+      if (!nacked) {
+        (_a2 = this.logger) == null ? void 0 : _a2.warn("Failed to nack message \u2014 channel likely closed. Broker will redeliver.", {
+          correlationId: message.correlationId
+        });
+      }
       return false;
     }
   }
 };
 
-// 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) {
@@ -481,11 +522,11 @@ var ConsumerCreatorUtils = class {
 // src/core/consumer/processors/RunMQRetriesCheckerProcessor.ts
 var _a;
 var RunMQRetriesCheckerProcessor = class {
-  constructor(consumer, config, DLQPublisher, logger) {
+  constructor(consumer, config, logger, logFullMessagePayload = false) {
     this.consumer = consumer;
     this.config = config;
-    this.DLQPublisher = DLQPublisher;
     this.logger = logger;
+    this.logFullMessagePayload = logFullMessagePayload;
     this.maxAttempts = (_a = this.config.attempts) != null ? _a : DEFAULTS.PROCESSING_ATTEMPTS;
   }
   async consume(message) {
@@ -494,7 +535,16 @@ var RunMQRetriesCheckerProcessor = class {
     } catch (e) {
       if (this.hasReachedMaxRetries(message)) {
         this.logMaxRetriesReached(message);
-        this.moveToFinalDeadLetter(message);
+        try {
+          await this.moveToFinalDeadLetter(message);
+        } catch (publishError) {
+          this.logger.error("Failed to publish to DLQ \u2014 message will be redelivered", {
+            correlationId: message.correlationId,
+            cause: publishError instanceof Error ? publishError.message : String(publishError)
+          });
+          message.nack(false);
+          return false;
+        }
         this.acknowledgeMessage(message);
         return false;
       }
@@ -508,44 +558,38 @@ var RunMQRetriesCheckerProcessor = class {
   logMaxRetriesReached(message) {
     this.logger.error(
       `Message reached maximum attempts. Moving to dead-letter queue.`,
-      {
-        message: message.message,
+      __spreadValues({
+        correlationId: message.correlationId,
+        messageId: message.id,
         attempts: this.getRejectionCount(message),
         max: this.maxAttempts
-      }
+      }, this.logFullMessagePayload ? { message: message.message } : {})
     );
   }
-  moveToFinalDeadLetter(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) {
+  // Republish the original AMQP body verbatim so the envelope (including
+  // publishedAt) is preserved end-to-end for audit/replay. The consumer
+  // channel runs in confirm mode (see RunMQConsumerCreator), so awaiting
+  // this publish surfaces broker-side rejections instead of dropping them.
+  async moveToFinalDeadLetter(message) {
+    if (!message.amqpMessage) return;
+    await message.channel.publish(
+      Constants.DEAD_LETTER_ROUTER_EXCHANGE_NAME,
+      ConsumerCreatorUtils.getDLQTopicName(this.config.name),
+      message.amqpMessage.content,
+      {
+        correlationId: message.correlationId,
+        messageId: message.id,
+        headers: message.headers,
+        persistent: true
       }
-    }
-    return message.message;
+    );
   }
   acknowledgeMessage(message) {
-    try {
-      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) });
-      throw error;
+    const acked = message.ack();
+    if (!acked) {
+      this.logger.warn("Failed to ack message after publishing to final dead letter \u2014 channel likely closed. Broker will redeliver.", {
+        correlationId: message.correlationId
+      });
     }
   }
   getRejectionCount(message) {
@@ -559,9 +603,10 @@ var RunMQRetriesCheckerProcessor = class {
 
 // src/core/consumer/processors/RunMQFailureLoggerProcessor.ts
 var RunMQFailureLoggerProcessor = class {
-  constructor(consumer, logger) {
+  constructor(consumer, logger, logFullMessagePayload = false) {
     this.consumer = consumer;
     this.logger = logger;
+    this.logFullMessagePayload = logFullMessagePayload;
   }
   async consume(message) {
     try {
@@ -569,9 +614,10 @@ var RunMQFailureLoggerProcessor = class {
     } catch (e) {
       this.logger.error(
         "Message processing failed",
-        {
-          message: message.message
-        },
+        __spreadValues({
+          correlationId: message.correlationId,
+          messageId: message.id
+        }, this.logFullMessagePayload ? { message: message.message } : {}),
         e instanceof Error ? e.stack : void 0
       );
       throw e;
@@ -579,39 +625,24 @@ var RunMQFailureLoggerProcessor = class {
   }
 };
 
-// src/core/consumer/processors/RunMQBaseProcessor.ts
-var RunMQBaseProcessor = class {
-  constructor(handler, processorConfig, serializer) {
-    this.handler = handler;
-    this.processorConfig = processorConfig;
-    this.serializer = serializer;
+// 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;
   }
-  async consume(message) {
-    const rabbitMQMessage = this.serializer.deserialize(message.message, this.processorConfig);
-    await this.handler(rabbitMQMessage);
-    return true;
+  constructor(message, meta) {
+    this.message = message;
+    this.meta = meta;
   }
 };
-
-// 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);
-      }
-    }
+var RunMQMessageMeta = class {
+  constructor(id, publishedAt, correlationId) {
+    this.id = id;
+    this.correlationId = correlationId;
+    this.publishedAt = publishedAt;
   }
 };
 
@@ -620,6 +651,17 @@ import Ajv from "ajv";
 var AjvSchemaValidator = class {
   constructor() {
     this.lastValidator = null;
+    /**
+     * Cache of compiled validators, keyed by schema identity.
+     *
+     * `ajv.compile()` codegens an optimized JS function from the schema
+     * (typically 2-10ms for non-trivial schemas). Without this cache the
+     * compile would run on every message — at high throughput it dominates
+     * CPU usage.
+     *
+     * WeakMap so we don't pin schemas in memory if a processor is removed.
+     */
+    this.compiled = /* @__PURE__ */ new WeakMap();
     this.ajv = new Ajv({
       allErrors: true,
       verbose: true,
@@ -627,8 +669,14 @@ var AjvSchemaValidator = class {
     });
   }
   validate(schema, data) {
-    this.lastValidator = this.ajv.compile(schema);
-    return this.lastValidator(data);
+    const key = schema;
+    let validator = this.compiled.get(key);
+    if (!validator) {
+      validator = this.ajv.compile(schema);
+      this.compiled.set(key, validator);
+    }
+    this.lastValidator = validator;
+    return validator(data);
   }
   getError() {
     if (!this.lastValidator || !this.lastValidator.errors) {
@@ -714,18 +762,111 @@ var DefaultDeserializer = class {
   }
 };
 
+// src/core/consumer/processors/RunMQSchemaFailureProcessor.ts
+var RunMQSchemaFailureProcessor = class {
+  constructor(consumer, config, DLQPublisher, logger) {
+    this.consumer = consumer;
+    this.config = config;
+    this.DLQPublisher = DLQPublisher;
+    this.logger = logger;
+  }
+  async consume(message) {
+    try {
+      return await this.consumer.consume(message);
+    } catch (e) {
+      if (this.shouldRouteToDLQ(e)) {
+        this.logger.warn("Schema validation failed \u2014 routing message to DLQ.", {
+          correlationId: message.correlationId,
+          error: e instanceof RunMQSchemaValidationError ? e.error : void 0
+        });
+        this.routeToDLQ(message);
+        return true;
+      }
+      throw e;
+    }
+  }
+  shouldRouteToDLQ(e) {
+    var _a2;
+    if (!(e instanceof RunMQSchemaValidationError)) return false;
+    return ((_a2 = this.config.messageSchema) == null ? void 0 : _a2.failureStrategy) === "dlq";
+  }
+  routeToDLQ(message) {
+    const dlqMessage = new RabbitMQMessage(
+      this.extractOriginalPayload(message),
+      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;
+  }
+};
+
+// 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/publisher/producers/RunMQFailureLoggerProducer.ts
 var RunMQFailureLoggerProducer = class {
   constructor(producer, logger) {
     this.producer = producer;
     this.logger = logger;
   }
-  publish(topic, message) {
+  async publish(topic, message) {
     try {
-      this.producer.publish(topic, message);
+      await this.producer.publish(topic, message);
     } catch (e) {
       this.logger.error("Message publishing failed", {
-        message,
+        topic,
+        correlationId: message.correlationId,
         error: e instanceof Error ? e.message : JSON.stringify(e),
         stack: e instanceof Error ? e.stack : void 0
       });
@@ -740,7 +881,7 @@ var RunMQBaseProducer = class {
     this.serializer = serializer;
     this.exchange = exchange;
   }
-  publish(topic, message) {
+  async publish(topic, message) {
     const runMQMessage = new RunMQMessage(
       message.message,
       new RunMQMessageMeta(
@@ -750,7 +891,7 @@ var RunMQBaseProducer = class {
       )
     );
     const serialized = this.serializer.serialize(runMQMessage);
-    message.channel.publish(this.exchange, topic, Buffer.from(serialized), {
+    await message.channel.publish(this.exchange, topic, Buffer.from(serialized), {
       correlationId: message.correlationId,
       messageId: message.id,
       headers: message.headers,
@@ -1175,9 +1316,10 @@ var RunMQMetadataManager = class {
 
 // src/core/consumer/RunMQConsumerCreator.ts
 var RunMQConsumerCreator = class {
-  constructor(client, logger, managementConfig) {
+  constructor(client, logger, managementConfig, logFullMessagePayload = false) {
     this.client = client;
     this.logger = logger;
+    this.logFullMessagePayload = logFullMessagePayload;
     this.ttlPolicyManager = new RunMQTTLPolicyManager(logger, managementConfig);
     this.metadataManager = new RunMQMetadataManager(logger, managementConfig);
   }
@@ -1200,39 +1342,67 @@ var RunMQConsumerCreator = class {
     );
   }
   async runProcessor(consumerConfiguration) {
-    const consumerChannel = await this.getProcessorChannel();
+    var _a2;
+    const consumerChannel = await this.client.getChannel({
+      onClose: () => {
+        if (!this.client.isActive()) {
+          return;
+        }
+        this.logger.warn("Consumer channel closed; attempting to re-subscribe", {
+          processor: consumerConfiguration.processorConfig.name
+        });
+        this.resubscribeProcessor(consumerConfiguration);
+      }
+    });
     const DLQPublisher = new RunMQPublisherCreator(this.logger).createPublisher(Constants.DEAD_LETTER_ROUTER_EXCHANGE_NAME);
-    await consumerChannel.prefetch(DEFAULTS.PREFETCH_COUNT);
+    await consumerChannel.confirmSelect();
+    const prefetchCount = (_a2 = consumerConfiguration.processorConfig.prefetch) != null ? _a2 : DEFAULTS.PREFETCH_COUNT;
+    await consumerChannel.prefetch(prefetchCount);
     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(
+      if (!msg) return;
+      const rabbitmqMessage = new RabbitMQMessage(
+        msg.content.toString(),
+        msg.properties.messageId,
+        msg.properties.correlationId,
+        consumerChannel,
+        msg,
+        msg.properties.headers
+      );
+      try {
+        await new RunMQExceptionLoggerProcessor(
           new RunMQSucceededMessageAcknowledgerProcessor(
             new RunMQFailedMessageRejecterProcessor(
               new RunMQRetriesCheckerProcessor(
                 new RunMQFailureLoggerProcessor(
-                  new RunMQBaseProcessor(
-                    consumerConfiguration.processor,
+                  new RunMQSchemaFailureProcessor(
+                    new RunMQBaseProcessor(
+                      consumerConfiguration.processor,
+                      consumerConfiguration.processorConfig,
+                      new DefaultDeserializer()
+                    ),
                     consumerConfiguration.processorConfig,
-                    new DefaultDeserializer()
+                    DLQPublisher,
+                    this.logger
                   ),
-                  this.logger
+                  this.logger,
+                  this.logFullMessagePayload
                 ),
                 consumerConfiguration.processorConfig,
-                DLQPublisher,
-                this.logger
-              )
-            )
+                this.logger,
+                this.logFullMessagePayload
+              ),
+              this.logger
+            ),
+            this.logger
           ),
           this.logger
         ).consume(rabbitmqMessage);
+      } catch (e) {
+        this.logger.error("Unhandled error in consumer chain", {
+          correlationId: rabbitmqMessage.correlationId,
+          cause: e instanceof Error ? e.message : String(e),
+          stack: e instanceof Error ? e.stack : void 0
+        });
       }
     });
   }
@@ -1301,8 +1471,20 @@ var RunMQConsumerCreator = class {
       ConsumerCreatorUtils.getDLQTopicName(consumerConfiguration.processorConfig.name)
     );
   }
-  async getProcessorChannel() {
-    return await this.client.getChannel();
+  resubscribeProcessor(consumerConfiguration) {
+    const delay = DEFAULTS.RECONNECT_DELAY;
+    setTimeout(() => {
+      if (!this.client.isActive()) {
+        return;
+      }
+      this.runProcessor(consumerConfiguration).catch((err) => {
+        this.logger.error("Failed to re-subscribe consumer; will retry", {
+          processor: consumerConfiguration.processorConfig.name,
+          error: err instanceof Error ? err.message : err
+        });
+        this.resubscribeProcessor(consumerConfiguration);
+      });
+    }, delay);
   }
 };
 
@@ -1334,7 +1516,7 @@ var RunMQ = class _RunMQ {
       maxReconnectAttempts: (_b = config.maxReconnectAttempts) != null ? _b : DEFAULTS.MAX_RECONNECT_ATTEMPTS
     });
     this.client = new RabbitMQClientAdapter(this.config, this.logger);
-    this.consumer = new RunMQConsumerCreator(this.client, this.logger, this.config.management);
+    this.consumer = new RunMQConsumerCreator(this.client, this.logger, this.config.management, this.config.logFullMessagePayload);
   }
   /**
    * Starts the RunMQ instance by establishing a connection to RabbitMQ and initializing necessary components.
@@ -1358,29 +1540,38 @@ var RunMQ = class _RunMQ {
     await this.consumer.createConsumer(new ConsumerConfiguration(topic, config, processor));
   }
   /**
-   * Publishes a message to the specified topic with an optional correlation ID
+   * Publishes a message to the specified topic with an optional correlation ID.
+   *
+   * If publisher confirms are enabled (`usePublisherConfirms: true` in the
+   * connection config), the returned promise resolves only after RabbitMQ
+   * acknowledges the message; if the broker rejects, the promise rejects.
+   * Otherwise it resolves once the message is flushed to the TCP socket
+   * (fire-and-forget, no delivery guarantee — same behavior as before
+   * publisher confirms were introduced).
+   *
    * @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 || !this.defaultChannel) {
+  async publish(topic, message, correlationId = RunMQUtils.generateUUID()) {
+    if (!this.publisher || !this.publishChannel) {
       throw new RunMQException(Exceptions.NOT_INITIALIZED, {});
     }
     RunMQUtils.assertRecord(message);
-    this.publisher.publish(
+    const messageId = RunMQUtils.generateUUID();
+    await this.publisher.publish(
       topic,
       RabbitMQMessage.from(
         message,
-        this.defaultChannel,
-        new RabbitMQMessageProperties(RunMQUtils.generateUUID(), correlationId)
+        this.publishChannel,
+        new RabbitMQMessageProperties(messageId, correlationId)
       )
     );
-    this.logger.info(`Published message`, {
+    this.logger.info(`Published message`, __spreadValues({
       topic,
       correlationId,
-      message
-    });
+      messageId
+    }, this.config.logFullMessagePayload ? { message } : {}));
   }
   /**
    * Disconnects from RabbitMQ, handling any errors that may occur during the disconnection process.
@@ -1433,6 +1624,10 @@ var RunMQ = class _RunMQ {
     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.publishChannel = await this.client.getChannel();
+    if (this.config.usePublisherConfirms !== false) {
+      await this.publishChannel.confirmSelect();
+    }
     this.publisher = new RunMQPublisherCreator(this.logger).createPublisher();
   }
 };