@rivet-dev/vercel-world 2.3.6

package/tests/integration/workflow-events.test.ts

@@ -0,0 +1,326 @@
+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";
+
+const uid = () => randomUUID().slice(0, 8);
+type Client = Awaited<ReturnType<typeof setupTest>>["client"];
+
+function runActor(client: Client, runId: string) {
+	return client.workflowRun.getOrCreate([runId]);
+}
+
+async function createRun(client: Client, runId: string) {
+	return runActor(client, runId).appendEvent(runId, {
+		eventType: "run_created",
+		specVersion: SPEC_VERSION_CURRENT,
+		eventData: { deploymentId: "rivet", workflowName: "evt", input: { n: 1 } },
+	});
+}
+
+describe("workflowRun event dedup + materialization", () => {
+	let dispose: (() => Promise<void>) | undefined;
+	afterEach(async () => {
+		if (dispose) await dispose();
+		dispose = undefined;
+	});
+
+	test("run_created materializes the run row and is idempotent on redelivery", async (c) => {
+		const { client } = await setupTest(c, registry);
+		const runId = `wrun_${uid()}`;
+		const first = await createRun(client, runId);
+		expect(first.run?.runId).toBe(runId);
+		expect(first.run?.status).toBe("pending");
+
+		// Redeliver the same creation event: must collapse, not create a second.
+		const second = await createRun(client, runId);
+		expect(second.run?.runId).toBe(runId);
+
+		const events = await runActor(client, runId).listEvents({
+			runId,
+			pagination: { limit: 100 },
+		});
+		const created = events.data.filter((e) => e.eventType === "run_created");
+		expect(created).toHaveLength(1);
+	});
+
+	test("step_created / wait_created materialize and dedupe by correlationId", async (c) => {
+		const { client } = await setupTest(c, registry);
+		const runId = `wrun_${uid()}`;
+		await createRun(client, runId);
+
+		const stepId = `step-${uid()}`;
+		await runActor(client, runId).appendEvent(runId, {
+			eventType: "step_created",
+			specVersion: SPEC_VERSION_CURRENT,
+			correlationId: stepId,
+			eventData: { stepName: "s1", input: {} },
+		});
+		await runActor(client, runId).appendEvent(runId, {
+			eventType: "step_created",
+			specVersion: SPEC_VERSION_CURRENT,
+			correlationId: stepId,
+			eventData: { stepName: "s1", input: {} },
+		});
+		const step = await runActor(client, runId).getStep(runId, stepId, {
+			resolveData: "none",
+		});
+		expect(step.stepId).toBe(stepId);
+
+		const waitCorrelationId = `wait-${uid()}`;
+		const waitData = {
+			eventType: "wait_created" as const,
+			specVersion: SPEC_VERSION_CURRENT,
+			correlationId: waitCorrelationId,
+			eventData: { resumeAt: new Date(Date.now() + 60_000) },
+		};
+		const firstWait = await runActor(client, runId).appendEvent(
+			runId,
+			waitData,
+		);
+		const secondWait = await runActor(client, runId).appendEvent(
+			runId,
+			waitData,
+		);
+		expect(secondWait.wait?.waitId).toBe(firstWait.wait?.waitId);
+
+		const events = await runActor(client, runId).listEvents({
+			runId,
+			pagination: { limit: 100 },
+		});
+		expect(
+			events.data.filter((e) => e.eventType === "step_created"),
+		).toHaveLength(1);
+		expect(
+			events.data.filter((e) => e.eventType === "wait_created"),
+		).toHaveLength(1);
+	});
+
+	test("listEventsByCorrelationId advances its cursor", async (c) => {
+		const { client } = await setupTest(c, registry);
+		const runId = `wrun_${uid()}`;
+		await createRun(client, runId);
+		const correlationId = `hook-${uid()}`;
+		for (let i = 0; i < 3; i++) {
+			await runActor(client, runId).appendEvent(runId, {
+				eventType: "hook_received",
+				specVersion: SPEC_VERSION_CURRENT,
+				correlationId,
+				eventData: { payload: { i } },
+			});
+		}
+
+		const first = await runActor(client, runId).listEventsByCorrelationId({
+			correlationId,
+			pagination: { limit: 2 },
+		});
+		expect(first.data).toHaveLength(2);
+		expect(first.hasMore).toBe(true);
+		const second = await runActor(client, runId).listEventsByCorrelationId({
+			correlationId,
+			pagination: { limit: 2, cursor: first.cursor ?? undefined },
+		});
+		expect(second.data).toHaveLength(1);
+		expect(second.hasMore).toBe(false);
+		expect(second.data[0]?.eventId).not.toBe(first.data[0]?.eventId);
+		expect(second.data[0]?.eventId).not.toBe(first.data[1]?.eventId);
+	});
+
+	test("actor actions reject keys that do not match their actor", async (c) => {
+		const { client } = await setupTest(c, registry);
+		const runId = `wrun_${uid()}`;
+		const otherRunId = `wrun_${uid()}`;
+		await expect(
+			runActor(client, runId).appendEvent(otherRunId, {
+				eventType: "run_created",
+				specVersion: SPEC_VERSION_CURRENT,
+				eventData: { deploymentId: "rivet", workflowName: "evt", input: {} },
+			}),
+		).rejects.toThrow();
+		await expect(runActor(client, runId).getRun(otherRunId)).rejects.toThrow();
+		await expect(
+			client.workflowRun
+				.getOrCreate([runId])
+				.enqueue(
+					otherRunId,
+					`msg_${uid()}`,
+					"__wkf_workflow_probe",
+					"http://127.0.0.1:1",
+					JSON.stringify({ runId: otherRunId }),
+				),
+		).rejects.toThrow();
+	});
+
+	test("ownsHook only matches the actor's persisted hook and token", async (c) => {
+		const { client } = await setupTest(c, registry);
+		const runId = `wrun_${uid()}`;
+		await createRun(client, runId);
+		const hookId = `hook-${uid()}`;
+		const token = `token-${uid()}`;
+		await runActor(client, runId).appendEvent(runId, {
+			eventType: "hook_created",
+			specVersion: SPEC_VERSION_CURRENT,
+			correlationId: hookId,
+			eventData: { token },
+		});
+		expect(await runActor(client, runId).ownsHook(hookId, token)).toBe(true);
+		expect(await runActor(client, runId).ownsHook(hookId, "wrong-token")).toBe(
+			false,
+		);
+	});
+
+	test("run_started recreates the run when run_created was lost (resilient start)", async (c) => {
+		const { client } = await setupTest(c, registry);
+		const runId = `wrun_${uid()}`;
+		// No run_created first — simulate it being lost. run_started carries the
+		// creation fields, so the run must be materialized and marked running.
+		const started = await runActor(client, runId).appendEvent(runId, {
+			eventType: "run_started",
+			specVersion: SPEC_VERSION_CURRENT,
+			eventData: {
+				deploymentId: "rivet",
+				workflowName: "resilient",
+				input: { recovered: true },
+			},
+		});
+		expect(started.run?.runId).toBe(runId);
+		expect(started.run?.status).toBe("running");
+
+		const run = await runActor(client, runId).getRun(runId);
+		expect(run.workflowName).toBe("resilient");
+		expect(run.input).toEqual({ recovered: true });
+	});
+
+	test("lazy step_started atomically creates the step and its replay event", async (c) => {
+		const { client } = await setupTest(c, registry);
+		const runId = `wrun_${uid()}`;
+		const stepId = `step-${uid()}`;
+		await createRun(client, runId);
+		const result = await runActor(client, runId).appendEvent(runId, {
+			eventType: "step_started",
+			specVersion: SPEC_VERSION_CURRENT,
+			correlationId: stepId,
+			eventData: {
+				stepName: "lazy",
+				input: { value: 1 },
+				ownerMessageId: `msg_${uid()}`,
+			},
+		});
+		expect(result.stepCreated).toBe(true);
+		expect(result.step?.status).toBe("running");
+
+		const events = await runActor(client, runId).listEvents({
+			runId,
+			pagination: { limit: 100 },
+		});
+		expect(
+			events.data
+				.filter((event) => event.correlationId === stepId)
+				.map((event) => event.eventType),
+		).toEqual(["step_created", "step_started"]);
+		const replay = await runActor(client, runId).appendEvent(runId, {
+				eventType: "step_started",
+				specVersion: SPEC_VERSION_CURRENT,
+				correlationId: stepId,
+				eventData: { stepName: "lazy", input: { value: 1 } },
+			});
+		expect(replay.step?.status).toBe("running");
+		expect(replay.step?.attempt).toBe(1);
+
+		await expect(
+			runActor(client, runId).appendEvent(runId, {
+				eventType: "step_started",
+				specVersion: SPEC_VERSION_CURRENT,
+				correlationId: stepId,
+				eventData: { stepName: "lazy", input: { value: 2 } },
+			}),
+		).rejects.toThrow();
+	});
+
+	test("rejects child events without a run and after the run terminates", async (c) => {
+		const { client } = await setupTest(c, registry);
+		const missingRunId = `wrun_${uid()}`;
+		await expect(
+			runActor(client, missingRunId).appendEvent(missingRunId, {
+				eventType: "step_created",
+				specVersion: SPEC_VERSION_CURRENT,
+				correlationId: `step-${uid()}`,
+				eventData: { stepName: "orphan", input: {} },
+			}),
+		).rejects.toThrow();
+
+		const runId = `wrun_${uid()}`;
+		await createRun(client, runId);
+		await runActor(client, runId).appendEvent(runId, {
+			eventType: "run_completed",
+			specVersion: SPEC_VERSION_CURRENT,
+			eventData: { output: null },
+		});
+		await expect(
+			runActor(client, runId).appendEvent(runId, {
+				eventType: "hook_received",
+				specVersion: SPEC_VERSION_CURRENT,
+				correlationId: `hook-${uid()}`,
+				eventData: { payload: {} },
+			}),
+		).rejects.toThrow();
+	});
+
+	test("concurrent run_created turns for one run yield exactly one creation event", async (c) => {
+		const { client } = await setupTest(c, registry);
+		const runId = `wrun_${uid()}`;
+		// Two turns racing to create the same run (recovery re-enqueue vs live, or
+		// duplicate delivery). The creation-only unique index must collapse them.
+		const results = await Promise.all([
+			createRun(client, runId),
+			createRun(client, runId),
+		]);
+		for (const r of results) expect(r.run?.runId).toBe(runId);
+
+		const events = await runActor(client, runId).listEvents({
+			runId,
+			pagination: { limit: 100 },
+		});
+		expect(
+			events.data.filter((e) => e.eventType === "run_created"),
+		).toHaveLength(1);
+	});
+
+	test("concurrent step_created turns for one correlationId yield exactly one step", async (c) => {
+		const { client } = await setupTest(c, registry);
+		const runId = `wrun_${uid()}`;
+		await createRun(client, runId);
+		const stepId = `step-${uid()}`;
+		// Two genuinely-concurrent creation turns for the same correlationId is
+		// enough to exercise the creation-only unique index race (matches the
+		// run_created concurrency test); the SQL-level dedup itself is covered
+		// exhaustively by the deterministic unit suite.
+		await Promise.all([
+			runActor(client, runId).appendEvent(runId, {
+				eventType: "step_created",
+				specVersion: SPEC_VERSION_CURRENT,
+				correlationId: stepId,
+				eventData: { stepName: "s", input: {} },
+			}),
+			runActor(client, runId).appendEvent(runId, {
+				eventType: "step_created",
+				specVersion: SPEC_VERSION_CURRENT,
+				correlationId: stepId,
+				eventData: { stepName: "s", input: {} },
+			}),
+		]);
+		const events = await runActor(client, runId).listEvents({
+			runId,
+			pagination: { limit: 100 },
+		});
+		expect(
+			events.data.filter((e) => e.eventType === "step_created"),
+		).toHaveLength(1);
+		const steps = await runActor(client, runId).listSteps({
+			runId,
+			pagination: { limit: 100 },
+		});
+		expect(steps.data.filter((s) => s.stepId === stepId)).toHaveLength(1);
+	});
+});

