@spinajs/queue-amqp-transport 2.0.482 → 2.0.485

package/lib/mjs/connection.d.ts

@@ -0,0 +1,148 @@
+import { IQueueMessage, IQueueConnectionOptions, QueueClient, QueueMessage } from '@spinajs/queue';
+import { Channel, ChannelModel, ConfirmChannel, ConsumeMessage, Options } from 'amqplib';
+import { Constructor } from '@spinajs/di';
+import { ResiliencePipeline } from '@spinajs/util';
+/**
+ * Everything needed to re-establish a subscription after a reconnect. amqplib consumers do not
+ * survive a dropped connection, so we keep descriptors and replay them on every (re)connect.
+ */
+interface ISubscriptionDescriptor {
+    channel: string;
+    callback: (e: IQueueMessage) => Promise<void>;
+    subscriptionId?: string;
+    durable: boolean;
+    /** Runtime state - refreshed on every (re)connect. */
+    consumerTag?: string;
+    queue?: string;
+}
+interface IPendingEmit {
+    message: IQueueMessage;
+    resolve: () => void;
+    reject: (err: unknown) => void;
+}
+export declare class AmqpQueueClient extends QueueClient {
+    protected Connection: ChannelModel;
+    /** Confirm channel used for publishing so emit() resolves only after a broker ack. */
+    protected PublishChannel: ConfirmChannel;
+    /** Separate channel for consumers so publisher back-pressure cannot stall consumer acks. */
+    protected ConsumeChannel: Channel;
+    protected Subscriptions: Map<string, ISubscriptionDescriptor>;
+    protected AssertedQueues: Set<string>;
+    protected AssertedExchanges: Set<string>;
+    protected AssertedRetryQueues: Set<string>;
+    /** Messages emitted while disconnected - flushed on (re)connect. */
+    protected PendingEmits: IPendingEmit[];
+    protected Connected: boolean;
+    protected Disposing: boolean;
+    protected ReconnectTimer?: ReturnType<typeof setTimeout>;
+    /** Publisher-side resilience: time-bound + retry each publish so transient broker hiccups
+     * don't lose an emit. Safe against the resulting duplicates because consumers dedupe by JobId. */
+    protected EmitPipeline: ResiliencePipeline<void>;
+    get ClientId(): string;
+    protected get TopicPrefix(): string;
+    protected get ReconnectDelay(): number;
+    protected get Prefetch(): number;
+    get IsConnected(): boolean;
+    constructor(options: IQueueConnectionOptions);
+    resolve(): Promise<void>;
+    /**
+     * Creates the underlying amqplib connection. Isolated as a seam so tests can inject a fake
+     * broker without a real server ( mirrors the STOMP transport's createClient seam ).
+     */
+    protected createConnection(url: string | Options.Connect, socketOptions: Record<string, unknown>): Promise<ChannelModel>;
+    /**
+     * Builds the amqplib connection target from the configured options.
+     *
+     * A url-style host ( `amqp://.../vhost` ) is parsed into an explicit {@link Options.Connect}
+     * object rather than passed as a raw string, so every setting - crucially the credentials - is a
+     * clear field instead of being buried in the url. amqplib derives credentials for a *string* url
+     * only from the url's own userinfo, which is why the discrete `login` / `password` config fields
+     * were previously ignored for a url host. Credentials embedded in the url still win; the config
+     * fields are the fallback when the url carries none ( matching amqplib's own precedence ).
+     */
+    protected buildConnectionTarget(): Options.Connect;
+    /** Connect-options object built from the discrete `host` / `port` / `login` / `password` fields. */
+    protected connectOptionsFromFields(hostname: string): Options.Connect;
+    dispose(): Promise<void>;
+    /**
+     * Establishes the connection + channels, then replays subscriptions and flushes buffered emits.
+     * Called on initial resolve and on every reconnect.
+     */
+    protected connect(): Promise<void>;
+    /**
+     * Handles an unexpected connection drop by scheduling a reconnect ( unless we are disposing ).
+     */
+    protected onConnectionLost(): void;
+    protected scheduleReconnect(): void;
+    emit(message: IQueueMessage): Promise<void>;
+    subscribe(channelOrMessage: string | Constructor<QueueMessage>, callback: (e: IQueueMessage) => Promise<void>, subscriptionId?: string, durable?: boolean): Promise<void>;
+    unsubscribe(channelOrMessage: string | Constructor<QueueMessage>, _removeDurable?: boolean): void;
+    /**
+     * Re-establishes every known subscription. Called after a (re)connect.
+     */
+    protected replaySubscriptions(): Promise<void>;
+    /**
+     * Declares the queue for a subscription and starts consuming, wiring ack/nack + retry/dead-letter.
+     */
+    protected startConsumer(descriptor: ISubscriptionDescriptor): Promise<void>;
+    /**
+     * Handles a message whose consumer callback rejected.
+     *
+     * Events are fire-and-forget - logged and acked ( dropped ). Jobs are retried up to their
+     * RetryCount by re-publishing to a TTL "retry" queue that dead-letters back to the work queue
+     * after an exponential delay, then dead-lettered once retries are exhausted.
+     */
+    protected handleFailedMessage(msg: ConsumeMessage, qMessage: IQueueMessage, channel: string, err: unknown): void;
+    /**
+     * Republishes a failed job to a per-delay TTL retry queue that dead-letters back to the work
+     * queue after the delay, giving broker-side ( crash-safe ) exponential backoff. Then acks original.
+     */
+    protected retryJob(msg: ConsumeMessage, qMessage: IQueueMessage, workQueue: string, nextAttempt: number, reason: string): Promise<void>;
+    /**
+     * Publishes a failed/unparseable message to the dead-letter queue and acks the original to
+     * unblock the source queue. When no dead-letter queue is configured the message is dropped
+     * ( acked ) with a warning - we never nack-loop a poison message forever.
+     */
+    protected deadLetterRaw(msg: ConsumeMessage, dlq: string | undefined, channel: string, reason: string, attempt?: number): void;
+    /**
+     * Exponential backoff ( ms ) for the given retry attempt, based on `Options.retryDelay`.
+     * Returns 0 ( immediate redelivery ) when no base delay is configured.
+     */
+    protected retryBackoff(attempt: number): number;
+    /**
+     * Publisher-side resilience pipeline: bounds each publish by a timeout and retries transient
+     * failures / nacks with exponential backoff. Consumer dedup ( by JobId ) makes the resulting
+     * rare duplicates harmless.
+     */
+    protected buildEmitPipeline(): ResiliencePipeline<void>;
+    protected publishMessage(message: IQueueMessage): Promise<void>;
+    /** Asserts the destination ( once ) and publishes a single message on the confirm channel. */
+    protected publishToChannel(channel: string, buffer: Buffer, options: Options.Publish): Promise<void>;
+    /**
+     * Publishes on the confirm channel and resolves only once the broker acks the message.
+     */
+    protected publishWithConfirm(exchange: string, routingKey: string, content: Buffer, options: Options.Publish): Promise<void>;
+    protected flushPendingEmits(): Promise<void>;
+    /**
+     * Declares ( and for topics binds ) the broker queue a subscription should consume from.
+     */
+    protected assertSubscriptionQueue(channel: string, subscriptionId?: string, durable?: boolean): Promise<string>;
+    /**
+     * Declares a durable work queue, asserting it on the broker only once per connection.
+     */
+    protected assertQueue(channel: Channel | ConfirmChannel, name: string): Promise<string>;
+    /**
+     * Declares a durable fanout exchange, asserting it on the broker only once per connection.
+     */
+    protected assertExchange(channel: Channel | ConfirmChannel, name: string): Promise<void>;
+    /**
+     * Declares a durable TTL retry queue that dead-letters expired messages back to `workQueue`
+     * ( via the default exchange, routing key = queue name ). One queue per distinct delay.
+     */
+    protected assertRetryQueue(workQueue: string, delay: number): Promise<string>;
+    protected isTopic(channel: string): boolean;
+    protected closeChannel(channel?: Channel | ConfirmChannel): Promise<void>;
+    protected warnOnUnsupportedScheduling(message: IQueueMessage): void;
+}
+export {};
+//# sourceMappingURL=connection.d.ts.map

