@wildo-ai/saas-backend-lib 1.1.2 → 1.1.3

package/dist/esm/queue/adapters/in-memory-queue-adapter.backend.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-queue-adapter.backend.service.js","sourceRoot":"","sources":["../../../../../src/queue/adapters/in-memory-queue-adapter.backend.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { randomUUID } from 'node:crypto';\n\nimport type { JobPayload, JobResult } from '@wildo-ai/saas-models';\nimport { inject, injectable } from 'inversify';\n\nimport { SAAS_SERVICE_TYPES } from '~wildo-backend-lib/inject/models/service-types';\nimport { LoggerService } from '~wildo-backend-lib/monitoring/logger/services/logger.service';\nimport { describeCaughtError } from '~wildo-backend-lib/errors/utils/error-log-level-classification.backend.utils';\nimport type {\n  MessageHandler,\n  QueueAdapter,\n  QueueConsumeMessage,\n  QueueMessageAcknowledger,\n} from '~wildo-backend-lib/queue/adapters/queue-adapter.backend.interface';\nimport type {\n  PublishOptions,\n  QueueAssertOptions,\n} from '~wildo-backend-lib/queue/adapters/queue-adapter.backend.options';\n\n/**\n * An in-process {@link QueueAdapter}, so background-work BEHAVIOUR can be tested without a broker (#502).\n *\n * ## What this is for, and the bar it had to clear\n *\n * `QueueAdapterType` declared three adapters and one existed. The decision was to build this one and\n * collapse the other two, on a stated justification: *\"a queue that needs no RabbitMQ makes\n * background-work behaviour testable in-process\"*. That justification also sets the bar — an adapter\n * nothing runs against would have been a fourth unreachable thing built to fix three — so this ships\n * with a lane that drives real consumer behaviour through it, and that lane, not this file, is what\n * makes the decision honest.\n *\n * ## It is a QUEUE, not a stub\n *\n * The distinction matters, because a stub proves the caller compiles and a queue proves the caller is\n * right. So this really does what the port promises:\n *\n * - **`nack(requeue: true)` puts the message back**, at the FRONT, and the consumer sees it again.\n *   That is the retry loop every job consumer depends on, and a stub that swallowed it would let a\n *   broken retry pass.\n * - **`nack(requeue: false)` dead-letters** to the queue named by the source queue's\n *   `deadLetterExchange`/`deadLetterRoutingKey` assertion when one was declared, so a test can assert\n *   a poison message ARRIVED somewhere rather than merely that it left.\n * - **`scheduleDelayedRetry` really waits**, on a timer, and the delay is observable. RabbitMQ does\n *   this with a per-delay TTL queue dead-lettering back to the source; the observable contract — the\n *   job reappears on its source queue after `delayMs` — is identical, which is the only part a\n *   consumer may depend on.\n * - **An unacknowledged message stays unacknowledged.** Nothing auto-acks. A handler that forgets to\n *   settle leaves the message in flight here exactly as it would on a broker, and the count is\n *   readable through {@link getQueueDepth}.\n *\n * ## What it deliberately does NOT do\n *\n * No durability, no cross-process visibility, no broker permissions, no exchange topology. Those are\n * the properties a real deployment buys a broker FOR, and simulating them here would produce a second\n * queue implementation whose divergences from RabbitMQ nobody could enumerate. This is for tests and\n * for a single-process runtime that has declared it wants no broker — it is not a smaller RabbitMQ.\n *\n * Delivery is asynchronous (`queueMicrotask`), never synchronous inside `publish`. A synchronous\n * hand-off would let a test pass that deadlocks against a real broker, because the publisher would be\n * holding whatever the handler then waits on.\n */\n\ninterface InMemoryQueue {\n  readonly messages: QueueConsumeMessage[];\n  readonly options: QueueAssertOptions;\n  /** In-flight: delivered and not yet settled. Keyed by the identity handed to the handler. */\n  readonly unsettled: Set<QueueConsumeMessage>;\n  consumer?: { tag: string; handler: MessageHandler };\n  draining: boolean;\n}\n\n@injectable()\nexport class InMemoryQueueAdapterBackendService implements QueueAdapter {\n  private readonly queues = new Map<string, InMemoryQueue>();\n  private readonly pendingDelays = new Set<NodeJS.Timeout>();\n  private readonly podId = `in-memory-${randomUUID()}`;\n  private replyQueueName: string | null = null;\n  private connected = false;\n\n  constructor(\n    @inject(SAAS_SERVICE_TYPES.Logger) private readonly logger: LoggerService,\n  ) {}\n\n  public async connect(): Promise<void> {\n    this.connected = true;\n  }\n\n  public async close(): Promise<void> {\n    // Timers first: a delayed retry firing after close would republish onto a queue nobody is\n    // consuming, and in a test run that surfaces as an unhandled rejection in the NEXT test.\n    for (const timer of this.pendingDelays) clearTimeout(timer);\n    this.pendingDelays.clear();\n    this.queues.clear();\n    this.replyQueueName = null;\n    this.connected = false;\n  }\n\n  public isConnected(): boolean {\n    return this.connected;\n  }\n\n  public async assertQueue(queueName: string, options: QueueAssertOptions = {}): Promise<void> {\n    const existing = this.queues.get(queueName);\n    if (existing) {\n      // Idempotent, like the broker's own `assertQueue`. The options of the FIRST assertion win, so a\n      // later assertion cannot silently retune a live queue's dead-lettering.\n      return;\n    }\n    this.queues.set(queueName, { messages: [], options, unsettled: new Set(), draining: false });\n  }\n\n  public async publish(queueName: string, payload: JobPayload, options: PublishOptions = {}): Promise<void> {\n    await this.assertQueue(queueName);\n    this.enqueue(queueName, this.buildMessage(payload, options), 'back');\n  }\n\n  public async scheduleDelayedRetry(\n    sourceQueueName: string,\n    job: JobPayload,\n    delayMs: number,\n    options: PublishOptions = {},\n  ): Promise<void> {\n    await this.assertQueue(sourceQueueName);\n    /*\n     * A timer, where RabbitMQ uses a per-delay queue whose TTL dead-letters back to the source. The\n     * MECHANISM differs and the observable contract does not: the job reappears on its source queue\n     * after `delayMs`. A consumer that depended on the intermediate delay queue existing would be\n     * depending on a RabbitMQ implementation detail, which is exactly what the port exists to stop.\n     */\n    const timer = setTimeout(() => {\n      this.pendingDelays.delete(timer);\n      this.enqueue(sourceQueueName, this.buildMessage(job, options), 'back');\n    }, delayMs);\n    // Never hold the event loop open: a pending retry must not keep a test process (or a shutting-down\n    // runtime) alive past its work.\n    timer.unref?.();\n    this.pendingDelays.add(timer);\n  }\n\n  public async consume(queueName: string, handler: MessageHandler): Promise<string> {\n    await this.assertQueue(queueName);\n    const queue = this.queues.get(queueName) as InMemoryQueue;\n    const tag = `in-memory-consumer-${randomUUID()}`;\n    queue.consumer = { tag, handler };\n    this.scheduleDrain(queueName);\n    return tag;\n  }\n\n  public async cancelConsumer(queueName: string): Promise<void> {\n    const queue = this.queues.get(queueName);\n    if (queue) queue.consumer = undefined;\n  }\n\n  public async setupReplyQueue(\n    appId: string,\n    onReply: (correlationId: string, result: JobResult) => void,\n  ): Promise<string> {\n    const queueName = `${appId}.replies.${this.podId}`;\n    await this.assertQueue(queueName, { exclusive: true, autoDelete: true });\n    await this.consume(queueName, async (message, acknowledger) => {\n      const correlationId = message.properties.correlationId;\n      if (typeof correlationId === 'string') {\n        onReply(correlationId, JSON.parse(message.content.toString()) as JobResult);\n      }\n      acknowledger.ack(message);\n    });\n    this.replyQueueName = queueName;\n    return queueName;\n  }\n\n  public async publishResult(replyTo: string, correlationId: string, result: JobResult): Promise<void> {\n    await this.assertQueue(replyTo);\n    this.enqueue(\n      replyTo,\n      {\n        content: Buffer.from(JSON.stringify(result)),\n        fields: { redelivered: false },\n        properties: { correlationId },\n      },\n      'back',\n    );\n  }\n\n  public getReplyQueueName(): string | null {\n    return this.replyQueueName;\n  }\n\n  public async getQueueDepth(queueName: string): Promise<number | null> {\n    // A real number, not `null`: this adapter genuinely knows, and monitoring is one of the things a\n    // broker-free lane exists to exercise. `null` is reserved for \"cannot say\", which would be a lie\n    // here.\n    return this.queues.get(queueName)?.messages.length ?? 0;\n  }\n\n  public getPodId(): string {\n    return this.podId;\n  }\n\n  /** In-flight count for a queue — delivered, not yet settled. Test-facing, and the reason it exists. */\n  public getUnsettledCount(queueName: string): number {\n    return this.queues.get(queueName)?.unsettled.size ?? 0;\n  }\n\n  /**\n   * Every queue this adapter currently knows about.\n   *\n   * Test-facing, and it exists because of a mutation that survived without it: a version that\n   * INVENTED a dead-letter destination when a queue declared none passed a suite asserting only that\n   * the source queue was empty. \"The message went nowhere\" is a claim about every queue, and it\n   * cannot be checked one queue at a time.\n   */\n  public getQueueNames(): readonly string[] {\n    return [...this.queues.keys()];\n  }\n\n  /**\n   * Delayed retries still waiting to fire.\n   *\n   * Also mutation-driven: `close()` clearing the queue map makes a late timer harmless by accident,\n   * so a test asserting depth after close passed with the timer cleanup deleted. This exposes the\n   * mechanism itself, which is the thing the cleanup is actually for.\n   */\n  public getPendingDelayCount(): number {\n    return this.pendingDelays.size;\n  }\n\n  private buildMessage(payload: JobPayload | JobResult, options: PublishOptions): QueueConsumeMessage {\n    return {\n      content: Buffer.from(JSON.stringify(payload)),\n      fields: { redelivered: false },\n      // Only what the port declares. `priority` and `expiration` are accepted by `PublishOptions`\n      // and are BROKER scheduling hints — this queue has no priority ordering and says so by not\n      // pretending to carry them, rather than storing a value nothing reads.\n      properties: {\n        correlationId: options.correlationId ?? null,\n        replyTo: options.replyTo,\n      },\n    };\n  }\n\n  private enqueue(queueName: string, message: QueueConsumeMessage, end: 'front' | 'back'): void {\n    const queue = this.queues.get(queueName);\n    if (!queue) return;\n    if (end === 'front') queue.messages.unshift(message);\n    else queue.messages.push(message);\n    this.scheduleDrain(queueName);\n  }\n\n  /**\n   * Deliver on a microtask, one message at a time, never re-entrantly.\n   *\n   * `draining` is what makes a handler that publishes to its OWN queue terminate: without it the\n   * enqueue inside the handler re-enters the drain and the stack grows until it overflows — a failure\n   * that would appear only under the in-memory adapter and would read as a defect in the consumer.\n   */\n  private scheduleDrain(queueName: string): void {\n    const queue = this.queues.get(queueName);\n    if (!queue || queue.draining || !queue.consumer) return;\n    queue.draining = true;\n    queueMicrotask(() => void this.drain(queueName));\n  }\n\n  private async drain(queueName: string): Promise<void> {\n    const queue = this.queues.get(queueName);\n    if (!queue) return;\n    try {\n      while (queue.consumer && queue.messages.length > 0) {\n        const message = queue.messages.shift() as QueueConsumeMessage;\n        queue.unsettled.add(message);\n        try {\n          await queue.consumer.handler(message, this.acknowledgerFor(queueName));\n        } catch (error) {\n          /*\n           * A handler that THROWS has not settled the message, and the broker would hold it in\n           * flight until the channel closed. Mirrored rather than silently requeued: auto-requeueing\n           * here would turn a crashing handler into an infinite hot loop that no real deployment\n           * would produce.\n           */\n          this.logger.warn('In-memory queue handler threw; message left unsettled', {\n            queueName,\n            error: describeCaughtError(error),\n          });\n        }\n      }\n    } finally {\n      queue.draining = false;\n      // A message that arrived while we were awaiting a handler needs its own drain.\n      if (queue.consumer && queue.messages.length > 0) this.scheduleDrain(queueName);\n    }\n  }\n\n  private acknowledgerFor(queueName: string): QueueMessageAcknowledger {\n    return {\n      ack: (message) => {\n        this.queues.get(queueName)?.unsettled.delete(message);\n      },\n      nack: (message, _allUpTo = false, requeue = false) => {\n        const queue = this.queues.get(queueName);\n        if (!queue) return;\n        queue.unsettled.delete(message);\n        if (requeue) {\n          // FRONT, and redelivered — the broker's own semantics for a requeue, and the difference a\n          // retry test can actually observe.\n          this.enqueue(queueName, { ...message, fields: { ...message.fields, redelivered: true } }, 'front');\n          return;\n        }\n        this.deadLetter(queue, message);\n      },\n    };\n  }\n\n  /**\n   * Route a rejected message to the dead-letter destination the source queue DECLARED.\n   *\n   * Only when one was declared. Inventing a destination would make a test pass that proves nothing\n   * about a deployment whose queue was asserted without dead-lettering — the message is dropped there,\n   * and dropping it here is the truthful simulation.\n   */\n  private deadLetter(queue: InMemoryQueue, message: QueueConsumeMessage): void {\n    const destination = queue.options.deadLetterRoutingKey ?? queue.options.deadLetterExchange;\n    if (!destination) return;\n    if (!this.queues.has(destination)) {\n      this.queues.set(destination, { messages: [], options: {}, unsettled: new Set(), draining: false });\n    }\n    this.enqueue(destination, message, 'back');\n  }\n}\n"]}

package/dist/esm/queue/adapters/queue-adapter.backend.binding.d.ts

@@ -0,0 +1,12 @@
+import type { Container } from 'inversify';
+import { QueueAdapterType } from '@wildo-ai/saas-models';
+/**
+ * Bind the queue adapter a runtime will use.
+ *
+ * Rebinds when the token is already bound, so a test lane can select the in-memory adapter against a
+ * container the framework has already configured — which is the shape every consumer of this
+ * actually needs, and a bind-only version would have forced each of them to build a container from
+ * scratch.
+ */
+export declare function bindQueueAdapter(container: Container, adapterType: QueueAdapterType): void;
+//# sourceMappingURL=queue-adapter.backend.binding.d.ts.map

package/dist/esm/queue/adapters/queue-adapter.backend.binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-adapter.backend.binding.d.ts","sourceRoot":"","sources":["../../../../../src/queue/adapters/queue-adapter.backend.binding.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAkCzD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,gBAAgB,GAAG,IAAI,CAM1F"}

package/dist/esm/queue/adapters/queue-adapter.backend.binding.js

@@ -0,0 +1,47 @@
+import { QueueAdapterType } from '@wildo-ai/saas-models';
+import { SAAS_SERVICE_TYPES } from '../../inject/models/service-types.js';
+import { InMemoryQueueAdapterBackendService } from '../../queue/adapters/in-memory-queue-adapter.backend.service.js';
+import { RabbitMQAdapterBackendService } from '../../queue/adapters/rabbitmq-adapter.backend.service.js';
+/**
+ * The one place a queue adapter is chosen (#502).
+ *
+ * ## Why this function exists at all
+ *
+ * `QueueAdapterType` had **zero readers**. It declared three adapters while one class existed and
+ * every consumer injected that class by name, so the enum was a vocabulary describing a choice
+ * nothing could make — and adding an adapter without adding a way to select it would have produced a
+ * second unreachable thing rather than fixing the first.
+ *
+ * So the enum is now read HERE, and this is the only site that maps a member to an implementation.
+ * A `Record` over the type rather than a `switch` with a default, for the reason
+ * `invariant-call-site-enumeration.md` #21 records: a `default:` arm silently absorbs a new member
+ * into whatever it returns, while a total record makes adding one a compile error until somebody
+ * says which class serves it.
+ *
+ * ## The default is RabbitMQ, and that is not a placeholder
+ *
+ * A deployed application wants a broker: durability across a restart, visibility across processes,
+ * and permissions per runtime are the properties it is buying. {@link QueueAdapterType.MEMORY} is
+ * for a test lane, and for a single-process runtime that has declared it wants no broker — it is not
+ * a smaller RabbitMQ, and `InMemoryQueueAdapterBackendService` says exactly what it does not provide.
+ */
+const QUEUE_ADAPTER_IMPLEMENTATIONS = {
+    [QueueAdapterType.RABBITMQ]: RabbitMQAdapterBackendService,
+    [QueueAdapterType.MEMORY]: InMemoryQueueAdapterBackendService,
+};
+/**
+ * Bind the queue adapter a runtime will use.
+ *
+ * Rebinds when the token is already bound, so a test lane can select the in-memory adapter against a
+ * container the framework has already configured — which is the shape every consumer of this
+ * actually needs, and a bind-only version would have forced each of them to build a container from
+ * scratch.
+ */
+export function bindQueueAdapter(container, adapterType) {
+    const implementation = QUEUE_ADAPTER_IMPLEMENTATIONS[adapterType];
+    if (container.isBound(SAAS_SERVICE_TYPES.RabbitMQAdapterService)) {
+        container.unbind(SAAS_SERVICE_TYPES.RabbitMQAdapterService);
+    }
+    container.bind(SAAS_SERVICE_TYPES.RabbitMQAdapterService).to(implementation).inSingletonScope();
+}
+//# sourceMappingURL=queue-adapter.backend.binding.js.map

package/dist/esm/queue/adapters/queue-adapter.backend.binding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-adapter.backend.binding.js","sourceRoot":"","sources":["../../../../../src/queue/adapters/queue-adapter.backend.binding.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AACpF,OAAO,EAAE,kCAAkC,EAAE,MAAM,2EAA2E,CAAC;AAC/H,OAAO,EAAE,6BAA6B,EAAE,MAAM,oEAAoE,CAAC;AAEnH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,6BAA6B,GAAG;IACpC,CAAC,gBAAgB,CAAC,QAAQ,CAAC,EAAE,6BAA6B;IAC1D,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAAE,kCAAkC;CACiB,CAAC;AAEjF;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,SAAoB,EAAE,WAA6B;IAClF,MAAM,cAAc,GAAG,6BAA6B,CAAC,WAAW,CAAC,CAAC;IAClE,IAAI,SAAS,CAAC,OAAO,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,EAAE,CAAC;QACjE,SAAS,CAAC,MAAM,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;IAC9D,CAAC;IACD,SAAS,CAAC,IAAI,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,CAAC,EAAE,CAAC,cAAc,CAAC,CAAC,gBAAgB,EAAE,CAAC;AAClG,CAAC","sourcesContent":["import type { Container } from 'inversify';\nimport { QueueAdapterType } from '@wildo-ai/saas-models';\n\nimport { SAAS_SERVICE_TYPES } from '~wildo-backend-lib/inject/models/service-types';\nimport { InMemoryQueueAdapterBackendService } from '~wildo-backend-lib/queue/adapters/in-memory-queue-adapter.backend.service';\nimport { RabbitMQAdapterBackendService } from '~wildo-backend-lib/queue/adapters/rabbitmq-adapter.backend.service';\n\n/**\n * The one place a queue adapter is chosen (#502).\n *\n * ## Why this function exists at all\n *\n * `QueueAdapterType` had **zero readers**. It declared three adapters while one class existed and\n * every consumer injected that class by name, so the enum was a vocabulary describing a choice\n * nothing could make — and adding an adapter without adding a way to select it would have produced a\n * second unreachable thing rather than fixing the first.\n *\n * So the enum is now read HERE, and this is the only site that maps a member to an implementation.\n * A `Record` over the type rather than a `switch` with a default, for the reason\n * `invariant-call-site-enumeration.md` #21 records: a `default:` arm silently absorbs a new member\n * into whatever it returns, while a total record makes adding one a compile error until somebody\n * says which class serves it.\n *\n * ## The default is RabbitMQ, and that is not a placeholder\n *\n * A deployed application wants a broker: durability across a restart, visibility across processes,\n * and permissions per runtime are the properties it is buying. {@link QueueAdapterType.MEMORY} is\n * for a test lane, and for a single-process runtime that has declared it wants no broker — it is not\n * a smaller RabbitMQ, and `InMemoryQueueAdapterBackendService` says exactly what it does not provide.\n */\nconst QUEUE_ADAPTER_IMPLEMENTATIONS = {\n  [QueueAdapterType.RABBITMQ]: RabbitMQAdapterBackendService,\n  [QueueAdapterType.MEMORY]: InMemoryQueueAdapterBackendService,\n} as const satisfies Record<QueueAdapterType, new (...args: never[]) => unknown>;\n\n/**\n * Bind the queue adapter a runtime will use.\n *\n * Rebinds when the token is already bound, so a test lane can select the in-memory adapter against a\n * container the framework has already configured — which is the shape every consumer of this\n * actually needs, and a bind-only version would have forced each of them to build a container from\n * scratch.\n */\nexport function bindQueueAdapter(container: Container, adapterType: QueueAdapterType): void {\n  const implementation = QUEUE_ADAPTER_IMPLEMENTATIONS[adapterType];\n  if (container.isBound(SAAS_SERVICE_TYPES.RabbitMQAdapterService)) {\n    container.unbind(SAAS_SERVICE_TYPES.RabbitMQAdapterService);\n  }\n  container.bind(SAAS_SERVICE_TYPES.RabbitMQAdapterService).to(implementation).inSingletonScope();\n}\n"]}

package/dist/esm/queue/adapters/queue-adapter.backend.interface.d.ts

@@ -0,0 +1,87 @@
+import type { JobPayload, JobResult } from '@wildo-ai/saas-models';
+import type { PublishOptions, QueueAssertOptions } from '../../queue/adapters/queue-adapter.backend.options';
+/**
+ * The queue port every background-work consumer depends on (#502).
+ *
+ * ## Why this exists, and what it deliberately excludes
+ *
+ * `QueueAdapterType` declared RabbitMQ, Redis and in-memory adapters and there was **one** class,
+ * injected concretely by every consumer through `SAAS_SERVICE_TYPES.RabbitMQAdapterService`. So the
+ * enum offered a choice nothing could make, and there was no shape a second adapter could satisfy.
+ *
+ * The surface here is not the RabbitMQ class's public API — it is what consumers were **measured**
+ * to call. Two amqplib escape hatches are excluded on purpose:
+ *
+ * - `getChannel()` / `getTopologyChannel()` return an amqplib `Channel`, which nothing but a broker
+ *   can produce. Their one consumer outside the adapter was queue monitoring, reading a queue depth,
+ *   and that is now {@link QueueAdapter.getQueueDepth} — a question every adapter can answer about
+ *   itself instead of a connection handle only one of them has.
+ *
+ * Anything genuinely RabbitMQ-specific stays on `RabbitMQAdapterBackendService` and is reached by
+ * naming that class, which is an honest dependency rather than a port with a hole in it.
+ */
+/**
+ * One delivered message, in the shape a handler reads it.
+ *
+ * Structurally satisfied by amqplib's `ConsumeMessage`, so the RabbitMQ adapter passes its own
+ * messages through unchanged and no translation layer sits on the hot path. Handlers were measured
+ * to read `content` and `properties` only; `fields` is carried because the redelivery flag is the
+ * kind of thing a retry decision legitimately reaches for, and omitting it would push a consumer
+ * straight back to the amqplib type.
+ */
+export interface QueueConsumeMessage {
+    readonly content: Buffer;
+    readonly fields: {
+        readonly redelivered: boolean;
+    };
+    readonly properties: {
+        readonly correlationId?: string | null;
+        readonly replyTo?: string;
+    };
+}
+/**
+ * Settling a delivery: the only thing handlers ever did with the `Channel` they were handed.
+ *
+ * Measured across every consumer before this was carved: **15 `nack` and 7 `ack`**, and nothing
+ * else. An amqplib `Channel` satisfies this structurally, which is what keeps the RabbitMQ path
+ * unchanged — it hands the real channel over and the narrower type simply stops a handler reaching
+ * for `sendToQueue` or `prefetch` from inside a message callback.
+ */
+export interface QueueMessageAcknowledger {
+    ack(message: QueueConsumeMessage): void;
+    nack(message: QueueConsumeMessage, allUpTo?: boolean, requeue?: boolean): void;
+}
+export type MessageHandler = (message: QueueConsumeMessage, acknowledger: QueueMessageAcknowledger) => Promise<void>;
+/** What a background-work consumer needs from a queue, and nothing more. */
+export interface QueueAdapter {
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    isConnected(): boolean;
+    assertQueue(queueName: string, options?: QueueAssertOptions): Promise<void>;
+    publish(queueName: string, payload: JobPayload, options?: PublishOptions): Promise<void>;
+    /**
+     * Re-deliver a job after a delay.
+     *
+     * A first-class port method rather than "publish to a queue you named yourself", because the delay
+     * is realised very differently per adapter — RabbitMQ needs a per-delay queue with a TTL and a
+     * dead-letter exchange back to the source, while an in-memory adapter needs a timer. A consumer
+     * that had to know which is a consumer that cannot change adapters.
+     */
+    scheduleDelayedRetry(sourceQueueName: string, job: JobPayload, delayMs: number, options?: PublishOptions): Promise<void>;
+    consume(queueName: string, handler: MessageHandler): Promise<string>;
+    cancelConsumer(queueName: string): Promise<void>;
+    setupReplyQueue(appId: string, onReply: (correlationId: string, result: JobResult) => void): Promise<string>;
+    publishResult(replyTo: string, correlationId: string, result: JobResult): Promise<void>;
+    getReplyQueueName(): string | null;
+    /**
+     * How many messages are waiting, or `null` when this adapter cannot say.
+     *
+     * `null` is an ANSWER — "not observable here" — and monitoring reports empty metrics for it,
+     * exactly as it already did when no channel was open. It is not an error, because a queue depth
+     * being unavailable is not a fault in the runtime being monitored.
+     */
+    getQueueDepth(queueName: string): Promise<number | null>;
+    /** Identifies the consuming process, so a reply queue is addressed to one runtime. */
+    getPodId(): string;
+}
+//# sourceMappingURL=queue-adapter.backend.interface.d.ts.map

package/dist/esm/queue/adapters/queue-adapter.backend.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-adapter.backend.interface.d.ts","sourceRoot":"","sources":["../../../../../src/queue/adapters/queue-adapter.backend.interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,iEAAiE,CAAC;AAE1H;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAUzB,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;KAAE,CAAC;IACnD,QAAQ,CAAC,UAAU,EAAE;QAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5F;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,wBAAwB;IACvC,GAAG,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACxC,IAAI,CAAC,OAAO,EAAE,mBAAmB,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAChF;AAED,MAAM,MAAM,cAAc,GAAG,CAC3B,OAAO,EAAE,mBAAmB,EAC5B,YAAY,EAAE,wBAAwB,KACnC,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,4EAA4E;AAC5E,MAAM,WAAW,YAAY;IAC3B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,WAAW,IAAI,OAAO,CAAC;IAEvB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5E,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzF;;;;;;;OAOG;IACH,oBAAoB,CAClB,eAAe,EAAE,MAAM,EACvB,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrE,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjD,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7G,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxF,iBAAiB,IAAI,MAAM,GAAG,IAAI,CAAC;IAEnC;;;;;;OAMG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAEzD,sFAAsF;IACtF,QAAQ,IAAI,MAAM,CAAC;CACpB"}

package/dist/esm/queue/adapters/queue-adapter.backend.interface.js

@@ -0,0 +1 @@
+//# sourceMappingURL=queue-adapter.backend.interface.js.map

package/dist/esm/queue/adapters/queue-adapter.backend.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-adapter.backend.interface.js","sourceRoot":"","sources":["../../../../../src/queue/adapters/queue-adapter.backend.interface.ts"],"names":[],"mappings":"","sourcesContent":["import type { JobPayload, JobResult } from '@wildo-ai/saas-models';\n\nimport type { PublishOptions, QueueAssertOptions } from '~wildo-backend-lib/queue/adapters/queue-adapter.backend.options';\n\n/**\n * The queue port every background-work consumer depends on (#502).\n *\n * ## Why this exists, and what it deliberately excludes\n *\n * `QueueAdapterType` declared RabbitMQ, Redis and in-memory adapters and there was **one** class,\n * injected concretely by every consumer through `SAAS_SERVICE_TYPES.RabbitMQAdapterService`. So the\n * enum offered a choice nothing could make, and there was no shape a second adapter could satisfy.\n *\n * The surface here is not the RabbitMQ class's public API — it is what consumers were **measured**\n * to call. Two amqplib escape hatches are excluded on purpose:\n *\n * - `getChannel()` / `getTopologyChannel()` return an amqplib `Channel`, which nothing but a broker\n *   can produce. Their one consumer outside the adapter was queue monitoring, reading a queue depth,\n *   and that is now {@link QueueAdapter.getQueueDepth} — a question every adapter can answer about\n *   itself instead of a connection handle only one of them has.\n *\n * Anything genuinely RabbitMQ-specific stays on `RabbitMQAdapterBackendService` and is reached by\n * naming that class, which is an honest dependency rather than a port with a hole in it.\n */\n\n/**\n * One delivered message, in the shape a handler reads it.\n *\n * Structurally satisfied by amqplib's `ConsumeMessage`, so the RabbitMQ adapter passes its own\n * messages through unchanged and no translation layer sits on the hot path. Handlers were measured\n * to read `content` and `properties` only; `fields` is carried because the redelivery flag is the\n * kind of thing a retry decision legitimately reaches for, and omitting it would push a consumer\n * straight back to the amqplib type.\n */\nexport interface QueueConsumeMessage {\n  readonly content: Buffer;\n  /*\n   * NO index signature on either member, and that is load-bearing rather than minimal.\n   *\n   * amqplib's `ConsumeMessageFields` and `MessageProperties` are closed interfaces, and an index\n   * signature makes them un-assignable (\"index signature for type 'string' is missing\") — so the\n   * RabbitMQ adapter could not hand its own messages through and would have needed a translation\n   * layer on the hot path, purely to satisfy a convenience this port does not need. Declaring only\n   * the members consumers were measured to read keeps the real message structurally compatible.\n   */\n  readonly fields: { readonly redelivered: boolean };\n  readonly properties: { readonly correlationId?: string | null; readonly replyTo?: string };\n}\n\n/**\n * Settling a delivery: the only thing handlers ever did with the `Channel` they were handed.\n *\n * Measured across every consumer before this was carved: **15 `nack` and 7 `ack`**, and nothing\n * else. An amqplib `Channel` satisfies this structurally, which is what keeps the RabbitMQ path\n * unchanged — it hands the real channel over and the narrower type simply stops a handler reaching\n * for `sendToQueue` or `prefetch` from inside a message callback.\n */\nexport interface QueueMessageAcknowledger {\n  ack(message: QueueConsumeMessage): void;\n  nack(message: QueueConsumeMessage, allUpTo?: boolean, requeue?: boolean): void;\n}\n\nexport type MessageHandler = (\n  message: QueueConsumeMessage,\n  acknowledger: QueueMessageAcknowledger,\n) => Promise<void>;\n\n/** What a background-work consumer needs from a queue, and nothing more. */\nexport interface QueueAdapter {\n  connect(): Promise<void>;\n  close(): Promise<void>;\n  isConnected(): boolean;\n\n  assertQueue(queueName: string, options?: QueueAssertOptions): Promise<void>;\n  publish(queueName: string, payload: JobPayload, options?: PublishOptions): Promise<void>;\n  /**\n   * Re-deliver a job after a delay.\n   *\n   * A first-class port method rather than \"publish to a queue you named yourself\", because the delay\n   * is realised very differently per adapter — RabbitMQ needs a per-delay queue with a TTL and a\n   * dead-letter exchange back to the source, while an in-memory adapter needs a timer. A consumer\n   * that had to know which is a consumer that cannot change adapters.\n   */\n  scheduleDelayedRetry(\n    sourceQueueName: string,\n    job: JobPayload,\n    delayMs: number,\n    options?: PublishOptions,\n  ): Promise<void>;\n\n  consume(queueName: string, handler: MessageHandler): Promise<string>;\n  cancelConsumer(queueName: string): Promise<void>;\n\n  setupReplyQueue(appId: string, onReply: (correlationId: string, result: JobResult) => void): Promise<string>;\n  publishResult(replyTo: string, correlationId: string, result: JobResult): Promise<void>;\n  getReplyQueueName(): string | null;\n\n  /**\n   * How many messages are waiting, or `null` when this adapter cannot say.\n   *\n   * `null` is an ANSWER — \"not observable here\" — and monitoring reports empty metrics for it,\n   * exactly as it already did when no channel was open. It is not an error, because a queue depth\n   * being unavailable is not a fault in the runtime being monitored.\n   */\n  getQueueDepth(queueName: string): Promise<number | null>;\n\n  /** Identifies the consuming process, so a reply queue is addressed to one runtime. */\n  getPodId(): string;\n}\n"]}

package/dist/esm/queue/adapters/queue-adapter.backend.options.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Broker-neutral options shared by every queue adapter (#502).
+ *
+ * These sat inside `rabbitmq-adapter.backend.service.ts` while there was only one adapter. They
+ * describe INTENT — durability, a dead-letter destination, a correlation id — rather than any
+ * broker's wire format, so leaving them there would have made the port import the implementation it
+ * exists to abstract.
+ *
+ * An adapter that cannot honour an option ignores it rather than refusing: an in-memory queue has no
+ * meaningful `persistent`, and a caller asking for durability from a queue that lives in a process is
+ * not making a mistake — it is asking for the same job semantics on a different substrate.
+ */
+/** Queue assertion options. */
+export interface QueueAssertOptions {
+    durable?: boolean;
+    exclusive?: boolean;
+    autoDelete?: boolean;
+    deadLetterExchange?: string;
+    deadLetterRoutingKey?: string;
+    messageTtl?: number;
+    maxLength?: number;
+}
+/** Publish options for messages. */
+export interface PublishOptions {
+    correlationId?: string;
+    replyTo?: string;
+    persistent?: boolean;
+    expiration?: string;
+    priority?: number;
+}
+//# sourceMappingURL=queue-adapter.backend.options.d.ts.map

package/dist/esm/queue/adapters/queue-adapter.backend.options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-adapter.backend.options.d.ts","sourceRoot":"","sources":["../../../../../src/queue/adapters/queue-adapter.backend.options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,+BAA+B;AAC/B,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,oCAAoC;AACpC,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB"}

package/dist/esm/queue/adapters/queue-adapter.backend.options.js

@@ -0,0 +1,13 @@
+/**
+ * Broker-neutral options shared by every queue adapter (#502).
+ *
+ * These sat inside `rabbitmq-adapter.backend.service.ts` while there was only one adapter. They
+ * describe INTENT — durability, a dead-letter destination, a correlation id — rather than any
+ * broker's wire format, so leaving them there would have made the port import the implementation it
+ * exists to abstract.
+ *
+ * An adapter that cannot honour an option ignores it rather than refusing: an in-memory queue has no
+ * meaningful `persistent`, and a caller asking for durability from a queue that lives in a process is
+ * not making a mistake — it is asking for the same job semantics on a different substrate.
+ */
+//# sourceMappingURL=queue-adapter.backend.options.js.map

package/dist/esm/queue/adapters/queue-adapter.backend.options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-adapter.backend.options.js","sourceRoot":"","sources":["../../../../../src/queue/adapters/queue-adapter.backend.options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG","sourcesContent":["/**\n * Broker-neutral options shared by every queue adapter (#502).\n *\n * These sat inside `rabbitmq-adapter.backend.service.ts` while there was only one adapter. They\n * describe INTENT — durability, a dead-letter destination, a correlation id — rather than any\n * broker's wire format, so leaving them there would have made the port import the implementation it\n * exists to abstract.\n *\n * An adapter that cannot honour an option ignores it rather than refusing: an in-memory queue has no\n * meaningful `persistent`, and a caller asking for durability from a queue that lives in a process is\n * not making a mistake — it is asking for the same job semantics on a different substrate.\n */\n\n/** Queue assertion options. */\nexport interface QueueAssertOptions {\n  durable?: boolean;\n  exclusive?: boolean;\n  autoDelete?: boolean;\n  deadLetterExchange?: string;\n  deadLetterRoutingKey?: string;\n  messageTtl?: number;\n  maxLength?: number;\n}\n\n/** Publish options for messages. */\nexport interface PublishOptions {\n  correlationId?: string;\n  replyTo?: string;\n  persistent?: boolean;\n  expiration?: string;\n  priority?: number;\n}\n"]}

package/dist/esm/queue/adapters/rabbitmq-adapter.backend.service.d.ts

@@ -10,6 +10,8 @@ import { AppConfigurationService } from '../../config/services/app-configuration
 import { ErrorBuilderBackendService } from '../../errors/services/error-builder.backend.service';
 import { JobPayload, JobResult } from '@wildo-ai/saas-models';
 import type { Channel, ConsumeMessage } from 'amqplib';
+import type { MessageHandler, QueueAdapter } from '../../queue/adapters/queue-adapter.backend.interface';
+import type { PublishOptions, QueueAssertOptions } from '../../queue/adapters/queue-adapter.backend.options';
 /**
  * RabbitMQ configuration for connection.
  */
@@ -24,32 +26,15 @@ export interface RabbitMQConfig {
     channelMax?: number;
 }
 /**
- * Queue assertion options.
- */
-export interface QueueAssertOptions {
-    durable?: boolean;
-    exclusive?: boolean;
-    autoDelete?: boolean;
-    deadLetterExchange?: string;
-    deadLetterRoutingKey?: string;
-    messageTtl?: number;
-    maxLength?: number;
-}
-/**
- * Publish options for messages.
- */
-export interface PublishOptions {
-    correlationId?: string;
-    replyTo?: string;
-    persistent?: boolean;
-    expiration?: string;
-    priority?: number;
-}
-/**
- * Message handler type for consumers.
+ * The RabbitMQ realisation of {@link QueueAdapter} (#502).
+ *
+ * Everything a background-work consumer needs is declared on the port; what remains here and NOT on
+ * it is genuinely broker-specific — `configure()` takes a `RabbitMQConfig`, and `getChannel()` /
+ * `getTopologyChannel()` hand out an amqplib `Channel` that only a broker can produce. A caller that
+ * needs one of those names this class, which is an honest dependency rather than a port with a hole
+ * in it.
  */
-export type MessageHandler = (msg: ConsumeMessage, channel: Channel) => Promise<void>;
-export declare class RabbitMQAdapterBackendService {
+export declare class RabbitMQAdapterBackendService implements QueueAdapter {
     private readonly logger;
     private readonly appConfigService;
     private readonly errorBuilder;
@@ -268,6 +253,15 @@ export declare class RabbitMQAdapterBackendService {
     /**
      * Get pod ID for this instance.
      */
+    /**
+     * Queue depth from the broker, or `null` when no channel is open (#502).
+     *
+     * This replaces monitoring reaching for `getChannel()` and calling `checkQueue` itself. The
+     * behaviour is unchanged — `null` here produces the same empty metrics that a null channel already
+     * produced — but the question is now one every adapter can answer about itself, instead of a
+     * connection handle only this one can hand out.
+     */
+    getQueueDepth(queueName: string): Promise<number | null>;
     getPodId(): string;
 }
 //# sourceMappingURL=rabbitmq-adapter.backend.service.d.ts.map

package/dist/esm/queue/adapters/rabbitmq-adapter.backend.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rabbitmq-adapter.backend.service.d.ts","sourceRoot":"","sources":["../../../../../src/queue/adapters/rabbitmq-adapter.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAsB,SAAS,EAAE,MAAM,WAAW,CAAC;AAE1D,OAAO,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAC7F,OAAO,EAAE,uBAAuB,EAAE,MAAM,sEAAsE,CAAC;AAC/G,OAAO,EAAE,0BAA0B,EAAE,MAAM,kEAAkE,CAAC;AAG9G,OAAO,EAGL,UAAU,EACV,SAAS,EAMV,MAAM,uBAAuB,CAAC;AAI/B,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAW,MAAM,SAAS,CAAC;AAKhE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEtF,qBACa,6BAA6B;IAoDtC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAEvB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAEjC,OAAO,CAAC,QAAQ,CAAC,YAAY;IAGS,OAAO,CAAC,QAAQ,CAAC,SAAS;IA1DlE,SAAS,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACjF,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,OAAO,CAAwB;IACvC;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,eAAe,CAAwB;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+B;IACtD,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,YAAY,CAAkC;IACtD;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB,CAA0B;IACrD,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAAU;gBAIpC,MAAM,EAAE,aAAa,EAErB,gBAAgB,EAAE,uBAAuB,EAEzC,YAAY,EAAE,0BAA0B,EAGF,SAAS,EAAE,SAAS;IAY7E;;;OAGG;IACI,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAM9C;;OAEG;IACU,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAkFrC;;OAEG;IACI,WAAW,IAAI,OAAO;IAI7B;;OAEG;IACI,UAAU,IAAI,OAAO;IAc5B;;;;;OAKG;YACW,qBAAqB;IAkBnC;;;;;OAKG;IACU,kBAAkB,IAAI,OAAO,CAAC,OAAO,CAAC;IAkBnD;;;;;;;;OAQG;IACH,OAAO,CAAC,uBAAuB;IA0B/B;;;;;;;;;OASG;IACU,WAAW,CACtB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,IAAI,CAAC;IAkChB;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAQ5B;;;;;;;OAOG;YACW,wBAAwB;IAsCtC;;OAEG;IACU,OAAO,CAClB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,UAAU,EACnB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC;IA8ChB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACU,oBAAoB,CAC/B,eAAe,EAAE,MAAM,EACvB,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC;IAyBhB;;OAEG;IACU,aAAa,CACxB,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,SAAS,GAChB,OAAO,CAAC,IAAI,CAAC;IA6BhB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACU,OAAO,CAClB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,MAAM,CAAC;IA+ClB;;OAEG;IACU,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAW7D;;OAEG;IAEH;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,4BAA4B;IAkBvB,eAAe,CAC1B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,KAAK,IAAI,GAC1D,OAAO,CAAC,MAAM,CAAC;IA4ClB;;OAEG;IACI,iBAAiB,IAAI,MAAM,GAAG,IAAI;IAIzC;;OAEG;IACI,GAAG,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI;IAKrC;;OAEG;IACI,IAAI,CAAC,GAAG,EAAE,cAAc,EAAE,OAAO,GAAE,OAAe,GAAG,IAAI;IAKhE;;OAEG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA+CnC;;OAEG;IACI,QAAQ,IAAI,MAAM;CAG1B"}
+{"version":3,"file":"rabbitmq-adapter.backend.service.d.ts","sourceRoot":"","sources":["../../../../../src/queue/adapters/rabbitmq-adapter.backend.service.ts"],"names":[],"mappings":"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"}

package/dist/esm/queue/adapters/rabbitmq-adapter.backend.service.js

@@ -25,6 +25,15 @@ import { ErrorBuilderBackendService } from '../../errors/services/error-builder.
 import { describeCaughtError, projectCaughtErrorLogFields } from '../../errors/utils/error-log-level-classification.backend.utils.js';
 import { runInFreshRequestContextIfAbsent } from '../../runtime/models/request-context.als.backend.js';
 import { ErrorType, ErrorCustomMessageReference, RabbitMQQueueArgKeys, buildReplyQueueName, buildDelayQueueName, buildRabbitMQConnectionUrl, } from '@wildo-ai/saas-models';
+/**
+ * The RabbitMQ realisation of {@link QueueAdapter} (#502).
+ *
+ * Everything a background-work consumer needs is declared on the port; what remains here and NOT on
+ * it is genuinely broker-specific — `configure()` takes a `RabbitMQConfig`, and `getChannel()` /
+ * `getTopologyChannel()` hand out an amqplib `Channel` that only a broker can produce. A caller that
+ * needs one of those names this class, which is an honest dependency rather than a port with a hole
+ * in it.
+ */
 let RabbitMQAdapterBackendService = class RabbitMQAdapterBackendService {
     logger;
     appConfigService;
@@ -662,6 +671,30 @@ let RabbitMQAdapterBackendService = class RabbitMQAdapterBackendService {
     /**
      * Get pod ID for this instance.
      */
+    /**
+     * Queue depth from the broker, or `null` when no channel is open (#502).
+     *
+     * This replaces monitoring reaching for `getChannel()` and calling `checkQueue` itself. The
+     * behaviour is unchanged — `null` here produces the same empty metrics that a null channel already
+     * produced — but the question is now one every adapter can answer about itself, instead of a
+     * connection handle only this one can hand out.
+     */
+    async getQueueDepth(queueName) {
+        const channel = this.getChannel();
+        if (!channel) {
+            return null;
+        }
+        // `checkQueue` CLOSES the channel when the queue does not exist — the reason monitoring stopped
+        // probing dead-letter queues (see `getQueueMetrics`). Reported as "not observable" rather than
+        // thrown: a queue that has not been asserted yet is not a fault in the runtime being monitored.
+        try {
+            const queueInfo = await channel.checkQueue(queueName);
+            return queueInfo.messageCount;
+        }
+        catch {
+            return null;
+        }
+    }
     getPodId() {
         return this.podId;
     }