rivetkit 2.1.5 → 2.1.6-rc.1

package/src/driver-test-suite/tests/actor-inspector.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "vitest";
 import type { DriverTestConfig } from "../mod";
-import { setupDriverTest } from "../utils";
+import { setupDriverTest, waitFor } from "../utils";
 
 export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 	describe("Actor Inspector HTTP API", () => {
@@ -17,31 +17,29 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			});
 			expect(response.status).toBe(200);
 			const data = await response.json();
-			expect(data).toEqual({ state: { count: 5 } });
+			expect(data).toEqual({
+				state: { count: 5 },
+				isStateEnabled: true,
+			});
 		});
 
 		test("PATCH /inspector/state updates actor state", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
-			const handle = client.counter.getOrCreate([
-				"inspector-set-state",
-			]);
+			const handle = client.counter.getOrCreate(["inspector-set-state"]);
 
 			await handle.increment(5);
 
 			const gatewayUrl = await handle.getGatewayUrl();
 
 			// Replace state
-			const patchResponse = await fetch(
-				`${gatewayUrl}/inspector/state`,
-				{
-					method: "PATCH",
-					headers: {
-						"Content-Type": "application/json",
-						Authorization: "Bearer token",
-					},
-					body: JSON.stringify({ state: { count: 42 } }),
+			const patchResponse = await fetch(`${gatewayUrl}/inspector/state`, {
+				method: "PATCH",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: "Bearer token",
 				},
-			);
+				body: JSON.stringify({ state: { count: 42 } }),
+			});
 			expect(patchResponse.status).toBe(200);
 			const patchData = await patchResponse.json();
 			expect(patchData).toEqual({ ok: true });
@@ -96,9 +94,7 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 
 		test("POST /inspector/action/:name executes an action", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
-			const handle = client.counter.getOrCreate([
-				"inspector-action",
-			]);
+			const handle = client.counter.getOrCreate(["inspector-action"]);
 
 			await handle.increment(10);
 
@@ -156,9 +152,7 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 
 		test("GET /inspector/traces returns trace data", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
-			const handle = client.counter.getOrCreate([
-				"inspector-traces",
-			]);
+			const handle = client.counter.getOrCreate(["inspector-traces"]);
 
 			// Perform an action to generate traces
 			await handle.increment(1);
@@ -182,9 +176,7 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 
 		test("GET /inspector/workflow-history returns workflow status", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
-			const handle = client.counter.getOrCreate([
-				"inspector-workflow",
-			]);
+			const handle = client.counter.getOrCreate(["inspector-workflow"]);
 
 			// Ensure actor exists
 			await handle.increment(0);
@@ -208,22 +200,135 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			expect(data.history).toBeNull();
 		});
 
-		test("GET /inspector/summary returns full actor snapshot", async (c) => {
+		test("GET /inspector/database/schema returns SQLite schema", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
-			const handle = client.counter.getOrCreate([
-				"inspector-summary",
+			const handle = client.dbActorRaw.getOrCreate([
+				`inspector-database-schema-${crypto.randomUUID()}`,
 			]);
 
-			await handle.increment(7);
+			await handle.insertValue("Alice");
+			await handle.insertValue("Bob");
+
+			const gatewayUrl = await handle.getGatewayUrl();
+			const response = await fetch(
+				`${gatewayUrl}/inspector/database/schema`,
+				{
+					headers: { Authorization: "Bearer token" },
+				},
+			);
+			expect(response.status).toBe(200);
+			const data = (await response.json()) as {
+				schema: {
+					tables: Array<{
+						table: { schema: string; name: string; type: string };
+						columns: Array<{ name: string }>;
+						records: number;
+					}>;
+				};
+			};
+
+			expect(Array.isArray(data.schema.tables)).toBe(true);
+			const testDataTable = data.schema.tables.find(
+				(table) => table.table.name === "test_data",
+			);
+			expect(testDataTable).toBeDefined();
+			expect(testDataTable?.table.schema).toBe("main");
+			expect(testDataTable?.table.type).toBe("table");
+			expect(testDataTable?.records).toBe(2);
+			expect(testDataTable?.columns.map((column) => column.name)).toEqual(
+				["id", "value", "payload", "created_at"],
+			);
+		});
+
+		test("GET /inspector/workflow-history returns populated history for active workflows", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.workflowCounterActor.getOrCreate([
+				"inspector-workflow-active",
+			]);
+
+			let state = await handle.getState();
+			for (
+				let i = 0;
+				i < 40 &&
+				(state.runCount === 0 || state.history.length === 0);
+				i++
+			) {
+				await waitFor(driverTestConfig, 50);
+				state = await handle.getState();
+			}
+
+			expect(state.runCount).toBeGreaterThan(0);
+			expect(state.history.length).toBeGreaterThan(0);
+
+			const gatewayUrl = await handle.getGatewayUrl();
+			const response = await fetch(
+				`${gatewayUrl}/inspector/workflow-history`,
+				{
+					headers: { Authorization: "Bearer token" },
+				},
+			);
+			expect(response.status).toBe(200);
+			const data = (await response.json()) as {
+				history: {
+					nameRegistry: string[];
+					entries: unknown[];
+					entryMetadata: Record<string, unknown>;
+				} | null;
+				isWorkflowEnabled: boolean;
+			};
+			expect(data.isWorkflowEnabled).toBe(true);
+			expect(data.history).not.toBeNull();
+			expect(data.history?.nameRegistry.length).toBeGreaterThan(0);
+			expect(data.history?.entries.length).toBeGreaterThan(0);
+			expect(
+				Object.keys(data.history?.entryMetadata ?? {}).length,
+			).toBeGreaterThan(0);
+		});
+
+		test("GET /inspector/database/rows returns SQLite rows", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.dbActorRaw.getOrCreate([
+				`inspector-database-rows-${crypto.randomUUID()}`,
+			]);
+
+			await handle.insertValue("Alice");
+			await handle.insertValue("Bob");
 
 			const gatewayUrl = await handle.getGatewayUrl();
 			const response = await fetch(
-				`${gatewayUrl}/inspector/summary`,
+				`${gatewayUrl}/inspector/database/rows?table=test_data&limit=1&offset=1`,
 				{
 					headers: { Authorization: "Bearer token" },
 				},
 			);
 			expect(response.status).toBe(200);
+			const data = (await response.json()) as {
+				rows: Array<{
+					id: number;
+					value: string;
+					payload: string;
+					created_at: number;
+				}>;
+			};
+
+			expect(data.rows).toHaveLength(1);
+			expect(data.rows[0]?.id).toBe(2);
+			expect(data.rows[0]?.value).toBe("Bob");
+			expect(data.rows[0]?.payload).toBe("");
+			expect(typeof data.rows[0]?.created_at).toBe("number");
+		});
+
+		test("GET /inspector/summary returns full actor snapshot", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.counter.getOrCreate(["inspector-summary"]);
+
+			await handle.increment(7);
+
+			const gatewayUrl = await handle.getGatewayUrl();
+			const response = await fetch(`${gatewayUrl}/inspector/summary`, {
+				headers: { Authorization: "Bearer token" },
+			});
+			expect(response.status).toBe(200);
 			const data = (await response.json()) as {
 				state: { count: number };
 				connections: unknown[];
@@ -244,12 +349,49 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			expect(data.workflowHistory).toBeNull();
 		});
 
-		test("inspector endpoints require auth in non-dev mode", async (c) => {
+		test("GET /inspector/summary returns populated workflow history for active workflows", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
-			const handle = client.counter.getOrCreate([
-				"inspector-auth",
+			const handle = client.workflowCounterActor.getOrCreate([
+				"inspector-summary-workflow",
 			]);
 
+			let state = await handle.getState();
+			for (
+				let i = 0;
+				i < 40 &&
+				(state.runCount === 0 || state.history.length === 0);
+				i++
+			) {
+				await waitFor(driverTestConfig, 50);
+				state = await handle.getState();
+			}
+
+			const gatewayUrl = await handle.getGatewayUrl();
+			const response = await fetch(`${gatewayUrl}/inspector/summary`, {
+				headers: { Authorization: "Bearer token" },
+			});
+			expect(response.status).toBe(200);
+			const data = (await response.json()) as {
+				isWorkflowEnabled: boolean;
+				workflowHistory: {
+					nameRegistry: string[];
+					entries: unknown[];
+					entryMetadata: Record<string, unknown>;
+				} | null;
+			};
+			expect(data.isWorkflowEnabled).toBe(true);
+			expect(data.workflowHistory).not.toBeNull();
+			expect(data.workflowHistory?.nameRegistry.length).toBeGreaterThan(0);
+			expect(data.workflowHistory?.entries.length).toBeGreaterThan(0);
+			expect(
+				Object.keys(data.workflowHistory?.entryMetadata ?? {}).length,
+			).toBeGreaterThan(0);
+		});
+
+		test("inspector endpoints require auth in non-dev mode", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.counter.getOrCreate(["inspector-auth"]);
+
 			await handle.increment(0);
 
 			const gatewayUrl = await handle.getGatewayUrl();

package/src/driver-test-suite/tests/actor-kv.ts

@@ -6,22 +6,37 @@ export function runActorKvTests(driverTestConfig: DriverTestConfig) {
 	type KvTextHandle = {
 		putText: (key: string, value: string) => Promise<unknown>;
 		getText: (key: string) => Promise<string | null>;
-		listText: (prefix: string) => Promise<Array<{ key: string; value: string }>>;
+		listText: (
+			prefix: string,
+		) => Promise<Array<{ key: string; value: string }>>;
+		listTextRange: (
+			start: string,
+			end: string,
+			options?: {
+				reverse?: boolean;
+				limit?: number;
+			},
+		) => Promise<Array<{ key: string; value: string }>>;
+		deleteTextRange: (start: string, end: string) => Promise<unknown>;
 	};
 
 	type KvArrayBufferHandle = {
-		roundtripArrayBuffer: (key: string, bytes: number[]) => Promise<number[]>;
+		roundtripArrayBuffer: (
+			key: string,
+			bytes: number[],
+		) => Promise<number[]>;
 	};
 
-		describe("Actor KV Tests", () => {
-			test("supports text encoding and decoding", async (c: TestContext) => {
-				const { client: rawClient } = await setupDriverTest(
-					c,
-					driverTestConfig,
-				);
-				const client = rawClient as any;
-				const kvHandle =
-					client.kvActor.getOrCreate(["kv-text"]) as unknown as KvTextHandle;
+	describe("Actor KV Tests", () => {
+		test("supports text encoding and decoding", async (c: TestContext) => {
+			const { client: rawClient } = await setupDriverTest(
+				c,
+				driverTestConfig,
+			);
+			const client = rawClient as any;
+			const kvHandle = client.kvActor.getOrCreate([
+				"kv-text",
+			]) as unknown as KvTextHandle;
 
 			await kvHandle.putText("greeting", "hello");
 			const value = await kvHandle.getText("greeting");
@@ -38,28 +53,59 @@ export function runActorKvTests(driverTestConfig: DriverTestConfig) {
 			]);
 		});
 
-		test(
-			"supports arrayBuffer encoding and decoding",
-			async (c: TestContext) => {
-				const { client: rawClient } = await setupDriverTest(
-					c,
-					driverTestConfig,
-				);
-				const client = rawClient as any;
-				const kvHandle = client.kvActor.getOrCreate([
-					"kv-array-buffer",
-				]) as unknown as KvArrayBufferHandle;
+		test("supports range scans and range deletes", async (c: TestContext) => {
+			const { client: rawClient } = await setupDriverTest(
+				c,
+				driverTestConfig,
+			);
+			const client = rawClient as any;
+			const kvHandle = client.kvActor.getOrCreate([
+				"kv-range",
+			]) as unknown as KvTextHandle;
 
-				const values = await kvHandle.roundtripArrayBuffer("bytes", [
-					4,
-					8,
-					15,
-					16,
-					23,
-					42,
-				]);
-				expect(values).toEqual([4, 8, 15, 16, 23, 42]);
-			},
+			await kvHandle.putText("a", "alpha");
+			await kvHandle.putText("b", "bravo");
+			await kvHandle.putText("c", "charlie");
+			await kvHandle.putText("d", "delta");
+
+			const range = await kvHandle.listTextRange("b", "d");
+			expect(range).toEqual([
+				{ key: "b", value: "bravo" },
+				{ key: "c", value: "charlie" },
+			]);
+
+			const reversed = await kvHandle.listTextRange("a", "d", {
+				reverse: true,
+				limit: 2,
+			});
+			expect(reversed).toEqual([
+				{ key: "c", value: "charlie" },
+				{ key: "b", value: "bravo" },
+			]);
+
+			await kvHandle.deleteTextRange("b", "d");
+			const remaining = await kvHandle.listText("");
+			expect(remaining).toEqual([
+				{ key: "a", value: "alpha" },
+				{ key: "d", value: "delta" },
+			]);
+		});
+
+		test("supports arrayBuffer encoding and decoding", async (c: TestContext) => {
+			const { client: rawClient } = await setupDriverTest(
+				c,
+				driverTestConfig,
+			);
+			const client = rawClient as any;
+			const kvHandle = client.kvActor.getOrCreate([
+				"kv-array-buffer",
+			]) as unknown as KvArrayBufferHandle;
+
+			const values = await kvHandle.roundtripArrayBuffer(
+				"bytes",
+				[4, 8, 15, 16, 23, 42],
 			);
+			expect(values).toEqual([4, 8, 15, 16, 23, 42]);
 		});
-	}
+	});
+}

package/src/driver-test-suite/tests/actor-lifecycle.ts

@@ -45,9 +45,7 @@ export function runActorLifecycleTests(driverTestConfig: DriverTestConfig) {
 
 			// Create multiple actors rapidly to increase chance of race
 			const actors = Array.from({ length: 5 }, (_, i) =>
-				client.startStopRaceActor.getOrCreate([
-					`${actorKey}-${i}`,
-				]),
+				client.startStopRaceActor.getOrCreate([`${actorKey}-${i}`]),
 			);
 
 			// Resolve all actor IDs (this triggers start)
@@ -66,9 +64,7 @@ export function runActorLifecycleTests(driverTestConfig: DriverTestConfig) {
 					expect(err.group).toBe("actor");
 					expect(err.code).toBe("not_found");
 				}
-				expect(destroyed, `actor ${id} should be destroyed`).toBe(
-					true,
-				);
+				expect(destroyed, `actor ${id} should be destroyed`).toBe(true);
 			}
 		});
 
@@ -98,9 +94,7 @@ export function runActorLifecycleTests(driverTestConfig: DriverTestConfig) {
 			// Perform multiple rapid create/destroy cycles
 			for (let i = 0; i < 10; i++) {
 				const actorKey = `test-rapid-cycle-${Date.now()}-${i}`;
-				const actor = client.startStopRaceActor.getOrCreate([
-					actorKey,
-				]);
+				const actor = client.startStopRaceActor.getOrCreate([actorKey]);
 
 				// Trigger start
 				const resolvePromise = actor.resolve();
@@ -127,9 +121,7 @@ export function runActorLifecycleTests(driverTestConfig: DriverTestConfig) {
 			await actor.destroy();
 
 			// Try to recreate with same key - should work without issues
-			const newActor = client.startStopRaceActor.getOrCreate([
-				actorKey,
-			]);
+			const newActor = client.startStopRaceActor.getOrCreate([actorKey]);
 			const result = await newActor.ping();
 			expect(result).toBe("pong");
 

package/src/driver-test-suite/tests/actor-queue.ts

@@ -1,10 +1,67 @@
+// @ts-nocheck
 import { describe, expect, test } from "vitest";
 import type { ActorError } from "@/client/mod";
+import { MANY_QUEUE_NAMES } from "../../../fixtures/driver-test-suite/queue";
 import type { DriverTestConfig } from "../mod";
 import { setupDriverTest, waitFor } from "../utils";
 
 export function runActorQueueTests(driverTestConfig: DriverTestConfig) {
 	describe("Actor Queue Tests", () => {
+		async function expectManyQueueChildToDrain(
+			handle: Awaited<ReturnType<typeof setupDriverTest>>["client"]["manyQueueChildActor"],
+			key: string,
+		) {
+			const child = handle.getOrCreate([key]);
+			const conn = child.connect();
+			const messageCount = MANY_QUEUE_NAMES.length * 4;
+
+			try {
+				expect(await conn.ping()).toEqual(
+					expect.objectContaining({
+						pong: true,
+					}),
+				);
+
+				await Promise.all(
+					Array.from({ length: messageCount }, (_, index) =>
+						child.send(
+							MANY_QUEUE_NAMES[index % MANY_QUEUE_NAMES.length],
+							{ index },
+						),
+					),
+				);
+
+				let snapshot = await child.getSnapshot();
+				for (
+					let i = 0;
+					i < 60 && snapshot.processed.length < messageCount;
+					i++
+				) {
+					await waitFor(driverTestConfig, 100);
+					snapshot = await child.getSnapshot();
+				}
+
+				expect(snapshot.started).toBe(true);
+				expect(snapshot.processed).toHaveLength(messageCount);
+				expect(new Set(snapshot.processed)).toEqual(
+					new Set(MANY_QUEUE_NAMES),
+				);
+
+				expect(
+					await child.send(
+						MANY_QUEUE_NAMES[0],
+						{ index: messageCount },
+						{ wait: true, timeout: 1_000 },
+					),
+				).toEqual({
+					status: "completed",
+					response: { ok: true, index: messageCount },
+				});
+			} finally {
+				await conn.dispose().catch(() => undefined);
+			}
+		}
+
 		test("client can send to actor queue", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
 			const handle = client.queueActor.getOrCreate(["client-send"]);
@@ -182,16 +239,17 @@ export function runActorQueueTests(driverTestConfig: DriverTestConfig) {
 			}
 		});
 
-			test("wait send returns completion response", async (c) => {
-				const { client } = await setupDriverTest(c, driverTestConfig);
-				const handle = client.queueActor.getOrCreate(["wait-complete"]);
-				const waitTimeout = driverTestConfig.useRealTimers ? 5_000 : 1_000;
+		test("wait send returns completion response", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.queueActor.getOrCreate(["wait-complete"]);
+			const waitTimeout = driverTestConfig.useRealTimers ? 5_000 : 1_000;
 
-				const actionPromise = handle.receiveAndComplete("tasks");
-				const result = await handle.send("tasks", 
-					{ value: 123 },
-					{ wait: true, timeout: waitTimeout },
-				);
+			const actionPromise = handle.receiveAndComplete("tasks");
+			const result = await handle.send(
+				"tasks",
+				{ value: 123 },
+				{ wait: true, timeout: waitTimeout },
+			);
 
 			await actionPromise;
 			expect(result).toEqual({
@@ -204,7 +262,8 @@ export function runActorQueueTests(driverTestConfig: DriverTestConfig) {
 			const { client } = await setupDriverTest(c, driverTestConfig);
 			const handle = client.queueActor.getOrCreate(["wait-timeout"]);
 
-			const resultPromise = handle.send("timeout", 
+			const resultPromise = handle.send(
+				"timeout",
 				{ value: 456 },
 				{ wait: true, timeout: 50 },
 			);
@@ -215,6 +274,56 @@ export function runActorQueueTests(driverTestConfig: DriverTestConfig) {
 			expect(result.status).toBe("timedOut");
 		});
 
+		test(
+			"drains many-queue child actors created from actions while connected",
+			async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+				const parent = client.manyQueueActionParentActor.getOrCreate([
+					"many-action-parent",
+				]);
+
+				expect(await parent.spawnChild("many-action-child")).toEqual({
+					key: "many-action-child",
+				});
+
+				await expectManyQueueChildToDrain(
+					client.manyQueueChildActor,
+					"many-action-child",
+				);
+			},
+		);
+
+		test(
+			"drains many-queue child actors created from run handlers while connected",
+			async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+				const parent = client.manyQueueRunParentActor.getOrCreate([
+					"many-run-parent",
+				]);
+
+				expect(await parent.queueSpawn("many-run-child")).toEqual({
+					queued: true,
+				});
+
+				let spawned = await parent.getSpawned();
+				for (
+					let i = 0;
+					i < 30 && !spawned.includes("many-run-child");
+					i++
+				) {
+					await waitFor(driverTestConfig, 100);
+					spawned = await parent.getSpawned();
+				}
+
+				expect(spawned).toContain("many-run-child");
+
+				await expectManyQueueChildToDrain(
+					client.manyQueueChildActor,
+					"many-run-child",
+				);
+			},
+		);
+
 		test("manual receive retries message when not completed", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
 			const handle = client.queueActor.getOrCreate([
@@ -225,7 +334,9 @@ export function runActorQueueTests(driverTestConfig: DriverTestConfig) {
 			const first = await handle.receiveWithoutComplete("tasks");
 			expect(first).toEqual({ name: "tasks", body: { value: 789 } });
 
-			const retried = await handle.receiveOne("tasks", { timeout: 1_000 });
+			const retried = await handle.receiveOne("tasks", {
+				timeout: 1_000,
+			});
 			expect(retried).toEqual({ name: "tasks", body: { value: 789 } });
 		});
 
@@ -236,9 +347,8 @@ export function runActorQueueTests(driverTestConfig: DriverTestConfig) {
 			]);
 
 			await handle.send("tasks", { value: 111 });
-			const result = await handle.receiveManualThenNextWithoutComplete(
-				"tasks",
-			);
+			const result =
+				await handle.receiveManualThenNextWithoutComplete("tasks");
 			expect(result).toEqual({
 				group: "queue",
 				code: "previous_message_not_completed",
@@ -275,9 +385,7 @@ export function runActorQueueTests(driverTestConfig: DriverTestConfig) {
 
 		test("complete throws when called twice", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
-			const handle = client.queueActor.getOrCreate([
-				"complete-twice",
-			]);
+			const handle = client.queueActor.getOrCreate(["complete-twice"]);
 
 			await handle.send("twice", { value: "test" });
 			const result = await handle.receiveAndCompleteTwice("twice");