@kronos-ts/rabbitmq 0.2.1 → 0.3.1

package/src/distributed-subscriber-registry.ts

@@ -0,0 +1,286 @@
+import type { Channel, ConsumeMessage } from "amqplib"
+import type { AmqpConnection } from "./connection.js"
+import type { RabbitMqResolvedConfig } from "./rabbitmq.js"
+
+/**
+ * A subscription known to the cluster — either owned locally on this instance
+ * or owned by another instance and learned over gossip.
+ */
+export interface SubscriberRecord {
+  readonly subId: string
+  readonly queryName: string
+  readonly payload: unknown
+  readonly ownerInstanceId: string
+}
+
+export interface SerializedError {
+  readonly name?: string
+  readonly message: string
+  readonly stack?: string
+}
+
+/**
+ * Targeted message delivered to the owner of a specific subscription. The
+ * owner applies it locally against the buffered subscriber stream.
+ */
+export type DeliverEnvelope =
+  | { readonly kind: "update"; readonly subId: string; readonly update: unknown }
+  | { readonly kind: "complete"; readonly subId: string }
+  | {
+      readonly kind: "completeExceptionally"
+      readonly subId: string
+      readonly error: SerializedError
+    }
+
+/**
+ * Gossip envelopes broadcast to every instance over the fanout exchange.
+ *
+ * `claim`/`release` keep the cluster-wide subscriber mirror in sync. `sync`
+ * announces a fresh instance and prompts peers to re-emit their owned claims
+ * so the joiner can bootstrap its mirror.
+ *
+ * Every envelope carries the publisher's `ownerInstanceId` so receivers can
+ * drop their own loopback (the local mirror was already updated synchronously
+ * on the publish path).
+ */
+export type GossipEnvelope =
+  | {
+      readonly kind: "claim"
+      readonly ownerInstanceId: string
+      readonly subId: string
+      readonly queryName: string
+      readonly payload: unknown
+    }
+  | { readonly kind: "release"; readonly ownerInstanceId: string; readonly subId: string }
+  | { readonly kind: "syncRequest"; readonly requesterId: string }
+
+export interface DistributedSubscriberRegistry {
+  /** Stable identifier for this process. */
+  readonly instanceId: string
+
+  /** Add (or overwrite) a locally-owned subscriber and broadcast the claim. */
+  claim(record: Omit<SubscriberRecord, "ownerInstanceId">): Promise<void>
+
+  /** Remove a locally-owned subscriber and broadcast the release. */
+  release(subId: string): Promise<void>
+
+  /** Iterate every record in the cluster-wide mirror (locally owned + remote). */
+  records(): IterableIterator<SubscriberRecord>
+
+  /**
+   * Route a delivery to the owner of `subId`. Local owners are dispatched
+   * synchronously to the in-process handler; remote owners receive a direct-
+   * queue publish keyed by their instanceId.
+   */
+  deliver(envelope: DeliverEnvelope): Promise<void>
+
+  /** Set the handler invoked when a `DeliverEnvelope` for a local sub arrives. */
+  setDeliverHandler(handler: (envelope: DeliverEnvelope) => void): void
+
+  connect(): Promise<void>
+  close(): Promise<void>
+}
+
+/**
+ * AMQP-backed implementation.
+ *
+ * Topology:
+ *
+ *   - `<prefix>.subscribers.gossip` — fanout exchange. Every instance owns an
+ *     exclusive auto-delete queue bound to it. Carries claim / release /
+ *     syncRequest messages.
+ *
+ *   - `<prefix>.subscribers.direct` — direct exchange. Every instance owns an
+ *     exclusive auto-delete queue bound by routing key equal to its
+ *     `instanceId`. Carries DeliverEnvelope messages targeted at the owner.
+ *
+ * Consume mode is no-ack on both queues — the registry is a best-effort eventual
+ * mirror. A dropped claim is healed by the next sync request; a dropped deliver
+ * looks like a missed update, the same failure mode the broker-routed model has
+ * when a stream segment is lost.
+ *
+ * Loopback dedup: the publisher applies its own claim/release to the local
+ * mirror synchronously before publishing, and ignores its own envelopes on the
+ * inbound side via `ownerInstanceId === instanceId`.
+ *
+ * Joiner protocol: on connect the new instance publishes a `syncRequest`.
+ * Existing peers respond by re-broadcasting each of their owned claims over
+ * the same fanout exchange. New instance fills its mirror as they arrive; in
+ * the meantime emits routed to subs the joiner has yet to learn about are
+ * dropped on the joiner side — by design, since the joiner can't have any of
+ * its own subscribers yet either. The window self-closes as the mirror fills.
+ */
+export class AmqpDistributedSubscriberRegistry implements DistributedSubscriberRegistry {
+  private channel: Channel | undefined
+  private connectPromise: Promise<void> | undefined
+  private closed = false
+  private deliverHandler: ((envelope: DeliverEnvelope) => void) | undefined
+  private readonly mirror = new Map<string, SubscriberRecord>()
+  private readonly locallyOwnedSubIds = new Set<string>()
+
+  readonly instanceId: string
+
+  constructor(
+    private readonly config: RabbitMqResolvedConfig,
+    private readonly connection: AmqpConnection,
+  ) {
+    this.instanceId = `${config.identity.serviceName}.${config.identity.instanceId}`
+  }
+
+  async connect(): Promise<void> {
+    if (this.connectPromise) return this.connectPromise
+    this.connectPromise = this.doConnect()
+    return this.connectPromise
+  }
+
+  private async doConnect(): Promise<void> {
+    this.channel = await this.connection.channel()
+    const ch = this.channel
+
+    await ch.assertExchange(this.config.topology.subscribersGossipExchange, "fanout", {
+      durable: true,
+    })
+    await ch.assertExchange(this.config.topology.subscribersDirectExchange, "direct", {
+      durable: true,
+    })
+
+    const gossipQueue = this.config.topology.subscribersGossipQueue()
+    const directQueue = this.config.topology.subscribersDirectQueue()
+
+    await ch.assertQueue(gossipQueue, { durable: false, exclusive: true, autoDelete: true })
+    await ch.assertQueue(directQueue, { durable: false, exclusive: true, autoDelete: true })
+
+    await ch.bindQueue(gossipQueue, this.config.topology.subscribersGossipExchange, "")
+    await ch.bindQueue(directQueue, this.config.topology.subscribersDirectExchange, this.instanceId)
+
+    await ch.consume(gossipQueue, (msg) => this.handleGossip(msg), { noAck: true })
+    await ch.consume(directQueue, (msg) => this.handleDirect(msg), { noAck: true })
+
+    // Announce ourselves so existing peers re-broadcast their owned claims.
+    this.publishGossip({ kind: "syncRequest", requesterId: this.instanceId })
+  }
+
+  async close(): Promise<void> {
+    this.closed = true
+    await this.channel?.close().catch(() => {})
+  }
+
+  async claim(record: Omit<SubscriberRecord, "ownerInstanceId">): Promise<void> {
+    const full: SubscriberRecord = { ...record, ownerInstanceId: this.instanceId }
+    this.mirror.set(full.subId, full)
+    this.locallyOwnedSubIds.add(full.subId)
+    await this.connect()
+    if (this.closed) return
+    this.publishGossip({
+      kind: "claim",
+      ownerInstanceId: this.instanceId,
+      subId: full.subId,
+      queryName: full.queryName,
+      payload: full.payload,
+    })
+  }
+
+  async release(subId: string): Promise<void> {
+    this.mirror.delete(subId)
+    this.locallyOwnedSubIds.delete(subId)
+    await this.connect()
+    if (this.closed) return
+    this.publishGossip({ kind: "release", ownerInstanceId: this.instanceId, subId })
+  }
+
+  *records(): IterableIterator<SubscriberRecord> {
+    for (const record of this.mirror.values()) yield record
+  }
+
+  async deliver(envelope: DeliverEnvelope): Promise<void> {
+    const record = this.mirror.get(envelope.subId)
+    if (!record) return
+
+    if (record.ownerInstanceId === this.instanceId) {
+      this.deliverHandler?.(envelope)
+      return
+    }
+
+    await this.connect()
+    if (this.closed) return
+    const ch = this.requireChannel()
+    ch.publish(
+      this.config.topology.subscribersDirectExchange,
+      record.ownerInstanceId,
+      Buffer.from(JSON.stringify(envelope)),
+      { contentType: "application/json", persistent: false },
+    )
+  }
+
+  setDeliverHandler(handler: (envelope: DeliverEnvelope) => void): void {
+    this.deliverHandler = handler
+  }
+
+  private publishGossip(envelope: GossipEnvelope): void {
+    if (this.closed) return
+    const ch = this.channel
+    if (!ch) return
+    ch.publish(
+      this.config.topology.subscribersGossipExchange,
+      "",
+      Buffer.from(JSON.stringify(envelope)),
+      { contentType: "application/json", persistent: false },
+    )
+  }
+
+  private handleGossip(msg: ConsumeMessage | null): void {
+    if (!msg) return
+    let envelope: GossipEnvelope
+    try {
+      envelope = JSON.parse(msg.content.toString("utf8")) as GossipEnvelope
+    } catch {
+      return
+    }
+
+    if (envelope.kind === "claim") {
+      // Loopback — local mirror already updated synchronously by claim().
+      if (envelope.ownerInstanceId === this.instanceId) return
+      this.mirror.set(envelope.subId, {
+        subId: envelope.subId,
+        queryName: envelope.queryName,
+        payload: envelope.payload,
+        ownerInstanceId: envelope.ownerInstanceId,
+      })
+    } else if (envelope.kind === "release") {
+      if (envelope.ownerInstanceId === this.instanceId) return
+      this.mirror.delete(envelope.subId)
+    } else if (envelope.kind === "syncRequest") {
+      // Skip our own announcement; respond to every other instance by
+      // re-broadcasting our owned claims over the same fanout exchange.
+      if (envelope.requesterId === this.instanceId) return
+      for (const subId of this.locallyOwnedSubIds) {
+        const record = this.mirror.get(subId)
+        if (!record) continue
+        this.publishGossip({
+          kind: "claim",
+          ownerInstanceId: this.instanceId,
+          subId: record.subId,
+          queryName: record.queryName,
+          payload: record.payload,
+        })
+      }
+    }
+  }
+
+  private handleDirect(msg: ConsumeMessage | null): void {
+    if (!msg) return
+    if (!this.deliverHandler) return
+    let envelope: DeliverEnvelope
+    try {
+      envelope = JSON.parse(msg.content.toString("utf8")) as DeliverEnvelope
+    } catch {
+      return
+    }
+    this.deliverHandler(envelope)
+  }
+
+  private requireChannel(): Channel {
+    if (!this.channel) throw new Error("Distributed subscriber registry is not connected")
+    return this.channel
+  }
+}

