@bitspacerlabs/rabbit-relay 0.5.0

package/dist/cjs/rabbitmqBroker.d.ts

@@ -0,0 +1,62 @@
+import { Options } from "amqplib";
+import { EventEnvelope } from "./eventFactories";
+export interface ExchangeConfig {
+    exchangeType?: "topic" | "direct" | "fanout";
+    routingKey?: string;
+    durable?: boolean;
+    publisherConfirms?: boolean;
+    queueArgs?: Options.AssertQueue["arguments"];
+    /**
+     * If true, do NOT declare the queue; only check it exists.
+     * Use this when a separate setup step has already created the queue with specific args.
+     */
+    passiveQueue?: boolean;
+}
+export interface ConsumeOptions {
+    /** Max unacked messages this consumer can hold. Also default concurrency. */
+    prefetch?: number;
+    /** Parallel handler executions. Defaults to prefetch (or 1). */
+    concurrency?: number;
+    /** If true, nack+requeue on handler error; else ack even on error. (back-compat) */
+    requeueOnError?: boolean;
+    /** What to do when the handler throws. Default "ack". */
+    onError?: "ack" | "requeue" | "dead-letter";
+}
+/**
+ * Generic Broker Interface:
+ * TEvents maps event name keys -> EventEnvelope types.
+ */
+export interface BrokerInterface<TEvents extends Record<string, EventEnvelope>> {
+    handle<K extends keyof TEvents>(eventName: K | "*", handler: (id: string | number, event: TEvents[K]) => Promise<unknown>): BrokerInterface<TEvents>;
+    consume(opts?: ConsumeOptions): Promise<{
+        stop(): Promise<void>;
+    }>;
+    produce<K extends keyof TEvents>(...events: TEvents[K][]): Promise<void | unknown>;
+    produceMany<K extends keyof TEvents>(...events: TEvents[K][]): Promise<void>;
+    with<U extends Record<string, (...args: any[]) => EventEnvelope>>(events: U): BrokerInterface<{
+        [K in keyof U]: ReturnType<U[K]>;
+    }> & {
+        [K in keyof U]: (...args: Parameters<U[K]>) => ReturnType<U[K]>;
+    };
+}
+export declare class RabbitMQBroker {
+    private peerName;
+    private defaultCfg;
+    /** The current live channel promise (replaced after reconnect). */
+    private channelPromise;
+    /** Reconnect state */
+    private reconnecting;
+    private backoffMs;
+    private readonly maxBackoffMs;
+    /** Callbacks to run after a successful reconnect (like re-assert topology, resume consume). */
+    private onReconnectCbs;
+    constructor(peerName: string, config?: ExchangeConfig);
+    private initChannel;
+    private scheduleReconnect;
+    private getChannel;
+    private onReconnect;
+    queue(queueName: string): {
+        exchange: <TEvents extends Record<string, EventEnvelope>>(exchangeName: string, exchangeConfig?: ExchangeConfig) => Promise<BrokerInterface<TEvents>>;
+    };
+    private exchange;
+}

package/dist/cjs/rabbitmqBroker.js

