rivetkit 2.0.42 → 2.1.0-rc.1

package/src/db/shared.ts

@@ -0,0 +1,92 @@
+import type { DatabaseProviderContext } from "./config";
+import type { Database } from "@rivetkit/sqlite-vfs";
+import type { KvVfsOptions } from "./sqlite-vfs";
+
+type ActorKvOperations = DatabaseProviderContext["kv"];
+type SqliteBindings = NonNullable<Parameters<Database["run"]>[1]>;
+
+function isSqliteBindingValue(value: unknown): boolean {
+	if (
+		value === null ||
+		typeof value === "number" ||
+		typeof value === "string" ||
+		typeof value === "bigint" ||
+		value instanceof Uint8Array
+	) {
+		return true;
+	}
+
+	if (Array.isArray(value)) {
+		return value.every((item) => typeof item === "number");
+	}
+
+	return false;
+}
+
+export function toSqliteBindings(args: unknown[]): SqliteBindings {
+	for (const value of args) {
+		if (!isSqliteBindingValue(value)) {
+			throw new Error(
+				`unsupported sqlite binding type: ${typeof value}`,
+			);
+		}
+	}
+
+	return args as SqliteBindings;
+}
+
+/**
+ * Create a KV store wrapper that uses the actor driver's KV operations.
+ */
+export function createActorKvStore(kv: ActorKvOperations): KvVfsOptions {
+	return {
+		get: async (key: Uint8Array) => {
+			const results = await kv.batchGet([key]);
+			return results[0] ?? null;
+		},
+		getBatch: async (keys: Uint8Array[]) => {
+			return await kv.batchGet(keys);
+		},
+		put: async (key: Uint8Array, value: Uint8Array) => {
+			await kv.batchPut([[key, value]]);
+		},
+		putBatch: async (entries: [Uint8Array, Uint8Array][]) => {
+			await kv.batchPut(entries);
+		},
+		deleteBatch: async (keys: Uint8Array[]) => {
+			await kv.batchDelete(keys);
+		},
+	};
+}
+
+/**
+ * Serialize async operations on a shared non-reentrant resource.
+ */
+export class AsyncMutex {
+	#locked = false;
+	#waiting: (() => void)[] = [];
+
+	async acquire(): Promise<void> {
+		while (this.#locked) {
+			await new Promise<void>((resolve) => this.#waiting.push(resolve));
+		}
+		this.#locked = true;
+	}
+
+	release(): void {
+		this.#locked = false;
+		const next = this.#waiting.shift();
+		if (next) {
+			next();
+		}
+	}
+
+	async run<T>(fn: () => Promise<T>): Promise<T> {
+		await this.acquire();
+		try {
+			return await fn();
+		} finally {
+			this.release();
+		}
+	}
+}

package/src/db/sqlite-vfs.ts

@@ -0,0 +1,12 @@
+import { SqliteVfs, type KvVfsOptions } from "@rivetkit/sqlite-vfs";
+
+let sqliteVfsInstance: SqliteVfs | null = null;
+
+export async function getSqliteVfs(): Promise<SqliteVfs> {
+	if (!sqliteVfsInstance) {
+		sqliteVfsInstance = new SqliteVfs();
+	}
+	return sqliteVfsInstance;
+}
+
+export type { KvVfsOptions };

package/src/driver-helpers/mod.ts

@@ -1,4 +1,5 @@
 export type { ActorDriver } from "@/actor/driver";
+export { KEYS, makeConnKey } from "@/actor/instance/keys";
 export type { ActorInstance, AnyActorInstance } from "@/actor/instance/mod";
 export {
 	ALLOWED_PUBLIC_HEADERS,

package/src/driver-test-suite/mod.ts

@@ -10,12 +10,13 @@ import {
 	RegistryConfig,
 	RegistryConfigSchema,
 } from "@/registry/config";
-import { getPort } from "@/test/mod";
 import { logger } from "./log";
 import { runActionFeaturesTests } from "./tests/action-features";
+import { runAccessControlTests } from "./tests/access-control";
 import { runActorConnTests } from "./tests/actor-conn";
 import { runActorConnHibernationTests } from "./tests/actor-conn-hibernation";
 import { runActorConnStateTests } from "./tests/actor-conn-state";
+import { runActorDbTests } from "./tests/actor-db";
 import { runActorDestroyTests } from "./tests/actor-destroy";
 import { runActorDriverTests } from "./tests/actor-driver";
 import { runActorErrorHandlingTests } from "./tests/actor-error-handling";
@@ -25,7 +26,11 @@ import { runActorInspectorTests } from "./tests/actor-inspector";
 import { runActorKvTests } from "./tests/actor-kv";
 import { runActorMetadataTests } from "./tests/actor-metadata";
 import { runActorOnStateChangeTests } from "./tests/actor-onstatechange";
+import { runActorQueueTests } from "./tests/actor-queue";
+import { runActorRunTests } from "./tests/actor-run";
+import { runActorStatelessTests } from "./tests/actor-stateless";
 import { runActorVarsTests } from "./tests/actor-vars";
+import { runActorWorkflowTests } from "./tests/actor-workflow";
 import { runManagerDriverTests } from "./tests/manager-driver";
 import { runRawHttpTests } from "./tests/raw-http";
 import { runRawHttpRequestPropertiesTests } from "./tests/raw-http-request-properties";
@@ -81,67 +86,81 @@ export interface DriverDeployOutput {
 export function runDriverTests(
 	driverTestConfigPartial: Omit<DriverTestConfig, "clientType" | "encoding">,
 ) {
-	const clientTypes: ClientType[] = driverTestConfigPartial.skip?.inline
-		? ["http"]
-		: ["http", "inline"];
-	for (const clientType of clientTypes) {
-		describe(`client type (${clientType})`, () => {
-			const encodings: Encoding[] = ["bare", "cbor", "json"];
+	describe("Driver Tests", () => {
+		const clientTypes: ClientType[] = driverTestConfigPartial.skip?.inline
+			? ["http"]
+			: ["http", "inline"];
+		for (const clientType of clientTypes) {
+			describe(`client type (${clientType})`, () => {
+				const encodings: Encoding[] = ["bare", "cbor", "json"];
 
-			for (const encoding of encodings) {
-				describe(`encoding (${encoding})`, () => {
-					const driverTestConfig: DriverTestConfig = {
-						...driverTestConfigPartial,
-						clientType,
-						encoding,
-					};
+				for (const encoding of encodings) {
+					describe(`encoding (${encoding})`, () => {
+						const driverTestConfig: DriverTestConfig = {
+							...driverTestConfigPartial,
+							clientType,
+							encoding,
+						};
 
-					runActorDriverTests(driverTestConfig);
-					runManagerDriverTests(driverTestConfig);
+						runActorDriverTests(driverTestConfig);
+						runManagerDriverTests(driverTestConfig);
 
-					runActorConnTests(driverTestConfig);
+						runActorConnTests(driverTestConfig);
 
-					runActorConnStateTests(driverTestConfig);
+						runActorConnStateTests(driverTestConfig);
 
-					runActorConnHibernationTests(driverTestConfig);
+						runActorConnHibernationTests(driverTestConfig);
 
-					runActorDestroyTests(driverTestConfig);
+						runActorDbTests(driverTestConfig);
 
-					runRequestAccessTests(driverTestConfig);
+						runActorDestroyTests(driverTestConfig);
 
-					runActorHandleTests(driverTestConfig);
+						runRequestAccessTests(driverTestConfig);
 
-					runActionFeaturesTests(driverTestConfig);
+						runActorHandleTests(driverTestConfig);
 
-					runActorVarsTests(driverTestConfig);
+						runActionFeaturesTests(driverTestConfig);
 
-					runActorMetadataTests(driverTestConfig);
+						runAccessControlTests(driverTestConfig);
 
-					runActorOnStateChangeTests(driverTestConfig);
+						runActorVarsTests(driverTestConfig);
 
-					runActorErrorHandlingTests(driverTestConfig);
+						runActorMetadataTests(driverTestConfig);
 
-					runActorInlineClientTests(driverTestConfig);
+						runActorOnStateChangeTests(driverTestConfig);
 
-					runActorKvTests(driverTestConfig);
+						runActorErrorHandlingTests(driverTestConfig);
 
-					runRawHttpTests(driverTestConfig);
+						runActorQueueTests(driverTestConfig);
 
-					runRawHttpRequestPropertiesTests(driverTestConfig);
+						runActorRunTests(driverTestConfig);
 
-					runRawWebSocketTests(driverTestConfig);
+						runActorInlineClientTests(driverTestConfig);
 
-					// TODO: re-expose this once we can have actor queries on the gateway
-					// runRawHttpDirectRegistryTests(driverTestConfig);
+						runActorKvTests(driverTestConfig);
 
-					// TODO: re-expose this once we can have actor queries on the gateway
-					// runRawWebSocketDirectRegistryTests(driverTestConfig);
+						runActorWorkflowTests(driverTestConfig);
 
-					runActorInspectorTests(driverTestConfig);
-				});
-			}
-		});
-	}
+						runActorStatelessTests(driverTestConfig);
+
+						runRawHttpTests(driverTestConfig);
+
+						runRawHttpRequestPropertiesTests(driverTestConfig);
+
+						runRawWebSocketTests(driverTestConfig);
+
+						// TODO: re-expose this once we can have actor queries on the gateway
+						// runRawHttpDirectRegistryTests(driverTestConfig);
+
+						// TODO: re-expose this once we can have actor queries on the gateway
+						// runRawWebSocketDirectRegistryTests(driverTestConfig);
+
+						runActorInspectorTests(driverTestConfig);
+					});
+				}
+			});
+		}
+	});
 }
 
 /**
@@ -231,17 +250,24 @@ export async function createTestRuntime(
 
 		// TODO: I think this whole function is fucked, we should probably switch to calling registry.serve() directly
 		// Start server
-		const port = await getPort();
 		const server = honoServe({
 			fetch: router.fetch,
 			hostname: "127.0.0.1",
-			port,
+			port: 0,
 		});
+		if (!server.listening) {
+			await new Promise<void>((resolve) => {
+				server.once("listening", () => resolve());
+			});
+		}
 		invariant(
 			nodeWebSocket.injectWebSocket !== undefined,
 			"should have injectWebSocket",
 		);
 		nodeWebSocket.injectWebSocket(server);
+		const address = server.address();
+		invariant(address && typeof address !== "string", "missing server address");
+		const port = address.port;
 		const serverEndpoint = `http://127.0.0.1:${port}`;
 
 		logger().info({ msg: "test serer listening", port });

package/src/driver-test-suite/tests/access-control.ts

@@ -0,0 +1,218 @@
+import { describe, expect, test } from "vitest";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest } from "../utils";
+
+export function runAccessControlTests(driverTestConfig: DriverTestConfig) {
+	describe("access control", () => {
+		test("actions run without entrypoint auth gating", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.accessControlActor.getOrCreate(["actions"]);
+
+			const allowed = await handle.allowedAction("ok");
+			expect(allowed).toBe("allowed:ok");
+		});
+
+		test("passes connection id into canPublish context", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.accessControlActor.getOrCreate(["publish-ctx"]);
+
+			await handle.send("allowedQueue", { value: "one" });
+
+			const connId = await handle.allowedGetLastCanPublishConnId();
+			expect(typeof connId).toBe("string");
+			expect(connId.length).toBeGreaterThan(0);
+		});
+
+		test("allows and denies queue sends, and ignores undefined queues", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.accessControlActor.getOrCreate(["queue"]);
+
+			await handle.send("allowedQueue", { value: "one" });
+			await expect(
+				handle.send("blockedQueue", { value: "two" }),
+			).rejects.toMatchObject({
+				code: "forbidden",
+			});
+			await expect(
+				handle.send("missingQueue", { value: "three" }),
+			).resolves.toBeUndefined();
+			await expect(
+				handle.send(
+					"missingQueue",
+					{ value: "four" },
+					{ wait: true, timeout: 50 },
+				),
+			).resolves.toMatchObject({ status: "completed" });
+
+			const allowedMessage = await handle.allowedReceiveQueue();
+			expect(allowedMessage).toEqual({ value: "one" });
+
+			const remainingMessage = await handle.allowedReceiveAnyQueue();
+			expect(remainingMessage).toBeNull();
+		});
+
+		test("ignores incoming queue sends when actor has no queues config", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.accessControlNoQueuesActor.getOrCreate([
+				"no-queues",
+			]);
+
+			await expect(
+				handle.send("anyQueue", { value: "ignored" }),
+			).resolves.toBeUndefined();
+			await expect(
+				handle.send(
+					"anyQueue",
+					{ value: "ignored-wait" },
+					{ wait: true, timeout: 50 },
+				),
+			).resolves.toMatchObject({ status: "completed" });
+			expect(await handle.readAnyQueue()).toBeNull();
+		});
+
+		test("allows and denies subscriptions with canSubscribe", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.accessControlActor.getOrCreate([
+				"subscription",
+			]);
+			const conn = handle.connect();
+
+			const allowedEventPromise = new Promise<{ value: string }>(
+				(resolve, reject) => {
+					const unsubscribeError = conn.onError((error) => {
+						reject(error);
+					});
+					const unsubscribeEvent = conn.on(
+						"allowedEvent",
+						(payload) => {
+							unsubscribeError();
+							unsubscribeEvent();
+							resolve(payload as { value: string });
+						},
+					);
+				},
+			);
+
+			await conn.allowedAction("subscribe-ready");
+			await conn.allowedBroadcastAllowedEvent("hello");
+			expect(await allowedEventPromise).toEqual({ value: "hello" });
+
+			const connId = await conn.allowedGetLastCanSubscribeConnId();
+			expect(typeof connId).toBe("string");
+			expect(connId.length).toBeGreaterThan(0);
+
+			await conn.dispose();
+
+			const blockedConn = handle.connect();
+			blockedConn.on("blockedEvent", () => { });
+			await expect(
+				blockedConn.allowedAction("blocked-subscribe-ready"),
+			).rejects.toMatchObject({
+				code: "forbidden",
+			});
+			await blockedConn.dispose();
+		});
+
+		test("broadcasts undefined events without failing subscriptions", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.accessControlActor.getOrCreate([
+				"undefined-event",
+			]);
+			const conn = handle.connect();
+
+			const eventPromise = new Promise<{ value: string }>((resolve, reject) => {
+				const unsubscribeError = conn.onError((error) => {
+					reject(error);
+				});
+				const unsubscribeEvent = conn.on("undefinedEvent", (payload) => {
+					unsubscribeError();
+					unsubscribeEvent();
+					resolve(payload as { value: string });
+				});
+			});
+
+			await conn.allowedAction("undefined-subscribe-ready");
+			await conn.allowedBroadcastUndefinedEvent("wildcard");
+			expect(await eventPromise).toEqual({ value: "wildcard" });
+
+			await conn.dispose();
+		});
+
+		test("allows and denies raw request handlers", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const allowedHandle = client.accessControlActor.getOrCreate(
+				["raw-request-allow"],
+				{
+					params: { allowRequest: true },
+				},
+			);
+			const deniedHandle = client.accessControlActor.getOrCreate(
+				["raw-request-deny"],
+				{
+					params: { allowRequest: false },
+				},
+			);
+
+			const allowedResponse = await allowedHandle.fetch("/status");
+			expect(allowedResponse.status).toBe(200);
+			expect(await allowedResponse.json()).toEqual({ ok: true });
+
+			const deniedResponse = await deniedHandle.fetch("/status");
+			expect(deniedResponse.status).toBe(403);
+		});
+
+		test("allows and denies raw websocket handlers", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const allowedHandle = client.accessControlActor.getOrCreate(
+				["raw-websocket-allow"],
+				{
+					params: { allowWebSocket: true },
+				},
+			);
+			const ws = await allowedHandle.webSocket();
+			const welcome = await new Promise<{ type: string }>((resolve) => {
+				ws.addEventListener(
+					"message",
+					(event: any) => {
+						resolve(
+							JSON.parse(event.data as string) as {
+								type: string;
+							},
+						);
+					},
+					{ once: true },
+				);
+			});
+			expect(welcome.type).toBe("welcome");
+			ws.close();
+
+			const deniedHandle = client.accessControlActor.getOrCreate(
+				["raw-websocket-deny"],
+				{
+					params: { allowWebSocket: false },
+				},
+			);
+
+			let denied = false;
+			try {
+				const deniedWs = await deniedHandle.webSocket();
+				const closeEvent = await new Promise<any>((resolve) => {
+					deniedWs.addEventListener(
+						"close",
+						(event: any) => {
+							resolve(event);
+						},
+						{ once: true },
+					);
+				});
+				expect(closeEvent.code).toBe(1011);
+				denied = true;
+			} catch {
+				denied = true;
+			}
+			expect(denied).toBe(true);
+		});
+	});
+}

package/src/driver-test-suite/tests/actor-db-raw.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "vitest";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest } from "../utils";
+
+export function runActorDbRawTests(driverTestConfig: DriverTestConfig) {
+	describe("Actor Database (Raw) Tests", () => {
+		describe("Database Basic Operations", () => {
+			test("creates and queries database tables", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				const instance = client.dbActorRaw.getOrCreate();
+
+				// Add values
+				await instance.insertValue("Alice");
+				await instance.insertValue("Bob");
+
+				// Query values
+				const values = await instance.getValues();
+				expect(values).toHaveLength(2);
+				expect(values[0].value).toBe("Alice");
+				expect(values[1].value).toBe("Bob");
+			});
+
+			test("persists data across actor instances", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// First instance adds items
+				const instance1 = client.dbActorRaw.getOrCreate(["test-persistence"]);
+				await instance1.insertValue("Item 1");
+				await instance1.insertValue("Item 2");
+
+				// Second instance (same actor) should see persisted data
+				const instance2 = client.dbActorRaw.getOrCreate(["test-persistence"]);
+				const count = await instance2.getCount();
+				expect(count).toBe(2);
+			});
+
+			test("maintains separate databases for different actors", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// First actor
+				const actor1 = client.dbActorRaw.getOrCreate(["actor-1"]);
+				await actor1.insertValue("A");
+				await actor1.insertValue("B");
+
+				// Second actor
+				const actor2 = client.dbActorRaw.getOrCreate(["actor-2"]);
+				await actor2.insertValue("X");
+
+				// Verify separate data
+				const count1 = await actor1.getCount();
+				const count2 = await actor2.getCount();
+				expect(count1).toBe(2);
+				expect(count2).toBe(1);
+			});
+		});
+
+		describe("Database Migrations", () => {
+			test("runs migrations on actor startup", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				const instance = client.dbActorRaw.getOrCreate();
+
+				// Try to insert into the table to verify it exists
+				await instance.insertValue("test");
+				const values = await instance.getValues();
+
+				expect(values).toHaveLength(1);
+				expect(values[0].value).toBe("test");
+			});
+		});
+	});
+}