package/src/index.ts

@@ -30,6 +30,14 @@ export {
   type RabbitMqQueryBusOptions,
 } from "./query-bus.js"
 
+export {
+  AmqpDistributedSubscriberRegistry,
+  type DistributedSubscriberRegistry,
+  type SubscriberRecord,
+  type DeliverEnvelope,
+  type GossipEnvelope,
+} from "./distributed-subscriber-registry.js"
+
 export { AmqpRabbitMqCommandTransport } from "./amqp-command-transport.js"
 export { AmqpRabbitMqQueryTransport } from "./amqp-query-transport.js"
 

package/src/query-bus.ts

@@ -1,7 +1,22 @@
-import type { QueryBus, QueryMessage, SubscriptionQueryResult } from "@kronos-ts/messaging"
+import type {
+  QueryBus,
+  QueryMessage,
+  SubscriptionFilter,
+  SubscriptionQueryResult,
+  UpdateHandler,
+} from "@kronos-ts/messaging"
+import {
+  applySubscriptionFilter,
+  createUpdateHandler,
+  runAfterCommitOrImmediately,
+  runInNewUoW,
+} from "@kronos-ts/messaging"
 import { qualifiedNameToString } from "@kronos-ts/common"
-import { runInNewUoW } from "@kronos-ts/messaging"
 import type { RabbitMqResolvedConfig } from "./rabbitmq.js"
