@zdavison/matador 3.0.8 → 4.0.1

package/dist/index.cjs

@@ -179,6 +179,19 @@ var TransportSendError = class extends MatadorError {
     };
   }
 };
+var SomeSendError = class extends MatadorError {
+  constructor(eventKey, errors) {
+    const summary = errors.map((e) => `${e.subscriberName} (${e.queue}): ${e.error.message}`).join("; ");
+    super(
+      `send("${eventKey}") failed for ${errors.length} subscriber(s): ${summary}`
+    );
+    this.eventKey = eventKey;
+    this.errors = errors;
+  }
+  eventKey;
+  errors;
+  description = "One or more subscriber messages could not be published during send(). ACTION: Inspect the `errors` array for per-failure details. Each entry contains the subscriber name, target queue, and underlying error.";
+};
 var DelayedMessagesNotSupportedError = class extends MatadorError {
   constructor(transportName) {
     super(
@@ -249,6 +262,16 @@ var LocalTransportCannotProcessStubError = class extends MatadorError {
   subscriberName;
   description = "The LocalTransport cannot process events for SubscriberStubs. ACTION: SubscriberStubs represent remote implementations that only RabbitMQ can route. If using LocalTransport for testing, provide mock implementations instead of stubs. For production fallback scenarios, be aware that stub-targeted events will be dropped.";
 };
+var UnknownQueueReferenceError = class extends MatadorError {
+  constructor(queueName) {
+    super(
+      `Queue reference "${queueName}" is not declared in the topology. Add it via .addQueue(name), or .addQueue({ name, exact: true }) for a foreign queue.`
+    );
+    this.queueName = queueName;
+  }
+  queueName;
+  description = "A queue was referenced that is not declared in the topology. Matador only routes to queues it knows about; an unknown reference would otherwise be silently namespace-qualified and published to a queue nobody consumes, losing the message. ACTION: Declare the queue on the topology before referencing it. For a Matador-owned queue use `.addQueue(name)`; for a foreign queue owned by another service use `.addQueue({ name, exact: true })` so it is routed to verbatim.";
+};
 var QueueNotFoundError = class extends MatadorError {
   constructor(queueName) {
     super(
@@ -318,6 +341,9 @@ function isEventNotRegisteredError(error) {
 function isSubscriberNotRegisteredError(error) {
   return error instanceof SubscriberNotRegisteredError;
 }
+function isUnknownQueueReferenceError(error) {
+  return error instanceof UnknownQueueReferenceError;
+}
 function isMessageMaybePoisonedError(error) {
   return error instanceof MessageMaybePoisonedError;
 }
@@ -360,20 +386,41 @@ function isCheckpointStoreError(error) {
 }
 
 // src/topology/types.ts
-function getQualifiedQueueName(namespace, queueName) {
-  return `${namespace}.${queueName}`;
+function applyPrefix(prefix, name) {
+  return prefix == null ? name : `${prefix}.${name}`;
 }
-function getDeadLetterQueueName(namespace, queueName, dlqType) {
-  return `${namespace}.${queueName}.${dlqType}`;
+function getQualifiedQueueName(namespace, queueName, naming, prefix) {
+  return naming?.queue?.(namespace, queueName) ?? applyPrefix(prefix, `${namespace}.${queueName}`);
 }
-function getRetryQueueName(namespace, queueName) {
-  return `${namespace}.${queueName}.retry`;
+function getDeadLetterQueueName(namespace, queueName, dlqType, naming, prefix) {
+  return `${getQualifiedQueueName(namespace, queueName, naming, prefix)}.${dlqType}`;
 }
-function resolveQueueName(namespace, queueDef) {
+function getRetryQueueName(namespace, queueName, naming, prefix) {
+  return `${getQualifiedQueueName(namespace, queueName, naming, prefix)}.retry`;
+}
+function resolveQueueName(namespace, queueDef, naming, prefix) {
   if (queueDef.exact) {
     return queueDef.name;
   }
-  return `${namespace}.${queueDef.name}`;
+  return getQualifiedQueueName(namespace, queueDef.name, naming, prefix);
+}
+function findQueueDefinition(topology, queueName) {
+  return topology.queues.find((q) => q.name === queueName);
+}
+function resolveTargetQueueName(topology, queueName) {
+  const def = findQueueDefinition(topology, queueName);
+  if (def === void 0) {
+    throw new UnknownQueueReferenceError(queueName);
+  }
+  if (def.exact) {
+    return def.name;
+  }
+  return getQualifiedQueueName(
+    topology.namespace,
+    queueName,
+    topology.naming,
+    topology.prefix
+  );
 }
 
 // src/topology/builder.ts
@@ -408,6 +455,8 @@ var TopologyBuilder = class _TopologyBuilder {
     maxDelayMs: 3e5
     // 5 minutes
   };
+  naming;
+  prefix = "matador";
   /**
    * Sets the namespace prefix for all queues.
    */
@@ -415,6 +464,37 @@ var TopologyBuilder = class _TopologyBuilder {
     this.namespace = namespace;
     return this;
   }
+  /**
+   * Sets the prefix prepended to every default-derived broker resource name
+   * (e.g. `matador.{namespace}.{queue}`), so Matador-managed queues and
+   * exchanges are identifiable. Pass `null` to disable prefixing.
+   *
+   * Only applies to default names — a {@link withNaming} override fully owns
+   * its output and is never prefixed.
+   *
+   * Pass `null` or `undefined` to disable prefixing.
+   *
+   * @default 'matador'
+   * @example
+   * TopologyBuilder.create().withNamespace('myapp')            // matador.myapp.events
+   * TopologyBuilder.create().withNamespace('myapp').withGlobalPrefix('acme')  // acme.myapp.events
+   * TopologyBuilder.create().withNamespace('myapp').withGlobalPrefix(null)    // myapp.events
+   */
+  withGlobalPrefix(prefix) {
+    this.prefix = prefix;
+    return this;
+  }
+  /**
+   * Overrides how broker resource names are derived.
+   * Use during migrations to keep pre-existing queue/exchange names so a
+   * rolling deploy keeps routing through the resources already declared on
+   * the broker.
+   * @see TopologyNaming
+   */
+  withNaming(naming) {
+    this.naming = naming;
+    return this;
+  }
   addQueue(nameOrDefinition, options = {}) {
     if (isQueueDefinition(nameOrDefinition)) {
       this.queues.push(nameOrDefinition);
@@ -473,8 +553,10 @@ var TopologyBuilder = class _TopologyBuilder {
   validate() {
     return [
       ...validateNamespace(this.namespace),
+      ...validatePrefix(this.prefix),
       ...validateQueues(this.queues),
-      ...validateRetry(this.retry)
+      ...validateRetry(this.retry),
+      ...validateNaming(this.naming)
     ];
   }
   /**
@@ -493,7 +575,9 @@ var TopologyBuilder = class _TopologyBuilder {
       namespace: this.namespace,
       queues: [...this.queues],
       deadLetter: this.deadLetter,
-      retry: this.retry
+      retry: this.retry,
+      naming: this.naming,
+      prefix: this.prefix
     };
   }
 };
@@ -509,6 +593,20 @@ function validateNamespace(namespace) {
   }
   return [];
 }
+function validatePrefix(prefix) {
+  if (prefix == null) {
+    return [];
+  }
+  if (prefix.trim() === "") {
+    return ["Prefix must be a non-empty string, or null to disable prefixing"];
+  }
+  if (!IDENTIFIER_PATTERN.test(prefix)) {
+    return [
+      "Prefix must start with a letter and contain only alphanumeric characters, underscores, and hyphens"
+    ];
+  }
+  return [];
+}
 function validateQueueName(queue, seen) {
   if (!queue.name || queue.name.trim() === "") {
     return ["Queue name cannot be empty"];
@@ -546,6 +644,27 @@ function validateQueues(queues) {
   }
   return issues;
 }
+function validateNaming(naming) {
+  if (!naming) return [];
+  const issues = [];
+  for (const field of [
+    "queue",
+    "mainExchange",
+    "dlxExchange",
+    "delayedExchange"
+  ]) {
+    const value = naming[field];
+    if (value !== void 0 && typeof value !== "function") {
+      issues.push(`Naming override "${field}" must be a function`);
+    }
+  }
+  if (naming.dlxExchangeType !== void 0 && naming.dlxExchangeType !== "direct" && naming.dlxExchangeType !== "topic") {
+    issues.push(
+      `Naming override "dlxExchangeType" must be 'direct' or 'topic'`
+    );
+  }
+  return issues;
+}
 function validateRetry(retry) {
   if (!retry.enabled) return [];
   const issues = [];
@@ -686,14 +805,14 @@ var FanoutEngine = class {
   transport;
   schema;
   hooks;
-  namespace;
+  topology;
   defaultQueue;
   enqueuingCount = 0;
   constructor(config) {
     this.transport = config.transport;
     this.schema = config.schema;
     this.hooks = config.hooks;
-    this.namespace = config.namespace;
+    this.topology = config.topology;
     this.defaultQueue = config.defaultQueue;
   }
   /**
@@ -720,7 +839,7 @@ var FanoutEngine = class {
         continue;
       }
       const targetQueue = subscriber.targetQueue ?? this.defaultQueue;
-      const qualifiedQueue = getQualifiedQueueName(this.namespace, targetQueue);
+      const qualifiedQueue = resolveTargetQueueName(this.topology, targetQueue);
       const envelope = createEnvelope({
         eventKey,
         eventDescription: eventClass.description,
@@ -2060,7 +2179,7 @@ var Matador = class {
       transport: this.transport,
       schema: this.schema,
       hooks: this.hooks,
-      namespace: this.topology.namespace,
+      topology: this.topology,
       defaultQueue
     });
     this.shutdownManager = new ShutdownManager(
@@ -2134,13 +2253,14 @@ var Matador = class {
       this.hooks.logger.info(
         `[Matador] \u{1F7E2} Worker subscribing to '${this.consumeFrom.join(",")}'.`
       );
+    } else {
+      this.hooks.logger.info(
+        "[Matador] \u{1F7E1} Worker not subscribing to any queues (consumeFrom is empty)."
+      );
     }
     for (const queueName of this.consumeFrom) {
-      const qualifiedName = getQualifiedQueueName(
-        this.topology.namespace,
-        queueName
-      );
-      const queueDef = this.topology.queues.find((q) => q.name === queueName);
+      const qualifiedName = resolveTargetQueueName(this.topology, queueName);
+      const queueDef = findQueueDefinition(this.topology, queueName);
       const subscription = await this.transport.subscribe(
         qualifiedName,
         async (envelope, receipt) => {
@@ -2171,12 +2291,18 @@ var Matador = class {
       const data = dataOrOptions;
       const options2 = maybeOptions;
       const event2 = new eventClass2(data);
-      return this.fanout.send(eventClass2, event2, options2);
+      const result2 = await this.fanout.send(eventClass2, event2, options2);
+      if (result2.errors.length > 0)
+        throw new SomeSendError(result2.eventKey, result2.errors);
+      return result2;
     }
     const event = eventOrClass;
     const options = dataOrOptions;
     const eventClass = event.constructor;
-    return this.fanout.send(eventClass, event, options);
+    const result = await this.fanout.send(eventClass, event, options);
+    if (result.errors.length > 0)
+      throw new SomeSendError(result.eventKey, result.errors);
+    return result;
   }
   /**
    * Gets current handler state.
@@ -2437,7 +2563,12 @@ var LocalTransport = class {
       throw new TransportNotConnectedError(this.name, "applyTopology");
     }
     for (const queueDef of topology.queues) {
-      const queueName = `${topology.namespace}.${queueDef.name}`;
+      const queueName = resolveQueueName(
+        topology.namespace,
+        queueDef,
+        topology.naming,
+        topology.prefix
+      );
       if (!this.queues.has(queueName)) {
         this.queues.set(queueName, []);
       }
@@ -2483,7 +2614,12 @@ var LocalTransport = class {
   }
   async deliverToSubscribers(queue, message) {
     const subs = this.subscriptions.get(queue);
-    if (!subs) return;
+    if (!subs) {
+      this.logger.warn(
+        `[Matador][LocalTransport] \u{1F7E1} No subscriptions found for queue '${queue}', message will be lost.`
+      );
+      return;
+    }
     for (const sub of subs) {
       if (!sub.active || message.completed) continue;
       const receipt = {
@@ -2773,6 +2909,7 @@ var RabbitMQTransport = class {
   publishChannel = null;
   connectionManager;
   queueChannels = /* @__PURE__ */ new Map();
+  subscriptionIntents = [];
   topology = null;
   codec = new RabbitMQCodec();
   config;
@@ -2786,7 +2923,8 @@ var RabbitMQTransport = class {
       connection: config.connection ?? {},
       quorumQueues: config.quorumQueues ?? true,
       defaultPrefetch: config.defaultPrefetch ?? 10,
-      enableDelayedMessages: config.enableDelayedMessages ?? true
+      enableDelayedMessages: config.enableDelayedMessages ?? true,
+      publishTimeoutMs: config.publishTimeoutMs ?? 5e3
     };
     this.connectionManager = new ConnectionManager(
       () => this.doConnect(),
@@ -2809,14 +2947,18 @@ var RabbitMQTransport = class {
       throw new TransportNotConnectedError(this.name, "applyTopology");
     }
     const channel = this.publishChannel;
-    const mainExchange = this.getMainExchangeName(topology.namespace);
+    const mainExchange = this.getMainExchangeName(topology);
     await channel.assertExchange(mainExchange, "direct", { durable: true });
-    const dlxExchange = this.getDLXExchangeName(topology.namespace);
+    const dlxExchange = this.getDLXExchangeName(topology);
     if (topology.deadLetter.unhandled.enabled || topology.deadLetter.undeliverable.enabled) {
-      await channel.assertExchange(dlxExchange, "direct", { durable: true });
+      await channel.assertExchange(
+        dlxExchange,
+        topology.naming?.dlxExchangeType ?? "direct",
+        { durable: true }
+      );
     }
     if (this.config.enableDelayedMessages) {
-      await this.setupDelayedExchange(topology.namespace);
+      await this.setupDelayedExchange(topology);
     }
     for (const queueDef of topology.queues) {
       await this.assertWorkQueue(channel, topology, queueDef);
@@ -2848,14 +2990,13 @@ var RabbitMQTransport = class {
       if (!this.delayedExchangeAvailable) {
         throw new DelayedMessagesNotSupportedError(this.name);
       }
-      const delayedExchange = this.getDelayedExchangeName(
-        this.topology.namespace
-      );
+      const delayedExchange = this.getDelayedExchangeName(this.topology);
       publishOptions.headers = {
         ...publishOptions.headers,
         "x-delay": options.delay
       };
-      this.publishChannel.publish(
+      await this.confirmPublish(
+        this.publishChannel,
         delayedExchange,
         queue,
         buffer,
@@ -2870,14 +3011,67 @@ var RabbitMQTransport = class {
       publishOptions.persistent = options.transport.rabbitmq.persistent;
     }
     const routingKey = options?.transport?.rabbitmq?.routingKey ?? queue;
-    const exchange = this.getMainExchangeName(this.topology.namespace);
-    this.publishChannel.publish(exchange, routingKey, buffer, publishOptions);
+    const exchange = this.getMainExchangeName(this.topology);
+    await this.confirmPublish(
+      this.publishChannel,
+      exchange,
+      routingKey,
+      buffer,
+      publishOptions
+    );
     return this.name;
   }
   async subscribe(queue, handler, options = {}) {
     if (!this.connection || !this.topology) {
       throw new TransportNotConnectedError(this.name, "subscribe");
     }
+    const intent = {
+      queue,
+      handler,
+      options,
+      active: true,
+      currentConsumer: null
+    };
+    this.subscriptionIntents.push(intent);
+    await this.activateIntent(intent);
+    return {
+      unsubscribe: async () => {
+        intent.active = false;
+        const idx = this.subscriptionIntents.indexOf(intent);
+        if (idx !== -1) this.subscriptionIntents.splice(idx, 1);
+        const consumer = intent.currentConsumer;
+        if (consumer) {
+          consumer.active = false;
+          const queueChannel = this.queueChannels.get(queue);
+          if (queueChannel) {
+            try {
+              await queueChannel.channel.cancel(consumer.consumerTag);
+            } catch {
+            }
+            const cIdx = queueChannel.consumers.indexOf(consumer);
+            if (cIdx !== -1) queueChannel.consumers.splice(cIdx, 1);
+            if (queueChannel.consumers.length === 0) {
+              try {
+                await queueChannel.channel.close();
+              } catch {
+              }
+              this.queueChannels.delete(queue);
+            }
+          }
+          intent.currentConsumer = null;
+        }
+      },
+      get isActive() {
+        return intent.active;
+      }
+    };
+  }
+  /**
+   * Wires a single subscription intent to the current connection.
+   * Called once on subscribe() and again after each reconnect.
+   */
+  async activateIntent(intent) {
+    const { queue, handler, options } = intent;
     const queueChannel = await this.getOrCreateQueueChannel(queue, options);
     const { channel } = queueChannel;
     const consumer = {
@@ -2913,33 +3107,10 @@ var RabbitMQTransport = class {
         }
       },
       { noAck: false }
-      // Always manually ack
     );
     consumer.consumerTag = consumerTag;
     queueChannel.consumers.push(consumer);
-    return {
-      unsubscribe: async () => {
-        consumer.active = false;
-        try {
-          await channel.cancel(consumerTag);
-        } catch {
-        }
-        const idx = queueChannel.consumers.indexOf(consumer);
-        if (idx !== -1) {
-          queueChannel.consumers.splice(idx, 1);
-        }
-        if (queueChannel.consumers.length === 0) {
-          try {
-            await channel.close();
-          } catch {
-          }
-          this.queueChannels.delete(queue);
-        }
-      },
-      get isActive() {
-        return consumer.active;
-      }
-    };
+    intent.currentConsumer = consumer;
   }
   async complete(receipt) {
     const { channel, msg } = receipt.handle;
@@ -2963,7 +3134,7 @@ var RabbitMQTransport = class {
     };
     const encoded = this.codec.encode(dlqEnvelope);
     const buffer = Buffer.from(encoded.body);
-    const dlxExchange = this.getDLXExchangeName(this.topology.namespace);
+    const dlxExchange = this.getDLXExchangeName(this.topology);
     const dlqQueueName = `${receipt.sourceQueue}.${dlqName}`;
     const publishOptions = {
       persistent: true,
@@ -2975,7 +3146,8 @@ var RabbitMQTransport = class {
         "x-matador-dead-letter-reason": reason
       }
     };
-    this.publishChannel.publish(
+    await this.confirmPublish(
+      this.publishChannel,
       dlxExchange,
       dlqQueueName,
       buffer,
@@ -2983,6 +3155,41 @@ var RabbitMQTransport = class {
     );
     await this.complete(receipt);
   }
+  /**
+   * Publishes on the confirm channel and resolves once the broker
+   * acknowledges the message, rejecting on broker nack, channel error, or
+   * after `publishTimeoutMs` elapses without a confirm.
+   *
+   * Mirrors Matador v1's promise-wrapped amqplib publish callback to give
+   * callers confirmed (at-least-once) delivery semantics.
+   */
+  confirmPublish(channel, exchange, routingKey, buffer, options) {
+    return new Promise((resolve, reject) => {
+      let timeout = setTimeout(() => {
+        timeout = null;
+        reject(
+          new TransportSendError(
+            routingKey,
+            new Error(
+              `Publish not confirmed by broker within ${this.config.publishTimeoutMs}ms`
+            )
+          )
+        );
+      }, this.config.publishTimeoutMs);
+      channel.publish(exchange, routingKey, buffer, options, (err) => {
+        if (timeout) {
+          clearTimeout(timeout);
+        } else {
+          return;
+        }
+        if (err) {
+          reject(new TransportSendError(routingKey, err));
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
   // Private methods
   /**
    * Gets or creates a dedicated channel for a queue subscription.
@@ -3012,6 +3219,7 @@ var RabbitMQTransport = class {
     return queueChannel;
   }
   async doConnect() {
+    this.queueChannels.clear();
     this.logger.info(
       `[Matador] \u23F3 Connecting to RabbitMQ at '${redactAmqpUrl(this.config.url)}'.`
     );
@@ -3023,19 +3231,28 @@ var RabbitMQTransport = class {
       this.logger.error("[Matador] \u{1F534} RabbitMQ connection error", err);
     });
     connection.on("close", () => {
+      for (const queueChannel of this.queueChannels.values()) {
+        for (const consumer of queueChannel.consumers) {
+          consumer.active = false;
+        }
+      }
       if (this.connectionManager.isConnected()) {
         this.connectionManager.handleConnectionLost(
           new Error("Connection closed unexpectedly")
         );
       }
     });
-    this.publishChannel = await connection.createChannel();
+    this.publishChannel = await connection.createConfirmChannel();
     this.publishChannel.on("error", (err) => {
       this.logger.error("[Matador] \u{1F534} RabbitMQ publish channel error", err);
     });
     if (this.topology) {
       await this.applyTopology(this.topology);
+      for (const intent of this.subscriptionIntents) {
+        await this.activateIntent(intent);
+      }
     }
+    this.logger.info("[Matador] \u{1F50C} Connected to RabbitMQ");
   }
   async doDisconnect() {
     for (const queueChannel of this.queueChannels.values()) {
@@ -3072,12 +3289,12 @@ var RabbitMQTransport = class {
       delayedMessages: false
     };
   }
-  async setupDelayedExchange(namespace) {
+  async setupDelayedExchange(topology) {
     if (!this.connection) {
       return;
     }
     this.delayedExchangeAvailable = false;
-    const delayedExchange = this.getDelayedExchangeName(namespace);
+    const delayedExchange = this.getDelayedExchangeName(topology);
     const connection = this.connection;
     return new Promise((resolve) => {
       let resolved = false;
@@ -3129,7 +3346,7 @@ var RabbitMQTransport = class {
       queueOptions.arguments["x-queue-type"] = "quorum";
     }
     if (topology.deadLetter.unhandled.enabled || topology.deadLetter.undeliverable.enabled) {
-      queueOptions.arguments["x-dead-letter-exchange"] = this.getDLXExchangeName(topology.namespace);
+      queueOptions.arguments["x-dead-letter-exchange"] = this.getDLXExchangeName(topology);
     }
     if (queueDef.priorities) {
       queueOptions.arguments["x-max-priority"] = 10;
@@ -3140,23 +3357,39 @@ var RabbitMQTransport = class {
     return queueOptions;
   }
   async assertWorkQueue(channel, topology, queueDef) {
-    const queueName = queueDef.exact ? queueDef.name : `${topology.namespace}.${queueDef.name}`;
+    const queueName = resolveQueueName(
+      topology.namespace,
+      queueDef,
+      topology.naming,
+      topology.prefix
+    );
     const rabbitmqOptions = queueDef.transport?.rabbitmq?.options;
     const queueOptions = rabbitmqOptions ?? this.buildWorkQueueOptions(topology, queueDef);
     await channel.assertQueue(queueName, queueOptions);
-    const mainExchange = this.getMainExchangeName(topology.namespace);
+    const mainExchange = this.getMainExchangeName(topology);
     await channel.bindQueue(queueName, mainExchange, queueName);
     if (this.delayedExchangeAvailable) {
-      const delayedExchange = this.getDelayedExchangeName(topology.namespace);
+      const delayedExchange = this.getDelayedExchangeName(topology);
       await channel.bindQueue(queueName, delayedExchange, queueName);
     }
     if (topology.retry.enabled && !queueDef.exact) {
-      await this.assertRetryQueue(channel, topology, queueName);
+      await this.assertRetryQueue(channel, topology, queueDef);
     }
   }
-  async assertRetryQueue(channel, topology, workQueueName) {
-    const retryQueueName = `${workQueueName}.retry`;
-    const mainExchange = this.getMainExchangeName(topology.namespace);
+  async assertRetryQueue(channel, topology, queueDef) {
+    const workQueueName = resolveQueueName(
+      topology.namespace,
+      queueDef,
+      topology.naming,
+      topology.prefix
+    );
+    const retryQueueName = getRetryQueueName(
+      topology.namespace,
+      queueDef.name,
+      topology.naming,
+      topology.prefix
+    );
+    const mainExchange = this.getMainExchangeName(topology);
     const retryQueueOptions = {
       durable: true,
       arguments: {
@@ -3172,12 +3405,17 @@ var RabbitMQTransport = class {
     await channel.bindQueue(retryQueueName, mainExchange, retryQueueName);
   }
   async assertDeadLetterQueues(channel, topology, dlqType) {
-    const dlxExchange = this.getDLXExchangeName(topology.namespace);
+    const dlxExchange = this.getDLXExchangeName(topology);
     const dlConfig = topology.deadLetter[dlqType];
     for (const queueDef of topology.queues) {
       if (queueDef.exact) continue;
-      const workQueueName = `${topology.namespace}.${queueDef.name}`;
-      const dlqName = `${workQueueName}.${dlqType}`;
+      const dlqName = getDeadLetterQueueName(
+        topology.namespace,
+        queueDef.name,
+        dlqType,
+        topology.naming,
+        topology.prefix
+      );
       const dlqOptions = {
         durable: true,
         arguments: {}
@@ -3185,18 +3423,21 @@ var RabbitMQTransport = class {
       if (dlConfig.maxLength) {
         dlqOptions.arguments["x-max-length"] = dlConfig.maxLength;
       }
+      if (this.config.quorumQueues) {
+        dlqOptions.arguments["x-queue-type"] = "quorum";
+      }
       await channel.assertQueue(dlqName, dlqOptions);
       await channel.bindQueue(dlqName, dlxExchange, dlqName);
     }
   }
-  getMainExchangeName(namespace) {
-    return `${namespace}.exchange`;
+  getMainExchangeName(topology) {
+    return topology.naming?.mainExchange?.(topology.namespace) ?? applyPrefix(topology.prefix, `${topology.namespace}.exchange`);
   }
-  getDLXExchangeName(namespace) {
-    return `${namespace}.dlx`;
+  getDLXExchangeName(topology) {
+    return topology.naming?.dlxExchange?.(topology.namespace) ?? applyPrefix(topology.prefix, `${topology.namespace}.dlx`);
   }
-  getDelayedExchangeName(namespace) {
-    return `${namespace}.delayed`;
+  getDelayedExchangeName(topology) {
+    return topology.naming?.delayedExchange?.(topology.namespace) ?? applyPrefix(topology.prefix, `${topology.namespace}.delayed`);
   }
   getAttemptNumber(msg) {
     const headerValue = msg.properties.headers?.["x-matador-attempts"];
@@ -3275,6 +3516,7 @@ exports.SchemaError = SchemaError;
 exports.SchemaRegistry = SchemaRegistry;
 exports.ShutdownInProgressError = ShutdownInProgressError;
 exports.ShutdownManager = ShutdownManager;
+exports.SomeSendError = SomeSendError;
 exports.StandardRetryPolicy = StandardRetryPolicy;
 exports.SubscriberIsStubError = SubscriberIsStubError;
 exports.SubscriberNotRegisteredError = SubscriberNotRegisteredError;
@@ -3284,6 +3526,8 @@ exports.TopologyValidationError = TopologyValidationError;
 exports.TransportClosedError = TransportClosedError;
 exports.TransportNotConnectedError = TransportNotConnectedError;
 exports.TransportSendError = TransportSendError;
+exports.UnknownQueueReferenceError = UnknownQueueReferenceError;
+exports.applyPrefix = applyPrefix;
 exports.assertEvent = assertEvent;
 exports.bind = bind;
 exports.consoleLogger = consoleLogger;
@@ -3294,6 +3538,7 @@ exports.createSubscriberStub = createSubscriberStub;
 exports.defaultConnectionConfig = defaultConnectionConfig;
 exports.defaultRetryConfig = defaultRetryConfig;
 exports.defaultShutdownConfig = defaultShutdownConfig;
+exports.findQueueDefinition = findQueueDefinition;
 exports.getDeadLetterQueueName = getDeadLetterQueueName;
 exports.getQualifiedQueueName = getQualifiedQueueName;
 exports.getRetryQueueName = getRetryQueueName;
@@ -3316,7 +3561,9 @@ exports.isSubscriber = isSubscriber;
 exports.isSubscriberNotRegisteredError = isSubscriberNotRegisteredError;
 exports.isSubscriberStub = isSubscriberStub;
 exports.isTransportNotConnectedError = isTransportNotConnectedError;
+exports.isUnknownQueueReferenceError = isUnknownQueueReferenceError;
 exports.resolveQueueName = resolveQueueName;
+exports.resolveTargetQueueName = resolveTargetQueueName;
 exports.supportsDelayedMessages = supportsDelayedMessages;
 exports.supportsDeliveryMode = supportsDeliveryMode;
 exports.validResult = validResult;