@@ -0,0 +1,403 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMQBroker = void 0;
+const config_1 = require("./config");
+const pluginManager_1 = require("./pluginManager");
+function generateUuid() {
+    return Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
+}
+class RabbitMQBroker {
+    constructor(peerName, config = {}) {
+        var _a, _b, _c, _d, _e;
+        /** Reconnect state */
+        this.reconnecting = false;
+        this.backoffMs = 500;
+        this.maxBackoffMs = 20000;
+        /** Callbacks to run after a successful reconnect (like re-assert topology, resume consume). */
+        this.onReconnectCbs = [];
+        this.peerName = peerName;
+        this.defaultCfg = {
+            exchangeType: (_a = config.exchangeType) !== null && _a !== void 0 ? _a : "topic",
+            routingKey: (_b = config.routingKey) !== null && _b !== void 0 ? _b : "#",
+            durable: (_c = config.durable) !== null && _c !== void 0 ? _c : true,
+            publisherConfirms: (_d = config.publisherConfirms) !== null && _d !== void 0 ? _d : false,
+            queueArgs: config.queueArgs,
+            passiveQueue: (_e = config.passiveQueue) !== null && _e !== void 0 ? _e : false,
+        };
+        this.initChannel();
+    }
+    async initChannel() {
+        var _a, _b, _c, _d;
+        this.channelPromise = (0, config_1.getRabbitMQChannel)();
+        const ch = await this.channelPromise;
+        this.backoffMs = 500;
+        const onClose = () => this.scheduleReconnect("channel.close");
+        const onError = () => this.scheduleReconnect("channel.error");
+        (_b = (_a = ch).on) === null || _b === void 0 ? void 0 : _b.call(_a, "close", onClose);
+        (_d = (_c = ch).on) === null || _d === void 0 ? void 0 : _d.call(_c, "error", onError);
+    }
+    async scheduleReconnect(reason) {
+        if (this.reconnecting)
+            return;
+        this.reconnecting = true;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            try {
+                const jitter = Math.floor(Math.random() * 250);
+                await new Promise((r) => setTimeout(r, this.backoffMs + jitter));
+                await this.initChannel();
+                const ch = await this.channelPromise;
+                this.backoffMs = 500;
+                this.reconnecting = false;
+                for (const cb of this.onReconnectCbs) {
+                    try {
+                        await cb(ch);
+                    }
+                    catch (e) {
+                        console.error("[broker] onReconnect callback failed:", e);
+                    }
+                }
+                return;
+            }
+            catch {
+                this.backoffMs = Math.min(this.maxBackoffMs, Math.floor(this.backoffMs * 1.7 + Math.random() * 100));
+                console.error(`[broker] reconnect failed (${reason}), retrying in ~${this.backoffMs}ms`);
+            }
+        }
+    }
+    async getChannel() {
+        return this.channelPromise;
+    }
+    onReconnect(cb) {
+        this.onReconnectCbs.push(cb);
+    }
+    queue(queueName) {
+        return {
+            exchange: async (exchangeName, exchangeConfig = {}) => {
+                return this.exchange(exchangeName, queueName, exchangeConfig);
+            },
+        };
+    }
+    async exchange(exchangeName, queueName, exchangeConfig = {}) {
+        const assertTopology = async (channel) => {
+            var _a, _b, _c, _d, _e, _f;
+            const cfg = {
+                exchangeType: (_a = exchangeConfig.exchangeType) !== null && _a !== void 0 ? _a : this.defaultCfg.exchangeType,
+                routingKey: (_b = exchangeConfig.routingKey) !== null && _b !== void 0 ? _b : this.defaultCfg.routingKey,
+                durable: (_c = exchangeConfig.durable) !== null && _c !== void 0 ? _c : this.defaultCfg.durable,
+                publisherConfirms: (_d = exchangeConfig.publisherConfirms) !== null && _d !== void 0 ? _d : this.defaultCfg.publisherConfirms,
+                queueArgs: (_e = exchangeConfig.queueArgs) !== null && _e !== void 0 ? _e : this.defaultCfg.queueArgs,
+                passiveQueue: (_f = exchangeConfig.passiveQueue) !== null && _f !== void 0 ? _f : this.defaultCfg.passiveQueue,
+            };
+            await channel.assertExchange(exchangeName, cfg.exchangeType, { durable: cfg.durable });
+            if (cfg.passiveQueue) {
+                if (cfg.queueArgs) {
+                    console.warn(`[broker] passiveQueue=true: ignoring queueArgs for '${queueName}' (not declaring).`);
+                }
+                try {
+                    await channel.checkQueue(queueName);
+                }
+                catch (err) {
+                    const code = err === null || err === void 0 ? void 0 : err.code;
+                    if (code === 404) {
+                        throw new Error(`[broker] passiveQueue check failed: queue '${queueName}' does not exist. ` +
+                            `Either create it in your setup step with the desired arguments, ` +
+                            `or call with passiveQueue:false and queueArgs to auto-declare.`);
+                    }
+                    throw err;
+                }
+            }
+            else {
+                try {
+                    const qOpts = {
+                        durable: cfg.durable,
+                        ...(cfg.queueArgs ? { arguments: cfg.queueArgs } : {}),
+                    };
+                    await channel.assertQueue(queueName, qOpts);
+                }
+                catch (err) {
+                    if ((err === null || err === void 0 ? void 0 : err.code) === 406) {
+                        throw new Error(`[broker] QueueDeclare PRECONDITION_FAILED for '${queueName}'. ` +
+                            `Existing queue has different arguments. ` +
+                            `Fix: delete the queue or switch to { passiveQueue: true } if you're using a setup step.`);
+                    }
+                    throw err;
+                }
+            }
+            // (Re)bind is idempotent - safe to call even if binding already exists
+            await channel.bindQueue(queueName, exchangeName, cfg.routingKey);
+        };
+        const channel = await this.getChannel();
+        await assertTopology(channel);
+        const handlers = new Map();
+        let consumerTag;
+        let isConsuming = false;
+        let consumeCh = null;
+        let prefetchCount = 1;
+        let concurrency = 1;
+        let onError = "ack";
+        this.onReconnect(async (ch) => {
+            await assertTopology(ch);
+            if (isConsuming) {
+                if (prefetchCount > 0)
+                    await ch.prefetch(prefetchCount, false);
+                consumeCh = ch; // pin
+                const ok = await ch.consume(queueName, onMessage);
+                consumerTag = ok.consumerTag;
+            }
+        });
+        const handle = (eventName, handler) => {
+            handlers.set(eventName, handler);
+            return brokerInterface;
+        };
+        // Backpressure-aware publish helper
+        const waitForDrain = (ch) => new Promise((resolve) => {
+            const anyCh = ch;
+            if (typeof anyCh.once === "function")
+                anyCh.once("drain", resolve);
+            else
+                resolve(); // if not supported, resolve immediately
+        });
+        const publishWithBackpressure = async (ch, exchange, routingKey, content, options) => {
+            const ok = ch.publish(exchange, routingKey, content, options);
+            if (!ok) {
+                console.warn(`[amqp] publish backpressure: waiting for 'drain' (exchange=${exchange}, key=${routingKey}, size=${content.length})`);
+                const t0 = Date.now();
+                await waitForDrain(ch);
+                const dt = Date.now() - t0;
+                if (dt >= 1) {
+                    console.warn(`[amqp] drain resolved after ${dt}ms (exchange=${exchange}, key=${routingKey})`);
+                }
+            }
+        };
+        const getPubChannel = async () => {
+            var _a;
+            if ((_a = exchangeConfig.publisherConfirms) !== null && _a !== void 0 ? _a : this.defaultCfg.publisherConfirms) {
+                return (0, config_1.getRabbitMQConfirmChannel)();
+            }
+            return this.getChannel();
+        };
+        const maybeWaitForConfirms = async (ch) => {
+            const anyCh = ch;
+            if (typeof anyCh.waitForConfirms === "function") {
+                await anyCh.waitForConfirms();
+            }
+        };
+        const onMessage = async (msg) => {
+            if (!msg)
+                return;
+            const ch = consumeCh;
+            if (!ch)
+                return;
+            const id = msg.fields.deliveryTag;
+            const payload = JSON.parse(msg.content.toString());
+            const handler = handlers.get(payload.name) || handlers.get("*");
+            let result = null;
+            let errored = false;
+            try {
+                await pluginManager_1.pluginManager.executeHook("beforeProcess", id, payload);
+                if (handler) {
+                    // concurrency is enforced by prefetch limiting in-flight
+                    result = await handler(id, payload);
+                }
+                await pluginManager_1.pluginManager.executeHook("afterProcess", id, payload, result);
+            }
+            catch (err) {
+                errored = true;
+                console.error("Handler error:", err);
+            }
+            // RPC reply path (even if handler errored, you might still want a reply)
+            if (msg.properties.replyTo) {
+                try {
+                    await publishWithBackpressure(ch, "", msg.properties.replyTo, Buffer.from(JSON.stringify({ reply: errored ? null : result })), { correlationId: msg.properties.correlationId });
+                }
+                catch (e) {
+                    console.error("Reply publish failed:", e);
+                }
+            }
+            // Ack/Nack decision
+            try {
+                if (errored) {
+                    // derive behavior from onError (Backward compatibility: requeueOnError -> "requeue" handled in consume())
+                    if (onError === "requeue") {
+                        ch.nack(msg, false, true); // requeue back to SAME queue
+                    }
+                    else if (onError === "dead-letter") {
+                        ch.nack(msg, false, false); // route to DLX (if queue is DLX-configured)
+                    }
+                    else {
+                        ch.ack(msg); // swallow the error
+                    }
+                }
+                else {
+                    ch.ack(msg);
+                }
+            }
+            catch (e) {
+                console.error("Ack/Nack failed:", e);
+            }
+        };
+        const consume = async (opts) => {
+            var _a, _b, _c, _d;
+            prefetchCount = (_b = (_a = opts === null || opts === void 0 ? void 0 : opts.prefetch) !== null && _a !== void 0 ? _a : opts === null || opts === void 0 ? void 0 : opts.concurrency) !== null && _b !== void 0 ? _b : 1;
+            concurrency = (_c = opts === null || opts === void 0 ? void 0 : opts.concurrency) !== null && _c !== void 0 ? _c : prefetchCount;
+            // Back-compat: if requeueOnError is set and onError not explicitly provided, use "requeue"
+            onError = (_d = opts === null || opts === void 0 ? void 0 : opts.onError) !== null && _d !== void 0 ? _d : ((opts === null || opts === void 0 ? void 0 : opts.requeueOnError) ? "requeue" : "ack");
+            const ch = await this.getChannel();
+            consumeCh = ch;
+            if (prefetchCount > 0)
+                await ch.prefetch(prefetchCount, false);
+            const ok = await ch.consume(queueName, onMessage);
+            consumerTag = ok.consumerTag;
+            isConsuming = true;
+            return {
+                stop: async () => {
+                    isConsuming = false;
+                    try {
+                        const c = consumeCh;
+                        if (consumerTag && c)
+                            await c.cancel(consumerTag);
+                    }
+                    catch {
+                        // channel may be closed; ignore
+                    }
+                },
+            };
+        };
+        const safePublish = async (publish) => {
+            try {
+                const ch = await getPubChannel();
+                await publish(ch);
+                await maybeWaitForConfirms(ch);
+            }
+            catch {
+                // Broker is likely reconnecting. Briefly wait, then retry once.
+                const delay = Math.min(this.backoffMs * 2, 2000);
+                await new Promise(r => setTimeout(r, delay));
+                // try once more after reconnect
+                const ch2 = await getPubChannel();
+                await publish(ch2);
+                await maybeWaitForConfirms(ch2);
+            }
+        };
+        const produceMany = async (...events) => {
+            for (const evt of events) {
+                await pluginManager_1.pluginManager.executeHook("beforeProduce", evt);
+                await safePublish((ch) => {
+                    var _a, _b, _c;
+                    const e = evt;
+                    const props = {
+                        messageId: e.id, // idempotency key
+                        type: e.name, // event name
+                        timestamp: Math.floor(((_a = e.time) !== null && _a !== void 0 ? _a : Date.now()) / 1000),
+                        correlationId: (_b = e.meta) === null || _b === void 0 ? void 0 : _b.corrId,
+                        headers: (_c = e.meta) === null || _c === void 0 ? void 0 : _c.headers,
+                    };
+                    return publishWithBackpressure(ch, exchangeName, e.name, Buffer.from(JSON.stringify(e)), props);
+                });
+                await pluginManager_1.pluginManager.executeHook("afterProduce", evt, null);
+            }
+        };
+        const produce = async (...events) => {
+            var _a, _b, _c, _d, _e;
+            // Back-compat: upgrade legacy `wait` (if present) to meta fields
+            if (events.length === 1 && ((_a = events[0]) === null || _a === void 0 ? void 0 : _a.wait)) {
+                const first = events[0];
+                const w = first.wait;
+                first.meta = first.meta || {};
+                if (first.meta.expectsReply !== true)
+                    first.meta.expectsReply = true;
+                if ((w === null || w === void 0 ? void 0 : w.timeout) != null && first.meta.timeoutMs == null)
+                    first.meta.timeoutMs = w.timeout;
+                if (w === null || w === void 0 ? void 0 : w.source) {
+                    first.meta.headers = { ...(first.meta.headers || {}), source: w.source };
+                }
+            }
+            // RPC request path
+            if (events.length === 1 && ((_c = (_b = events[0]) === null || _b === void 0 ? void 0 : _b.meta) === null || _c === void 0 ? void 0 : _c.expectsReply) === true) {
+                const evt = events[0];
+                const correlationId = generateUuid();
+                const rpcCh = await this.getChannel(); // pin for reply consumer/ack
+                const temp = await rpcCh.assertQueue("", { exclusive: true, autoDelete: true });
+                await pluginManager_1.pluginManager.executeHook("beforeProduce", evt);
+                await safePublish(async () => {
+                    var _a, _b;
+                    // use (confirm) pub channel for the request publish
+                    const pubCh = await getPubChannel();
+                    const props = {
+                        messageId: evt.id,
+                        type: evt.name,
+                        timestamp: Math.floor(((_a = evt.time) !== null && _a !== void 0 ? _a : Date.now()) / 1000),
+                        correlationId,
+                        headers: (_b = evt.meta) === null || _b === void 0 ? void 0 : _b.headers,
+                        replyTo: temp.queue,
+                    };
+                    await publishWithBackpressure(pubCh, exchangeName, evt.name, Buffer.from(JSON.stringify(evt)), props);
+                });
+                const timeoutMs = (_e = (_d = evt.meta) === null || _d === void 0 ? void 0 : _d.timeoutMs) !== null && _e !== void 0 ? _e : 5000;
+                return await new Promise((resolve, reject) => {
+                    let ctag;
+                    const timer = setTimeout(async () => {
+                        try {
+                            if (ctag)
+                                await rpcCh.cancel(ctag);
+                        }
+                        catch { }
+                        try {
+                            await rpcCh.deleteQueue(temp.queue);
+                        }
+                        catch { }
+                        reject(new Error("Timeout waiting for reply"));
+                    }, timeoutMs);
+                    rpcCh
+                        .consume(temp.queue, (msg) => {
+                        if (!msg)
+                            return;
+                        if (msg.properties.correlationId !== correlationId)
+                            return;
+                        clearTimeout(timer);
+                        try {
+                            const reply = JSON.parse(msg.content.toString()).reply;
+                            pluginManager_1.pluginManager.executeHook("afterProduce", evt, reply);
+                            resolve(reply);
+                        }
+                        finally {
+                            Promise.resolve()
+                                .then(async () => {
+                                try {
+                                    if (ctag)
+                                        await rpcCh.cancel(ctag);
+                                }
+                                catch { }
+                                try {
+                                    await rpcCh.deleteQueue(temp.queue);
+                                }
+                                catch { }
+                            })
+                                .catch(() => undefined);
+                        }
+                    }, { noAck: true })
+                        .then((ok) => { ctag = ok.consumerTag; })
+                        .catch((err) => {
+                        clearTimeout(timer);
+                        reject(err);
+                    });
+                });
+            }
+            return produceMany(...events);
+        };
+        const brokerInterface = {
+            handle,
+            consume,
+            produce,
+            produceMany,
+            with: (events) => {
+                const { augmentEvents } = require("./eventFactories");
+                const augmented = augmentEvents(events, brokerInterface);
+                return augmented;
+            },
+        };
+        return brokerInterface;
+    }
+}
+exports.RabbitMQBroker = RabbitMQBroker;

