@relaymesh/relaybus-amqp 0.0.2

package/README.md

@@ -0,0 +1,35 @@
+# relaybus-amqp (TypeScript)
+
+AMQP publisher and subscriber utilities for Relaybus.
+
+## Install
+
+```
+npm install @relaymesh/relaybus-amqp
+```
+
+## Example
+
+```ts
+import { AmqpPublisher, AmqpSubscriber } from "@relaymesh/relaybus-amqp";
+
+async function main() {
+  const publisher = await AmqpPublisher.connect({
+    url: "amqp://guest:guest@localhost:5672/"
+  });
+  await publisher.publish("relaybus.demo", {
+    topic: "relaybus.demo",
+    payload: Buffer.from("hello")
+  });
+  await publisher.close();
+
+  const subscriber = await AmqpSubscriber.connect({
+    url: "amqp://guest:guest@localhost:5672/",
+    onMessage: (msg) => console.log(msg.topic, msg.payload.toString())
+  });
+  await subscriber.start("relaybus.demo");
+  await subscriber.close();
+}
+
+main().catch(console.error);
+```

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@relaymesh/relaybus-amqp",
+  "version": "0.0.2",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@types/amqplib": "^0.10.5"
+  },
+  "dependencies": {
+    "@relaymesh/relaybus-core": "workspace:*",
+    "amqplib": "^0.10.9"
+  }
+}

package/src/index.ts

@@ -0,0 +1,195 @@
+import { decodeEnvelope, encodeEnvelope, DecodedMessage, OutgoingMessage } from "@relaybus/relaybus-core";
+import { connect, Channel, ChannelModel, ConsumeMessage, ConfirmChannel } from "amqplib";
+
+export type Delivery = {
+  content: Buffer | string;
+};
+
+export type PublishOptions = {
+  contentType?: string;
+  messageId?: string;
+  timestamp?: number;
+  headers?: Record<string, string>;
+};
+
+export type AmqpChannel = {
+  publish: (
+    exchange: string,
+    routingKey: string,
+    content: Buffer,
+    options?: PublishOptions
+  ) => Promise<void> | void;
+};
+
+export type AmqpSubscriberConfig = {
+  onMessage: (msg: DecodedMessage) => void | Promise<void>;
+};
+
+export type AmqpPublisherConfig = {
+  channel: AmqpChannel;
+  exchange?: string;
+  routingKeyTemplate?: string;
+};
+
+export type AmqpPublisherConnectConfig = {
+  url: string;
+  exchange?: string;
+  routingKeyTemplate?: string;
+};
+
+export type AmqpSubscriberConnectConfig = {
+  url: string;
+  onMessage: (msg: DecodedMessage) => void | Promise<void>;
+  exchange?: string;
+  routingKeyTemplate?: string;
+  queue?: string;
+};
+
+export class AmqpSubscriber {
+  private readonly onMessage: (msg: DecodedMessage) => void | Promise<void>;
+  private channel?: Channel;
+  private connection?: ChannelModel;
+  private exchange?: string;
+  private routingKeyTemplate?: string;
+  private queue?: string;
+
+  constructor(config: AmqpSubscriberConfig) {
+    this.onMessage = config.onMessage;
+  }
+
+  static async connect(config: AmqpSubscriberConnectConfig): Promise<AmqpSubscriber> {
+    const connection = await connect(config.url);
+    const channel = await connection.createChannel();
+    const subscriber = new AmqpSubscriber({ onMessage: config.onMessage });
+    subscriber.channel = channel;
+    subscriber.connection = connection;
+    subscriber.exchange = config.exchange ?? "";
+    subscriber.routingKeyTemplate = config.routingKeyTemplate ?? "{topic}";
+    subscriber.queue = config.queue;
+    return subscriber;
+  }
+
+  async handleDelivery(delivery: Delivery): Promise<void> {
+    const decoded = decodeEnvelope(delivery.content);
+    await this.onMessage(decoded);
+  }
+
+  async start(topic: string): Promise<void> {
+    if (!this.channel) {
+      throw new Error("channel is not initialized");
+    }
+    const queueName = this.queue ?? topic;
+    await this.channel.assertQueue(queueName, { durable: false, autoDelete: true });
+    if (this.exchange) {
+      const key = buildRoutingKey(this.routingKeyTemplate ?? "{topic}", topic);
+      await this.channel.bindQueue(queueName, this.exchange, key);
+    }
+
+    await new Promise<void>((resolve, reject) => {
+      this.channel!.consume(queueName, async (msg: ConsumeMessage | null) => {
+        if (!msg) {
+          return;
+        }
+        try {
+          await this.handleDelivery({ content: msg.content });
+          this.channel!.ack(msg);
+          resolve();
+        } catch (err) {
+          this.channel!.nack(msg, false, true);
+          reject(err);
+        }
+      });
+    });
+  }
+
+  async close(): Promise<void> {
+    if (this.channel) {
+      await this.channel.close();
+    }
+    if (this.connection) {
+      await this.connection.close();
+    }
+  }
+}
+
+export class AmqpPublisher {
+  private readonly channel: AmqpChannel;
+  private readonly exchange: string;
+  private readonly routingKeyTemplate: string;
+  private connection?: ChannelModel;
+  private confirmChannel?: ConfirmChannel;
+
+  constructor(config: AmqpPublisherConfig) {
+    this.channel = config.channel;
+    this.exchange = config.exchange ?? "";
+    this.routingKeyTemplate = config.routingKeyTemplate ?? "{topic}";
+  }
+
+  static async connect(config: AmqpPublisherConnectConfig): Promise<AmqpPublisher> {
+    const connection = await connect(config.url);
+    const channel = await connection.createConfirmChannel();
+    const publisher = new AmqpPublisher({
+      channel: {
+        publish: (exchange, routingKey, content, options) => {
+          return new Promise<void>((resolve, reject) => {
+            channel.publish(exchange, routingKey, content, options, (err) => {
+              if (err) {
+                reject(err);
+                return;
+              }
+              resolve();
+            });
+          });
+        }
+      },
+      exchange: config.exchange,
+      routingKeyTemplate: config.routingKeyTemplate
+    });
+    publisher.connection = connection;
+    publisher.confirmChannel = channel;
+    return publisher;
+  }
+
+  async publish(topic: string, message: OutgoingMessage): Promise<void> {
+    const resolved = resolveTopic(topic, message.topic);
+    const payload = encodeEnvelope({ ...message, topic: resolved });
+    const routingKey = buildRoutingKey(this.routingKeyTemplate, resolved);
+    const options: PublishOptions = {
+      contentType: "application/json",
+      messageId: message.id,
+      timestamp: message.ts ? Math.floor(message.ts.getTime() / 1000) : undefined,
+      headers: message.meta ?? undefined
+    };
+    await this.channel.publish(this.exchange, routingKey, payload, options);
+  }
+
+  async close(): Promise<void> {
+    if (this.confirmChannel) {
+      await this.confirmChannel.close();
+    }
+    if (this.connection) {
+      await this.connection.close();
+    }
+  }
+}
+
+function resolveTopic(argumentTopic: string, messageTopic?: string): string {
+  const topic = messageTopic && messageTopic.length > 0 ? messageTopic : argumentTopic;
+  if (!topic) {
+    throw new Error("topic is required");
+  }
+  if (argumentTopic && messageTopic && argumentTopic !== messageTopic) {
+    throw new Error(`topic mismatch: ${messageTopic} vs ${argumentTopic}`);
+  }
+  return topic;
+}
+
+function buildRoutingKey(template: string, topic: string): string {
+  if (!template) {
+    return topic;
+  }
+  if (template.includes("{topic}")) {
+    return template.split("{topic}").join(topic);
+  }
+  return template;
+}

