@relaybus/rabbitmq 0.3.0 → 0.3.1

package/dist/index.cjs

@@ -32,6 +32,99 @@ var RabbitMqUnencodableEventError = class extends core.NonRetryableError {
   name = "RabbitMqUnencodableEventError";
   code = "RELAYBUS_RABBITMQ_UNENCODABLE_EVENT";
 };
+var NACK_MESSAGE = "message nacked";
+var ConfirmedPublishing = class {
+  #transportName;
+  #publishTimeoutMs;
+  constructor(transportName, publishTimeoutMs) {
+    this.#transportName = transportName;
+    this.#publishTimeoutMs = publishTimeoutMs;
+  }
+  async publish(publisher, input) {
+    const { exchange, routingKey, content, options, mandatory } = input;
+    const eventId = options.messageId ?? "unknown";
+    if (publisher === void 0) {
+      throw new RabbitMqUnavailableError(
+        `[RabbitMqTransport](publish) Not connected to the broker | transport=${this.#transportName} destination=${routingKey}`
+      );
+    }
+    const returnKey = unroutableKey(options.messageId, routingKey);
+    const target = { eventId, destination: routingKey };
+    await new Promise((resolve, reject) => {
+      const cancelTimeout = this.#startTimeout(target, reject);
+      const pending = { ...target, publisher, returnKey, cancelTimeout, resolve, reject };
+      try {
+        publisher.channel.publish(
+          exchange,
+          routingKey,
+          content,
+          { ...options, mandatory },
+          (error) => this.#confirmed(pending, error)
+        );
+      } catch (error) {
+        cancelTimeout();
+        reject(this.#toPublishError(error, target));
+      }
+    });
+  }
+  #startTimeout({ eventId, destination }, reject) {
+    return internal.schedule(core.systemClock, {
+      run: () => {
+        reject(
+          new RabbitMqUnavailableError(
+            `[RabbitMqTransport](publish) No broker confirm within ${this.#publishTimeoutMs}ms | transport=${this.#transportName} eventId=${eventId} destination=${destination}`
+          )
+        );
+      },
+      delayMs: this.#publishTimeoutMs
+    });
+  }
+  /** The broker's confirm (or nack) of one message arrived. */
+  #confirmed(pending, error) {
+    pending.cancelTimeout();
+    const returned = takeUnroutable(pending.publisher.unroutable, pending.returnKey);
+    if (error) {
+      pending.reject(this.#toPublishError(error, pending));
+    } else if (returned) {
+      pending.reject(
+        new UnroutableMessageError(
+          `[RabbitMqTransport](publish) No queue is bound to the routing key | transport=${this.#transportName} eventId=${pending.eventId} destination=${pending.destination}`
+        )
+      );
+    } else {
+      pending.resolve();
+    }
+  }
+  #toPublishError(error, { eventId, destination }) {
+    const { message } = core.toErrorInfo(error);
+    const detail = `transport=${this.#transportName} 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;
+}
 function abortableSleep(milliseconds, signal) {
   if (signal.aborted) {
     return Promise.resolve();
@@ -278,35 +371,41 @@ function visitObject(value, {
   }
   ancestors.add(value);
   if (Array.isArray(value)) {
-    for (let index = 0; index < value.length; index += 1) {
-      if (!(index in value)) {
-        throw refuse(eventId, {
-          path: `${path}[${index}]`,
-          reason: "is an array hole, which JSON turns into null"
-        });
-      }
-      visit(value[index], { path: `${path}[${index}]`, ancestors, eventId });
-    }
+    visitArray(value, { path, ancestors, eventId });
   } else {
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
+    visitPlainObject(value, { path, ancestors, eventId });
+  }
+  ancestors.delete(value);
+}
+function visitArray(value, { path, ancestors, eventId }) {
+  for (let index = 0; index < value.length; index += 1) {
+    if (!(index in value)) {
       throw refuse(eventId, {
-        path,
-        reason: "is not a plain object (class instance, Date, Map or Set)"
-      });
-    }
-    if (Object.getOwnPropertySymbols(value).length > 0) {
-      throw refuse(eventId, { path, reason: "has a symbol key, which JSON drops" });
-    }
-    for (const key of Object.keys(value)) {
-      visit(value[key], {
-        path: `${path}.${key}`,
-        ancestors,
-        eventId
+        path: `${path}[${index}]`,
+        reason: "is an array hole, which JSON turns into null"
       });
     }
+    visit(value[index], { path: `${path}[${index}]`, ancestors, eventId });
+  }
+}
+function visitPlainObject(value, { path, ancestors, eventId }) {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw refuse(eventId, {
+      path,
+      reason: "is not a plain object (class instance, Date, Map or Set)"
+    });
+  }
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw refuse(eventId, { path, reason: "has a symbol key, which JSON drops" });
+  }
+  for (const key of Object.keys(value)) {
+    visit(value[key], {
+      path: `${path}.${key}`,
+      ancestors,
+      eventId
+    });
   }
-  ancestors.delete(value);
 }
 function refuse(eventId, { path, reason }) {
   return new UnserializablePayloadError(
@@ -335,6 +434,22 @@ function encodeEnvelope(envelope) {
     [`${ATTRIBUTE_PREFIX}time`]: envelope.occurredAt.toISOString(),
     [`${ATTRIBUTE_PREFIX}datacontenttype`]: JSON_CONTENT_TYPE
   };
+  addOptionalAttributes(headers, envelope);
+  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() / MILLISECONDS_PER_SECOND),
+      ...mirror("type", envelope.type),
+      ...mirror("appId", envelope.source),
+      ...envelope.correlationId === null ? {} : mirror("correlationId", envelope.correlationId),
+      headers
+    }
+  };
+}
+function addOptionalAttributes(headers, envelope) {
   if (envelope.key !== null) {
     headers[`${ATTRIBUTE_PREFIX}subject`] = envelope.key;
   }
@@ -351,19 +466,6 @@ function encodeEnvelope(envelope) {
     );
     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() / MILLISECONDS_PER_SECOND),
-      ...mirror("type", envelope.type),
-      ...mirror("appId", envelope.source),
-      ...envelope.correlationId === null ? {} : mirror("correlationId", envelope.correlationId),
-      headers
-    }
-  };
 }
 function encodeStructuredEnvelope(envelope) {
   assertJsonPayload(envelope.payload, envelope.id);
@@ -548,18 +650,13 @@ function plainJsonDecoder(options) {
     if (properties.headers?.[SPEC_VERSION_HEADER] !== void 0 || internal.mediaTypeOf(properties.contentType) === STRUCTURED_MEDIA_TYPE) {
       return decodeCloudEvent(message);
     }
-    const plain = {
-      routingKey: message.fields.routingKey,
-      properties,
-      headers: readForeignHeaders(properties),
-      payload: parseJsonBody(message.content)
-    };
-    const type = resolveText(options.type, { message: plain, name: "type" });
+    const plain = plainMessageOf(message);
+    const type = RABBITMQ_EVENTS.text(options.type, { plain, name: "type" });
     if (type === void 0) {
       throw new MalformedMessageError("Message has no event type: the type option found none");
     }
     assertValidType(type, "The event type");
-    const id = resolveText(options.id, { message: plain, name: "id" }) ?? nonEmptyText(properties.messageId);
+    const id = RABBITMQ_EVENTS.text(options.id, { plain, name: "id" }) ?? nonEmptyText(properties.messageId);
     if (id === void 0) {
       throw new MalformedMessageError(
         "Message has no id: set the messageId property on the producer or configure the id option"
@@ -568,8 +665,8 @@ function plainJsonDecoder(options) {
     return {
       id,
       type,
-      source: resolveText(options.source, { message: plain, name: "source" }) ?? defaultSource(message),
-      key: resolveText(options.key, { message: plain, name: "key" }) ?? null,
+      source: RABBITMQ_EVENTS.text(options.source, { plain, name: "source" }) ?? defaultSource(message),
+      key: RABBITMQ_EVENTS.text(options.key, { plain, name: "key" }) ?? null,
       payload: plain.payload,
       headers: plain.headers,
       correlationId: null,
@@ -578,27 +675,35 @@ function plainJsonDecoder(options) {
     };
   };
 }
-function completeDecodedEvent(decoded, message) {
-  if (typeof decoded !== "object" || decoded === null) {
-    throw new MalformedMessageError("The decoder must return an event object synchronously");
-  }
-  if ("then" in decoded) {
-    observeRejection(decoded);
-    throw new MalformedMessageError("The decoder must return an event object synchronously");
-  }
-  const event = decoded;
+function plainMessageOf(message) {
+  const { properties } = message;
   return {
-    id: event.id,
-    type: event.type,
-    source: event.source ?? defaultSource(message),
-    key: event.key ?? null,
-    payload: event.payload,
-    headers: event.headers ?? {},
-    correlationId: event.correlationId ?? null,
-    causationId: event.causationId ?? null,
-    occurredAt: event.occurredAt ?? propertyTimeOrNow(message.properties)
+    routingKey: message.fields.routingKey,
+    properties,
+    headers: readForeignHeaders(properties),
+    payload: parseJsonBody(message.content)
   };
 }
+var RabbitMqDecodedEvents = class extends internal.DecodedEventReader {
+  invalid(reason) {
+    return new MalformedMessageError(reason);
+  }
+  defaultSource(message) {
+    return defaultSource(message);
+  }
+  /** None: AMQP messages carry no ordering key. */
+  defaultKey() {
+    return null;
+  }
+  /** The `timestamp` property, else the time of receipt. */
+  defaultTime(message) {
+    return propertyTimeOrNow(message.properties);
+  }
+};
+var RABBITMQ_EVENTS = new RabbitMqDecodedEvents();
+function completeDecodedEvent(decoded, message) {
+  return RABBITMQ_EVENTS.complete(decoded, message);
+}
 function parseJsonBody(content) {
   let text2;
   try {
@@ -643,35 +748,17 @@ function readForeignHeaders(properties) {
     )
   );
 }
-function resolveText(option, { message, name }) {
-  const value = typeof option === "function" ? option(message) : option;
-  if (value === void 0 || value === null) {
-    return void 0;
-  }
-  if (typeof value !== "string") {
-    observeRejection(value);
-    throw new MalformedMessageError(
-      `The ${name} option returned ${typeof value}, expected a string`
-    );
-  }
-  return value.length === 0 ? void 0 : value;
-}
 function resolveOccurredAt(option, message) {
   const value = option?.(message);
   if (value === void 0) {
     return propertyTimeOrNow(message.properties);
   }
   if (!(value instanceof Date) || Number.isNaN(value.getTime())) {
-    observeRejection(value);
+    internal.observeRejection(value);
     throw new MalformedMessageError("The occurredAt option returned no valid Date");
   }
   return value;
 }
-function observeRejection(value) {
-  if (typeof value === "object" && value !== null && "then" in value) {
-    Promise.resolve(value).catch(() => void 0);
-  }
-}
 
 // src/codecs.ts
 var cloudEventsBinary = Object.freeze({
@@ -842,7 +929,7 @@ function resolveSettings(options) {
   };
 }
 function resolveBasics(options) {
-  const exchange = nonEmpty(options.exchange ?? "relaybus", "exchange");
+  const exchange = internal.NonEmptyText.of(options.exchange ?? "relaybus", "exchange");
   const failOnConnectError = options.failOnConnectError ?? true;
   if (!failOnConnectError && options.reconnect === false) {
     throw new core.ConfigurationError(
@@ -850,7 +937,7 @@ function resolveBasics(options) {
     );
   }
   const ordered = options.ordered ?? false;
-  const prefetch = internal.assertPositiveInteger(
+  const prefetch = internal.PositiveInteger.of(
     options.prefetch ?? (ordered ? 1 : DEFAULT_PREFETCH),
     "prefetch"
   );
@@ -862,19 +949,19 @@ function resolveBasics(options) {
 }
 function resolveTopology(options, { exchange, prefetch }) {
   return {
-    name: nonEmpty(options.name ?? "rabbitmq", "name"),
+    name: internal.NonEmptyText.of(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(
+    queuePrefix: internal.NonEmptyText.of(options.queuePrefix ?? "relaybus", "queuePrefix"),
+    consumerGroup: internal.NonEmptyText.optional(options.consumerGroup, "consumerGroup"),
+    queue: internal.NonEmptyText.optional(options.queue, "queue"),
+    deadLetterExchange: internal.NonEmptyText.of(
       options.deadLetterExchange ?? `${exchange}.dead`,
       "deadLetterExchange"
     ),
-    deadLetterQueue: optionalNonEmpty(options.deadLetterQueue, "deadLetterQueue"),
-    deliveryLimit: internal.assertPositiveInteger(
+    deadLetterQueue: internal.NonEmptyText.optional(options.deadLetterQueue, "deadLetterQueue"),
+    deliveryLimit: internal.PositiveInteger.of(
       options.deliveryLimit ?? DEFAULT_DELIVERY_LIMIT,
       "deliveryLimit"
     )
@@ -885,7 +972,7 @@ function resolveRetries(options, { ordered, redelivery }) {
     handlerRetry: core.createRetryPolicy(options.handlerRetry, DEFAULT_HANDLER_RETRY),
     redelivery,
     retryLadder: ordered ? [] : buildRetryLadder(redelivery),
-    redeliveryMaxAgeMs: positiveDuration(
+    redeliveryMaxAgeMs: internal.Milliseconds.positive(
       options.redelivery?.maxAge ?? DEFAULT_REDELIVERY_MAX_AGE,
       "redelivery.maxAge"
     ),
@@ -897,8 +984,8 @@ function resolveRuntime(options, { failOnConnectError }) {
     reconnect: resolveReconnect(options.reconnect),
     failOnConnectError,
     allowUnroutable: options.allowUnroutable ?? false,
-    publishTimeoutMs: positiveDuration(options.publishTimeout ?? "30s", "publishTimeout"),
-    shutdownTimeoutMs: core.toMilliseconds(options.shutdownTimeout ?? "30s", "shutdownTimeout"),
+    publishTimeoutMs: internal.Milliseconds.positive(options.publishTimeout ?? "30s", "publishTimeout"),
+    shutdownTimeoutMs: internal.Milliseconds.of(options.shutdownTimeout ?? "30s", "shutdownTimeout"),
     ...resolveCodec(options),
     logger: options.logger ?? console,
     random: options.random ?? Math.random
@@ -951,22 +1038,6 @@ function resolveReconnect(reconnect) {
   }
   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 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) {
@@ -1309,20 +1380,22 @@ var SerialQueue = class {
 };
 
 // src/rabbitmq-transport.ts
-var NACK_MESSAGE = "message nacked";
-var RabbitMqTransport = class {
+var RabbitMqTransport = class extends internal.SubscribingTransport {
   name;
   system = "rabbitmq";
   #settings;
   #supervisor;
+  #publishing;
   /** Serializes topology work so a subscription never races a reconnect. */
   #topologyWork = new SerialQueue();
   #live;
   #subscription;
   #closing;
   constructor(options) {
+    super();
     this.#settings = resolveSettings(options);
     this.name = this.#settings.name;
+    this.#publishing = new ConfirmedPublishing(this.name, this.#settings.publishTimeoutMs);
     this.#supervisor = new ConnectionSupervisor({
       connect: this.#settings.connect,
       reconnect: this.#settings.reconnect,
@@ -1364,7 +1437,7 @@ var RabbitMqTransport = class {
   async publish(envelope, destination) {
     assertShortString("Destination (routing key)", destination);
     const { content, options } = this.#settings.encode(envelope);
-    await this.#publishConfirmed({
+    await this.#publishing.publish(this.#live?.publisher, {
       exchange: this.#settings.exchange,
       routingKey: destination,
       content,
@@ -1372,63 +1445,16 @@ var RabbitMqTransport = class {
       mandatory: !this.#settings.allowUnroutable
     });
   }
-  async #publishConfirmed(input) {
-    const { exchange, routingKey, content, options, mandatory } = input;
-    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 cancelTimeout = internal.schedule(core.systemClock, {
-        run: () => {
-          reject(
-            new RabbitMqUnavailableError(
-              `[RabbitMqTransport](publish) No broker confirm within ${this.#settings.publishTimeoutMs}ms | transport=${this.name} eventId=${eventId} destination=${routingKey}`
-            )
-          );
-        },
-        delayMs: this.#settings.publishTimeoutMs
-      });
-      const onConfirm = (error) => {
-        cancelTimeout();
-        const returned = takeUnroutable(publisher.unroutable, returnKey);
-        if (error) {
-          reject(this.#toPublishError(error, { eventId, destination: 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) {
-        cancelTimeout();
-        reject(this.#toPublishError(error, { eventId, destination: 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`.
    */
-  // eslint-disable-next-line relaybus/max-two-params -- the Transport.subscribe signature
-  async subscribe(destinations, onMessage, hooks) {
+  async openSubscription({
+    destinations,
+    onMessage,
+    hooks
+  }) {
     if (this.#subscription !== void 0) {
       throw new core.ConfigurationError(
         `Transport '${this.name}' already has a subscription; create another transport for another consumer group`
@@ -1439,34 +1465,8 @@ var RabbitMqTransport = class {
     }
     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, mandatory: true }),
-        shutdownTimeoutMs: this.#settings.shutdownTimeoutMs,
-        onMessage,
-        ...hooks === void 0 ? {} : { onInvalidMessage: hooks.onInvalidMessage },
-        decode: this.#settings.decode,
-        onConsumerLost: (reason) => this.#supervisor.recover(reason),
-        logger: this.#settings.logger,
-        random: this.#settings.random
-      })
+      topology: this.#topologyOf(queue, destinations),
+      consumer: this.#createConsumer(queue, { onMessage, hooks })
     };
     await this.#topologyWork.run(async () => {
       this.#subscription = subscription;
@@ -1475,6 +1475,44 @@ var RabbitMqTransport = class {
       }
     });
   }
+  #topologyOf(queue, destinations) {
+    return {
+      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
+    };
+  }
+  #createConsumer(queue, { onMessage, hooks }) {
+    return 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.#publishing.publish(this.#live?.publisher, {
+        exchange,
+        routingKey,
+        content,
+        options,
+        mandatory: true
+      }),
+      shutdownTimeoutMs: this.#settings.shutdownTimeoutMs,
+      onMessage,
+      ...hooks === void 0 ? {} : { onInvalidMessage: hooks.onInvalidMessage },
+      decode: this.#settings.decode,
+      onConsumerLost: (reason) => this.#supervisor.recover(reason),
+      logger: this.#settings.logger,
+      random: this.#settings.random
+    });
+  }
   /**
    * Stops consuming, waits up to `shutdownTimeout` for running handlers
    * (messages still being retried go back to the queue), then closes the
@@ -1544,36 +1582,7 @@ var RabbitMqTransport = class {
     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;
-}
 
 Object.defineProperty(exports, "fromHeader", {
   enumerable: true,