package/tests/setup.ts

@@ -0,0 +1,10 @@
+// Runs before each test file is imported, so the dispatcher module (which reads
+// these at evaluation time) picks up the test-tuned queue knobs. Keeps retry /
+// dead-letter / stale-reclaim windows short and deterministic.
+process.env.RIVET_WORLD_RIVET_MAX_DISPATCH_ATTEMPTS ??= "3";
+process.env.RIVET_WORLD_RIVET_RETRY_DELAY_MS ??= "100";
+process.env.RIVET_WORLD_RIVET_STALE_INFLIGHT_MS ??= "400";
+process.env.RIVET_WORLD_RIVET_TESTING ??= "1";
+
+const { registry } = await import("../src/actors.ts");
+registry.config.runtime = "native";

package/tests/unit/codec.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "vitest";
+import { compact, decodeValue, encodeValue } from "../../src/codec.ts";
+
+function roundtrip<T>(value: T): T {
+	return decodeValue<T>(encodeValue(value)) as T;
+}
+
+describe("codec round-trip (large + edge-case payloads)", () => {
+	test("undefined encodes to null and decodes back to undefined", () => {
+		expect(encodeValue(undefined)).toBeNull();
+		expect(decodeValue(null)).toBeUndefined();
+		expect(decodeValue(undefined)).toBeUndefined();
+	});
+
+	test("primitives and null round-trip", () => {
+		for (const value of [0, -1, 3.14159, "", "hello", true, false, null]) {
+			expect(roundtrip(value)).toEqual(value);
+		}
+	});
+
+	test("large string (1 MiB) round-trips", () => {
+		const value = "x".repeat(1024 * 1024);
+		expect(roundtrip(value)).toBe(value);
+	});
+
+	test("deeply nested structure round-trips", () => {
+		let nested: unknown = { leaf: 42 };
+		for (let i = 0; i < 200; i++) nested = { i, child: nested };
+		expect(roundtrip(nested)).toEqual(nested);
+	});
+
+	test("all-binary payload (Uint8Array with null bytes) round-trips", () => {
+		const bytes = new Uint8Array(2048);
+		for (let i = 0; i < bytes.length; i++) bytes[i] = i % 256;
+		const output = roundtrip(bytes);
+		expect(output).toBeInstanceOf(Uint8Array);
+		expect(Array.from(output)).toEqual(Array.from(bytes));
+	});
+
+	test("strings containing null bytes and unicode round-trip", () => {
+		const value = "a\0b\u{1F680}c\nd\te\\f\"g";
+		expect(roundtrip(value)).toBe(value);
+	});
+
+	test("mixed nested object with binary, arrays, and large fields round-trips", () => {
+		const payload = {
+			id: `wrun_${"z".repeat(64)}`,
+			input: {
+				items: Array.from({ length: 500 }, (_, i) => ({ i, name: `item-${i}` })),
+			},
+			blob: new Uint8Array([0, 1, 2, 255, 0, 128]),
+			meta: {
+				nested: { deep: { value: "\0end" } },
+				flag: false,
+				n: Number.MAX_SAFE_INTEGER,
+			},
+		};
+		expect(roundtrip(payload)).toEqual(payload);
+	});
+
+	test("decodeValue accepts Buffer and number-array encodings", () => {
+		const encoded = encodeValue({ a: 1, b: "two" });
+		expect(encoded).not.toBeNull();
+		expect(decodeValue(Buffer.from(encoded!))).toEqual({ a: 1, b: "two" });
+		expect(decodeValue(Array.from(encoded!))).toEqual({ a: 1, b: "two" });
+	});
+
+	test("compact drops undefined and null but keeps falsy values", () => {
+		expect(
+			compact({ a: 1, b: undefined, c: null, d: 0, e: "", f: false }),
+		).toEqual({ a: 1, d: 0, e: "", f: false });
+	});
+});