package/dist/cjs/utils/dedupe.d.ts

@@ -0,0 +1,12 @@
+export type KeyOf = (e: any) => string | undefined;
+export interface DedupeOpts {
+    ttlMs?: number;
+    maxKeys?: number;
+    keyOf?: KeyOf;
+}
+export interface Dedupe {
+    seen(id: string): boolean;
+    checkAndRemember(e: any): boolean;
+    size(): number;
+}
+export declare function makeMemoryDedupe(opts?: DedupeOpts): Dedupe;

package/dist/cjs/utils/dedupe.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMemoryDedupe = makeMemoryDedupe;
+function makeMemoryDedupe(opts = {}) {
+    var _a, _b, _c, _d, _e;
+    const ttl = Number((_b = (_a = process.env.DEDUPE_TTL_MS) !== null && _a !== void 0 ? _a : opts.ttlMs) !== null && _b !== void 0 ? _b : 10 * 60 * 1000);
+    const max = Number((_d = (_c = process.env.DEDUPE_MAX_KEYS) !== null && _c !== void 0 ? _c : opts.maxKeys) !== null && _d !== void 0 ? _d : 100000);
+    const keyOf = (_e = opts.keyOf) !== null && _e !== void 0 ? _e : ((e) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        return (_f = (_c = (_a = e === null || e === void 0 ? void 0 : e.id) !== null && _a !== void 0 ? _a : (_b = e === null || e === void 0 ? void 0 : e.meta) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : (_e = (_d = e === null || e === void 0 ? void 0 : e.meta) === null || _d === void 0 ? void 0 : _d.headers) === null || _e === void 0 ? void 0 : _e.messageId) !== null && _f !== void 0 ? _f : (_g = e === null || e === void 0 ? void 0 : e.meta) === null || _g === void 0 ? void 0 : _g.corrId;
+    });
+    const map = new Map();
+    function gc(now = Date.now()) {
+        // TTL cleanup
+        for (const [k, exp] of map) {
+            if (exp <= now)
+                map.delete(k);
+        }
+        // Size guard (simple LRU-ish by expiration)
+        if (map.size > max) {
+            const arr = [...map.entries()].sort((a, b) => a[1] - b[1]); // means oldest first
+            const toRemove = map.size - max;
+            for (let i = 0; i < toRemove; i++)
+                map.delete(arr[i][0]);
+        }
+    }
+    function remember(id) {
+        const now = Date.now();
+        gc(now);
+        map.set(id, now + ttl);
+    }
+    function seen(id) {
+        const exp = map.get(id);
+        const now = Date.now();
+        if (exp && exp > now)
+            return true;
+        if (exp)
+            map.delete(id);
+        return false;
+    }
+    return {
+        seen,
+        checkAndRemember(e) {
+            const id = typeof e === "string" ? e : keyOf(e);
+            if (!id)
+                return true; // nothing to de-dupe on -> treat as new one
+            if (seen(id))
+                return false;
+            remember(id);
+            return true;
+        },
+        size() {
+            return map.size;
+        },
+    };
+}

