@bitspacerlabs/rabbit-relay 0.5.2 → 0.6.1

package/dist/cjs/consumer.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConsumer = createConsumer;
+const pluginManager_1 = require("./pluginManager");
+const backpressure_1 = require("./backpressure");
+function createConsumer(params) {
+    const { queueName, handlers } = params;
+    let consumerTag;
+    let isConsuming = false;
+    let consumeCh = null;
+    let prefetchCount = 1;
+    // Note: concurrency is *effectively* enforced via prefetch as in the original file.
+    let concurrency = 1;
+    let onError = "ack";
+    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) {
+                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 (0, backpressure_1.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) {
+                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);
+        }
+    };
+    async function startConsume(getChannel, 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 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
+                }
+            },
+        };
+    }
+    async function resumeOnReconnect(ch) {
+        if (!isConsuming)
+            return;
+        if (prefetchCount > 0)
+            await ch.prefetch(prefetchCount, false);
+        consumeCh = ch;
+        const ok = await ch.consume(queueName, onMessage);
+        consumerTag = ok.consumerTag;
+    }
+    function getState() {
+        return { isConsuming, prefetchCount, concurrency, onError };
+    }
+    return {
+        startConsume,
+        resumeOnReconnect,
+        getState,
+    };
+}

package/dist/cjs/index.d.ts

@@ -2,3 +2,4 @@ export * from "./rabbitmqBroker";
 export * from "./eventFactories";
 export * from "./pluginManager";
 export * from "./utils/dedupe";
+export * from "./types";

package/dist/cjs/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./rabbitmqBroker"), exports);
 __exportStar(require("./eventFactories"), exports);
 __exportStar(require("./pluginManager"), exports);
 __exportStar(require("./utils/dedupe"), exports);
+__exportStar(require("./types"), exports);

package/dist/cjs/publisher.d.ts

@@ -0,0 +1,13 @@
+import { Channel } from "amqplib";
+import { EventEnvelope } from "./eventFactories";
+import { ExchangeConfig, InternalCfg } from "./types";
+export declare function createPublisher(params: {
+    exchangeName: string;
+    exchangeConfig: ExchangeConfig;
+    defaultCfg: InternalCfg;
+    getChannel: () => Promise<Channel>;
+    getBackoffMs: () => number;
+}): {
+    produce: <TEvents extends Record<string, EventEnvelope>, K extends keyof TEvents>(...events: TEvents[K][]) => Promise<void | unknown>;
+    produceMany: <TEvents extends Record<string, EventEnvelope>, K extends keyof TEvents>(...events: TEvents[K][]) => Promise<void>;
+};

package/dist/cjs/publisher.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPublisher = createPublisher;
+const config_1 = require("./config");
+const pluginManager_1 = require("./pluginManager");
+const backpressure_1 = require("./backpressure");
+const uuid_1 = require("./uuid");
+function createPublisher(params) {
+    const { exchangeName, exchangeConfig, defaultCfg, getChannel, getBackoffMs } = params;
+    const getPubChannel = async () => {
+        var _a;
+        if ((_a = exchangeConfig.publisherConfirms) !== null && _a !== void 0 ? _a : defaultCfg.publisherConfirms) {
+            return (0, config_1.getRabbitMQConfirmChannel)();
+        }
+        return getChannel();
+    };
+    const safePublish = async (publish) => {
+        try {
+            const ch = await getPubChannel();
+            await publish(ch);
+            await (0, backpressure_1.maybeWaitForConfirms)(ch);
+        }
+        catch {
+            // Broker is likely reconnecting. Briefly wait, then retry once.
+            const delay = Math.min(getBackoffMs() * 2, 2000);
+            await new Promise((r) => setTimeout(r, delay));
+            const ch2 = await getPubChannel();
+            await publish(ch2);
+            await (0, backpressure_1.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 (0, backpressure_1.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 = (0, uuid_1.generateUuid)();
+            const rpcCh = await 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 (0, backpressure_1.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 { produce, produceMany };
+}

package/dist/cjs/rabbitmqBroker.d.ts

@@ -1,58 +1,10 @@
-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]>;
-    };
-}
+import { ExchangeConfig, BrokerInterface } from "./types";
 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;
+    private reconnect;
     constructor(peerName: string, config?: ExchangeConfig);
-    private initChannel;
-    private scheduleReconnect;
     private getChannel;
     private onReconnect;
     queue(queueName: string): {