package/tests/unit/coordinator-record.test.ts

@@ -0,0 +1,177 @@
+import { SPEC_VERSION_CURRENT, type WorkflowRun } from "@workflow/world";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import {
+	applyCoordinatorUpdate,
+	coordinator,
+	type CoordinatorContext,
+} from "../../src/actors/coordinator.ts";
+import { migrateCoordinatorDb } from "../../src/actors/db.ts";
+import { makeCtx, type TestCtx } from "../helpers/db.ts";
+
+type Ctx = CoordinatorContext & { raw: TestCtx["raw"]; close: () => void };
+type ActorCtx = CoordinatorContext & { key: readonly unknown[] };
+
+const actions = coordinator.config.actions as unknown as {
+	listRuns: (c: ActorCtx, params?: Record<string, unknown>) => Promise<{
+		data: WorkflowRun[];
+		cursor: string | null;
+		hasMore: boolean;
+	}>;
+	listHookIndex: (
+		c: ActorCtx,
+		params?: Record<string, unknown>,
+	) => Promise<{
+		data: { hookId: string; runId: string }[];
+		cursor: string | null;
+		hasMore: boolean;
+	}>;
+};
+
+async function makeCoordCtx(): Promise<Ctx> {
+	const base = await makeCtx(migrateCoordinatorDb);
+	return { db: base.db, raw: base.raw, close: base.close };
+}
+
+function run(
+	runId: string,
+	status: WorkflowRun["status"] = "running",
+	createdAt = new Date("2026-01-01T00:00:00.000Z"),
+): WorkflowRun {
+	return {
+		runId,
+		status,
+		deploymentId: "rivet",
+		workflowName: "wf",
+		specVersion: SPEC_VERSION_CURRENT,
+		createdAt,
+		updatedAt: createdAt,
+	} as WorkflowRun;
+}
+
+describe("coordinator derived indexes", () => {
+	let ctx: Ctx;
+	beforeEach(async () => {
+		ctx = await makeCoordCtx();
+	});
+	afterEach(() => ctx.close());
+
+	test("run upserts cannot regress to an older revision", async () => {
+		await applyCoordinatorUpdate(ctx, {
+			type: "run.upsert",
+			run: run("wrun_1", "completed"),
+			runRevision: 2,
+		});
+		await applyCoordinatorUpdate(ctx, {
+			type: "run.upsert",
+			run: run("wrun_1", "running"),
+			runRevision: 1,
+		});
+
+		const row = ctx.raw
+			.prepare("SELECT run_revision, status FROM runs_index")
+			.get();
+		expect(row).toEqual({ run_revision: 2, status: "completed" });
+	});
+
+	test("correlation tombstones fence delayed puts and retain ownership", async () => {
+		await applyCoordinatorUpdate(ctx, {
+			type: "correlation.delete",
+			correlationId: "hook_1",
+			runId: "wrun_1",
+			kind: "hook",
+			runRevision: 3,
+		});
+		await applyCoordinatorUpdate(ctx, {
+			type: "correlation.put",
+			correlationId: "hook_1",
+			runId: "wrun_1",
+			kind: "hook",
+			runRevision: 3,
+		});
+		expect(
+			ctx.raw
+				.prepare(
+					"SELECT run_revision, status FROM correlation_index WHERE correlation_id = ?",
+				)
+				.get("hook_1"),
+		).toEqual({ run_revision: 3, status: "deleted" });
+
+		await expect(
+			applyCoordinatorUpdate(ctx, {
+				type: "correlation.put",
+				correlationId: "hook_1",
+				runId: "wrun_2",
+				kind: "hook",
+				runRevision: 4,
+			}),
+		).rejects.toThrow("another workflow entity");
+	});
+
+	test("hook tombstones fence delayed upserts", async () => {
+		const common = {
+			hookId: "hook_1",
+			runId: "wrun_1",
+			token: "token_1",
+			createdAt: 10,
+			updatedAt: 20,
+		};
+		await applyCoordinatorUpdate(ctx, {
+			...common,
+			type: "hook.delete",
+			runRevision: 5,
+		});
+		await applyCoordinatorUpdate(ctx, {
+			...common,
+			type: "hook.upsert",
+			runRevision: 6,
+		});
+		expect(
+			ctx.raw
+				.prepare("SELECT run_revision, status FROM hooks_index")
+				.get(),
+		).toEqual({ run_revision: 5, status: "deleted" });
+	});
+
+	test("run and hook listings use stable tuple cursors and hide tombstones", async () => {
+		const createdAt = new Date("2026-01-01T00:00:00.000Z");
+		for (const runId of ["wrun_1", "wrun_2", "wrun_3"]) {
+			await applyCoordinatorUpdate(ctx, {
+				type: "run.upsert",
+				run: run(runId, "running", createdAt),
+				runRevision: 1,
+			});
+		}
+		const actorCtx = { db: ctx.db, key: ["coordinator"] };
+		const firstRuns = await actions.listRuns(actorCtx, {
+			pagination: { limit: 2 },
+		});
+		expect(firstRuns.data.map((value) => value.runId)).toEqual([
+			"wrun_3",
+			"wrun_2",
+		]);
+		expect(firstRuns.hasMore).toBe(true);
+		const secondRuns = await actions.listRuns(actorCtx, {
+			pagination: { limit: 2, cursor: firstRuns.cursor },
+		});
+		expect(secondRuns.data.map((value) => value.runId)).toEqual(["wrun_1"]);
+
+		for (const hookId of ["hook_1", "hook_2", "hook_3"]) {
+			await applyCoordinatorUpdate(ctx, {
+				type: hookId === "hook_2" ? "hook.delete" : "hook.upsert",
+				hookId,
+				runId: `run_${hookId}`,
+				token: `token_${hookId}`,
+				runRevision: 1,
+				createdAt: 10,
+				updatedAt: 10,
+			});
+		}
+		const hooks = await actions.listHookIndex(actorCtx, {
+			pagination: { limit: 10 },
+		});
+		expect(hooks.data.map((value) => value.hookId)).toEqual([
+			"hook_3",
+			"hook_1",
+		]);
+	});
+});

