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

Formatting

Browse Source
This commit is contained in:
Harvmaster
2026-08-03 03:35:09 +00:00
parent 1cee27e78b
commit 161b56c756
3 changed files with 219 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/services/broadcaster.ts
+2
View File
@@ -6,6 +6,7 @@ import { ApplicationError } from '../errors/index.ts';
/** Request-scoped view from which the broadcaster obtains a stable connection. */ /** Request-scoped view from which the broadcaster obtains a stable connection. */
export interface BroadcastStream { export interface BroadcastStream {
/** Connection identity shared by every request on the same transport session. */ /** Connection identity shared by every request on the same transport session. */
readonly connection: BaseStream; readonly connection: BaseStream;
@@ -15,6 +16,7 @@ export interface BroadcastStream {
/** One pending subscribe call and the topics whose removal will resolve it. */ /** One pending subscribe call and the topics whose removal will resolve it. */
interface SubscriptionWaiter { interface SubscriptionWaiter {
/** Only topics newly introduced by this particular subscribe call. */ /** Only topics newly introduced by this particular subscribe call. */
readonly remainingTopics: Set<string>; readonly remainingTopics: Set<string>;
test/services/broadcaster.test.ts
+59 -78
View File
@@ -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); 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(); const settled = vi.fn();
void promise.then(settled); void promise.then(settled);
await Promise.resolve(); await Promise.resolve();
expect(settled).not.toHaveBeenCalled(); 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 broadcaster = createBroadcaster();
const connection = new TestConnection(true, true); const connection = new TestConnection(true, true);
const subscribed = broadcaster.subscribe(routeStream(connection), [ const subscribed = broadcaster.subscribe(routeStream(connection), [ 'items' ]);
"items",
]);
await expectPending(subscribed); 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(connection.messages).toEqual([
expect.objectContaining({ expect.objectContaining({
type: "item-changed", type: 'item-changed',
data: { id: "a" }, data: { id: 'a' },
}), }),
]); ]);
// A different request-scoped facade still resolves the connection's // A different request-scoped facade still resolves the connection's
// original subscription. // original subscription.
await broadcaster.unsubscribe(routeStream(connection), ["items"]); await broadcaster.unsubscribe(routeStream(connection), [ 'items' ]);
await expect(subscribed).resolves.toBeUndefined(); 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 broadcaster = createBroadcaster();
const connection = new TestConnection(true, true); 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 expect(duplicate).resolves.toBeUndefined();
await expectPending(first); await expectPending(first);
expect(connection.closeCallbacks).toHaveLength(1); expect(connection.closeCallbacks).toHaveLength(1);
await broadcaster.unsubscribe(routeStream(connection), ["items"]); await broadcaster.unsubscribe(routeStream(connection), [ 'items' ]);
await first; 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 broadcaster = createBroadcaster();
const connection = new TestConnection(true, true); 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 expect(first).resolves.toBeUndefined();
await expectPending(second); await expectPending(second);
await broadcaster.unsubscribe(routeStream(connection), ["b"]); await broadcaster.unsubscribe(routeStream(connection), [ 'b' ]);
await expect(second).resolves.toBeUndefined(); 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 broadcaster = createBroadcaster();
const connection = new TestConnection(true, false); 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(); connection.close();
await Promise.all([first, second]); 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([]); 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 broadcaster = createBroadcaster();
const connection = new TestConnection(true, false); const connection = new TestConnection(true, false);
connection.close(); 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 broadcaster = createBroadcaster();
const connection = new TestConnection(false, false); 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 broadcaster = createBroadcaster();
const connection = new TestConnection(true, true); 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)); await broadcaster.unsubscribe(routeStream(connection));
expect(connection.closeCallbacks).toHaveLength(0); 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 broadcaster = createBroadcaster();
const first = new TestConnection(true, false); const first = new TestConnection(true, false);
const second = new TestConnection(true, false); const second = new TestConnection(true, false);
@@ -141,23 +127,20 @@ describe("Broadcaster subscriptions", () => {
markSecondSent = resolve; markSecondSent = resolve;
}); });
first.send = async (message) => { first.send = async (message): Promise<void> => {
await firstReleased; await firstReleased;
await originalFirstSend(message); await originalFirstSend(message);
}; };
second.send = async (message) => {
second.send = async (message): Promise<void> => {
await TestConnection.prototype.send.call(second, message); await TestConnection.prototype.send.call(second, message);
markSecondSent(); 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: {}, data: {},
}); });
@@ -170,19 +153,17 @@ describe("Broadcaster subscriptions", () => {
first.close(); first.close();
second.close(); second.close();
await Promise.all([firstSubscription, secondSubscription]); 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 broadcaster = createBroadcaster();
const connection = new TestConnection(true, true); 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: {}, data: {},
}); });
await subscribed; await subscribed;
@@ -190,8 +171,8 @@ describe("Broadcaster subscriptions", () => {
expect(connection.closed).toBe(true); expect(connection.closed).toBe(true);
expect(connection.send).toHaveBeenCalledOnce(); expect(connection.send).toHaveBeenCalledOnce();
await broadcaster.publish("items", { await broadcaster.publish('items', {
type: "item-changed", type: 'item-changed',
data: {}, data: {},
}); });
expect(connection.send).toHaveBeenCalledOnce(); expect(connection.send).toHaveBeenCalledOnce();
test/subscription-flow.test.ts
+25 -34
View File
@@ -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 { return {
async getRoutes() { async getRoutes(): Promise<RouteDefinition[]> {
return routes; return routes;
}, },
}; };
} };
async function expectPending(promise: Promise<void>): Promise<void> { const expectPending = async (promise: Promise<void>): Promise<void> => {
const settled = vi.fn(); const settled = vi.fn();
void promise.then(settled); void promise.then(settled);
await Promise.resolve(); await Promise.resolve();
expect(settled).not.toHaveBeenCalled(); 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([ const router = await ApplicationRouter.create([
moduleWith([ 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({}); await stream.send({});
}, },
}, },
@@ -43,31 +43,22 @@ describe("long-lived subscription dispatch", () => {
]); ]);
const connection = new TestConnection(true, true); 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 vi.waitFor(() => expect(connection.closeCallbacks).toHaveLength(1));
await expectPending(original); await expectPending(original);
// This request uses a different ApplicationRouteStream over the same // This request uses a different ApplicationRouteStream over the same
// connection. Since the topic already exists, its dispatch completes. // 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 expectPending(original);
await router.dispatch( await router.dispatch({ path: '/items/unsubscribe', requestId: 'unsubscribe-1' }, connection);
{ path: "/items/unsubscribe", requestId: "unsubscribe-1" },
connection,
);
await original; await original;
expect(connection.messages).toEqual([ expect(connection.messages).toEqual([
{ {
id: "unsubscribe-1", id: 'unsubscribe-1',
type: "response", type: 'response',
statusCode: 200, statusCode: 200,
body: {}, body: {},
}, },