@bitspacerlabs/rabbit-relay 0.5.2 → 0.6.0

package/dist/cjs/rabbitmqBroker.js

@@ -1,20 +1,13 @@
 "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);
-}
+const reconnect_1 = require("./reconnect");
+const topology_1 = require("./topology");
+const consumer_1 = require("./consumer");
+const publisher_1 = require("./publisher");
 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",
@@ -24,52 +17,14 @@ class RabbitMQBroker {
             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`);
-            }
-        }
+        this.reconnect = new reconnect_1.ReconnectController();
+        void this.reconnect.initChannel();
     }
     async getChannel() {
-        return this.channelPromise;
+        return this.reconnect.getChannel();
     }
     onReconnect(cb) {
-        this.onReconnectCbs.push(cb);
+        this.reconnect.onReconnect(cb);
     }
     queue(queueName) {
         return {
@@ -79,312 +34,42 @@ class RabbitMQBroker {
         };
     }
     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 assertTopology = (0, topology_1.createAssertTopology)({
+            exchangeName,
+            queueName,
+            defaultCfg: this.defaultCfg,
+            exchangeConfig,
+        });
         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";
+        const consumer = (0, consumer_1.createConsumer)({
+            queueName,
+            handlers,
+        });
+        const publisher = (0, publisher_1.createPublisher)({
+            exchangeName,
+            exchangeConfig,
+            defaultCfg: this.defaultCfg,
+            getChannel: () => this.getChannel(),
+            getBackoffMs: () => this.reconnect.getBackoffMs(),
+        });
         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;
-            }
+            await consumer.resumeOnReconnect(ch);
         });
         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);
-            }
+            return consumer.startConsume(() => this.getChannel(), opts);
         };
         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);
-            }
+            return publisher.produceMany(...events);
         };
         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);
+            return publisher.produce(...events);
         };
         const brokerInterface = {
             handle,
@@ -392,7 +77,8 @@ class RabbitMQBroker {
             produce,
             produceMany,
             with: (events) => {
-                const { augmentEvents } = require("./eventFactories");
+                // keep original behavior (dynamic require) to avoid import cycles
+                const { augmentEvents } = require("../eventFactories");
                 const augmented = augmentEvents(events, brokerInterface);
                 return augmented;
             },

package/dist/cjs/reconnect.d.ts

@@ -0,0 +1,17 @@
+import { Channel } from "amqplib";
+export declare class ReconnectController {
+    /** 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();
+    initChannel(): Promise<void>;
+    getBackoffMs(): number;
+    onReconnect(cb: (ch: Channel) => void | Promise<void>): void;
+    getChannel(): Promise<Channel>;
+    private scheduleReconnect;
+}

package/dist/cjs/reconnect.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReconnectController = void 0;
+const config_1 = require("./config");
+class ReconnectController {
+    constructor() {
+        /** 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 = [];
+        // no-op
+    }
+    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);
+    }
+    getBackoffMs() {
+        return this.backoffMs;
+    }
+    onReconnect(cb) {
+        this.onReconnectCbs.push(cb);
+    }
+    async getChannel() {
+        return this.channelPromise;
+    }
+    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`);
+            }
+        }
+    }
+}
+exports.ReconnectController = ReconnectController;

package/dist/cjs/topology.d.ts

@@ -0,0 +1,9 @@
+import { Channel } from "amqplib";
+import { ExchangeConfig, InternalCfg } from "./types";
+export declare function mergeInternalCfg(defaultCfg: InternalCfg, exchangeConfig: ExchangeConfig): InternalCfg;
+export declare function createAssertTopology(params: {
+    exchangeName: string;
+    queueName: string;
+    defaultCfg: InternalCfg;
+    exchangeConfig: ExchangeConfig;
+}): (channel: Channel) => Promise<void>;

package/dist/cjs/topology.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeInternalCfg = mergeInternalCfg;
+exports.createAssertTopology = createAssertTopology;
+function mergeInternalCfg(defaultCfg, exchangeConfig) {
+    var _a, _b, _c, _d, _e, _f;
+    return {
+        exchangeType: (_a = exchangeConfig.exchangeType) !== null && _a !== void 0 ? _a : defaultCfg.exchangeType,
+        routingKey: (_b = exchangeConfig.routingKey) !== null && _b !== void 0 ? _b : defaultCfg.routingKey,
+        durable: (_c = exchangeConfig.durable) !== null && _c !== void 0 ? _c : defaultCfg.durable,
+        publisherConfirms: (_d = exchangeConfig.publisherConfirms) !== null && _d !== void 0 ? _d : defaultCfg.publisherConfirms,
+        queueArgs: (_e = exchangeConfig.queueArgs) !== null && _e !== void 0 ? _e : defaultCfg.queueArgs,
+        passiveQueue: (_f = exchangeConfig.passiveQueue) !== null && _f !== void 0 ? _f : defaultCfg.passiveQueue,
+    };
+}
+function createAssertTopology(params) {
+    const { exchangeName, queueName, defaultCfg, exchangeConfig } = params;
+    return async function assertTopology(channel) {
+        const cfg = mergeInternalCfg(defaultCfg, exchangeConfig);
+        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);
+    };
+}

package/dist/cjs/types.d.ts

@@ -0,0 +1,49 @@
+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 type InternalCfg = {
+    exchangeType: "topic" | "direct" | "fanout";
+    routingKey: string;
+    durable: boolean;
+    publisherConfirms: boolean;
+    queueArgs?: Options.AssertQueue["arguments"];
+    passiveQueue: boolean;
+};

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/uuid.d.ts

@@ -0,0 +1 @@
+export declare function generateUuid(): string;

package/dist/cjs/uuid.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUuid = generateUuid;
+function generateUuid() {
+    return Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
+}

package/dist/esm/backpressure.d.ts

@@ -0,0 +1,4 @@
+import { Channel, Options } from "amqplib";
+export declare const waitForDrain: (ch: Channel) => Promise<void>;
+export declare const publishWithBackpressure: (ch: Channel, exchange: string, routingKey: string, content: Buffer, options?: Options.Publish) => Promise<void>;
+export declare const maybeWaitForConfirms: (ch: Channel) => Promise<void>;