Harvmaster/sync-server-v2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch '3-add-routing' into 4-add-broadcaster

Browse Source
This commit is contained in:
Harvmaster
2026-08-03 03:33:28 +00:00
parent 1c1c1b6a07 a36e267280
commit 1cee27e78b
5 changed files with 130 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/routes/types.ts
+3
View File
@@ -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/router.ts
+1
View File
@@ -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/stream/base-stream.ts
+2
View File
@@ -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;
test/helpers/test-connection.ts
+3 -5
View File
@@ -1,7 +1,4 @@
import {
BaseStream,
type StreamMessage,
} from "../../source/services/stream/base-stream.js";
import { BaseStream, type StreamMessage } from '../../source/services/stream/base-stream.ts';
/** 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/router.test.ts
+40 -63
View File
@@ -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 { ApplicationError } from "../../source/errors/index.js";
import { ApplicationRouter } from "../../source/services/router.js";
import { TestConnection } from "../helpers/test-connection.js";
import type { RouteDefinition, RouteModule } from '../../source/routes/types.ts';
import { ApplicationRouter } from '../../source/services/router.ts';
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;
},
};
}
};
describe("ApplicationRouter initialization", () => {
it("rejects duplicate exact paths during startup", async () => {
const route = { url: "/echo", handler: () => undefined };
describe('ApplicationRouter initialization', (): void => {
it('rejects duplicate exact paths during startup', async (): Promise<void> => {
const route = { url: '/echo', handler: (): void => undefined };
await expect(
ApplicationRouter.create([moduleWith([route]), moduleWith([route])]),
).rejects.toThrow("Duplicate application route: /echo");
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");
},
);
it.each([ 'echo', '/', '/items/:id', '/items?active=true', '/items#active' ])('rejects the invalid route path %s', async (url): Promise<void> => {
await expect(ApplicationRouter.create([ moduleWith([{ url, handler: (): void => undefined }]) ])).rejects.toThrow('Invalid application route');
});
});
describe("ApplicationRouter dispatch", () => {
it("binds the connection, body, and request ID to one route stream", async () => {
describe('ApplicationRouter dispatch', (): void => {
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",
handler: async (stream) => {
url: '/echo',
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(
{ path: "/echo", body: { value: 1 }, requestId: "request-1" },
connection,
);
await router.dispatch({ path: '/echo', body: { value: 1 }, requestId: 'request-1' }, connection);
expect(connection.messages).toEqual([
{
id: "request-1",
type: "response",
id: 'request-1',
type: 'response',
statusCode: 200,
body: { value: 1 },
},
]);
await expect(
router.dispatch({ path: "/echo/other", body: {} }, connection),
).rejects.toMatchObject({ statusCode: 404 });
await expect(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",
handler: async (stream) => {
url: '/delayed',
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(
{ path: "/delayed", body: { key: "A" }, requestId: "A" },
connection,
);
const second = router.dispatch(
{ path: "/delayed", body: { key: "B" }, requestId: "B" },
connection,
);
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")?.();
completions.get('B')?.();
await second;
completions.get("A")?.();
completions.get('A')?.();
await first;
expect(connection.messages).toEqual([
{
id: "B",
type: "response",
id: 'B',
type: 'response',
statusCode: 200,
body: { key: "B" },
body: { key: 'B' },
},
{
id: "A",
type: "response",
id: 'A',
type: 'response',
statusCode: 200,
body: { key: "A" },
body: { key: 'A' },
},
]);
});
it("propagates route failures without infrastructure-specific cleanup", async () => {
const error = new Error("route failed");
it('propagates route failures without infrastructure-specific cleanup', async (): Promise<void> => {
const error = new Error('route failed');
const router = await ApplicationRouter.create([
moduleWith([
{
url: "/failure",
handler: () => {
url: '/failure',
handler: (): void => {
throw error;
},
},
]),
]);
await expect(
router.dispatch({ path: "/failure" }, new TestConnection(false, false)),
).rejects.toBe(error);
await expect(router.dispatch({ path: '/failure' }, new TestConnection(false, false))).rejects.toBe(error);
});
});