package/dist/esm/config.d.ts

@@ -0,0 +1,5 @@
+import { Channel, ConfirmChannel, ChannelModel } from "amqplib";
+export declare const rabbitMQUrl: string;
+export declare function getRabbitMQConnection(): Promise<ChannelModel>;
+export declare function getRabbitMQChannel(): Promise<Channel>;
+export declare function getRabbitMQConfirmChannel(): Promise<ConfirmChannel>;

package/dist/esm/config.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rabbitMQUrl = void 0;
+exports.getRabbitMQConnection = getRabbitMQConnection;
+exports.getRabbitMQChannel = getRabbitMQChannel;
+exports.getRabbitMQConfirmChannel = getRabbitMQConfirmChannel;
+const amqplib_1 = require("amqplib");
+const node_os_1 = __importDefault(require("node:os"));
+exports.rabbitMQUrl = (_a = process.env.RABBITMQ_URL) !== null && _a !== void 0 ? _a : "amqp://user:password@localhost";
+let conn = null;
+let ch = null;
+let opening = null;
+let cch = null;
+let cOpening = null;
+function attachConnHandlers(c) {
+    c.on("blocked", (reason) => console.warn("[amqp] connection blocked:", reason));
+    c.on("unblocked", () => console.log("[amqp] connection unblocked"));
+    c.on("close", () => {
+        console.error("[amqp] connection closed");
+        conn = null;
+        ch = null;
+        opening = null;
+        cch = null;
+        cOpening = null;
+    });
+    c.on("error", (err) => {
+        console.error("[amqp] connection error:", err);
+        // 'close' will clear caches
+    });
+}
+function attachChannelHandlers(channel, kind) {
+    channel.on("close", () => {
+        console.error(`[amqp] ${kind === "confirm" ? "confirm channel" : "channel"} closed`);
+        if (kind === "ch") {
+            ch = null;
+            opening = null;
+        }
+        else {
+            cch = null;
+            cOpening = null;
+        }
+    });
+    channel.on("error", (err) => {
+        console.error(`[amqp] ${kind === "confirm" ? "confirm channel" : "channel"} error:`, err);
+    });
+}
+async function getConn() {
+    if (conn)
+        return conn;
+    const c = await (0, amqplib_1.connect)(exports.rabbitMQUrl, {
+        clientProperties: {
+            connection_name: process.env.AMQP_CONN_NAME ||
+                `app:${process.title || "node"}@${node_os_1.default.hostname()}#${process.pid}`,
+        },
+    });
+    attachConnHandlers(c);
+    conn = c;
+    return c;
+}
+/** Always return a live channel */
+async function openChannelFresh() {
+    if (ch)
+        return ch;
+    if (opening)
+        return opening;
+    opening = (async () => {
+        try {
+            const c = await getConn();
+            const channel = await c.createChannel();
+            attachChannelHandlers(channel, "ch");
+            ch = channel;
+            return channel;
+        }
+        catch (err) {
+            opening = null;
+            ch = null;
+            conn = null;
+            throw err;
+        }
+    })();
+    return opening;
+}
+async function openConfirmChannelFresh() {
+    if (cch)
+        return cch;
+    if (cOpening)
+        return cOpening;
+    cOpening = (async () => {
+        try {
+            const c = await getConn();
+            const channel = await c.createConfirmChannel();
+            attachChannelHandlers(channel, "confirm");
+            cch = channel;
+            return channel;
+        }
+        catch (err) {
+            cOpening = null;
+            cch = null;
+            conn = null;
+            throw err;
+        }
+    })();
+    return cOpening;
+}
+async function getRabbitMQConnection() {
+    if (conn)
+        return conn;
+    await openChannelFresh();
+    return conn;
+}
+async function getRabbitMQChannel() {
+    return openChannelFresh();
+}
+async function getRabbitMQConfirmChannel() {
+    return openConfirmChannelFresh();
+}