+import type {
+  DeliverEnvelope,
+  DistributedSubscriberRegistry,
+} from "./distributed-subscriber-registry.js"
 
 export interface RabbitMqQueryEnvelope {
   readonly kind: "query"
@@ -32,23 +47,105 @@ export interface RabbitMqQueryTransport {
 export interface RabbitMqQueryBusOptions {
   readonly localSegment: QueryBus
   readonly transport: RabbitMqQueryTransport
+  readonly subscriberRegistry?: DistributedSubscriberRegistry
   readonly config: RabbitMqResolvedConfig
 }
 
 /**
  * Distributed query bus decorator.
  *
- * Direct request/reply queries (`query` + `subscribe`) route over RabbitMQ.
- * Subscription queries (`subscriptionQuery`, `subscribeToUpdates`, `emitUpdate`,
- * `completeSubscription*`) remain process-local and delegate to the local
- * segment — distributing subscription-query update streams over RabbitMQ is
- * intentionally out of scope for this version (see rabbitmq-extension-plan.md).
+ * Direct request/reply queries (`query` + `subscribe`) route over the
+ * request/reply transport.
+ *
+ * Subscription queries use a distributed-mirror model. Every subscribe
+ * publishes a `claim` over the gossip fanout exchange so every instance
+ * learns about it; every unsubscribe publishes a `release`. Each instance
+ * keeps a cluster-wide `Map<subId, SubscriberRecord>` mirror.
+ *
+ * `emitUpdate` walks the mirror locally (it holds every cluster-wide
+ * subscriber's payload), applies the filter — function predicates work
+ * because evaluation happens colocated with the payload, not over the wire —
+ * and routes per-subscriber delivery via the registry. Local subs are
+ * dispatched in-process; remote subs receive a `DeliverEnvelope` on the
+ * owner's direct queue.
+ *
+ * The same model handles `completeSubscription` and
+ * `completeSubscriptionExceptionally`.
+ *
+ * Falls back to local-only behaviour when no `subscriberRegistry` is supplied.
  */
 export function createRabbitMqQueryBus(options: RabbitMqQueryBusOptions): QueryBus {
   const localHandlers = new Set<string>()
-  const { localSegment, transport, config } = options
+  const { localSegment, transport, subscriberRegistry, config } = options
+
+  // UpdateHandlers for subs owned BY this instance, keyed by subId.
+  const localOwnedHandlers = new Map<string, UpdateHandler>()
+
+  function applyDelivery(envelope: DeliverEnvelope): void {
+    const handler = localOwnedHandlers.get(envelope.subId)
+    if (!handler) return
+
+    if (envelope.kind === "update") {
+      if (!handler.active) {
+        localOwnedHandlers.delete(envelope.subId)
+        return
+      }
+      const accepted = handler.offer(envelope.update)
+      if (!accepted) {
+        handler.completeExceptionally(new Error("Subscription query update buffer overflow"))
+        localOwnedHandlers.delete(envelope.subId)
+      }
+    } else if (envelope.kind === "complete") {
+      handler.complete()
+      localOwnedHandlers.delete(envelope.subId)
+    } else if (envelope.kind === "completeExceptionally") {
+      const error = Object.assign(new Error(envelope.error.message), {
+        name: envelope.error.name ?? "RemoteSubscriptionError",
+      })
+      handler.completeExceptionally(error)
+      localOwnedHandlers.delete(envelope.subId)
+    }
+  }
+
+  if (subscriberRegistry) {
+    subscriberRegistry.setDeliverHandler(applyDelivery)
+  }
+
+  function registerSubscription(
+    message: QueryMessage,
+    bufferSize?: number,
+  ): UpdateHandler & { iterable: AsyncIterable<unknown> } {
+    const subId = message.identifier
+    if (localOwnedHandlers.has(subId)) {
+      throw new Error(`Subscription query already registered for identifier "${subId}"`)
+    }
+    const handler = createUpdateHandler(message, bufferSize)
+    localOwnedHandlers.set(subId, handler)
+
+    if (subscriberRegistry) {
+      void subscriberRegistry
+        .claim({
+          subId,
+          queryName: qualifiedNameToString(message.name),
+          payload: message.payload,
+        })
+        .catch(() => {})
+    }
+    return handler
+  }
+
+  function unregisterSubscription(message: QueryMessage): void {
+    const subId = message.identifier
+    const existing = localOwnedHandlers.get(subId)
+    if (!existing) return
+    localOwnedHandlers.delete(subId)
+    existing.complete()
+    if (subscriberRegistry) {
+      void subscriberRegistry.release(subId).catch(() => {})
+    }
+  }
 
-  return {
+  const bus: QueryBus = {
     async query(message: QueryMessage): Promise<unknown> {
       const queryName = qualifiedNameToString(message.name)
       const preferLocal = config.queries.preferLocalHandlers && !config.queries.alwaysUseDistributedBus
@@ -85,41 +182,125 @@ export function createRabbitMqQueryBus(options: RabbitMqQueryBusOptions): QueryB
       })
     },
 
-    // Subscription queries stay process-local — see the doc comment above.
     subscriptionQuery(message: QueryMessage, bufferSize?: number): SubscriptionQueryResult {
-      return localSegment.subscriptionQuery(message, bufferSize)
+      const updateHandler = registerSubscription(message, bufferSize)
+      const initialResult = bus.query(message)
+      return {
+        initialResult,
+        updates: updateHandler.iterable,
+        close: () => unregisterSubscription(message),
+      }
     },
 
     subscribeToUpdates(
       message: QueryMessage,
       bufferSize?: number,
     ): AsyncIterable<unknown> & { close(): void } {
-      return localSegment.subscribeToUpdates(message, bufferSize)
+      const updateHandler = registerSubscription(message, bufferSize)
+      return {
+        [Symbol.asyncIterator]: () => updateHandler.iterable[Symbol.asyncIterator](),
+        close: () => unregisterSubscription(message),
+      }
     },
 
-    emitUpdate(
+    async emitUpdate(
       queryName: string,
-      filter: (queryPayload: unknown) => boolean,
+      filter: SubscriptionFilter,
       update: unknown,
     ): Promise<void> {
-      return localSegment.emitUpdate(queryName, filter, update)
+      runAfterCommitOrImmediately(() => {
+        if (subscriberRegistry) {
+          for (const record of subscriberRegistry.records()) {
+            if (record.queryName !== queryName) continue
+            if (!applySubscriptionFilter(filter, record.payload)) continue
+            void subscriberRegistry
+              .deliver({ kind: "update", subId: record.subId, update })
+              .catch(() => {})
+          }
+          return
+        }
+
+        // Local-only mode: filter and offer against the local subscriber set.
+        for (const [id, handler] of localOwnedHandlers) {
+          if (!handler.active) {
+            localOwnedHandlers.delete(id)
+            continue
+          }
+          const handlerQueryName = qualifiedNameToString(handler.query.name)
+          if (handlerQueryName !== queryName) continue
+          if (!applySubscriptionFilter(filter, handler.query.payload)) continue
+
+          const accepted = handler.offer(update)
+          if (!accepted) {
+            handler.completeExceptionally(
+              new Error("Subscription query update buffer overflow"),
+            )
+            localOwnedHandlers.delete(id)
+          }
+        }
+      })
     },
 
-    completeSubscription(
+    async completeSubscription(
       queryName: string,
-      filter?: (queryPayload: unknown) => boolean,
+      filter?: SubscriptionFilter,
     ): Promise<void> {
-      return localSegment.completeSubscription(queryName, filter)
+      runAfterCommitOrImmediately(() => {
+        if (subscriberRegistry) {
+          for (const record of subscriberRegistry.records()) {
+            if (record.queryName !== queryName) continue
+            if (filter && !applySubscriptionFilter(filter, record.payload)) continue
+            void subscriberRegistry
+              .deliver({ kind: "complete", subId: record.subId })
+              .catch(() => {})
+          }
+          return
+        }
+
+        for (const [id, handler] of localOwnedHandlers) {
+          const handlerQueryName = qualifiedNameToString(handler.query.name)
+          if (handlerQueryName !== queryName) continue
+          if (filter && !applySubscriptionFilter(filter, handler.query.payload)) continue
+          handler.complete()
+          localOwnedHandlers.delete(id)
+        }
+      })
     },
 
-    completeSubscriptionExceptionally(
+    async completeSubscriptionExceptionally(
       queryName: string,
       error: Error,
-      filter?: (queryPayload: unknown) => boolean,
+      filter?: SubscriptionFilter,
     ): Promise<void> {
-      return localSegment.completeSubscriptionExceptionally(queryName, error, filter)
+      runAfterCommitOrImmediately(() => {
+        if (subscriberRegistry) {
+          const serialized = serializeError(error) ?? { message: String(error) }
+          for (const record of subscriberRegistry.records()) {
+            if (record.queryName !== queryName) continue
+            if (filter && !applySubscriptionFilter(filter, record.payload)) continue
+            void subscriberRegistry
+              .deliver({
+                kind: "completeExceptionally",
+                subId: record.subId,
+                error: serialized,
+              })
+              .catch(() => {})
+          }
+          return
+        }
+
+        for (const [id, handler] of localOwnedHandlers) {
+          const handlerQueryName = qualifiedNameToString(handler.query.name)
+          if (handlerQueryName !== queryName) continue
+          if (filter && !applySubscriptionFilter(filter, handler.query.payload)) continue
+          handler.completeExceptionally(error)
+          localOwnedHandlers.delete(id)
+        }
+      })
     },
   }
+
+  return bus
 }
 
 function serializeError(error: unknown): RabbitMqQueryReplyEnvelope["error"] {

package/src/rabbitmq.ts

@@ -4,6 +4,7 @@ import { createRabbitMqCommandBus } from "./command-bus.js"
 import { createRabbitMqQueryBus } from "./query-bus.js"
 import { AmqpRabbitMqCommandTransport } from "./amqp-command-transport.js"
 import { AmqpRabbitMqQueryTransport } from "./amqp-query-transport.js"
+import { AmqpDistributedSubscriberRegistry } from "./distributed-subscriber-registry.js"
 import { createAmqpConnection } from "./connection.js"
 
 export interface RabbitMqCommandDispatchConfig {
@@ -73,10 +74,11 @@ export function resolveRabbitMqConfig(app: App, config: RabbitMqExtensionConfig)
 /**
  * RabbitMQ distributed messaging extension.
  *
- * Wraps the command and query buses with RabbitMQ-backed request/reply
- * transports. Both transports share a single broker connection, each taking
- * its own channel. Subscription queries remain process-local — distributing
- * their update streams is out of scope for this version.
+ * Wraps the command and query buses with RabbitMQ-backed transports.
+ * Direct request/reply commands and queries share one channel each; a third
+ * channel hosts the subscription-query update broadcast (topic exchange plus
+ * an exclusive per-instance queue). All three share a single broker
+ * connection.
  */
 export function rabbitMq(config: RabbitMqExtensionConfig): (app: App) => void {
   return (app) => {
@@ -84,6 +86,7 @@ export function rabbitMq(config: RabbitMqExtensionConfig): (app: App) => void {
     const connection = createAmqpConnection(resolved.url)
     const commandTransport = new AmqpRabbitMqCommandTransport(resolved, connection)
     const queryTransport = new AmqpRabbitMqQueryTransport(resolved, connection)
+    const subscriberRegistry = new AmqpDistributedSubscriberRegistry(resolved, connection)
 
     app.decorate("commandBus", (localSegment) =>
       createRabbitMqCommandBus({
@@ -97,14 +100,17 @@ export function rabbitMq(config: RabbitMqExtensionConfig): (app: App) => void {
       createRabbitMqQueryBus({
         localSegment,
         transport: queryTransport,
+        subscriberRegistry,
         config: resolved,
       }),
     )
 
     app.onStart("connect", () => commandTransport.connect())
     app.onStart("connect", () => queryTransport.connect())
+    app.onStart("connect", () => subscriberRegistry.connect())
     app.onStop("connect", () => commandTransport.close())
     app.onStop("connect", () => queryTransport.close())
+    app.onStop("connect", () => subscriberRegistry.close())
     app.onStop("connect", () => connection.close())
   }
 }

package/src/topology.ts

@@ -5,16 +5,22 @@ export interface RabbitMqTopologyConfig {
   readonly prefix?: string
   readonly commandsExchange?: string
   readonly queriesExchange?: string
+  readonly subscribersGossipExchange?: string
+  readonly subscribersDirectExchange?: string
   readonly durableQueues?: boolean
 }
 
 export interface RabbitMqTopologyNames {
   readonly commandsExchange: string
   readonly queriesExchange: string
+  readonly subscribersGossipExchange: string
+  readonly subscribersDirectExchange: string
   commandRoutingKey(commandName: QualifiedName | string): string
   commandQueue(commandName: QualifiedName | string): string
   queryRoutingKey(queryName: QualifiedName | string): string
   queryQueue(queryName: QualifiedName | string): string
+  subscribersGossipQueue(): string
+  subscribersDirectQueue(): string
   commandReplyQueue(): string
   queryReplyQueue(): string
 }
@@ -28,10 +34,16 @@ export function createRabbitMqTopologyNames(
   const instance = sanitizeSegment(identity.instanceId)
   const commandsExchange = config.commandsExchange ?? `${prefix}.commands`
   const queriesExchange = config.queriesExchange ?? `${prefix}.queries`
+  const subscribersGossipExchange =
+    config.subscribersGossipExchange ?? `${prefix}.subscribers.gossip`
+  const subscribersDirectExchange =
+    config.subscribersDirectExchange ?? `${prefix}.subscribers.direct`
 
   return {
     commandsExchange,
     queriesExchange,
+    subscribersGossipExchange,
+    subscribersDirectExchange,
     commandRoutingKey(commandName) {
       return messageName(commandName)
     },
@@ -44,6 +56,12 @@ export function createRabbitMqTopologyNames(
     queryQueue(queryName) {
       return `${prefix}.queries.${service}.${sanitizeMessageName(messageName(queryName))}`
     },
+    subscribersGossipQueue() {
+      return `${prefix}.subscribers.gossip.${service}.${instance}`
+    },
+    subscribersDirectQueue() {
+      return `${prefix}.subscribers.direct.${service}.${instance}`
+    },
     commandReplyQueue() {
       return `${prefix}.replies.${service}.${instance}`
     },