@relaymesh/relaybus-http 0.0.2

package/README.md

@@ -0,0 +1,32 @@
+# relaybus-http (TypeScript)
+
+HTTP publisher and subscriber utilities for Relaybus.
+
+## Install
+
+```
+npm install @relaymesh/relaybus-http
+```
+
+## Example
+
+```ts
+import { HttpPublisher, HttpSubscriber } from "@relaymesh/relaybus-http";
+
+async function main() {
+  const subscriber = new HttpSubscriber({
+    onMessage: (msg) => console.log(msg.topic, msg.payload.toString())
+  });
+  await subscriber.listen({ port: 8088 });
+
+  const publisher = HttpPublisher.connect({
+    endpoint: "http://localhost:8088/{topic}"
+  });
+  await publisher.publish("relaybus.demo", {
+    topic: "relaybus.demo",
+    payload: Buffer.from("hello")
+  });
+}
+
+main().catch(console.error);
+```

package/package.json

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

package/src/index.ts

@@ -0,0 +1,156 @@
+import { decodeEnvelope, encodeEnvelope, DecodedMessage, OutgoingMessage } from "@relaybus/relaybus-core";
+import http from "node:http";
+
+export type HttpRequest = {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  body: Buffer;
+};
+
+export type HttpResponse = {
+  status: number;
+};
+
+export type HttpDoer = (req: HttpRequest) => Promise<HttpResponse> | HttpResponse;
+
+export type HttpPublisherConfig = {
+  endpoint: string;
+  doer: HttpDoer;
+  headers?: Record<string, string>;
+  idempotencyHeader?: string;
+};
+
+export type HttpPublisherConnectConfig = {
+  endpoint: string;
+  headers?: Record<string, string>;
+  idempotencyHeader?: string;
+};
+
+export class HttpPublisher {
+  private readonly endpoint: string;
+  private readonly doer: HttpDoer;
+  private readonly headers: Record<string, string>;
+  private readonly idempotencyHeader: string;
+
+  constructor(config: HttpPublisherConfig) {
+    if (!config.endpoint) {
+      throw new Error("endpoint is required");
+    }
+    if (!config.doer) {
+      throw new Error("doer is required");
+    }
+    this.endpoint = config.endpoint;
+    this.doer = config.doer;
+    this.headers = config.headers ?? {};
+    this.idempotencyHeader = config.idempotencyHeader ?? "Idempotency-Key";
+  }
+
+  static connect(config: HttpPublisherConnectConfig): HttpPublisher {
+    if (!globalThis.fetch) {
+      throw new Error("fetch is not available");
+    }
+    return new HttpPublisher({
+      endpoint: config.endpoint,
+      headers: config.headers,
+      idempotencyHeader: config.idempotencyHeader,
+      doer: async (req) => {
+        const response = await fetch(req.url, {
+          method: req.method,
+          headers: req.headers,
+          body: new Uint8Array(req.body)
+        });
+        return { status: response.status };
+      }
+    });
+  }
+
+  async publish(topic: string, message: OutgoingMessage): Promise<void> {
+    const resolved = resolveTopic(topic, message.topic);
+    const payload = encodeEnvelope({ ...message, topic: resolved });
+
+    const req: HttpRequest = {
+      url: buildEndpoint(this.endpoint, resolved),
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers
+      },
+      body: payload
+    };
+
+    if (message.id) {
+      req.headers[this.idempotencyHeader] = message.id;
+    }
+
+    const response = await Promise.resolve(this.doer(req));
+    if (response.status < 200 || response.status >= 300) {
+      throw new Error(`http status ${response.status}`);
+    }
+  }
+}
+
+export type HttpSubscriberConfig = {
+  onMessage: (msg: DecodedMessage) => void | Promise<void>;
+};
+
+export type HttpSubscriberListenConfig = {
+  port: number;
+  host?: string;
+};
+
+export class HttpSubscriber {
+  private readonly onMessage: (msg: DecodedMessage) => void | Promise<void>;
+
+  constructor(config: HttpSubscriberConfig) {
+    this.onMessage = config.onMessage;
+  }
+
+  async handle(body: Buffer | string): Promise<void> {
+    const decoded = decodeEnvelope(body);
+    await this.onMessage(decoded);
+  }
+
+  async listen(config: HttpSubscriberListenConfig): Promise<http.Server> {
+    const server = http.createServer((req, res) => {
+      const chunks: Buffer[] = [];
+      req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+      req.on("end", async () => {
+        try {
+          await this.handle(Buffer.concat(chunks));
+          res.statusCode = 204;
+        } catch {
+          res.statusCode = 400;
+        }
+        res.end();
+      });
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(config.port, config.host, () => resolve());
+    });
+    return server;
+  }
+}
+
+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 buildEndpoint(endpoint: string, topic: string): string {
+  if (endpoint.includes("{topic}")) {
+    return endpoint.split("{topic}").join(encodeURIComponent(topic));
+  }
+  if (!topic) {
+    return endpoint;
+  }
+  return endpoint.replace(/\/$/, "") + "/" + encodeURIComponent(topic);
+}

package/test/http.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import { HttpPublisher, HttpSubscriber } from "../src/index";
+import { decodeEnvelope } from "@relaybus/relaybus-core";
+
+describe("HttpPublisher", () => {
+  it("posts encoded envelope", async () => {
+    const calls: any[] = [];
+    const publisher = new HttpPublisher({
+      endpoint: "https://example.test/{topic}",
+      doer: async (req) => {
+        calls.push(req);
+        return { status: 204 };
+      }
+    });
+
+    await publisher.publish("alpha", {
+      id: "id-1",
+      topic: "alpha",
+      payload: Buffer.from("hi")
+    });
+
+    expect(calls).toHaveLength(1);
+    const call = calls[0];
+    expect(call.url).toBe("https://example.test/alpha");
+    expect(call.headers["Content-Type"]).toBe("application/json");
+    expect(call.headers["Idempotency-Key"]).toBe("id-1");
+    const decoded = decodeEnvelope(call.body);
+    expect(decoded.id).toBe("id-1");
+  });
+
+  it("rejects non-2xx", async () => {
+    const publisher = new HttpPublisher({
+      endpoint: "https://example.test/{topic}",
+      doer: async () => ({ status: 500 })
+    });
+
+    await expect(
+      publisher.publish("alpha", { topic: "alpha", payload: Buffer.from("hi") })
+    ).rejects.toThrow(/http status 500/);
+  });
+});
+
+describe("HttpSubscriber", () => {
+  it("decodes and forwards", async () => {
+    let seen = "";
+    const subscriber = new HttpSubscriber({
+      onMessage: (msg) => {
+        seen = msg.id;
+      }
+    });
+
+    await subscriber.handle(
+      Buffer.from(
+        JSON.stringify({
+          v: "v1",
+          id: "id",
+          topic: "alpha",
+          ts: "2024-01-01T00:00:00Z",
+          content_type: "text/plain",
+          payload_b64: "aGVsbG8=",
+          meta: {}
+        })
+      )
+    );
+
+    expect(seen).toBe("id");
+  });
+
+  it("rejects invalid json", async () => {
+    const subscriber = new HttpSubscriber({
+      onMessage: () => {}
+    });
+    await expect(subscriber.handle("{")).rejects.toThrow(/invalid json/);
+  });
+});

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"]
+}