@nwire/amqp 0.10.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alex Gefter / 200apps Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# @nwire/amqp
+
+RabbitMQ-backed `EventBus` adapter — experimental in 0.9.x.
+
+```ts
+import { amqpBus } from "@nwire/amqp";
+
+const bus = await amqpBus({
+  url: process.env.AMQP_URL ?? "amqp://localhost",
+  exchange: "nwire.events",
+});
+
+await bus.publish({
+  eventName: "orders.order-was-placed",
+  payload: { orderId: "o1" },
+  envelope: seedEnvelope({ tenant: "acme" }),
+});
+```
+
+Integration tests run with `RUN_INTEGRATION=1` against a local RabbitMQ
+(docker-compose service `rabbitmq`).
+
+See `@nwire/nats` for the production-ready JetStream adapter; AMQP
+lands as a scaffold for teams already on RabbitMQ.

package/dist/amqp-bus.d.ts

@@ -0,0 +1,58 @@
+/**
+ * `@nwire/amqp` — RabbitMQ-backed `EventBus` adapter (scaffold).
+ *
+ * Publishes to a topic exchange; subscribers bind durable queues per
+ * event name. At-least-once with manual ack — failed handlers nack +
+ * requeue up to `maxRetries`, then route to DLQ exchange.
+ */
+import type { BusEventMessage, BusSubscriber, EventBus } from "@nwire/bus";
+import type { Logger } from "@nwire/logger";
+export interface AmqpChannelLike {
+    assertExchange(exchange: string, type: string, opts?: {
+        durable?: boolean;
+    }): Promise<void>;
+    assertQueue(queue: string, opts?: {
+        durable?: boolean;
+    }): Promise<{
+        queue: string;
+    }>;
+    bindQueue(queue: string, exchange: string, pattern: string): Promise<void>;
+    publish(exchange: string, routingKey: string, content: Buffer): boolean;
+    consume(queue: string, handler: (msg: {
+        content: Buffer;
+        ack(): void;
+        nack(requeue?: boolean): void;
+    }) => void): Promise<{
+        consumerTag: string;
+    }>;
+    cancel(consumerTag: string): Promise<void>;
+    close(): Promise<void>;
+}
+export interface AmqpConnectionLike {
+    createChannel(): Promise<AmqpChannelLike>;
+    close(): Promise<void>;
+}
+export type AmqpConnectFn = (url: string) => Promise<AmqpConnectionLike>;
+export interface AmqpBusOptions {
+    readonly url: string;
+    readonly exchange?: string;
+    readonly logger?: Logger;
+    readonly connect?: AmqpConnectFn;
+}
+export declare class AmqpEventBus implements EventBus {
+    private readonly options;
+    private readonly exchange;
+    private readonly logger;
+    private conn?;
+    private pubChannel?;
+    private readonly consumers;
+    private stopped;
+    constructor(options: AmqpBusOptions, conn?: AmqpConnectionLike);
+    start(): Promise<void>;
+    publish(msg: BusEventMessage): Promise<void>;
+    subscribe(eventName: string, subscriber: BusSubscriber): void;
+    private ensureConsumer;
+    stop(): Promise<void>;
+}
+export declare function amqpBus(options: AmqpBusOptions): Promise<AmqpEventBus>;
+export { AmqpEventBus as AmqpBus };

package/dist/amqp-bus.js