package/test/publisher.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import { AmqpPublisher } from "../src/index";
+import { decodeEnvelope } from "@relaybus/relaybus-core";
+
+type PublishCall = {
+  exchange: string;
+  routingKey: string;
+  content: Buffer;
+  options?: any;
+};
+
+describe("AmqpPublisher", () => {
+  it("publishes encoded envelope with routing key", async () => {
+    const calls: PublishCall[] = [];
+    const channel = {
+      publish: async (exchange: string, routingKey: string, content: Buffer, options?: any) => {
+        calls.push({ exchange, routingKey, content, options });
+      }
+    };
+
+    const publisher = new AmqpPublisher({
+      channel,
+      exchange: "ex",
+      routingKeyTemplate: "events.{topic}"
+    });
+
+    await publisher.publish("alpha", {
+      id: "id-1",
+      topic: "alpha",
+      payload: Buffer.from("hi"),
+      meta: { source: "unit" }
+    });
+
+    expect(calls).toHaveLength(1);
+    const call = calls[0];
+    expect(call.exchange).toBe("ex");
+    expect(call.routingKey).toBe("events.alpha");
+    const decoded = decodeEnvelope(call.content);
+    expect(decoded.id).toBe("id-1");
+    expect(decoded.topic).toBe("alpha");
+    expect(decoded.payload.toString()).toBe("hi");
+  });
+
+  it("rejects topic mismatch", async () => {
+    const channel = {
+      publish: async () => {}
+    };
+    const publisher = new AmqpPublisher({ channel });
+    await expect(
+      publisher.publish("alpha", { topic: "beta", payload: Buffer.from("hi") })
+    ).rejects.toThrow(/topic mismatch/);
+  });
+});

package/test/subscriber.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { AmqpSubscriber } from "../src/index";
+
+const rootDir = path.resolve(__dirname, "../../../..", "spec", "corpus");
+const samplePath = path.join(rootDir, "samples", "sample1.json");
+const expectedPath = path.join(rootDir, "expected", "sample1.json");
+
+type Expected = {
+  v: "v1";
+  id: string;
+  topic: string;
+  ts: string;
+  content_type: string;
+  meta: Record<string, string>;
+  payload_bytes_b64: string;
+};
+
+describe("AmqpSubscriber", () => {
+  it("invokes handler with decoded message", async () => {
+    const sample = readFileSync(samplePath, "utf8");
+    const expected = JSON.parse(readFileSync(expectedPath, "utf8")) as Expected;
+
+    let received: any = null;
+    const subscriber = new AmqpSubscriber({
+      onMessage: (msg) => {
+        received = msg;
+      }
+    });
+
+    await subscriber.handleDelivery({ content: Buffer.from(sample) });
+
+    expect(received).not.toBeNull();
+    expect(received.id).toBe(expected.id);
+    expect(received.topic).toBe(expected.topic);
+    const expectedDate = new Date(expected.ts);
+    expect(received.ts.toISOString()).toBe(expectedDate.toISOString());
+    expect(received.contentType).toBe(expected.content_type);
+    expect(received.meta).toEqual(expected.meta);
+    expect(received.payload.toString("base64")).toBe(expected.payload_bytes_b64);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,
+    "types": ["node"],
+    "baseUrl": ".",
+    "paths": {
+      "@relaybus/relaybus-core": ["../../core/typescript/dist"]
+    }
+  },
+  "include": ["src/**/*.ts"]
+}