package/tests/unit/db-migrations.test.ts

@@ -0,0 +1,65 @@
+import { afterEach, describe, expect, test } from "vitest";
+import {
+	migrateCoordinatorDb,
+	migrateHookTokenDb,
+	migrateWorkflowDb,
+} from "../../src/actors/db.ts";
+import { makeCtx, type TestCtx } from "../helpers/db.ts";
+
+const contexts: TestCtx[] = [];
+afterEach(() => {
+	for (const ctx of contexts.splice(0)) ctx.close();
+});
+
+function columns(ctx: TestCtx, table: string): string[] {
+	return ctx.raw
+		.prepare(`PRAGMA table_info(${table})`)
+		.all()
+		.map((row) => String(row.name));
+}
+
+describe("Vercel World database migrations", () => {
+	test("creates the consolidated workflowRun schema at v1", async () => {
+		const ctx = await makeCtx(migrateWorkflowDb);
+		contexts.push(ctx);
+		expect(columns(ctx, "workflow_runs")).toEqual(
+			expect.arrayContaining(["run_revision", "attributes"]),
+		);
+		expect(columns(ctx, "workflow_waits")).toEqual(
+			expect.arrayContaining([
+				"runtime_url",
+				"queue_name",
+				"headers",
+				"resume_enqueued_at",
+			]),
+		);
+		expect(columns(ctx, "dispatcher_queue")).toContain("idem_key");
+		expect(columns(ctx, "workflow_hooks")).toContain("token_generation");
+		expect(columns(ctx, "stream_chunks")).toContain("sequence");
+		expect(columns(ctx, "pending_ops")).toEqual(
+			expect.arrayContaining(["operation_revision", "claim_id", "next_at"]),
+		);
+	});
+
+	test("creates the derived coordinator schema at v1", async () => {
+		const ctx = await makeCtx(migrateCoordinatorDb);
+		contexts.push(ctx);
+		expect(columns(ctx, "runs_index")).toEqual(
+			expect.arrayContaining(["run_revision", "attributes"]),
+		);
+		expect(columns(ctx, "correlation_index")).toEqual(
+			expect.arrayContaining(["kind", "run_revision", "status"]),
+		);
+		expect(columns(ctx, "hooks_index")).toEqual(
+			expect.arrayContaining(["run_revision", "token", "status"]),
+		);
+	});
+
+	test("creates generation-fenced hook ownership at v1", async () => {
+		const ctx = await makeCtx(migrateHookTokenDb);
+		contexts.push(ctx);
+		expect(columns(ctx, "hook_token_state")).toEqual(
+			expect.arrayContaining(["generation", "status", "expires_at"]),
+		);
+	});
+});