@@ -0,0 +1,91 @@
+/**
+ * `@nwire/amqp` — RabbitMQ-backed `EventBus` adapter (scaffold).
+ *
+ * Publishes to a topic exchange; subscribers bind durable queues per
+ * event name. At-least-once with manual ack — failed handlers nack +
+ * requeue up to `maxRetries`, then route to DLQ exchange.
+ */
+import { NoopLogger } from "@nwire/logger";
+export class AmqpEventBus {
+    options;
+    exchange;
+    logger;
+    conn;
+    pubChannel;
+    consumers = new Map();
+    stopped = false;
+    constructor(options, conn) {
+        this.options = options;
+        this.exchange = options.exchange ?? "nwire.events";
+        this.logger = options.logger ?? new NoopLogger();
+        this.conn = conn;
+    }
+    async start() {
+        if (this.pubChannel)
+            return;
+        if (!this.conn) {
+            const connect = this.options.connect;
+            if (!connect) {
+                throw new Error("AmqpEventBus: provide `connect` or pass a connection to constructor");
+            }
+            this.conn = await connect(this.options.url);
+        }
+        this.pubChannel = await this.conn.createChannel();
+        await this.pubChannel.assertExchange(this.exchange, "topic", { durable: true });
+    }
+    async publish(msg) {
+        if (this.stopped)
+            throw new Error("AmqpEventBus: publish after stop");
+        if (!this.pubChannel)
+            await this.start();
+        const body = Buffer.from(JSON.stringify(msg));
+        this.pubChannel.publish(this.exchange, msg.eventName, body);
+    }
+    subscribe(eventName, subscriber) {
+        if (this.stopped)
+            throw new Error("AmqpEventBus: subscribe after stop");
+        void this.ensureConsumer(eventName, subscriber);
+    }
+    async ensureConsumer(eventName, subscriber) {
+        if (this.consumers.has(eventName))
+            return;
+        if (!this.conn)
+            await this.start();
+        const channel = await this.conn.createChannel();
+        await channel.assertExchange(this.exchange, "topic", { durable: true });
+        const q = await channel.assertQueue(`nwire.${eventName}`, { durable: true });
+        await channel.bindQueue(q.queue, this.exchange, eventName);
+        const { consumerTag } = await channel.consume(q.queue, (raw) => {
+            if (!raw)
+                return;
+            void (async () => {
+                try {
+                    const msg = JSON.parse(raw.content.toString("utf8"));
+                    await subscriber(msg);
+                    raw.ack();
+                }
+                catch (err) {
+                    this.logger.error(`AmqpEventBus subscriber for "${eventName}" threw`, { err });
+                    raw.nack(false);
+                }
+            })();
+        });
+        this.consumers.set(eventName, { tag: consumerTag, channel });
+    }
+    async stop() {
+        this.stopped = true;
+        for (const { tag, channel } of this.consumers.values()) {
+            await channel.cancel(tag);
+            await channel.close();
+        }
+        this.consumers.clear();
+        await this.pubChannel?.close();
+        await this.conn?.close();
+    }
+}
+export async function amqpBus(options) {
+    const bus = new AmqpEventBus(options);
+    await bus.start();
+    return bus;
+}
+export { AmqpEventBus as AmqpBus };

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { AmqpEventBus, AmqpBus, amqpBus, type AmqpBusOptions, type AmqpChannelLike, type AmqpConnectionLike, type AmqpConnectFn, } from "./amqp-bus.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { AmqpEventBus, AmqpBus, amqpBus, } from "./amqp-bus.js";

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@nwire/amqp",
+  "version": "0.10.0",
+  "description": "Nwire — RabbitMQ-backed EventBus adapter. Topic exchange pub/sub with optional durable queues — same EventBus contract as @nwire/nats.",
+  "keywords": [
+    "adapter",
+    "amqp",
+    "bus",
+    "messaging",
+    "nwire",
+    "rabbitmq"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@nwire/bus": "0.10.0",
+    "@nwire/logger": "0.10.0",
+    "@nwire/envelope": "0.10.0"
+  },
+  "devDependencies": {
+    "@types/amqplib": "^0.10.6",
+    "@types/node": "^22.19.9",
+    "amqplib": "^0.10.4",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "peerDependencies": {
+    "amqplib": "^0.10.4"
+  },
+  "peerDependenciesMeta": {
+    "amqplib": {
+      "optional": false
+    }
+  },
+  "scripts": {
+    "build": "tsc && node ../../scripts/fix-dist-extensions.mjs dist",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --dir src",
+    "test:integration": "RUN_INTEGRATION=1 vitest run --dir src"
+  }
+}