@relaybus/rabbitmq 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1113 @@
+'use strict';
+
+var core = require('@relaybus/core');
+
+// src/errors.ts
+var RabbitMqUnavailableError = class extends core.RelayBusError {
+};
+var RabbitMqPublishRejectedError = class extends core.RelayBusError {
+};
+var UnroutableMessageError = class extends core.RelayBusError {
+};
+var MalformedMessageError = class extends core.RelayBusError {
+};
+var UnserializablePayloadError = class extends core.NonRetryableError {
+  name = "UnserializablePayloadError";
+};
+var AmqpLimitExceededError = class extends core.NonRetryableError {
+  name = "AmqpLimitExceededError";
+};
+
+// src/abortable-sleep.ts
+function abortableSleep(milliseconds, signal) {
+  if (signal.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const finish = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", finish);
+      resolve();
+    };
+    const timer = setTimeout(finish, milliseconds);
+    signal.addEventListener("abort", finish, { once: true });
+  });
+}
+
+// src/connection-supervisor.ts
+var ConnectionSupervisor = class {
+  #settings;
+  #stop = new AbortController();
+  #current;
+  #ready = false;
+  #started = false;
+  #closed = false;
+  #reconnecting;
+  constructor(settings) {
+    this.#settings = settings;
+  }
+  /** True while a connection is open and `onConnected` has completed for it. */
+  isConnected() {
+    return this.#ready;
+  }
+  /**
+   * Connects once. When that fails it rejects if `failOnError`, otherwise it
+   * resolves and keeps trying in the background. Does nothing when already started.
+   */
+  async start(failOnError) {
+    if (this.#started) {
+      return;
+    }
+    if (this.#closed) {
+      throw new RabbitMqUnavailableError("[ConnectionSupervisor](start) Transport is closed");
+    }
+    try {
+      await this.#establish();
+      this.#started = true;
+    } catch (error) {
+      if (failOnError) {
+        throw error;
+      }
+      this.#settings.logger.warn(
+        `[ConnectionSupervisor](start) Broker unreachable, retrying in the background | error=${core.toErrorInfo(error).message}`
+      );
+      this.#started = true;
+      this.#startReconnecting();
+    }
+  }
+  /**
+   * Drops the current connection because one of its channels failed, then
+   * reconnects. Closing the channel alone would leave topology half-restored.
+   */
+  recover(reason) {
+    const connection = this.#current;
+    if (connection === void 0) {
+      return;
+    }
+    this.#handleLoss(connection, reason);
+    connection.close().catch(() => void 0);
+  }
+  /**
+   * Stops reconnecting, runs `beforeDisconnect` while the connection is still
+   * open (to drain consumers) and closes the connection.
+   */
+  async close(beforeDisconnect) {
+    this.#closed = true;
+    this.#stop.abort();
+    await this.#reconnecting;
+    try {
+      await beforeDisconnect();
+    } finally {
+      const connection = this.#current;
+      this.#current = void 0;
+      this.#ready = false;
+      await connection?.close().catch(() => void 0);
+    }
+  }
+  async #establish() {
+    const connection = await this.#settings.connect();
+    connection.on("error", (error) => {
+      this.#settings.logger.warn(
+        `[ConnectionSupervisor](establish) Connection error | error=${error.message}`
+      );
+    });
+    connection.on("close", (error) => {
+      this.#handleLoss(connection, error?.message ?? "closed by peer");
+    });
+    this.#current = connection;
+    try {
+      await this.#settings.onConnected(connection);
+      if (this.#current !== connection) {
+        throw new RabbitMqUnavailableError(
+          "Connection was lost while the topology was being set up"
+        );
+      }
+    } catch (error) {
+      await this.#discard(connection);
+      throw error;
+    }
+    this.#ready = true;
+  }
+  async #discard(connection) {
+    if (this.#current === connection) {
+      this.#current = void 0;
+    }
+    this.#settings.onDisconnected();
+    await connection.close().catch(() => void 0);
+  }
+  #handleLoss(connection, reason) {
+    if (connection !== this.#current) {
+      return;
+    }
+    this.#current = void 0;
+    this.#ready = false;
+    this.#settings.logger.warn(
+      `[ConnectionSupervisor](handleLoss) Connection lost | reason=${reason}`
+    );
+    this.#settings.onDisconnected();
+    this.#startReconnecting();
+  }
+  #startReconnecting() {
+    if (this.#settings.reconnect === void 0 || this.#closed || !this.#started || this.#reconnecting !== void 0) {
+      return;
+    }
+    const policy = this.#settings.reconnect;
+    this.#reconnecting = this.#reconnectUntilConnected(policy).finally(() => {
+      this.#reconnecting = void 0;
+    });
+  }
+  async #reconnectUntilConnected(policy) {
+    for (let attempt = 1; !this.#closed; attempt += 1) {
+      const delayMs = core.computeRetryDelay(policy, attempt, this.#settings.random);
+      this.#settings.logger.log(
+        `[ConnectionSupervisor](reconnect) Reconnecting | attempt=${attempt} delayMs=${delayMs}`
+      );
+      await abortableSleep(delayMs, this.#stop.signal);
+      if (this.#closed) {
+        return;
+      }
+      try {
+        await this.#establish();
+        this.#settings.logger.log(
+          `[ConnectionSupervisor](reconnect) Reconnected | attempt=${attempt}`
+        );
+        return;
+      } catch (error) {
+        this.#settings.logger.warn(
+          `[ConnectionSupervisor](reconnect) Attempt failed | attempt=${attempt} error=${core.toErrorInfo(error).message}`
+        );
+      }
+    }
+  }
+};
+var REDELIVERIES_HEADER = "x-relaybus-redeliveries";
+var FIRST_FAILURE_HEADER = "x-relaybus-first-failure-at";
+var DEAD_LETTER_REASON_HEADER = "x-relaybus-dead-letter-reason";
+var RELAYBUS_STATE_HEADERS = [REDELIVERIES_HEADER, FIRST_FAILURE_HEADER];
+var BROKER_COUNTER_HEADERS = ["x-delivery-count", "x-acquired-count"];
+var MAXIMUM_LADDER_TIERS = 16;
+function buildRetryLadder(policy) {
+  if (policy.initialDelayMs < 1) {
+    throw new core.ConfigurationError("redelivery.initialDelay must be at least 1ms");
+  }
+  const tiers = [];
+  let delay = policy.initialDelayMs;
+  for (; ; ) {
+    const tier = Math.round(Math.min(delay, policy.maxDelayMs));
+    tiers.push(tier);
+    if (tier >= policy.maxDelayMs || policy.factor === 1) {
+      return tiers;
+    }
+    if (tiers.length === MAXIMUM_LADDER_TIERS) {
+      throw new core.ConfigurationError(
+        `redelivery needs more than ${MAXIMUM_LADDER_TIERS} retry queues; raise redelivery.factor or lower redelivery.maxDelay`
+      );
+    }
+    delay *= policy.factor;
+  }
+}
+function chooseRetryTier(ladder, delayMs, random) {
+  const upperIndex = ladder.findIndex((tier) => tier >= delayMs);
+  if (upperIndex === -1) {
+    return ladder.at(-1);
+  }
+  if (upperIndex === 0) {
+    return ladder[0];
+  }
+  const lower = ladder[upperIndex - 1];
+  const upper = ladder[upperIndex];
+  return random() < (delayMs - lower) / (upper - lower) ? upper : lower;
+}
+function readCounterHeader(message, name) {
+  const value = message.properties.headers[name];
+  const parsed = typeof value === "string" && /^\d+$/.test(value) ? Number(value) : value;
+  return typeof parsed === "number" && Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function copyForRepublish(message, headerChanges) {
+  const { properties } = message;
+  const headers = { ...properties.headers };
+  for (const name of [
+    ...RELAYBUS_STATE_HEADERS,
+    DEAD_LETTER_REASON_HEADER,
+    ...BROKER_COUNTER_HEADERS
+  ]) {
+    delete headers[name];
+  }
+  Object.assign(headers, headerChanges);
+  return {
+    content: message.content,
+    options: {
+      contentType: typeof properties.contentType === "string" ? properties.contentType : "application/json",
+      persistent: true,
+      ...typeof properties.messageId === "string" ? { messageId: properties.messageId } : {},
+      ...typeof properties.type === "string" ? { type: properties.type } : {},
+      ...typeof properties.appId === "string" ? { appId: properties.appId } : {},
+      ...typeof properties.correlationId === "string" ? { correlationId: properties.correlationId } : {},
+      ...typeof properties.timestamp === "number" ? { timestamp: properties.timestamp } : {},
+      headers
+    }
+  };
+}
+
+// src/options.ts
+var DEFAULT_HANDLER_RETRY = {
+  attempts: 3,
+  initialDelayMs: 200,
+  factor: 2,
+  maxDelayMs: 5e3,
+  jitter: "equal",
+  retryIf: void 0
+};
+var DEFAULT_REDELIVERY = {
+  attempts: Number.POSITIVE_INFINITY,
+  initialDelayMs: 2e3,
+  factor: 2,
+  maxDelayMs: 3e5,
+  jitter: "equal",
+  retryIf: void 0
+};
+var DEFAULT_REDELIVERY_MAX_AGE = "1h";
+var DEFAULT_RECONNECT = {
+  attempts: 1,
+  initialDelayMs: 500,
+  factor: 2,
+  maxDelayMs: 3e4,
+  jitter: "equal",
+  retryIf: void 0
+};
+function resolveSettings(options) {
+  const exchange = nonEmpty(options.exchange ?? "relaybus", "exchange");
+  const failOnConnectError = options.failOnConnectError ?? true;
+  if (!failOnConnectError && options.reconnect === false) {
+    throw new core.ConfigurationError(
+      "failOnConnectError=false needs reconnect enabled, otherwise the transport would never connect"
+    );
+  }
+  const ordered = options.ordered ?? false;
+  const prefetch = positiveInteger(options.prefetch ?? (ordered ? 1 : 50), "prefetch");
+  if (ordered && prefetch !== 1) {
+    throw new core.ConfigurationError(`ordered consumption needs prefetch 1, received ${prefetch}`);
+  }
+  const redelivery = core.createRetryPolicy(options.redelivery, DEFAULT_REDELIVERY);
+  return {
+    name: nonEmpty(options.name ?? "rabbitmq", "name"),
+    connect: resolveConnect(options),
+    exchange,
+    prefetch,
+    queuePrefix: nonEmpty(options.queuePrefix ?? "relaybus", "queuePrefix"),
+    consumerGroup: optionalNonEmpty(options.consumerGroup, "consumerGroup"),
+    queue: optionalNonEmpty(options.queue, "queue"),
+    deadLetterExchange: nonEmpty(
+      options.deadLetterExchange ?? `${exchange}.dead`,
+      "deadLetterExchange"
+    ),
+    deadLetterQueue: optionalNonEmpty(options.deadLetterQueue, "deadLetterQueue"),
+    deliveryLimit: positiveInteger(options.deliveryLimit ?? 10, "deliveryLimit"),
+    handlerRetry: core.createRetryPolicy(options.handlerRetry, DEFAULT_HANDLER_RETRY),
+    redelivery,
+    retryLadder: ordered ? [] : buildRetryLadder(redelivery),
+    redeliveryMaxAgeMs: positiveDuration(
+      options.redelivery?.maxAge ?? DEFAULT_REDELIVERY_MAX_AGE,
+      "redelivery.maxAge"
+    ),
+    ordered,
+    reconnect: resolveReconnect(options.reconnect),
+    failOnConnectError,
+    allowUnroutable: options.allowUnroutable ?? false,
+    publishTimeoutMs: positiveDuration(options.publishTimeout ?? "30s", "publishTimeout"),
+    shutdownTimeoutMs: core.toMilliseconds(options.shutdownTimeout ?? "30s", "shutdownTimeout"),
+    logger: options.logger ?? console,
+    random: options.random ?? Math.random
+  };
+}
+function resolveQueueName(settings) {
+  if (settings.queue !== void 0) {
+    return settings.queue;
+  }
+  if (settings.consumerGroup === void 0) {
+    throw new core.ConfigurationError(
+      `Transport '${settings.name}' needs 'consumerGroup' or 'queue' to subscribe`
+    );
+  }
+  return `${settings.queuePrefix}.${settings.consumerGroup}`;
+}
+function resolveConnect(options) {
+  const { url, connect } = options;
+  if (url === void 0 === (connect === void 0)) {
+    throw new core.ConfigurationError("Give exactly one of 'url' and 'connect'");
+  }
+  if (connect !== void 0) {
+    return connect;
+  }
+  return async () => {
+    const amqplib = await import('amqplib');
+    return amqplib.connect(url);
+  };
+}
+function resolveReconnect(reconnect) {
+  if (reconnect === false) {
+    return void 0;
+  }
+  return core.createRetryPolicy({ ...reconnect, attempts: 1 }, DEFAULT_RECONNECT);
+}
+function nonEmpty(value, name) {
+  if (value.length === 0) {
+    throw new core.ConfigurationError(`${name} must not be empty`);
+  }
+  return value;
+}
+function optionalNonEmpty(value, name) {
+  return value === void 0 ? void 0 : nonEmpty(value, name);
+}
+function positiveInteger(value, name) {
+  if (!Number.isInteger(value) || value < 1) {
+    throw new core.ConfigurationError(`${name} must be a positive integer, received ${value}`);
+  }
+  return value;
+}
+function positiveDuration(value, name) {
+  const milliseconds = core.toMilliseconds(value, name);
+  if (milliseconds === 0) {
+    throw new core.ConfigurationError(`${name} must be greater than zero`);
+  }
+  return milliseconds;
+}
+
+// src/topology.ts
+function retryQueueName(queue, delayMs) {
+  return `${queue}.retry.${delayMs}`;
+}
+async function assertExchange(channel, exchange) {
+  await channel.assertExchange(exchange, "topic", { durable: true });
+}
+async function assertConsumerTopology(channel, topology) {
+  await assertExchange(channel, topology.exchange);
+  await channel.assertExchange(topology.deadLetterExchange, "direct", { durable: true });
+  await channel.assertQueue(topology.deadLetterQueue, {
+    durable: true,
+    arguments: { "x-queue-type": "quorum" }
+  });
+  await channel.bindQueue(topology.deadLetterQueue, topology.deadLetterExchange, topology.queue);
+  for (const delayMs of topology.retryDelaysMs) {
+    await channel.assertQueue(retryQueueName(topology.queue, delayMs), {
+      durable: true,
+      arguments: {
+        "x-queue-type": "quorum",
+        "x-message-ttl": delayMs,
+        "x-dead-letter-exchange": "",
+        "x-dead-letter-routing-key": topology.queue,
+        "x-dead-letter-strategy": "at-least-once",
+        "x-overflow": "reject-publish"
+      }
+    });
+  }
+  await channel.assertQueue(topology.queue, {
+    durable: true,
+    arguments: {
+      "x-queue-type": "quorum",
+      "x-delivery-limit": topology.deliveryLimit,
+      "x-dead-letter-exchange": topology.deadLetterExchange,
+      "x-dead-letter-routing-key": topology.queue,
+      "x-dead-letter-strategy": "at-least-once",
+      "x-overflow": "reject-publish",
+      ...topology.ordered ? { "x-single-active-consumer": true } : {}
+    }
+  });
+  for (const destination of topology.destinations) {
+    await channel.bindQueue(topology.queue, topology.exchange, destination);
+  }
+}
+
+// src/json-payload.ts
+function assertJsonPayload(payload, eventId) {
+  visit(payload, "$", /* @__PURE__ */ new Set(), eventId);
+}
+function visit(value, path, ancestors, eventId) {
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return;
+    case "number":
+      if (!Number.isFinite(value)) {
+        throw refuse(eventId, path, `is ${value}, which JSON turns into null`);
+      }
+      return;
+    case "object":
+      if (value !== null) {
+        visitObject(value, path, ancestors, eventId);
+      }
+      return;
+    default:
+      throw refuse(eventId, path, `is ${typeof value}, which JSON cannot represent`);
+  }
+}
+function visitObject(value, path, ancestors, eventId) {
+  if (ancestors.has(value)) {
+    throw refuse(eventId, path, "is a circular reference");
+  }
+  ancestors.add(value);
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index += 1) {
+      if (!(index in value)) {
+        throw refuse(eventId, `${path}[${index}]`, "is an array hole, which JSON turns into null");
+      }
+      visit(value[index], `${path}[${index}]`, ancestors, eventId);
+    }
+  } else {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw refuse(eventId, path, "is not a plain object (class instance, Date, Map or Set)");
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw refuse(eventId, path, "has a symbol key, which JSON drops");
+    }
+    for (const key of Object.keys(value)) {
+      visit(value[key], `${path}.${key}`, ancestors, eventId);
+    }
+  }
+  ancestors.delete(value);
+}
+function refuse(eventId, path, reason) {
+  return new UnserializablePayloadError(
+    `Event ${eventId} has a payload JSON cannot represent faithfully: ${path} ${reason}`
+  );
+}
+
+// src/wire-format.ts
+var ATTRIBUTE_PREFIX = "cloudEvents:";
+var EVENT_HEADER_PREFIX = "relaybus:";
+var SPEC_VERSION = "1.0";
+var JSON_CONTENT_TYPE = "application/json";
+var SHORT_STRING_LIMIT_BYTES = 255;
+var RFC3339_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/i;
+function encodeEnvelope(envelope) {
+  assertJsonPayload(envelope.payload, envelope.id);
+  assertShortString("Event id", envelope.id);
+  const headers = {
+    [`${ATTRIBUTE_PREFIX}specversion`]: SPEC_VERSION,
+    [`${ATTRIBUTE_PREFIX}id`]: envelope.id,
+    [`${ATTRIBUTE_PREFIX}type`]: envelope.type,
+    [`${ATTRIBUTE_PREFIX}source`]: envelope.source,
+    [`${ATTRIBUTE_PREFIX}time`]: envelope.occurredAt.toISOString(),
+    [`${ATTRIBUTE_PREFIX}datacontenttype`]: JSON_CONTENT_TYPE
+  };
+  if (envelope.key !== null) {
+    headers[`${ATTRIBUTE_PREFIX}subject`] = envelope.key;
+  }
+  if (envelope.causationId !== null) {
+    headers[`${ATTRIBUTE_PREFIX}causationid`] = envelope.causationId;
+  }
+  if (envelope.correlationId !== null) {
+    headers[`${ATTRIBUTE_PREFIX}correlationid`] = envelope.correlationId;
+  }
+  for (const [name, value] of Object.entries(envelope.headers)) {
+    assertShortString(
+      `Header name '${EVENT_HEADER_PREFIX}${name}'`,
+      `${EVENT_HEADER_PREFIX}${name}`
+    );
+    headers[`${EVENT_HEADER_PREFIX}${name}`] = value;
+  }
+  return {
+    content: Buffer.from(JSON.stringify(envelope.payload), "utf8"),
+    options: {
+      contentType: JSON_CONTENT_TYPE,
+      persistent: true,
+      messageId: envelope.id,
+      timestamp: Math.floor(envelope.occurredAt.getTime() / 1e3),
+      ...mirror("type", envelope.type),
+      ...mirror("appId", envelope.source),
+      ...envelope.correlationId === null ? {} : mirror("correlationId", envelope.correlationId),
+      headers
+    }
+  };
+}
+function assertShortString(label, value) {
+  const bytes = Buffer.byteLength(value, "utf8");
+  if (bytes > SHORT_STRING_LIMIT_BYTES) {
+    throw new AmqpLimitExceededError(
+      `${label} is ${bytes} bytes, above the AMQP limit of ${SHORT_STRING_LIMIT_BYTES} bytes`
+    );
+  }
+}
+function mirror(name, value) {
+  return Buffer.byteLength(value, "utf8") > SHORT_STRING_LIMIT_BYTES ? {} : { [name]: value };
+}
+function decodeEnvelope(message) {
+  const { properties } = message;
+  const attributes = properties.headers ?? {};
+  if (attributes[`${ATTRIBUTE_PREFIX}specversion`] !== SPEC_VERSION) {
+    throw new MalformedMessageError(
+      `Message is not a CloudEvents ${SPEC_VERSION} event (header ${ATTRIBUTE_PREFIX}specversion)`
+    );
+  }
+  return {
+    id: required("id", text(attributes[`${ATTRIBUTE_PREFIX}id`]) ?? text(properties.messageId)),
+    type: required("type", text(attributes[`${ATTRIBUTE_PREFIX}type`]) ?? text(properties.type)),
+    source: required(
+      "source",
+      text(attributes[`${ATTRIBUTE_PREFIX}source`]) ?? text(properties.appId)
+    ),
+    key: text(attributes[`${ATTRIBUTE_PREFIX}subject`]) ?? null,
+    payload: parsePayload(message.content),
+    headers: extractEventHeaders(attributes),
+    correlationId: text(attributes[`${ATTRIBUTE_PREFIX}correlationid`]) ?? text(properties.correlationId) ?? null,
+    causationId: text(attributes[`${ATTRIBUTE_PREFIX}causationid`]) ?? null,
+    occurredAt: parseTime(attributes[`${ATTRIBUTE_PREFIX}time`], properties.timestamp)
+  };
+}
+function extractEventHeaders(attributes) {
+  const headers = {};
+  for (const [name, value] of Object.entries(attributes)) {
+    if (name.startsWith(EVENT_HEADER_PREFIX) && typeof value === "string") {
+      Object.defineProperty(headers, name.slice(EVENT_HEADER_PREFIX.length), {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+    }
+  }
+  return headers;
+}
+function parsePayload(content) {
+  try {
+    return JSON.parse(content.toString("utf8"));
+  } catch {
+    throw new MalformedMessageError("Message body is not valid JSON");
+  }
+}
+function parseTime(rawTime, timestampSeconds) {
+  if (rawTime === void 0) {
+    const fallback = typeof timestampSeconds === "number" ? new Date(timestampSeconds * 1e3) : void 0;
+    if (fallback === void 0 || Number.isNaN(fallback.getTime())) {
+      throw new MalformedMessageError("Message has no valid time (header cloudEvents:time)");
+    }
+    return fallback;
+  }
+  const occurredAt = typeof rawTime === "string" && RFC3339_PATTERN.test(rawTime) ? new Date(rawTime) : void 0;
+  if (occurredAt === void 0 || Number.isNaN(occurredAt.getTime())) {
+    throw new MalformedMessageError(
+      "Message time (header cloudEvents:time) is not an RFC 3339 timestamp"
+    );
+  }
+  return occurredAt;
+}
+function text(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function required(attribute, value) {
+  if (value === void 0 || value.length === 0) {
+    throw new MalformedMessageError(
+      `Message has no ${attribute} (header ${ATTRIBUTE_PREFIX}${attribute})`
+    );
+  }
+  return value;
+}
+
+// src/queue-consumer.ts
+var QueueConsumer = class {
+  #settings;
+  #inFlight = /* @__PURE__ */ new Set();
+  #stopping = new AbortController();
+  #channel;
+  #consumerTag;
+  constructor(settings) {
+    this.#settings = settings;
+  }
+  /** True while a consumer is registered on a live channel. */
+  isActive() {
+    return this.#consumerTag !== void 0;
+  }
+  /**
+   * Starts consuming on a channel whose topology is already declared.
+   *
+   * @throws {RabbitMqUnavailableError} the channel closed while it was being set up
+   */
+  async attach(channel) {
+    let closedDuringSetup = false;
+    channel.on("error", (error) => {
+      this.#settings.logger.warn(
+        `[QueueConsumer](attach) Channel error | queue=${this.#settings.queue} error=${error.message}`
+      );
+    });
+    channel.on("close", () => {
+      closedDuringSetup = true;
+      if (this.#channel === channel) {
+        this.#channel = void 0;
+        this.#consumerTag = void 0;
+        this.#settings.onConsumerLost("consumer channel closed");
+      }
+    });
+    await channel.prefetch(this.#settings.prefetch);
+    const { consumerTag } = await channel.consume(
+      this.#settings.queue,
+      (message) => this.#receive(channel, message),
+      { noAck: false }
+    );
+    if (closedDuringSetup) {
+      throw new RabbitMqUnavailableError(
+        `[QueueConsumer](attach) Consumer channel closed while the consumer was being set up | queue=${this.#settings.queue}`
+      );
+    }
+    this.#channel = channel;
+    this.#consumerTag = consumerTag;
+  }
+  /** Forgets the channel without closing it, because its connection is gone. */
+  detach() {
+    this.#channel = void 0;
+    this.#consumerTag = void 0;
+  }
+  /**
+   * Stops taking messages, aborts pending handler backoff (those messages are
+   * requeued), waits up to the shutdown timeout for running handlers, then
+   * closes the channel. Unacknowledged messages return to the queue.
+   */
+  async stop() {
+    this.#stopping.abort();
+    const channel = this.#channel;
+    const consumerTag = this.#consumerTag;
+    this.#channel = void 0;
+    this.#consumerTag = void 0;
+    if (channel !== void 0 && consumerTag !== void 0) {
+      await channel.cancel(consumerTag).catch((error) => {
+        this.#settings.logger.warn(
+          `[QueueConsumer](stop) Could not cancel consumer | queue=${this.#settings.queue} error=${core.toErrorInfo(error).message}`
+        );
+      });
+    }
+    await this.#awaitInFlight();
+    await channel?.close().catch(() => void 0);
+  }
+  async #awaitInFlight() {
+    if (this.#inFlight.size === 0) {
+      return;
+    }
+    const timeout = new AbortController();
+    const timedOut = abortableSleep(this.#settings.shutdownTimeoutMs, timeout.signal);
+    await Promise.race([Promise.allSettled([...this.#inFlight]), timedOut]);
+    timeout.abort();
+  }
+  #receive(channel, message) {
+    if (message === null) {
+      this.#consumerTag = void 0;
+      this.#settings.onConsumerLost("consumer cancelled by the broker");
+      return;
+    }
+    const task = this.#process(channel, message).finally(() => {
+      this.#inFlight.delete(task);
+    });
+    this.#inFlight.add(task);
+  }
+  async #process(channel, message) {
+    const { queue, handlerRetry } = this.#settings;
+    let envelope;
+    try {
+      envelope = decodeEnvelope(message);
+    } catch (error) {
+      this.#settings.logger.error(
+        `[QueueConsumer](process) Dead-lettering malformed message | queue=${queue} routingKey=${message.fields.routingKey} error=${core.toErrorInfo(error).message}`
+      );
+      await this.#deadLetter(channel, message, "malformed message");
+      return;
+    }
+    let redeliveries = readCounterHeader(message, REDELIVERIES_HEADER) ?? 0;
+    let firstFailureAt = readCounterHeader(message, FIRST_FAILURE_HEADER);
+    for (let attempt = 1; ; attempt += 1) {
+      try {
+        await this.#settings.onMessage(envelope);
+        this.#settle(channel, message, "ack");
+        return;
+      } catch (error) {
+        const failure = `queue=${queue} eventId=${envelope.id} attempt=${attempt} error=${core.toErrorInfo(error).message}`;
+        if (!core.isRetryableError(handlerRetry, error)) {
+          this.#settings.logger.error(
+            `[QueueConsumer](process) Dead-lettering message the handler cannot process | ${failure}`
+          );
+          await this.#deadLetter(channel, message, "non-retryable handler error");
+          return;
+        }
+        if (attempt < handlerRetry.attempts) {
+          const delayMs2 = core.computeRetryDelay(handlerRetry, attempt, this.#settings.random);
+          this.#settings.logger.warn(
+            `[QueueConsumer](process) Handler failed, retrying | ${failure} delayMs=${delayMs2}`
+          );
+          if (await this.#interrupted(delayMs2)) {
+            this.#settle(channel, message, "requeue");
+            return;
+          }
+          continue;
+        }
+        redeliveries += 1;
+        const now = Date.now();
+        firstFailureAt ??= now;
+        const delayMs = this.#redeliveryDelay(redeliveries);
+        if (now + delayMs - firstFailureAt > this.#settings.redeliveryMaxAgeMs) {
+          this.#settings.logger.error(
+            `[QueueConsumer](process) Dead-lettering message that kept failing | ${failure} redeliveries=${redeliveries - 1} failingForMs=${now - firstFailureAt} maxAgeMs=${this.#settings.redeliveryMaxAgeMs}`
+          );
+          await this.#deadLetter(channel, message, "redelivery window exhausted");
+          return;
+        }
+        this.#settings.logger.warn(
+          `[QueueConsumer](process) Handler attempts spent, retrying later | ${failure} redeliveries=${redeliveries} delayMs=${delayMs}`
+        );
+        if (!this.#settings.ordered) {
+          await this.#redeliverLater(channel, message, delayMs, redeliveries, firstFailureAt);
+          return;
+        }
+        if (await this.#interrupted(delayMs)) {
+          this.#settle(channel, message, "requeue");
+          return;
+        }
+      }
+    }
+  }
+  /** The backoff before the next delayed redelivery: a retry queue's TTL, or an exact wait when ordered. */
+  #redeliveryDelay(redeliveries) {
+    const { redelivery, retryLadder, ordered, random } = this.#settings;
+    const delayMs = core.computeRetryDelay(redelivery, redeliveries, random);
+    return ordered ? delayMs : chooseRetryTier(retryLadder, delayMs, random);
+  }
+  /** Sleeps; true when the consumer is stopping, so the caller must give the message back. */
+  async #interrupted(delayMs) {
+    await abortableSleep(delayMs, this.#stopping.signal);
+    return this.#stopping.signal.aborted;
+  }
+  /**
+   * Parks a copy in the retry queue of `delayMs` and acknowledges the original
+   * only once the broker confirmed the copy. When the copy cannot be confirmed
+   * the original is requeued after the same delay, so it is neither lost nor
+   * hot-looped.
+   */
+  async #redeliverLater(channel, message, delayMs, redeliveries, firstFailureAt) {
+    const { content, options } = copyForRepublish(message, {
+      [REDELIVERIES_HEADER]: String(redeliveries),
+      [FIRST_FAILURE_HEADER]: String(firstFailureAt)
+    });
+    try {
+      await this.#settings.republish(
+        "",
+        retryQueueName(this.#settings.queue, delayMs),
+        content,
+        options
+      );
+    } catch (error) {
+      this.#settings.logger.warn(
+        `[QueueConsumer](redeliverLater) Could not park the message in the retry queue, requeueing it | queue=${this.#settings.queue} delayMs=${delayMs} error=${core.toErrorInfo(error).message}`
+      );
+      await this.#interrupted(delayMs);
+      this.#settle(channel, message, "requeue");
+      return;
+    }
+    this.#settle(channel, message, "ack");
+  }
+  /**
+   * Moves the message to the dead-letter queue through a confirmed copy that
+   * carries the reason and no retry state. If the copy cannot be confirmed the
+   * message is rejected without requeue, which makes the broker dead-letter it
+   * (at-least-once), so it still ends up in the dead-letter queue.
+   */
+  async #deadLetter(channel, message, reason) {
+    const { content, options } = copyForRepublish(message, {
+      [DEAD_LETTER_REASON_HEADER]: reason
+    });
+    try {
+      await this.#settings.republish(
+        this.#settings.deadLetterExchange,
+        this.#settings.queue,
+        content,
+        options
+      );
+    } catch (error) {
+      this.#settings.logger.warn(
+        `[QueueConsumer](deadLetter) Could not publish to the dead-letter exchange, leaving it to the broker | queue=${this.#settings.queue} error=${core.toErrorInfo(error).message}`
+      );
+      this.#settle(channel, message, "dead-letter");
+      return;
+    }
+    this.#settle(channel, message, "ack");
+  }
+  #settle(channel, message, settlement) {
+    try {
+      if (settlement === "ack") {
+        channel.ack(message);
+      } else {
+        channel.nack(message, false, settlement === "requeue");
+      }
+    } catch (error) {
+      this.#settings.logger.warn(
+        `[QueueConsumer](settle) Could not ${settlement} message, the broker will redeliver it | queue=${this.#settings.queue} error=${core.toErrorInfo(error).message}`
+      );
+    }
+  }
+};
+
+// src/serial-queue.ts
+var SerialQueue = class {
+  #tail = Promise.resolve();
+  run(task) {
+    const result = this.#tail.then(task);
+    this.#tail = result.catch(() => void 0);
+    return result;
+  }
+};
+
+// src/rabbitmq-transport.ts
+var NACK_MESSAGE = "message nacked";
+var RabbitMqTransport = class {
+  name;
+  #settings;
+  #supervisor;
+  /** Serializes topology work so a subscription never races a reconnect. */
+  #topologyWork = new SerialQueue();
+  #live;
+  #subscription;
+  #closed = false;
+  constructor(options) {
+    this.#settings = resolveSettings(options);
+    this.name = this.#settings.name;
+    this.#supervisor = new ConnectionSupervisor({
+      connect: this.#settings.connect,
+      reconnect: this.#settings.reconnect,
+      onConnected: (connection) => this.#establishChannels(connection),
+      onDisconnected: () => this.#forgetConnection(),
+      logger: this.#settings.logger,
+      random: this.#settings.random
+    });
+  }
+  /**
+   * True while the connection is open and publishing and consuming are set up.
+   * Use it for readiness probes.
+   */
+  isConnected() {
+    return this.#supervisor.isConnected();
+  }
+  /**
+   * True when the transport can publish and, once subscribed, is consuming: the
+   * connection is up, its channels are open and the consumer is registered. False while reconnecting and after a cancelled consumer.
+   */
+  isReady() {
+    return this.#supervisor.isConnected() && this.#live !== void 0 && (this.#subscription === void 0 || this.#subscription.consumer.isActive());
+  }
+  /** Connects to the broker. Rejects when it is unreachable unless `failOnConnectError` is false. */
+  async connect() {
+    await this.#supervisor.start(this.#settings.failOnConnectError);
+  }
+  /**
+   * Publishes to the exchange with `destination` as routing key and resolves
+   * after the broker confirmed the message.
+   *
+   * @throws {UnserializablePayloadError} the payload is not representable as JSON (never retried)
+   * @throws {AmqpLimitExceededError} the event id, a header name or `destination` exceeds 255 bytes (never retried)
+   * @throws {RabbitMqUnavailableError} not connected, channel lost, or confirm timed out
+   * @throws {RabbitMqPublishRejectedError} the broker nacked the message
+   * @throws {UnroutableMessageError} no queue is bound to `destination` (unless `allowUnroutable`)
+   */
+  async publish(envelope, destination) {
+    assertShortString("Destination (routing key)", destination);
+    const { content, options } = encodeEnvelope(envelope);
+    await this.#publishConfirmed(
+      this.#settings.exchange,
+      destination,
+      content,
+      options,
+      !this.#settings.allowUnroutable
+    );
+  }
+  async #publishConfirmed(exchange, routingKey, content, options, mandatory) {
+    const publisher = this.#live?.publisher;
+    const eventId = options.messageId ?? "unknown";
+    if (publisher === void 0) {
+      throw new RabbitMqUnavailableError(
+        `[RabbitMqTransport](publish) Not connected to the broker | transport=${this.name} destination=${routingKey}`
+      );
+    }
+    const returnKey = unroutableKey(options.messageId, routingKey);
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(
+          new RabbitMqUnavailableError(
+            `[RabbitMqTransport](publish) No broker confirm within ${this.#settings.publishTimeoutMs}ms | transport=${this.name} eventId=${eventId} destination=${routingKey}`
+          )
+        );
+      }, this.#settings.publishTimeoutMs);
+      const onConfirm = (error) => {
+        clearTimeout(timer);
+        const returned = takeUnroutable(publisher.unroutable, returnKey);
+        if (error) {
+          reject(this.#toPublishError(error, eventId, routingKey));
+        } else if (returned) {
+          reject(
+            new UnroutableMessageError(
+              `[RabbitMqTransport](publish) No queue is bound to the routing key | transport=${this.name} eventId=${eventId} destination=${routingKey}`
+            )
+          );
+        } else {
+          resolve();
+        }
+      };
+      try {
+        publisher.channel.publish(
+          exchange,
+          routingKey,
+          content,
+          { ...options, mandatory },
+          onConfirm
+        );
+      } catch (error) {
+        clearTimeout(timer);
+        reject(this.#toPublishError(error, eventId, routingKey));
+      }
+    });
+  }
+  /**
+   * Binds one durable quorum queue to `destinations` and delivers its messages
+   * to `onMessage`. Call it once per transport; give each subscription its own
+   * transport instance, with its own `name` and `consumerGroup`.
+   */
+  async subscribe(destinations, onMessage) {
+    if (this.#subscription !== void 0) {
+      throw new core.ConfigurationError(
+        `Transport '${this.name}' already has a subscription; create another transport for another consumer group`
+      );
+    }
+    if (destinations.length === 0) {
+      throw new core.ConfigurationError(`Transport '${this.name}' needs at least one destination`);
+    }
+    const queue = resolveQueueName(this.#settings);
+    const subscription = {
+      topology: {
+        exchange: this.#settings.exchange,
+        queue,
+        deadLetterExchange: this.#settings.deadLetterExchange,
+        deadLetterQueue: this.#settings.deadLetterQueue ?? `${queue}.dead`,
+        deliveryLimit: this.#settings.deliveryLimit,
+        ordered: this.#settings.ordered,
+        retryDelaysMs: this.#settings.retryLadder,
+        destinations
+      },
+      consumer: new QueueConsumer({
+        queue,
+        prefetch: this.#settings.prefetch,
+        handlerRetry: this.#settings.handlerRetry,
+        redelivery: this.#settings.redelivery,
+        retryLadder: this.#settings.retryLadder,
+        redeliveryMaxAgeMs: this.#settings.redeliveryMaxAgeMs,
+        ordered: this.#settings.ordered,
+        deadLetterExchange: this.#settings.deadLetterExchange,
+        republish: (exchange, routingKey, content, options) => this.#publishConfirmed(exchange, routingKey, content, options, true),
+        shutdownTimeoutMs: this.#settings.shutdownTimeoutMs,
+        onMessage,
+        onConsumerLost: (reason) => this.#supervisor.recover(reason),
+        logger: this.#settings.logger,
+        random: this.#settings.random
+      })
+    };
+    await this.#topologyWork.run(async () => {
+      this.#subscription = subscription;
+      if (this.#live !== void 0) {
+        await this.#startConsuming(this.#live.connection, subscription);
+      }
+    });
+  }
+  /**
+   * Stops consuming, waits up to `shutdownTimeout` for running handlers
+   * (messages still being retried go back to the queue), then closes the
+   * channels and the connection.
+   */
+  async close() {
+    if (this.#closed) {
+      return;
+    }
+    this.#closed = true;
+    await this.#supervisor.close(
+      () => this.#topologyWork.run(async () => {
+        const live = this.#live;
+        this.#live = void 0;
+        await this.#subscription?.consumer.stop();
+        await live?.publisher.channel.close().catch(() => void 0);
+      })
+    );
+  }
+  async #establishChannels(connection) {
+    await this.#topologyWork.run(async () => {
+      const channel = await connection.createConfirmChannel();
+      const publisher = { channel, unroutable: /* @__PURE__ */ new Map(), closed: false };
+      channel.on("error", (error) => {
+        this.#settings.logger.warn(
+          `[RabbitMqTransport](establishChannels) Publisher channel error | transport=${this.name} error=${error.message}`
+        );
+      });
+      channel.on("close", () => {
+        publisher.closed = true;
+        if (this.#live?.publisher === publisher) {
+          this.#supervisor.recover("publisher channel closed");
+        }
+      });
+      channel.on("return", (message) => {
+        recordUnroutable(
+          publisher.unroutable,
+          unroutableKey(message.properties.messageId, message.fields.routingKey)
+        );
+      });
+      await assertExchange(channel, this.#settings.exchange);
+      if (this.#subscription !== void 0) {
+        await this.#startConsuming(connection, this.#subscription);
+      }
+      if (publisher.closed) {
+        throw new RabbitMqUnavailableError(
+          `[RabbitMqTransport](establishChannels) Publisher channel closed while the transport was being set up | transport=${this.name}`
+        );
+      }
+      this.#live = { connection, publisher };
+    });
+  }
+  async #startConsuming(connection, subscription) {
+    const channel = await connection.createChannel();
+    await assertConsumerTopology(channel, subscription.topology);
+    await subscription.consumer.attach(channel);
+  }
+  #forgetConnection() {
+    this.#live = void 0;
+    this.#subscription?.consumer.detach();
+  }
+  #toPublishError(error, eventId, destination) {
+    const { message } = core.toErrorInfo(error);
+    const detail = `transport=${this.name} eventId=${eventId} destination=${destination} error=${message}`;
+    return message === NACK_MESSAGE ? new RabbitMqPublishRejectedError(
+      `[RabbitMqTransport](publish) Broker nacked the message | ${detail}`,
+      { cause: error }
+    ) : new RabbitMqUnavailableError(`[RabbitMqTransport](publish) Publish failed | ${detail}`, {
+      cause: error
+    });
+  }
+};
+function unroutableKey(messageId, routingKey) {
+  return `${String(messageId)}
+${routingKey}`;
+}
+function recordUnroutable(unroutable, key) {
+  unroutable.set(key, (unroutable.get(key) ?? 0) + 1);
+}
+function takeUnroutable(unroutable, key) {
+  const count = unroutable.get(key);
+  if (count === void 0) {
+    return false;
+  }
+  if (count === 1) {
+    unroutable.delete(key);
+  } else {
+    unroutable.set(key, count - 1);
+  }
+  return true;
+}
+
+exports.AmqpLimitExceededError = AmqpLimitExceededError;
+exports.MalformedMessageError = MalformedMessageError;
+exports.RabbitMqPublishRejectedError = RabbitMqPublishRejectedError;
+exports.RabbitMqTransport = RabbitMqTransport;
+exports.RabbitMqUnavailableError = RabbitMqUnavailableError;
+exports.UnroutableMessageError = UnroutableMessageError;
+exports.UnserializablePayloadError = UnserializablePayloadError;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map