@bitspacerlabs/rabbit-relay 0.5.0

package/dist/esm/eventFactories.d.ts

@@ -0,0 +1,31 @@
+/** Optional metadata carried alongside the event payload. */
+export interface EventMeta {
+    corrId?: string;
+    causationId?: string;
+    /** Optional application headers. */
+    headers?: Record<string, string>;
+    expectsReply?: boolean;
+    timeoutMs?: number;
+}
+export interface EventEnvelope<T = unknown> {
+    id: string;
+    name: string;
+    v: string;
+    time: number;
+    data: T;
+    meta?: EventMeta;
+}
+export type EnvelopeFactory<T> = (data: T, meta?: EventMeta) => EventEnvelope<T>;
+export declare function expectReply(meta?: EventMeta, timeoutMs?: number): EventMeta;
+export declare function event(name: string, v?: string): {
+    of: <T = unknown>() => EnvelopeFactory<T>;
+};
+export declare function eventWithReply(name: string, v?: string): {
+    of: <T = unknown, R = unknown>() => EnvelopeFactory<T>;
+};
+/**
+ * Augment an events map so calling a factory publishes via broker.produce().
+ */
+export declare function augmentEvents<T extends object>(events: Record<string, (...args: any[]) => EventEnvelope>, broker: {
+    produce: (...evts: EventEnvelope[]) => Promise<unknown>;
+}): T & Record<string, (...args: any[]) => Promise<unknown>>;

package/dist/esm/eventFactories.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectReply = expectReply;
+exports.event = event;
+exports.eventWithReply = eventWithReply;
+exports.augmentEvents = augmentEvents;
+const crypto_1 = require("crypto");
+function expectReply(meta, timeoutMs) {
+    return { ...(meta !== null && meta !== void 0 ? meta : {}), expectsReply: true, ...(timeoutMs != null ? { timeoutMs } : {}) };
+}
+function randomId() {
+    var _a;
+    try {
+        return (_a = crypto_1.randomUUID === null || crypto_1.randomUUID === void 0 ? void 0 : (0, crypto_1.randomUUID)()) !== null && _a !== void 0 ? _a : `evt_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    }
+    catch {
+        return `evt_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    }
+}
+function event(name, v = "1.0.0") {
+    return {
+        of: () => (data, meta) => ({
+            id: randomId(),
+            name,
+            v,
+            time: Date.now(),
+            data,
+            meta,
+        }),
+    };
+}
+function eventWithReply(name, v = "1.0.0") {
+    return {
+        of: () => (data, meta) => ({
+            id: randomId(),
+            name,
+            v,
+            time: Date.now(),
+            data,
+            meta: { expectsReply: false, ...(meta !== null && meta !== void 0 ? meta : {}) },
+        }),
+    };
+}
+/**
+ * Augment an events map so calling a factory publishes via broker.produce().
+ */
+function augmentEvents(events, broker) {
+    const augmented = { ...events, ...broker };
+    for (const key of Object.keys(events)) {
+        const factory = events[key];
+        augmented[key] = async (...args) => broker.produce(factory(...args));
+    }
+    return augmented;
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./rabbitmqBroker";
+export * from "./eventFactories";
+export * from "./pluginManager";
+export * from "./utils/dedupe";

package/dist/esm/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./rabbitmqBroker"), exports);
+__exportStar(require("./eventFactories"), exports);
+__exportStar(require("./pluginManager"), exports);
+__exportStar(require("./utils/dedupe"), exports);

package/dist/esm/pluginManager.d.ts

@@ -0,0 +1,13 @@
+import { EventEnvelope } from "./eventFactories";
+export interface Plugin {
+    beforeProduce?(event: EventEnvelope): Promise<void>;
+    afterProduce?(event: EventEnvelope, result: unknown): Promise<void>;
+    beforeProcess?(id: string | number, event: EventEnvelope): Promise<void>;
+    afterProcess?(id: string | number, event: EventEnvelope, result: unknown): Promise<void>;
+}
+export declare class PluginManager {
+    private plugins;
+    register(plugin: Plugin): void;
+    executeHook<K extends keyof Plugin>(hookName: K, ...args: Parameters<NonNullable<Plugin[K]>>): Promise<void>;
+}
+export declare const pluginManager: PluginManager;

package/dist/esm/pluginManager.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginManager = exports.PluginManager = void 0;
+class PluginManager {
+    constructor() {
+        this.plugins = [];
+    }
+    register(plugin) {
+        this.plugins.push(plugin);
+    }
+    async executeHook(hookName, ...args) {
+        for (const plugin of this.plugins) {
+            const fn = plugin[hookName];
+            if (typeof fn === "function") {
+                try {
+                    await fn
+                        .call(plugin, ...args);
+                }
+                catch (err) {
+                    console.error(`Error executing hook ${String(hookName)}:`, err);
+                }
+            }
+        }
+    }
+}
+exports.PluginManager = PluginManager;
+exports.pluginManager = new PluginManager();

package/dist/esm/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/esm/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/esm/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;