Add transport-neutral routing and stream contracts

tests/helpers/test-connection.ts

@@ -0,0 +1,45 @@
+import {
+  BaseStream,
+  type StreamMessage,
+} from "../../src/services/stream/base-stream.js";
+
+/** Minimal observable connection used by application and broadcaster tests. */
+export class TestConnection extends BaseStream {
+  readonly messages: StreamMessage[] = [];
+  readonly closeCallbacks: Array<() => void> = [];
+  closed = false;
+
+  constructor(
+    readonly streaming: boolean,
+    readonly bidirectional: boolean,
+  ) {
+    super();
+  }
+
+  async send(message: StreamMessage): Promise<void> {
+    if (this.closed) {
+      throw new Error("connection is closed");
+    }
+
+    this.messages.push(message);
+  }
+
+  close(): void {
+    if (this.closed) {
+      return;
+    }
+
+    this.closed = true;
+    const callbacks = this.closeCallbacks.splice(0);
+    callbacks.forEach((callback) => callback());
+  }
+
+  onClose(callback: () => void): void {
+    if (this.closed) {
+      callback();
+      return;
+    }
+
+    this.closeCallbacks.push(callback);
+  }
+}

tests/services/router.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vitest";
+
+import type { RouteDefinition, RouteModule } from "../../src/routes/types.js";
+import { ApplicationError } from "../../src/errors/index.js";
+import { ApplicationRouter } from "../../src/services/router.js";
+import { TestConnection } from "../helpers/test-connection.js";
+
+function moduleWith(routes: RouteDefinition[]): RouteModule {
+  return {
+    async getRoutes() {
+      return routes;
+    },
+  };
+}
+
+describe("ApplicationRouter initialization", () => {
+  it("rejects duplicate exact paths during startup", async () => {
+    const route = { url: "/echo", handler: () => undefined };
+
+    await expect(
+      ApplicationRouter.create([moduleWith([route]), moduleWith([route])]),
+    ).rejects.toThrow("Duplicate application route: /echo");
+  });
+
+  it.each(["echo", "/", "/items/:id", "/items?active=true", "/items#active"])(
+    "rejects the invalid route path %s",
+    async (url) => {
+      await expect(
+        ApplicationRouter.create([
+          moduleWith([{ url, handler: () => undefined }]),
+        ]),
+      ).rejects.toThrow("Invalid application route");
+    },
+  );
+});
+
+describe("ApplicationRouter dispatch", () => {
+  it("binds the connection, body, and request ID to one route stream", async () => {
+    const connection = new TestConnection(false, false);
+    const router = await ApplicationRouter.create([
+      moduleWith([
+        {
+          url: "/echo",
+          handler: async (stream) => {
+            expect(stream.connection).toBe(connection);
+            await stream.send(stream.body);
+          },
+        },
+      ]),
+    ]);
+
+    await router.dispatch(
+      { path: "/echo", body: { value: 1 }, requestId: "request-1" },
+      connection,
+    );
+
+    expect(connection.messages).toEqual([
+      {
+        id: "request-1",
+        type: "response",
+        statusCode: 200,
+        body: { value: 1 },
+      },
+    ]);
+
+    await expect(
+      router.dispatch({ path: "/echo/other", body: {} }, connection),
+    ).rejects.toMatchObject({ statusCode: 404 });
+  });
+
+  it("preserves correlation when concurrent requests finish out of order", async () => {
+    const completions = new Map<string, () => void>();
+    const router = await ApplicationRouter.create([
+      moduleWith([
+        {
+          url: "/delayed",
+          handler: async (stream) => {
+            const key = (stream.body as { key: string }).key;
+            await new Promise<void>((resolve) => completions.set(key, resolve));
+            await stream.send({ key });
+          },
+        },
+      ]),
+    ]);
+    const connection = new TestConnection(true, true);
+
+    const first = router.dispatch(
+      { path: "/delayed", body: { key: "A" }, requestId: "A" },
+      connection,
+    );
+    const second = router.dispatch(
+      { path: "/delayed", body: { key: "B" }, requestId: "B" },
+      connection,
+    );
+
+    completions.get("B")?.();
+    await second;
+    completions.get("A")?.();
+    await first;
+
+    expect(connection.messages).toEqual([
+      {
+        id: "B",
+        type: "response",
+        statusCode: 200,
+        body: { key: "B" },
+      },
+      {
+        id: "A",
+        type: "response",
+        statusCode: 200,
+        body: { key: "A" },
+      },
+    ]);
+  });
+
+  it("propagates route failures without infrastructure-specific cleanup", async () => {
+    const error = new Error("route failed");
+    const router = await ApplicationRouter.create([
+      moduleWith([
+        {
+          url: "/failure",
+          handler: () => {
+            throw error;
+          },
+        },
+      ]),
+    ]);
+
+    await expect(
+      router.dispatch({ path: "/failure" }, new TestConnection(false, false)),
+    ).rejects.toBe(error);
+  });
+});