package/lib/mjs/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../src/connection.ts"],"names":[],"mappings":"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"}

package/lib/mjs/connection.js

@@ -0,0 +1,523 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { InvalidArgument, UnexpectedServerError } from '@spinajs/exceptions';
+import { QueueClient, QueueMessageType } from '@spinajs/queue';
+import amqp from 'amqplib';
+import _ from 'lodash';
+import { Injectable, PerInstanceCheck } from '@spinajs/di';
+import { BackoffType, ResiliencePipelineBuilder } from '@spinajs/util';
+/**
+ * Default prefix that marks a channel as a topic ( pub-sub / fanout exchange ).
+ * Every other channel is treated as a durable work queue ( single consumer, job semantics ).
+ *
+ * This keeps parity with the STOMP transport convention of `/topic/...` vs `/queue/...`.
+ */
+const DEFAULT_TOPIC_PREFIX = '/topic/';
+/** Header carrying the retry attempt count across redeliveries. */
+const RETRY_COUNT_HEADER = 'x-retry-count';
+let AmqpQueueClient = class AmqpQueueClient extends QueueClient {
+    get ClientId() {
+        return this.Options.clientId ?? this.Options.name;
+    }
+    get TopicPrefix() {
+        return this.Options.options?.topicPrefix ?? DEFAULT_TOPIC_PREFIX;
+    }
+    get ReconnectDelay() {
+        return this.Options.reconnectDelay ?? 5000;
+    }
+    get Prefetch() {
+        return this.Options.options?.prefetch ?? 1;
+    }
+    get IsConnected() {
+        return this.Connected;
+    }
+    constructor(options) {
+        super(options);
+        this.Subscriptions = new Map();
+        // destinations already declared on the broker, so we assert each one only once per connection
+        // ( assert is a network round-trip ). Cleared on reconnect because channels are recreated.
+        this.AssertedQueues = new Set();
+        this.AssertedExchanges = new Set();
+        this.AssertedRetryQueues = new Set();
+        /** Messages emitted while disconnected - flushed on (re)connect. */
+        this.PendingEmits = [];
+        this.Connected = false;
+        this.Disposing = false;
+        /** Publisher-side resilience: time-bound + retry each publish so transient broker hiccups
+         * don't lose an emit. Safe against the resulting duplicates because consumers dedupe by JobId. */
+        this.EmitPipeline = this.buildEmitPipeline();
+    }
+    async resolve() {
+        await this.connect();
+    }
+    /**
+     * Creates the underlying amqplib connection. Isolated as a seam so tests can inject a fake
+     * broker without a real server ( mirrors the STOMP transport's createClient seam ).
+     */
+    createConnection(url, socketOptions) {
+        return amqp.connect(url, socketOptions);
+    }
+    /**
+     * Builds the amqplib connection target from the configured options.
+     *
+     * A url-style host ( `amqp://.../vhost` ) is parsed into an explicit {@link Options.Connect}
+     * object rather than passed as a raw string, so every setting - crucially the credentials - is a
+     * clear field instead of being buried in the url. amqplib derives credentials for a *string* url
+     * only from the url's own userinfo, which is why the discrete `login` / `password` config fields
+     * were previously ignored for a url host. Credentials embedded in the url still win; the config
+     * fields are the fallback when the url carries none ( matching amqplib's own precedence ).
+     */
+    buildConnectionTarget() {
+        const host = this.Options.host;
+        // discrete-fields host ( no scheme ) - build straight from the individual config fields
+        if (!host || !host.includes('://')) {
+            return this.connectOptionsFromFields(host ?? 'localhost');
+        }
+        let parsed;
+        try {
+            parsed = new URL(host);
+        }
+        catch {
+            // not a parseable url - treat the whole value as a bare hostname and use the config fields
+            return this.connectOptionsFromFields(host);
+        }
+        const protocol = parsed.protocol.replace(/:$/, '') || 'amqp';
+        // amqplib treats the url's credentials as authoritative when it carries either field; only when
+        // it carries neither do we fall back to the login / password config fields.
+        const urlHasCredentials = parsed.username !== '' || parsed.password !== '';
+        const target = {
+            protocol,
+            // strip IPv6 brackets - amqplib uses hostname verbatim as the socket host in object mode
+            hostname: parsed.hostname.replace(/^\[|\]$/g, ''),
+            port: parsed.port ? Number(parsed.port) : this.Options.port ?? (protocol === 'amqps' ? 5671 : 5672),
+            username: urlHasCredentials ? decodeURIComponent(parsed.username) : this.Options.login,
+            password: urlHasCredentials ? decodeURIComponent(parsed.password) : this.Options.password,
+            // keep the vhost percent-encoded - amqplib unescapes it exactly once ( decoding here too would
+            // double-decode, eg. %2f -> / -> wrong vhost ). An empty path keeps the broker default.
+            vhost: parsed.pathname && parsed.pathname !== '/' ? parsed.pathname.slice(1) : '/',
+        };
+        // connection tuning params live in the url query string in string-mode; carry the ones amqplib
+        // understands over so switching to object-mode does not silently drop them.
+        const heartbeat = parsed.searchParams.get('heartbeat');
+        const frameMax = parsed.searchParams.get('frameMax');
+        const locale = parsed.searchParams.get('locale');
+        if (heartbeat !== null)
+            target.heartbeat = Number(heartbeat);
+        if (frameMax !== null)
+            target.frameMax = Number(frameMax);
+        if (locale !== null)
+            target.locale = locale;
+        return target;
+    }
+    /** Connect-options object built from the discrete `host` / `port` / `login` / `password` fields. */
+    connectOptionsFromFields(hostname) {
+        return {
+            protocol: 'amqp',
+            hostname,
+            port: this.Options.port ?? 5672,
+            username: this.Options.login,
+            password: this.Options.password,
+            vhost: this.Options.options?.vhost ?? '/',
+        };
+    }
+    async dispose() {
+        this.Log.info(`Disposing queue connection ${this.Options.name} ...`);
+        this.Disposing = true;
+        if (this.ReconnectTimer) {
+            clearTimeout(this.ReconnectTimer);
+            this.ReconnectTimer = undefined;
+        }
+        await this.closeChannel(this.PublishChannel);
+        await this.closeChannel(this.ConsumeChannel);
+        try {
+            if (this.Connection) {
+                await this.Connection.close();
+            }
+        }
+        catch (err) {
+            this.Log.warn(`Error while closing AMQP connection for ${this.Options.name}: ${err?.message}`);
+        }
+        this.Connected = false;
+        this.Subscriptions.clear();
+        this.Log.success(`AMQP connection ${this.Options.name} disposed`);
+    }
+    /**
+     * Establishes the connection + channels, then replays subscriptions and flushes buffered emits.
+     * Called on initial resolve and on every reconnect.
+     */
+    async connect() {
+        this.Log.info(`Connecting to AMQP queue at ${this.Options.host ?? 'localhost'} with client-id: ${this.ClientId} ...`);
+        // channels are recreated - forget what the previous ( dead ) channels had asserted
+        this.AssertedQueues.clear();
+        this.AssertedExchanges.clear();
+        this.AssertedRetryQueues.clear();
+        try {
+            // resolve the connection target from config. A url-style host is parsed into an explicit
+            // Options.Connect object ( see buildConnectionTarget ) so the credentials and every other
+            // setting are clear fields instead of being hidden inside a url string.
+            const url = this.buildConnectionTarget();
+            this.Connection = await this.createConnection(url, {
+                clientProperties: { connection_name: this.ClientId },
+                ...this.Options.options,
+            });
+        }
+        catch (err) {
+            throw new UnexpectedServerError(`Cannot connect to AMQP queue server at ${this.Options.host ?? 'localhost'}`, err);
+        }
+        this.Connection.on('error', (err) => {
+            this.Log.error(`AMQP connection error, client-id: ${this.ClientId}, name: ${this.Options.name}: ${err?.message}`);
+        });
+        this.Connection.on('close', () => {
+            this.onConnectionLost();
+        });
+        // confirm channel for publishing ( emit() waits for the broker ack ), plain channel for consuming
+        this.PublishChannel = await this.Connection.createConfirmChannel();
+        this.ConsumeChannel = await this.Connection.createChannel();
+        // limit in-flight unacked messages per consumer. Defaults to 1 ( fair dispatch, mirrors STOMP
+        // `activemq.prefetchSize: 1` ). Raise via options.prefetch to trade fairness for throughput.
+        await this.ConsumeChannel.prefetch(this.Prefetch);
+        this.Connected = true;
+        this.Log.success(`Connected to AMQP broker, client-id: ${this.ClientId}`);
+        await this.replaySubscriptions();
+        await this.flushPendingEmits();
+    }
+    /**
+     * Handles an unexpected connection drop by scheduling a reconnect ( unless we are disposing ).
+     */
+    onConnectionLost() {
+        if (this.Disposing || !this.Connected) {
+            return;
+        }
+        this.Connected = false;
+        this.Log.warn(`AMQP connection ${this.Options.name} lost, scheduling reconnect in ${this.ReconnectDelay}ms`);
+        this.scheduleReconnect();
+    }
+    scheduleReconnect() {
+        if (this.ReconnectTimer || this.Disposing) {
+            return;
+        }
+        this.ReconnectTimer = setTimeout(() => {
+            this.ReconnectTimer = undefined;
+            this.connect().catch((err) => {
+                this.Log.error(`AMQP reconnect for ${this.Options.name} failed: ${err?.message}. Retrying in ${this.ReconnectDelay}ms`);
+                this.scheduleReconnect();
+            });
+        }, this.ReconnectDelay);
+    }
+    async emit(message) {
+        this.warnOnUnsupportedScheduling(message);
+        // buffer while disconnected so callers can emit during a reconnect window
+        if (!this.Connected) {
+            return new Promise((resolve, reject) => {
+                this.PendingEmits.push({ message, resolve, reject });
+            });
+        }
+        return this.publishMessage(message);
+    }
+    async subscribe(channelOrMessage, callback, subscriptionId, durable) {
+        const channels = _.isString(channelOrMessage) ? [channelOrMessage] : this.getChannelForMessage(channelOrMessage);
+        for (const c of channels) {
+            if (this.Subscriptions.has(c)) {
+                this.Log.warn(`Channel ${c} already subscribed !`);
+                continue;
+            }
+            const descriptor = { channel: c, callback, subscriptionId, durable: !!durable };
+            this.Subscriptions.set(c, descriptor);
+            await this.startConsumer(descriptor);
+        }
+    }
+    unsubscribe(channelOrMessage, _removeDurable) {
+        const channels = _.isString(channelOrMessage) ? [channelOrMessage] : this.getChannelForMessage(channelOrMessage);
+        for (const c of channels) {
+            const sub = this.Subscriptions.get(c);
+            if (!sub) {
+                continue;
+            }
+            this.Subscriptions.delete(c);
+            // cancel only the consumer. For durable subscriptions the bound queue is left in place
+            // so messages keep accumulating while no consumer is attached ( same semantics as STOMP ).
+            if (sub.consumerTag) {
+                this.ConsumeChannel.cancel(sub.consumerTag).catch((err) => {
+                    this.Log.warn(`Error while cancelling consumer for channel ${c}: ${err?.message}`);
+                });
+            }
+        }
+    }
+    /**
+     * Re-establishes every known subscription. Called after a (re)connect.
+     */
+    async replaySubscriptions() {
+        for (const descriptor of this.Subscriptions.values()) {
+            await this.startConsumer(descriptor);
+        }
+    }
+    /**
+     * Declares the queue for a subscription and starts consuming, wiring ack/nack + retry/dead-letter.
+     */
+    async startConsumer(descriptor) {
+        const c = descriptor.channel;
+        const queue = await this.assertSubscriptionQueue(c, descriptor.subscriptionId, descriptor.durable);
+        descriptor.queue = queue;
+        const { consumerTag } = await this.ConsumeChannel.consume(queue, (msg) => {
+            // null is delivered when the consumer is cancelled by the broker
+            if (!msg) {
+                return;
+            }
+            let qMessage;
+            try {
+                qMessage = JSON.parse(msg.content.toString());
+            }
+            catch (err) {
+                this.Log.error(`Cannot parse incoming message on channel ${c}, dead-lettering it: ${err?.message}`);
+                this.deadLetterRaw(msg, this.Options.defaultQueueDeadLetterChannel, c, err?.message ?? String(err));
+                return;
+            }
+            descriptor
+                .callback(qMessage)
+                .then(() => this.ConsumeChannel.ack(msg))
+                .catch((err) => this.handleFailedMessage(msg, qMessage, c, err));
+        }, { noAck: false });
+        descriptor.consumerTag = consumerTag;
+        this.Log.success(`Channel ${c}, durable: ${descriptor.durable ? 'true' : 'false'} subscribed and ready to receive messages !`);
+    }
+    /**
+     * Handles a message whose consumer callback rejected.
+     *
+     * Events are fire-and-forget - logged and acked ( dropped ). Jobs are retried up to their
+     * RetryCount by re-publishing to a TTL "retry" queue that dead-letters back to the work queue
+     * after an exponential delay, then dead-lettered once retries are exhausted.
+     */
+    handleFailedMessage(msg, qMessage, channel, err) {
+        const reason = err?.message ?? String(err);
+        // events are not retried or tracked - drop them
+        if (qMessage.Type !== QueueMessageType.Job || this.isTopic(channel)) {
+            this.Log.warn(`Handler failed on channel ${channel}, dropping message ${qMessage.Name}. ${reason}`);
+            this.ConsumeChannel.ack(msg);
+            return;
+        }
+        const maxRetries = qMessage.RetryCount ?? 0;
+        const attempt = Number(msg.properties.headers?.[RETRY_COUNT_HEADER] ?? 0);
+        if (attempt < maxRetries) {
+            this.retryJob(msg, qMessage, channel, attempt + 1, reason).catch((retryErr) => {
+                this.Log.error(`Failed to reschedule job ${qMessage.Name} on ${channel}, nacking instead: ${retryErr.message}`);
+                this.ConsumeChannel.nack(msg, false, false);
+            });
+            return;
+        }
+        // retries exhausted - route to the dead-letter queue
+        this.deadLetterRaw(msg, this.getDeadLetterChannelForMessage(qMessage), channel, reason, attempt);
+    }
+    /**
+     * Republishes a failed job to a per-delay TTL retry queue that dead-letters back to the work
+     * queue after the delay, giving broker-side ( crash-safe ) exponential backoff. Then acks original.
+     */
+    async retryJob(msg, qMessage, workQueue, nextAttempt, reason) {
+        const delay = this.retryBackoff(nextAttempt);
+        const retryQueue = await this.assertRetryQueue(workQueue, delay);
+        this.ConsumeChannel.sendToQueue(retryQueue, msg.content, {
+            persistent: true,
+            contentType: 'application/json',
+            priority: msg.properties.priority,
+            headers: { ...msg.properties.headers, [RETRY_COUNT_HEADER]: nextAttempt },
+        });
+        this.ConsumeChannel.ack(msg);
+        this.Log.warn(`Job ${qMessage.Name} failed on ${workQueue}, retry ${nextAttempt}/${qMessage.RetryCount} scheduled in ${delay}ms. ${reason}`);
+    }
+    /**
+     * Publishes a failed/unparseable message to the dead-letter queue and acks the original to
+     * unblock the source queue. When no dead-letter queue is configured the message is dropped
+     * ( acked ) with a warning - we never nack-loop a poison message forever.
+     */
+    deadLetterRaw(msg, dlq, channel, reason, attempt) {
+        if (!dlq) {
+            this.Log.warn(`Message failed on channel ${channel}, no dead-letter queue configured - dropping. ${reason}`);
+            this.ConsumeChannel.ack(msg);
+            return;
+        }
+        this.assertQueue(this.ConsumeChannel, dlq)
+            .then(() => {
+            this.ConsumeChannel.sendToQueue(dlq, msg.content, {
+                persistent: true,
+                contentType: 'application/json',
+                headers: { ...msg.properties.headers, 'x-error': reason, ...(attempt !== undefined ? { [RETRY_COUNT_HEADER]: attempt } : {}) },
+            });
+            this.ConsumeChannel.ack(msg);
+            this.Log.warn(`Message failed on channel ${channel}, routed to dead-letter ${dlq}. ${reason}`);
+        })
+            .catch((dlqErr) => {
+            this.Log.error(`Failed to route message to dead-letter ${dlq}, nacking instead: ${dlqErr.message}`);
+            this.ConsumeChannel.nack(msg, false, false);
+        });
+    }
+    /**
+     * Exponential backoff ( ms ) for the given retry attempt, based on `Options.retryDelay`.
+     * Returns 0 ( immediate redelivery ) when no base delay is configured.
+     */
+    retryBackoff(attempt) {
+        const base = this.Options.retryDelay ?? 0;
+        return base > 0 ? base * 2 ** (attempt - 1) : 0;
+    }
+    /**
+     * Publisher-side resilience pipeline: bounds each publish by a timeout and retries transient
+     * failures / nacks with exponential backoff. Consumer dedup ( by JobId ) makes the resulting
+     * rare duplicates harmless.
+     */
+    buildEmitPipeline() {
+        const attempts = this.Options.options?.emitRetries ?? 3;
+        const timeout = this.Options.receiptTimeout ?? 5000;
+        const base = this.Options.retryDelay && this.Options.retryDelay > 0 ? this.Options.retryDelay : 200;
+        return new ResiliencePipelineBuilder()
+            .addRetry({ MaxRetryAttempts: attempts, Delay: base, MaxDelay: 30000, BackoffType: BackoffType.Exponential, UseJitter: true })
+            .addTimeout(timeout)
+            .build();
+    }
+    async publishMessage(message) {
+        const channels = this.getChannelForMessage(message);
+        const buffer = Buffer.from(JSON.stringify(message));
+        const publishOptions = {
+            persistent: !!message.Persistent,
+            contentType: 'application/json',
+        };
+        if (message.JobId) {
+            publishOptions.correlationId = message.JobId;
+        }
+        if (message.Priority) {
+            publishOptions.priority = message.Priority;
+        }
+        for (const c of channels) {
+            await this.EmitPipeline.execute(() => this.publishToChannel(c, buffer, publishOptions));
+            this.Log.trace(`Published ${message.Type} Name: ${message.Name} to channel ${c} ( ${this.Options.name} )`);
+        }
+    }
+    /** Asserts the destination ( once ) and publishes a single message on the confirm channel. */
+    async publishToChannel(channel, buffer, options) {
+        if (this.isTopic(channel)) {
+            await this.assertExchange(this.PublishChannel, channel);
+            await this.publishWithConfirm(channel, '', buffer, options);
+        }
+        else {
+            await this.assertQueue(this.PublishChannel, channel);
+            await this.publishWithConfirm('', channel, buffer, options);
+        }
+    }
+    /**
+     * Publishes on the confirm channel and resolves only once the broker acks the message.
+     */
+    publishWithConfirm(exchange, routingKey, content, options) {
+        return new Promise((resolve, reject) => {
+            this.PublishChannel.publish(exchange, routingKey, content, options, (err) => {
+                if (err) {
+                    reject(err instanceof Error ? err : new UnexpectedServerError(`Broker nacked message on ${exchange || routingKey}`, err));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    async flushPendingEmits() {
+        if (this.PendingEmits.length === 0) {
+            return;
+        }
+        const pending = this.PendingEmits;
+        this.PendingEmits = [];
+        this.Log.info(`Flushing ${pending.length} buffered message(s) for queue ${this.Options.name}`);
+        for (const p of pending) {
+            this.publishMessage(p.message).then(p.resolve).catch(p.reject);
+        }
+    }
+    /**
+     * Declares ( and for topics binds ) the broker queue a subscription should consume from.
+     */
+    async assertSubscriptionQueue(channel, subscriptionId, durable) {
+        if (!this.isTopic(channel)) {
+            return this.assertQueue(this.ConsumeChannel, channel);
+        }
+        await this.assertExchange(this.ConsumeChannel, channel);
+        let queueName;
+        if (durable) {
+            if (!subscriptionId) {
+                throw new InvalidArgument(`subscriptionId cannot be empty if using durable subscriptions`);
+            }
+            const q = await this.ConsumeChannel.assertQueue(subscriptionId, { durable: true, exclusive: false, autoDelete: false });
+            queueName = q.queue;
+        }
+        else {
+            // server-named, exclusive, auto-deleted queue ( unique per subscriber )
+            const q = await this.ConsumeChannel.assertQueue(subscriptionId ?? '', { durable: false, exclusive: !subscriptionId, autoDelete: true });
+            queueName = q.queue;
+        }
+        await this.ConsumeChannel.bindQueue(queueName, channel, '');
+        return queueName;
+    }
+    /**
+     * Declares a durable work queue, asserting it on the broker only once per connection.
+     */
+    async assertQueue(channel, name) {
+        if (!this.AssertedQueues.has(name)) {
+            await channel.assertQueue(name, { durable: true });
+            this.AssertedQueues.add(name);
+        }
+        return name;
+    }
+    /**
+     * Declares a durable fanout exchange, asserting it on the broker only once per connection.
+     */
+    async assertExchange(channel, name) {
+        if (!this.AssertedExchanges.has(name)) {
+            await channel.assertExchange(name, 'fanout', { durable: true });
+            this.AssertedExchanges.add(name);
+        }
+    }
+    /**
+     * Declares a durable TTL retry queue that dead-letters expired messages back to `workQueue`
+     * ( via the default exchange, routing key = queue name ). One queue per distinct delay.
+     */
+    async assertRetryQueue(workQueue, delay) {
+        const name = `${workQueue}.retry.${delay}`;
+        if (!this.AssertedRetryQueues.has(name)) {
+            await this.ConsumeChannel.assertQueue(name, {
+                durable: true,
+                arguments: {
+                    'x-message-ttl': delay,
+                    'x-dead-letter-exchange': '',
+                    'x-dead-letter-routing-key': workQueue,
+                },
+            });
+            this.AssertedRetryQueues.add(name);
+        }
+        return name;
+    }
+    isTopic(channel) {
+        return channel.startsWith(this.TopicPrefix);
+    }
+    async closeChannel(channel) {
+        try {
+            if (channel) {
+                await channel.close();
+            }
+        }
+        catch (err) {
+            this.Log.warn(`Error while closing AMQP channel for ${this.Options.name}: ${err?.message}`);
+        }
+    }
+    warnOnUnsupportedScheduling(message) {
+        if (message.ScheduleDelay || message.ScheduleCron || message.SchedulePeriod || message.ScheduleRepeat) {
+            this.Log.warn(`Message ${message.Name} has scheduling options set, but the AMQP transport does not support delayed/scheduled delivery yet. Message will be delivered immediately.`);
+        }
+    }
+};
+AmqpQueueClient = __decorate([
+    PerInstanceCheck(),
+    Injectable(QueueClient),
+    __metadata("design:paramtypes", [Object])
+], AmqpQueueClient);
+export { AmqpQueueClient };
+//# sourceMappingURL=connection.js.map