@rivet-dev/vercel-world 2.3.6

package/tests/integration/hook-token.test.ts

@@ -0,0 +1,160 @@
+import { randomUUID } from "node:crypto";
+import { SPEC_VERSION_CURRENT } from "@workflow/world";
+import { setup } from "rivetkit";
+import { setupTest } from "rivetkit/test";
+import { describe, expect, test } from "vitest";
+import { hookToken } from "../../src/actors/hook-token.ts";
+import { workflowRun } from "../../src/actors/workflow-run.ts";
+
+const registry = setup({ use: { hookToken, workflowRun } });
+
+const uid = () => randomUUID().slice(0, 8);
+type Client = Awaited<ReturnType<typeof setupTest>>["client"];
+
+function tokenActor(client: Client, token: string) {
+	return client.hookToken.getOrCreate([token]);
+}
+
+describe("hookToken ownership generations", () => {
+	test("reserve, confirm, and release are idempotent for one owner", async (c) => {
+		const { client } = await setupTest(c, registry);
+		const token = `token-${uid()}`;
+		const owner = { runId: `wrun_${uid()}`, hookId: `hook-${uid()}` };
+		const handle = tokenActor(client, token);
+
+		const first = await handle.reserve(token, owner.runId, owner.hookId);
+		expect(first.ok).toBe(true);
+		const repeated = await handle.reserve(token, owner.runId, owner.hookId);
+		expect(repeated.generation).toBe(first.generation);
+
+		expect(
+			await handle.confirm(
+				token,
+				first.generation,
+				owner.runId,
+				owner.hookId,
+			),
+		).toEqual({ ok: true });
+		expect(
+			await handle.confirm(
+				token,
+				first.generation,
+				owner.runId,
+				owner.hookId,
+			),
+		).toEqual({ ok: true });
+		expect(await handle.get(token)).toMatchObject({
+			...owner,
+			generation: first.generation,
+		});
+
+		expect(
+			await handle.release(
+				token,
+				first.generation,
+				owner.runId,
+				owner.hookId,
+			),
+		).toEqual({ ok: true });
+		expect(
+			await handle.release(
+				token,
+				first.generation,
+				owner.runId,
+				owner.hookId,
+			),
+		).toEqual({ ok: true });
+		expect(await handle.get(token)).toBeNull();
+	});
+
+	test("operations from an older generation cannot change a replacement owner", async (c) => {
+		const { client } = await setupTest(c, registry);
+		const token = `token-${uid()}`;
+		const handle = tokenActor(client, token);
+		const oldOwner = { runId: `wrun_${uid()}`, hookId: `hook-${uid()}` };
+		const newOwner = { runId: `wrun_${uid()}`, hookId: `hook-${uid()}` };
+
+		const oldReservation = await handle.reserve(
+			token,
+			oldOwner.runId,
+			oldOwner.hookId,
+		);
+		await handle.confirm(
+			token,
+			oldReservation.generation,
+			oldOwner.runId,
+			oldOwner.hookId,
+		);
+		await handle.release(
+			token,
+			oldReservation.generation,
+			oldOwner.runId,
+			oldOwner.hookId,
+		);
+
+		const replacement = await handle.reserve(
+			token,
+			newOwner.runId,
+			newOwner.hookId,
+		);
+		expect(replacement.generation).toBeGreaterThan(oldReservation.generation);
+		await handle.confirm(
+			token,
+			replacement.generation,
+			newOwner.runId,
+			newOwner.hookId,
+		);
+
+		expect(
+			await handle.confirm(
+				token,
+				oldReservation.generation,
+				oldOwner.runId,
+				oldOwner.hookId,
+			),
+		).toEqual({ ok: false });
+		expect(
+			await handle.release(
+				token,
+				oldReservation.generation,
+				oldOwner.runId,
+				oldOwner.hookId,
+			),
+		).toEqual({ ok: false });
+		expect(await handle.get(token)).toMatchObject(newOwner);
+	});
+
+	test("pending lookup verifies canonical workflow ownership before exposure", async (c) => {
+		const { client } = await setupTest(c, registry);
+		const token = `token-${uid()}`;
+		const runId = `wrun_${uid()}`;
+		const hookId = `hook-${uid()}`;
+		const handle = tokenActor(client, token);
+
+		const reservation = await handle.reserve(token, runId, hookId);
+		expect(await handle.get(token)).toBeNull();
+
+		const workflow = client.workflowRun.getOrCreate([runId]);
+		await workflow.appendEvent(runId, {
+			eventType: "run_created",
+			specVersion: SPEC_VERSION_CURRENT,
+			eventData: {
+				deploymentId: "rivet",
+				workflowName: "pending-hook-verification",
+				input: {},
+			},
+		});
+		await workflow.appendEvent(runId, {
+			eventType: "hook_created",
+			specVersion: SPEC_VERSION_CURRENT,
+			correlationId: hookId,
+			eventData: { token, metadata: {} },
+		});
+
+		expect(await handle.get(token)).toMatchObject({
+			runId,
+			hookId,
+			generation: reservation.generation,
+		});
+	});
+});

