Merge branch '5-add-http-and-sse' into 6-add-websocket-transport

source/index.ts

@@ -39,6 +39,7 @@ export class App {
         // Both transports share one ApplicationRouter. Routes use the shared
         // Broadcaster directly, while HTTP and WebSocket remain protocol adapters.
         const http = new HttpTransportRouter(router, debug);
+
         const ws = new WsTransportRouter(router, debug, config.server.maxRequestBodyBytes);
         const host = new ServerHost(config, debug, [http, ws]);
 
@@ -53,6 +54,7 @@ export class App {
     ) {}
 
     async start(): Promise<void> {
+        await this.database.start();
         await this.host.start();
     }
 

source/routes/types.ts

@@ -1,6 +1,7 @@
 import type { BaseStream } from '../services/stream/base-stream.js';
 
 export type RouteSendOptions = {
+
     /** Defaults to `response`; any other value sends an application event. */
     type?: string;
 
@@ -15,6 +16,7 @@ export type RouteSendOptions = {
  * connection lifetime are shared with other requests on the same connection.
  */
 export interface RouteStream {
+
     /** Connection shared by every request on the same transport session. */
     readonly connection: BaseStream;
 
@@ -29,6 +31,7 @@ export type RouteHandler = (stream: RouteStream) => void | Promise<void>;
 
 /** An exact application route with no transport-specific metadata. */
 export type RouteDefinition = {
+
     /** Exact route name. Parameter and wildcard syntax are not supported. */
     url: string;
     handler: RouteHandler;

source/services/broadcaster.ts

@@ -6,6 +6,7 @@ import { ApplicationError } from '../errors/index.ts';
 
 /** Request-scoped view from which the broadcaster obtains a stable connection. */
 export interface BroadcastStream {
+
     /** Connection identity shared by every request on the same transport session. */
     readonly connection: BaseStream;
 
@@ -15,6 +16,7 @@ export interface BroadcastStream {
 
 /** One pending subscribe call and the topics whose removal will resolve it. */
 interface SubscriptionWaiter {
+
     /** Only topics newly introduced by this particular subscribe call. */
     readonly remainingTopics: Set<string>;
 

source/services/router.ts

@@ -5,6 +5,7 @@ import type { BaseStream } from './stream/base-stream.ts';
 
 /** Canonical request produced by every transport adapter. */
 export type ApplicationRequest = {
+
     /** Exact application route name. */
     path: string;
 

source/services/storage/database.ts

@@ -6,6 +6,7 @@ import type { Logger } from '../../utils/logger.ts';
 
 /** Options required to open a SQLite database connection. */
 export type DatabaseOptions = {
+
     /** Filesystem path to the SQLite database file. */
     path: string;
 
@@ -39,9 +40,6 @@ export class Database {
         this.kysely = new Kysely<DatabaseTables>({
             dialect: this.dialect,
         });
-
-        // Configure the SQLite pragmas.
-        this.configurePragmas();
     }
 
     /**
@@ -53,6 +51,13 @@ export class Database {
         return this.kysely;
     }
 
+    async start(): Promise<void> {
+        this.debug('starting database connection');
+
+        // Configure the SQLite pragmas.
+        await this.configurePragmas();
+    }
+
     /**
      * Destroys the database connection.
      */
@@ -66,10 +71,10 @@ export class Database {
      *
      * WAL improves write concurrency; foreign keys enforce referential integrity.
      */
-    private configurePragmas(): void {
+    private async configurePragmas(): Promise<void> {
         this.debug('configuring SQLite pragmas');
 
-        this.kysely.executeQuery(CompiledQuery.raw('PRAGMA journal_mode = WAL'));
+        await this.kysely.executeQuery(CompiledQuery.raw('PRAGMA journal_mode = WAL'));
-        this.kysely.executeQuery(CompiledQuery.raw('PRAGMA foreign_keys = ON'));
+        await this.kysely.executeQuery(CompiledQuery.raw('PRAGMA foreign_keys = ON'));
     }
 }

source/services/storage/migrations/001-resources.ts

@@ -33,5 +33,6 @@ export const up = async (db: Kysely<DatabaseTables>): Promise<void> => {
  * @param db - Kysely database to apply the rollback against.
  */
 export const down = async (db: Kysely<DatabaseTables>): Promise<void> => {
-    await db.schema.dropTable('resource_data').ifExists().execute();
+    await db.schema.dropTable('resource_data').ifExists()
+.execute();
 };

source/services/storage/tables.ts

@@ -10,6 +10,7 @@ export type BlobColumn = ColumnType<Buffer, Buffer | Uint8Array, Buffer>;
  * One row per (resource_id, public_key). Each publicKey owns a slot within a shared resource.
  */
 export interface ResourceDataTable {
+
     /** Shared resource identifier grouping related instances. */
     resource_id: string;
 

source/services/stream/base-stream.ts

@@ -1,5 +1,6 @@
 /** A normal request/response result before transport encoding. */
 export type StreamResponse = {
+
     /** Optional correlation ID for multiplexed transports. */
     id?: string;
 
@@ -15,6 +16,7 @@ export type StreamResponse = {
 
 /** An application event before a transport applies its wire encoding. */
 export type StreamEvent = {
+
     /** Optional event or correlation ID. */
     id?: string;
 

source/services/transport/transport-router.ts

@@ -4,6 +4,7 @@ import type { Hono } from 'hono';
 /** Hono variables populated by transport-boundary middleware. */
 export type AppEnv = {
     Variables: {
+
         /** Decoded Extended JSON request body, when present. */
         parsedBody?: unknown;
 
@@ -19,6 +20,7 @@ export type AppEnv = {
  * not application routing. Implementations remain unaware of route modules.
  */
 export interface TransportRouter {
+
     /**
      * Attach wire endpoints and middleware to the shared Hono application.
      *
@@ -32,6 +34,7 @@ export interface TransportRouter {
 
 /** A transport which also supplies the WebSocket server used during upgrade. */
 export interface UpgradeTransportRouter extends TransportRouter {
+
     /** WebSocket server instance passed to the Node HTTP listener. */
     readonly websocketServer: WebSocketServerLike;
 }

test/helpers/test-connection.ts

@@ -1,7 +1,4 @@
-import {
+import { BaseStream, type StreamMessage } from '../../source/services/stream/base-stream.ts';
-  BaseStream,
-  type StreamMessage,
-} from "../../source/services/stream/base-stream.js";
 
 /** Minimal observable connection used by application and broadcaster tests. */
 export class TestConnection extends BaseStream {
@@ -18,7 +15,7 @@ export class TestConnection extends BaseStream {
 
     async send(message: StreamMessage): Promise<void> {
         if (this.closed) {
-      throw new Error("connection is closed");
+            throw new Error('connection is closed');
         }
 
         this.messages.push(message);
@@ -37,6 +34,7 @@ export class TestConnection extends BaseStream {
     onClose(callback: () => void): void {
         if (this.closed) {
             callback();
+
             return;
         }
 

test/services/broadcaster.test.ts

@@ -1,133 +1,119 @@
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi } from 'vitest';
 
-import { ApplicationError } from "../../source/errors/index.js";
+import { Broadcaster } from '../../source/services/broadcaster.ts';
-import { Broadcaster } from "../../source/services/broadcaster.js";
+import { ApplicationRouteStream } from '../../source/services/route-stream.ts';
-import { ApplicationRouteStream } from "../../source/services/route-stream.js";
+import { Logger } from '../../source/utils/logger.ts';
-import { Logger } from "../../source/utils/logger.js";
+import { TestConnection } from '../helpers/test-connection.ts';
-import { TestConnection } from "../helpers/test-connection.js";
 
-function createBroadcaster(): Broadcaster {
+const createBroadcaster = (): Broadcaster => {
-  return new Broadcaster(new Logger("broadcaster-test"));
+    return new Broadcaster(new Logger('broadcaster-test'));
-}
+};
 
-function routeStream(connection: TestConnection): ApplicationRouteStream {
+const routeStream = (connection: TestConnection): ApplicationRouteStream => {
     return new ApplicationRouteStream(connection, undefined);
-}
+};
 
-async function expectPending(promise: Promise<void>): Promise<void> {
+const expectPending = async (promise: Promise<void>): Promise<void> => {
     const settled = vi.fn();
     void promise.then(settled);
     await Promise.resolve();
     expect(settled).not.toHaveBeenCalled();
-}
+};
 
-describe("Broadcaster subscriptions", () => {
+describe('Broadcaster subscriptions', () => {
-  it("delivers events and resolves after a later request removes the topic", async () => {
+    it('delivers events and resolves after a later request removes the topic', async (): Promise<void> => {
         const broadcaster = createBroadcaster();
         const connection = new TestConnection(true, true);
-    const subscribed = broadcaster.subscribe(routeStream(connection), [
+        const subscribed = broadcaster.subscribe(routeStream(connection), [ 'items' ]);
-      "items",
-    ]);
 
         await expectPending(subscribed);
-    await broadcaster.publish("items", {
+        await broadcaster.publish('items', {
-      type: "item-changed",
+            type: 'item-changed',
-      data: { id: "a" },
+            data: { id: 'a' },
         });
 
         expect(connection.messages).toEqual([
             expect.objectContaining({
-        type: "item-changed",
+                type: 'item-changed',
-        data: { id: "a" },
+                data: { id: 'a' },
             }),
         ]);
 
         // A different request-scoped facade still resolves the connection's
         // original subscription.
-    await broadcaster.unsubscribe(routeStream(connection), ["items"]);
+        await broadcaster.unsubscribe(routeStream(connection), [ 'items' ]);
         await expect(subscribed).resolves.toBeUndefined();
     });
 
-  it("resolves fully duplicate subscriptions immediately", async () => {
+    it('resolves fully duplicate subscriptions immediately', async (): Promise<void> => {
         const broadcaster = createBroadcaster();
         const connection = new TestConnection(true, true);
-    const first = broadcaster.subscribe(routeStream(connection), [
+        const first = broadcaster.subscribe(routeStream(connection), [ 'items', 'items' ]);
-      "items",
+        const duplicate = broadcaster.subscribe(routeStream(connection), [ 'items' ]);
-      "items",
-    ]);
-    const duplicate = broadcaster.subscribe(routeStream(connection), ["items"]);
 
         await expect(duplicate).resolves.toBeUndefined();
         await expectPending(first);
         expect(connection.closeCallbacks).toHaveLength(1);
 
-    await broadcaster.unsubscribe(routeStream(connection), ["items"]);
+        await broadcaster.unsubscribe(routeStream(connection), [ 'items' ]);
         await first;
     });
 
-  it("waits only for topics newly added by a partially overlapping call", async () => {
+    it('waits only for topics newly added by a partially overlapping call', async (): Promise<void> => {
         const broadcaster = createBroadcaster();
         const connection = new TestConnection(true, true);
-    const first = broadcaster.subscribe(routeStream(connection), ["a"]);
+        const first = broadcaster.subscribe(routeStream(connection), [ 'a' ]);
-    const second = broadcaster.subscribe(routeStream(connection), ["a", "b"]);
+        const second = broadcaster.subscribe(routeStream(connection), [ 'a', 'b' ]);
 
-    await broadcaster.unsubscribe(routeStream(connection), ["a"]);
+        await broadcaster.unsubscribe(routeStream(connection), [ 'a' ]);
         await expect(first).resolves.toBeUndefined();
         await expectPending(second);
 
-    await broadcaster.unsubscribe(routeStream(connection), ["b"]);
+        await broadcaster.unsubscribe(routeStream(connection), [ 'b' ]);
         await expect(second).resolves.toBeUndefined();
     });
 
-  it("resolves every pending subscription and removes topics on close", async () => {
+    it('resolves every pending subscription and removes topics on close', async (): Promise<void> => {
         const broadcaster = createBroadcaster();
         const connection = new TestConnection(true, false);
-    const first = broadcaster.subscribe(routeStream(connection), ["a"]);
+        const first = broadcaster.subscribe(routeStream(connection), [ 'a' ]);
-    const second = broadcaster.subscribe(routeStream(connection), ["b"]);
+        const second = broadcaster.subscribe(routeStream(connection), [ 'b' ]);
 
         connection.close();
         await Promise.all([ first, second ]);
-    await broadcaster.publish("a", { type: "changed", data: null });
+        await broadcaster.publish('a', { type: 'changed', data: null });
-    await broadcaster.publish("b", { type: "changed", data: null });
+        await broadcaster.publish('b', { type: 'changed', data: null });
 
         expect(connection.messages).toEqual([]);
     });
 
-  it("immediately resolves registration against an already-closed connection", async () => {
+    it('immediately resolves registration against an already-closed connection', async (): Promise<void> => {
         const broadcaster = createBroadcaster();
         const connection = new TestConnection(true, false);
         connection.close();
 
-    await expect(
+        await expect(broadcaster.subscribe(routeStream(connection), [ 'items' ])).resolves.toBeUndefined();
-      broadcaster.subscribe(routeStream(connection), ["items"]),
-    ).resolves.toBeUndefined();
     });
 
-  it("rejects subscriptions on a non-streaming connection", () => {
+    it('rejects subscriptions on a non-streaming connection', (): void => {
         const broadcaster = createBroadcaster();
         const connection = new TestConnection(false, false);
 
-    expect(() =>
+        expect(() => broadcaster.subscribe(routeStream(connection), [ 'items' ])).toThrowError(expect.objectContaining({ statusCode: 406 }));
-      broadcaster.subscribe(routeStream(connection), ["items"]),
-    ).toThrowError(
-      expect.objectContaining({ statusCode: 406 }),
-    );
     });
 
-  it("treats an empty subscription and repeated unsubscribe as no-ops", async () => {
+    it('treats an empty subscription and repeated unsubscribe as no-ops', async (): Promise<void> => {
         const broadcaster = createBroadcaster();
         const connection = new TestConnection(true, true);
 
-    await expect(
+        await expect(broadcaster.subscribe(routeStream(connection), [])).resolves.toBeUndefined();
-      broadcaster.subscribe(routeStream(connection), []),
+        await broadcaster.unsubscribe(routeStream(connection), [ 'missing' ]);
-    ).resolves.toBeUndefined();
-    await broadcaster.unsubscribe(routeStream(connection), ["missing"]);
         await broadcaster.unsubscribe(routeStream(connection));
 
         expect(connection.closeCallbacks).toHaveLength(0);
     });
 
-  it("fans out concurrently to independent connections", async () => {
+    it('fans out concurrently to independent connections', async (): Promise<void> => {
         const broadcaster = createBroadcaster();
         const first = new TestConnection(true, false);
         const second = new TestConnection(true, false);
@@ -141,23 +127,20 @@ describe("Broadcaster subscriptions", () => {
             markSecondSent = resolve;
         });
 
-    first.send = async (message) => {
+        first.send = async (message): Promise<void> => {
             await firstReleased;
             await originalFirstSend(message);
         };
-    second.send = async (message) => {
+
+        second.send = async (message): Promise<void> => {
             await TestConnection.prototype.send.call(second, message);
             markSecondSent();
         };
 
-    const firstSubscription = broadcaster.subscribe(routeStream(first), [
+        const firstSubscription = broadcaster.subscribe(routeStream(first), [ 'items' ]);
-      "items",
+        const secondSubscription = broadcaster.subscribe(routeStream(second), [ 'items' ]);
-    ]);
+        const publication = broadcaster.publish('items', {
-    const secondSubscription = broadcaster.subscribe(routeStream(second), [
+            type: 'item-changed',
-      "items",
-    ]);
-    const publication = broadcaster.publish("items", {
-      type: "item-changed",
             data: {},
         });
 
@@ -173,16 +156,14 @@ describe("Broadcaster subscriptions", () => {
         await Promise.all([ firstSubscription, secondSubscription ]);
     });
 
-  it("closes and removes a connection whose event delivery fails", async () => {
+    it('closes and removes a connection whose event delivery fails', async (): Promise<void> => {
         const broadcaster = createBroadcaster();
         const connection = new TestConnection(true, true);
-    connection.send = vi.fn().mockRejectedValue(new Error("socket failed"));
+        connection.send = vi.fn().mockRejectedValue(new Error('socket failed'));
-    const subscribed = broadcaster.subscribe(routeStream(connection), [
+        const subscribed = broadcaster.subscribe(routeStream(connection), [ 'items' ]);
-      "items",
-    ]);
 
-    await broadcaster.publish("items", {
+        await broadcaster.publish('items', {
-      type: "item-changed",
+            type: 'item-changed',
             data: {},
         });
         await subscribed;
@@ -190,8 +171,8 @@ describe("Broadcaster subscriptions", () => {
         expect(connection.closed).toBe(true);
         expect(connection.send).toHaveBeenCalledOnce();
 
-    await broadcaster.publish("items", {
+        await broadcaster.publish('items', {
-      type: "item-changed",
+            type: 'item-changed',
             data: {},
         });
         expect(connection.send).toHaveBeenCalledOnce();

test/services/router.test.ts

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

test/services/transports/http-transport.test.ts

@@ -1,27 +1,26 @@
-import { Hono } from "hono";
+import { Hono } from 'hono';
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi } from 'vitest';
 
-import type { RouteDefinition } from "../../../source/routes/types.js";
+import type { RouteDefinition } from '../../../source/routes/types.ts';
-import { ApplicationError } from "../../../source/errors/index.js";
+import { ApplicationError } from '../../../source/errors/index.ts';
-import { ApplicationRouter } from "../../../source/services/router.js";
+import { ApplicationRouter } from '../../../source/services/router.ts';
-import { Broadcaster } from "../../../source/services/broadcaster.js";
+import { Broadcaster } from '../../../source/services/broadcaster.ts';
-import { HttpTransportRouter } from "../../../source/services/transport/http-transport.js";
+import { HttpTransportRouter } from '../../../source/services/transport/http-transport.ts';
-import type { AppEnv } from "../../../source/services/transport/transport-router.js";
+import type { AppEnv } from '../../../source/services/transport/transport-router.ts';
-import { fromExtendedJson, toExtendedJson } from "@xo-cash/utils";
+import { fromExtendedJson, toExtendedJson } from '@xo-cash/utils';
-import { Logger } from "../../../source/utils/logger.js";
+import { Logger } from '../../../source/utils/logger.ts';
-import { ServerHost } from "../../../source/services/server-host.js";
+import { ServerHost } from '../../../source/services/server-host.ts';
 
-async function createApp(
+const createApp = async (
     routes: RouteDefinition[] | ((broadcaster: Broadcaster) => RouteDefinition[]),
     maxRequestBodyBytes = 1024 * 1024,
-): Promise<Hono<AppEnv>> {
+): Promise<Hono<AppEnv>> => {
-  const debug = new Logger("http-transport-test");
+    const debug = new Logger('http-transport-test');
     const broadcaster = new Broadcaster(debug);
-  const resolvedRoutes =
+    const resolvedRoutes = typeof routes === 'function' ? routes(broadcaster) : routes;
-    typeof routes === "function" ? routes(broadcaster) : routes;
     const router = await ApplicationRouter.create([
         {
-      async getRoutes() {
+            async getRoutes(): Promise<RouteDefinition[]> {
                 return resolvedRoutes;
             },
         },
@@ -30,25 +29,26 @@ async function createApp(
     const app = new Hono<AppEnv>();
 
     app.onError(HttpTransportRouter.createErrorHandler(debug));
-  app.use("*", ServerHost.limitBodySizeMiddleware(maxRequestBodyBytes, debug));
+    app.use('*', ServerHost.limitBodySizeMiddleware(maxRequestBodyBytes, debug));
-  app.use("*", HttpTransportRouter.createExtJsonMiddleware(debug));
+    app.use('*', HttpTransportRouter.createExtJsonMiddleware(debug));
     transport.register(app);
-  return app;
-}
 
-describe("HttpTransportRouter", () => {
+    return app;
-  it("runs normal HTTP through a non-streaming route stream", async () => {
+};
+
+describe('HttpTransportRouter', (): void => {
+    it('runs normal HTTP through a non-streaming route stream', async (): Promise<void> => {
         const app = await createApp([
             {
-        url: "/echo",
+                url: '/echo',
-        handler: async (stream) => stream.send(stream.body),
+                handler: async (stream): Promise<void> => stream.send(stream.body),
             },
         ]);
         const value = new Uint8Array([ 1, 2, 3 ]);
 
-    const response = await app.request("/echo", {
+        const response = await app.request('/echo', {
-      method: "POST",
+            method: 'POST',
-      headers: { "content-type": "application/json" },
+            headers: { 'content-type': 'application/json' },
             body: toExtendedJson({ value }),
         });
 
@@ -56,102 +56,100 @@ describe("HttpTransportRouter", () => {
         expect(fromExtendedJson(await response.text())).toEqual({ value });
     });
 
-  it("returns 204 when a normal HTTP route sends nothing", async () => {
+    it('returns 204 when a normal HTTP route sends nothing', async (): Promise<void> => {
         const app = await createApp([
             {
-        url: "/nothing",
+                url: '/nothing',
-        handler: () => undefined,
+                handler: (): void => undefined,
             },
         ]);
 
-    const response = await app.request("/nothing", { method: "POST" });
+        const response = await app.request('/nothing', { method: 'POST' });
 
         expect(response.status).toBe(204);
-    expect(await response.text()).toBe("");
+        expect(await response.text()).toBe('');
     });
 
-  it("returns normalized errors for non-streaming requests", async () => {
+    it('returns normalized errors for non-streaming requests', async (): Promise<void> => {
         const app = await createApp([]);
 
-    const missing = await app.request("/missing", { method: "POST" });
+        const missing = await app.request('/missing', { method: 'POST' });
         expect(missing.status).toBe(404);
         expect(await missing.json()).toEqual({
             statusCode: 404,
-      error: "No route found for /missing",
+            error: 'No route found for /missing',
         });
 
-    const invalid = await app.request("/missing", {
+        const invalid = await app.request('/missing', {
-      method: "POST",
+            method: 'POST',
-      headers: { "content-type": "application/json" },
+            headers: { 'content-type': 'application/json' },
-      body: "{",
+            body: '{',
         });
         expect(invalid.status).toBe(400);
         expect(await invalid.json()).toEqual({
             statusCode: 400,
-      error: "Invalid JSON in request body",
+            error: 'Invalid JSON in request body',
         });
     });
 
-  it("rejects subscribe when normal HTTP has no streaming capability", async () => {
+    it('rejects subscribe when normal HTTP has no streaming capability', async (): Promise<void> => {
         const app = await createApp((broadcaster) => [
             {
-        url: "/items/subscribe",
+                url: '/items/subscribe',
-        handler: async (stream) => {
+                handler: async (stream): Promise<void> => {
-          await broadcaster.subscribe(stream, ["items"]);
+                    await broadcaster.subscribe(stream, [ 'items' ]);
                 },
             },
         ]);
 
-    const response = await app.request("/items/subscribe", { method: "POST" });
+        const response = await app.request('/items/subscribe', { method: 'POST' });
 
         expect(response.status).toBe(406);
         expect(await response.json()).toMatchObject({ statusCode: 406 });
     });
 
-  it("sends SSE route errors as events and closes only that stream", async () => {
+    it('sends SSE route errors as events and closes only that stream', async (): Promise<void> => {
         const app = await createApp([
             {
-        url: "/items/subscribe",
+                url: '/items/subscribe',
-        handler: () => {
+                handler: (): void => {
-          throw new Error("private storage failure");
+                    throw new Error('private storage failure');
                 },
             },
         ]);
 
-    const response = await app.request("/items/subscribe", {
+        const response = await app.request('/items/subscribe', {
-      method: "POST",
+            method: 'POST',
-      headers: { accept: "text/event-stream" },
+            headers: { accept: 'text/event-stream' },
         });
         const events = await response.text();
 
         expect(response.status).toBe(200);
-    expect(events).toContain("event: error");
+        expect(events).toContain('event: error');
-    expect(events).toContain(
+        expect(events).toContain('data: {"statusCode":500,"error":"Internal Server Error"}');
-      'data: {"statusCode":500,"error":"Internal Server Error"}',
+        expect(events).not.toContain('private storage failure');
-    );
-    expect(events).not.toContain("private storage failure");
     });
 
-  it("sends a normal route as one SSE response event and then closes", async () => {
+    it('sends a normal route as one SSE response event and then closes', async (): Promise<void> => {
         const app = await createApp([
             {
-        url: "/echo",
+                url: '/echo',
-        handler: (stream) => stream.send({ ok: true }),
+                handler: (stream): Promise<void> => stream.send({ ok: true }),
             },
         ]);
 
-    const response = await app.request("/echo", {
+        const response = await app.request('/echo', {
-      method: "POST",
+            method: 'POST',
-      headers: { accept: "text/event-stream" },
+            headers: { accept: 'text/event-stream' },
         });
         const events = await response.text();
 
         expect(response.status).toBe(200);
-    expect(events).toContain("event: response");
+        expect(events).toContain('event: response');
         expect(events).toContain('data: {"ok":true}');
     });
 
-  it("keeps SSE open until the route's subscription promise resolves", async () => {
+    it("keeps SSE open until the route's subscription promise resolves", async (): Promise<void> => {
         let removeSubscription: () => Promise<void> = async () => undefined;
         let markSubscribed: () => void = () => undefined;
         const subscribed = new Promise<void>((resolve) => {
@@ -159,10 +157,10 @@ describe("HttpTransportRouter", () => {
         });
         const app = await createApp((broadcaster) => [
             {
-        url: "/items/subscribe",
+                url: '/items/subscribe',
-        handler: async (stream) => {
+                handler: async (stream): Promise<void> => {
-          const topics = ["items"];
+                    const topics = [ 'items' ];
-          removeSubscription = () => broadcaster.unsubscribe(stream, topics);
+                    removeSubscription = (): Promise<void> => broadcaster.unsubscribe(stream, topics);
 
                     const removed = broadcaster.subscribe(stream, topics);
                     markSubscribed();
@@ -171,9 +169,9 @@ describe("HttpTransportRouter", () => {
             },
         ]);
 
-    const response = await app.request("/items/subscribe", {
+        const response = await app.request('/items/subscribe', {
-      method: "POST",
+            method: 'POST',
-      headers: { accept: "text/event-stream" },
+            headers: { accept: 'text/event-stream' },
         });
         const body = response.text();
         const completed = vi.fn();
@@ -185,58 +183,55 @@ describe("HttpTransportRouter", () => {
 
         await removeSubscription();
 
-    expect(await body).toBe("");
+        expect(await body).toBe('');
         expect(completed).toHaveBeenCalledOnce();
     });
 
-  it("rejects unsubscribe over non-bidirectional SSE", async () => {
+    it('rejects unsubscribe over non-bidirectional SSE', async (): Promise<void> => {
         const app = await createApp((broadcaster) => [
             {
-        url: "/items/unsubscribe",
+                url: '/items/unsubscribe',
-        handler: async (stream) => {
+                handler: async (stream): Promise<void> => {
                     if (!stream.bidirectional) {
-            throw new ApplicationError(
+                        throw new ApplicationError(400, 'This route requires an existing bidirectional stream');
-              400,
-              "This route requires an existing bidirectional stream",
-            );
                     }
 
-          await broadcaster.unsubscribe(stream, ["items"]);
+                    await broadcaster.unsubscribe(stream, [ 'items' ]);
                 },
             },
         ]);
 
-    const response = await app.request("/items/unsubscribe", {
+        const response = await app.request('/items/unsubscribe', {
-      method: "POST",
+            method: 'POST',
-      headers: { accept: "text/event-stream" },
+            headers: { accept: 'text/event-stream' },
         });
         const events = await response.text();
 
         expect(response.status).toBe(200);
-    expect(events).toContain("event: error");
+        expect(events).toContain('event: error');
         expect(events).toContain('"statusCode":400');
     });
-  it("rejects HTTP bodies larger than the configured byte limit", async () => {
+    it('rejects HTTP bodies larger than the configured byte limit', async (): Promise<void> => {
         const app = await createApp(
             [
                 {
-          url: "/echo",
+                    url: '/echo',
-          handler: async (stream) => stream.send(stream.body),
+                    handler: async (stream): Promise<void> => stream.send(stream.body),
                 },
             ],
             32,
         );
 
-    const response = await app.request("/echo", {
+        const response = await app.request('/echo', {
-      method: "POST",
+            method: 'POST',
-      headers: { "content-type": "application/json" },
+            headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ value: "x".repeat(64) }),
+            body: JSON.stringify({ value: 'x'.repeat(64) }),
         });
 
         expect(response.status).toBe(413);
         expect(await response.json()).toEqual({
             statusCode: 413,
-      error: "Request body exceeds the 32 byte limit",
+            error: 'Request body exceeds the 32 byte limit',
         });
     });
 });

test/subscription-flow.test.ts

@@ -1,41 +1,41 @@
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi } from 'vitest';
 
-import type { RouteDefinition, RouteModule } from "../source/routes/types.js";
+import type { RouteDefinition, RouteModule } from '../source/routes/types.ts';
-import { ApplicationRouter } from "../source/services/router.js";
+import { ApplicationRouter } from '../source/services/router.ts';
-import { Broadcaster } from "../source/services/broadcaster.js";
+import { Broadcaster } from '../source/services/broadcaster.ts';
-import { Logger } from "../source/utils/logger.js";
+import { Logger } from '../source/utils/logger.ts';
-import { TestConnection } from "./helpers/test-connection.js";
+import { TestConnection } from './helpers/test-connection.ts';
 
-function moduleWith(routes: RouteDefinition[]): RouteModule {
+const moduleWith = (routes: RouteDefinition[]): RouteModule => {
     return {
-    async getRoutes() {
+        async getRoutes(): Promise<RouteDefinition[]> {
             return routes;
         },
     };
-}
+};
 
-async function expectPending(promise: Promise<void>): Promise<void> {
+const expectPending = async (promise: Promise<void>): Promise<void> => {
     const settled = vi.fn();
     void promise.then(settled);
     await Promise.resolve();
     expect(settled).not.toHaveBeenCalled();
-}
+};
 
-describe("long-lived subscription dispatch", () => {
+describe('long-lived subscription dispatch', (): void => {
-  it("allows duplicate subscribe and unsubscribe requests while the original request waits", async () => {
+    it('allows duplicate subscribe and unsubscribe requests while the original request waits', async (): Promise<void> => {
-    const broadcaster = new Broadcaster(new Logger("subscription-flow-test"));
+        const broadcaster = new Broadcaster(new Logger('subscription-flow-test'));
         const router = await ApplicationRouter.create([
             moduleWith([
                 {
-          url: "/items/subscribe",
+                    url: '/items/subscribe',
-          handler: async (stream) => {
+                    handler: async (stream): Promise<void> => {
-            await broadcaster.subscribe(stream, ["items"]);
+                        await broadcaster.subscribe(stream, [ 'items' ]);
                     },
                 },
                 {
-          url: "/items/unsubscribe",
+                    url: '/items/unsubscribe',
-          handler: async (stream) => {
+                    handler: async (stream): Promise<void> => {
-            await broadcaster.unsubscribe(stream, ["items"]);
+                        await broadcaster.unsubscribe(stream, [ 'items' ]);
                         await stream.send({});
                     },
                 },
@@ -43,31 +43,22 @@ describe("long-lived subscription dispatch", () => {
         ]);
         const connection = new TestConnection(true, true);
 
-    const original = router.dispatch(
+        const original = router.dispatch({ path: '/items/subscribe', requestId: 'subscribe-1' }, connection);
-      { path: "/items/subscribe", requestId: "subscribe-1" },
-      connection,
-    );
         await vi.waitFor(() => expect(connection.closeCallbacks).toHaveLength(1));
         await expectPending(original);
 
         // This request uses a different ApplicationRouteStream over the same
         // connection. Since the topic already exists, its dispatch completes.
-    await router.dispatch(
+        await router.dispatch({ path: '/items/subscribe', requestId: 'subscribe-2' }, connection);
-      { path: "/items/subscribe", requestId: "subscribe-2" },
-      connection,
-    );
         await expectPending(original);
 
-    await router.dispatch(
+        await router.dispatch({ path: '/items/unsubscribe', requestId: 'unsubscribe-1' }, connection);
-      { path: "/items/unsubscribe", requestId: "unsubscribe-1" },
-      connection,
-    );
         await original;
 
         expect(connection.messages).toEqual([
             {
-        id: "unsubscribe-1",
+                id: 'unsubscribe-1',
-        type: "response",
+                type: 'response',
                 statusCode: 200,
                 body: {},
             },

tsconfig.json

@@ -15,5 +15,5 @@
         "declarationMap": true,
         "types": ["node"]
     },
-    "exclude": ["node_modules/**/*", "dist/**/*", "test"]
+    "exclude": ["node_modules/**/*", "dist/**/*"]
 }