package/tests/integration/hooks.test.ts

@@ -0,0 +1,123 @@
+import { randomUUID } from "node:crypto";
+import { setupTest } from "rivetkit/test";
+import { afterEach, describe, expect, test } from "vitest";
+import { SPEC_VERSION_CURRENT } from "@workflow/world";
+import { registry } from "../../src/actors.ts";
+import { RivetClientWorld } from "../../src/index.ts";
+
+const uid = () => randomUUID().slice(0, 8);
+
+async function createRun(world: RivetClientWorld, name: string) {
+	const created = await world.events.create(null, {
+		eventType: "run_created",
+		specVersion: SPEC_VERSION_CURRENT,
+		eventData: { deploymentId: "rivet", workflowName: name, input: {} },
+	});
+	const runId = created.run?.runId;
+	if (!runId) throw new Error("expected run id");
+	return runId;
+}
+
+describe("hook token reserve/append orphan (P0 #3)", () => {
+	let world: RivetClientWorld | undefined;
+	afterEach(async () => {
+		if (world) await world.close();
+		world = undefined;
+	});
+
+	test("releases a reserved token when the hook_created append fails", async (c) => {
+		const { client } = await setupTest(c, registry);
+		world = new RivetClientWorld({ client, runtimeUrl: "http://127.0.0.1:1" });
+		const token = `token-${uid()}`;
+		const runA = await createRun(world, "orphanProbeA");
+		const runB = await createRun(world, "orphanProbeB");
+
+		// Drive runA terminal first: a hook_created against a terminal run reserves
+		// the token (World step 1) but then throws EntityConflictError inside the
+		// append (workflow-run step 2) — a real failure path that strands the
+		// reservation unless events.create releases it on failure.
+		await world.events.create(runA, {
+			eventType: "run_completed",
+			specVersion: SPEC_VERSION_CURRENT,
+			eventData: { output: { ok: true } },
+		});
+		await expect(
+			world.events.create(runA, {
+				eventType: "hook_created",
+				specVersion: SPEC_VERSION_CURRENT,
+				correlationId: `hook-${uid()}`,
+				eventData: { token, metadata: {} },
+			}),
+		).rejects.toThrow();
+
+		// The reservation must have been rolled back, so a different run can now
+		// claim the same token without hitting a (stale) conflict.
+		const second = await world.events.create(runB, {
+			eventType: "hook_created",
+			specVersion: SPEC_VERSION_CURRENT,
+			correlationId: `hook-${uid()}`,
+			eventData: { token, metadata: {} },
+		});
+		expect(second.event?.eventType).toBe("hook_created");
+		expect(second.hook?.runId).toBe(runB);
+		expect(second.hook?.token).toBe(token);
+	});
+
+	test("a genuine concurrent token claim still surfaces as hook_conflict", async (c) => {
+		const { client } = await setupTest(c, registry);
+		world = new RivetClientWorld({ client, runtimeUrl: "http://127.0.0.1:1" });
+		const token = `token-${uid()}`;
+		const runA = await createRun(world, "conflictProbeA");
+		const runB = await createRun(world, "conflictProbeB");
+
+		const first = await world.events.create(runA, {
+			eventType: "hook_created",
+			specVersion: SPEC_VERSION_CURRENT,
+			correlationId: `hook-${uid()}`,
+			eventData: { token, metadata: {} },
+		});
+		expect(first.hook?.runId).toBe(runA);
+
+		const conflict = await world.events.create(runB, {
+			eventType: "hook_created",
+			specVersion: SPEC_VERSION_CURRENT,
+			correlationId: `hook-${uid()}`,
+			eventData: { token, metadata: {} },
+		});
+		expect(conflict.event?.eventType).toBe("hook_conflict");
+		expect(conflict.event?.eventData?.conflictingRunId).toBe(runA);
+	});
+
+	test("a duplicate hook id cannot confirm a different token", async (c) => {
+		const { client } = await setupTest(c, registry);
+		world = new RivetClientWorld({ client, runtimeUrl: "http://127.0.0.1:1" });
+		const runA = await createRun(world, "duplicateHookA");
+		const runB = await createRun(world, "duplicateHookB");
+		const hookId = `hook-${uid()}`;
+		const firstToken = `token-${uid()}`;
+		const secondToken = `token-${uid()}`;
+
+		await world.events.create(runA, {
+			eventType: "hook_created",
+			specVersion: SPEC_VERSION_CURRENT,
+			correlationId: hookId,
+			eventData: { token: firstToken },
+		});
+		await expect(
+			world.events.create(runA, {
+				eventType: "hook_created",
+				specVersion: SPEC_VERSION_CURRENT,
+				correlationId: hookId,
+				eventData: { token: secondToken },
+			}),
+		).rejects.toThrow("different token");
+
+		const created = await world.events.create(runB, {
+			eventType: "hook_created",
+			specVersion: SPEC_VERSION_CURRENT,
+			correlationId: `hook-${uid()}`,
+			eventData: { token: secondToken },
+		});
+		expect(created.hook?.token).toBe(secondToken);
+	});
+});

package/tests/integration/streams.test.ts

@@ -0,0 +1,178 @@
+import { randomUUID } from "node:crypto";
+import { setupTest } from "rivetkit/test";
+import { afterEach, describe, expect, test } from "vitest";
+import { registry } from "../../src/actors.ts";
+import { RivetClientWorld } from "../../src/index.ts";
+
+const uid = () => randomUUID().slice(0, 8);
+const ENV = "RIVET_WORLD_RIVET_INJECT_BROADCAST_DROP_RATE";
+const READ_DELAY = "RIVET_WORLD_RIVET_INJECT_STREAM_READ_DELAY_MS";
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+async function readN(
+	stream: ReadableStream<Uint8Array>,
+	n: number,
+	timeoutMs = 8_000,
+) {
+	const reader = stream.getReader();
+	const out: string[] = [];
+	const deadline = Date.now() + timeoutMs;
+	while (out.length < n) {
+		const remaining = deadline - Date.now();
+		if (remaining <= 0) {
+			void reader.cancel();
+			throw new Error(`readN timed out after ${out.length}/${n} chunks`);
+		}
+		const result = await Promise.race([
+			reader.read(),
+			new Promise<{ timeout: true }>((r) =>
+				setTimeout(() => r({ timeout: true }), remaining),
+			),
+		]);
+		if ("timeout" in result) {
+			void reader.cancel();
+			throw new Error(`readN timed out after ${out.length}/${n} chunks`);
+		}
+		if (result.done) break;
+		out.push(new TextDecoder().decode(result.value));
+	}
+	void reader.cancel();
+	return out;
+}
+
+async function readAll(stream: ReadableStream<Uint8Array>, timeoutMs = 8_000) {
+	const reader = stream.getReader();
+	const out: string[] = [];
+	const deadline = Date.now() + timeoutMs;
+	for (;;) {
+		const remaining = deadline - Date.now();
+		if (remaining <= 0) throw new Error("readAll timed out");
+		const result = await Promise.race([
+			reader.read(),
+			new Promise<{ timeout: true }>((r) =>
+				setTimeout(() => r({ timeout: true }), remaining),
+			),
+		]);
+		if ("timeout" in result) throw new Error("readAll timed out");
+		if (result.done) return out;
+		out.push(new TextDecoder().decode(result.value));
+	}
+}
+
+describe("live stream broadcast-loss resilience", () => {
+	let world: RivetClientWorld | undefined;
+	afterEach(async () => {
+		delete process.env[ENV];
+		delete process.env[READ_DELAY];
+		if (world) await world.close();
+		world = undefined;
+	});
+
+	test("re-drains a chunk that lands mid-drain on a still-open stream (no signal lost)", async (c) => {
+		const { client } = await setupTest(c, registry);
+		world = new RivetClientWorld({ client, runtimeUrl: "http://127.0.0.1:1" });
+		const name = `stream-race-${uid()}`;
+		const runId = `wrun_stream_${uid()}`;
+
+		// Hold each read open 150ms so a write can land *during* the in-flight
+		// drain. Its broadcast arrives while draining; without the pending re-drain
+		// guard the signal is coalesced away and the chunk is stranded (the stream
+		// is never closed, so nothing else recovers it).
+		process.env[READ_DELAY] = "150";
+		await world.writeToStream(name, runId, "c0");
+		const live = await world.readFromStream(runId, name, 0);
+		await sleep(50); // initial drain is mid-flight (in the 150ms read window)
+		await world.writeToStream(name, runId, "c1");
+
+		expect(await readN(live, 2)).toEqual(["c0", "c1"]);
+	});
+
+	test("recovers every chunk via re-drain when ALL append broadcasts are dropped", async (c) => {
+		const { client } = await setupTest(c, registry);
+		world = new RivetClientWorld({ client, runtimeUrl: "http://127.0.0.1:1" });
+		const name = `stream-dropped-${uid()}`;
+		const runId = `wrun_stream_${uid()}`;
+
+		// Drop 100% of append broadcasts; only the EOF (close) broadcast survives,
+		// and its re-drain must catch up all chunks whose signals were lost.
+		process.env[ENV] = "1";
+		const live = await world.readFromStream(runId, name, 0);
+		const expected = ["a", "b", "c", "d", "e"];
+		for (const chunk of expected) {
+			await world.writeToStream(name, runId, chunk);
+		}
+		await world.closeStream(name, runId);
+
+		const received = await readAll(live);
+		expect(received).toEqual(expected);
+	});
+
+	test("recovers all chunks under partial broadcast loss with no gaps or dupes", async (c) => {
+		const { client } = await setupTest(c, registry);
+		world = new RivetClientWorld({ client, runtimeUrl: "http://127.0.0.1:1" });
+		const name = `stream-partial-${uid()}`;
+		const runId = `wrun_stream_${uid()}`;
+
+		process.env[ENV] = "0.5"; // drop every other append broadcast
+		const live = await world.readFromStream(runId, name, 0);
+		const expected = Array.from({ length: 8 }, (_, i) => `chunk-${i}`);
+		for (const chunk of expected) {
+			await world.writeToStream(name, runId, chunk);
+		}
+		await world.closeStream(name, runId);
+
+		const received = await readAll(live);
+		expect(received).toEqual(expected);
+	});
+
+	test("delivers chunks written before the reader connects (initial drain)", async (c) => {
+		const { client } = await setupTest(c, registry);
+		world = new RivetClientWorld({ client, runtimeUrl: "http://127.0.0.1:1" });
+		const name = `stream-preexisting-${uid()}`;
+		const runId = `wrun_stream_${uid()}`;
+
+		await world.writeToStream(name, runId, "first");
+		await world.writeToStream(name, runId, "second");
+		const live = await world.readFromStream(runId, name, 0);
+		await world.closeStream(name, runId);
+
+		expect(await readAll(live)).toEqual(["first", "second"]);
+	});
+
+	test("catches up after the reader actor connection opens", async (c) => {
+		const { client } = await setupTest(c, registry);
+		world = new RivetClientWorld({ client, runtimeUrl: "http://127.0.0.1:1" });
+		const name = `stream-opening-${uid()}`;
+		const runId = `wrun_stream_${uid()}`;
+
+		// Drop the append broadcast to model a write that lands while the actor
+		// connection is still opening. The on-open drain must recover the chunk.
+		process.env[ENV] = "1";
+		const live = await world.readFromStream(runId, name, 0);
+		await world.writeToStream(name, runId, "during-open");
+		process.env[ENV] = "0";
+		await world.closeStream(name, runId);
+
+		expect(await readAll(live)).toEqual(["during-open"]);
+	});
+
+	test("isolates the same stream name between workflow runs", async (c) => {
+		const { client } = await setupTest(c, registry);
+		world = new RivetClientWorld({ client, runtimeUrl: "http://127.0.0.1:1" });
+		const name = `shared-${uid()}`;
+		const firstRun = `wrun_stream_${uid()}`;
+		const secondRun = `wrun_stream_${uid()}`;
+		await world.writeToStream(name, firstRun, "first");
+		await world.closeStream(name, firstRun);
+		await world.writeToStream(name, secondRun, "second");
+		await world.closeStream(name, secondRun);
+
+		expect(await readAll(await world.readFromStream(firstRun, name))).toEqual([
+			"first",
+		]);
+		expect(await readAll(await world.readFromStream(secondRun, name))).toEqual([
+			"second",
+		]);
+	});
+});