rivetkit 2.0.23 → 2.0.24

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

@@ -1,10 +1,9 @@
 import { serve as honoServe } from "@hono/node-server";
 import { createNodeWebSocket, type NodeWebSocket } from "@hono/node-ws";
-import { bundleRequire } from "bundle-require";
 import invariant from "invariant";
 import { describe } from "vitest";
 import { ClientConfigSchema } from "@/client/config";
-import type { Encoding, Transport } from "@/client/mod";
+import type { Encoding } from "@/client/mod";
 import { configureInspectorAccessToken } from "@/inspector/utils";
 import { createManagerRouter } from "@/manager/router";
 import {
@@ -19,17 +18,15 @@ import { logger } from "./log";
 import { runActionFeaturesTests } from "./tests/action-features";
 import { runActorConnTests } from "./tests/actor-conn";
 import { runActorConnStateTests } from "./tests/actor-conn-state";
-import {
-	runActorDriverTests,
-	runActorDriverTestsWithTransport,
-} from "./tests/actor-driver";
+import { runActorDestroyTests } from "./tests/actor-destroy";
+import { runActorDriverTests } from "./tests/actor-driver";
 import { runActorErrorHandlingTests } from "./tests/actor-error-handling";
 import { runActorHandleTests } from "./tests/actor-handle";
+import { runActorConnHibernationTests } from "./tests/actor-conn-hibernation";
 import { runActorInlineClientTests } from "./tests/actor-inline-client";
 import { runActorInspectorTests } from "./tests/actor-inspector";
 import { runActorMetadataTests } from "./tests/actor-metadata";
 import { runActorOnStateChangeTests } from "./tests/actor-onstatechange";
-import { runActorReconnectTests } from "./tests/actor-reconnect";
 import { runActorVarsTests } from "./tests/actor-vars";
 import { runManagerDriverTests } from "./tests/manager-driver";
 import { runRawHttpTests } from "./tests/raw-http";
@@ -40,7 +37,7 @@ import { runRequestAccessTests } from "./tests/request-access";
 export interface SkipTests {
 	schedule?: boolean;
 	sleep?: boolean;
-	sse?: boolean;
+	hibernation?: boolean;
 	inline?: boolean;
 }
 
@@ -59,8 +56,6 @@ export interface DriverTestConfig {
 
 	skip?: SkipTests;
 
-	transport?: Transport;
-
 	encoding?: Encoding;
 
 	clientType: ClientType;
@@ -86,10 +81,7 @@ export interface DriverDeployOutput {
 
 /** Runs all Vitest tests against the provided drivers. */
 export function runDriverTests(
-	driverTestConfigPartial: Omit<
-		DriverTestConfig,
-		"clientType" | "transport" | "encoding"
-	>,
+	driverTestConfigPartial: Omit<DriverTestConfig, "clientType" | "encoding">,
 ) {
 	const clientTypes: ClientType[] = driverTestConfigPartial.skip?.inline
 		? ["http"]
@@ -109,37 +101,15 @@ export function runDriverTests(
 					runActorDriverTests(driverTestConfig);
 					runManagerDriverTests(driverTestConfig);
 
-					const transports: Transport[] = driverTestConfig.skip?.sse
-						? ["websocket"]
-						: ["websocket", "sse"];
-					for (const transport of transports) {
-						describe(`transport (${transport})`, () => {
-							runActorConnTests({
-								...driverTestConfig,
-								transport,
-							});
-
-							runActorConnStateTests({
-								...driverTestConfig,
-								transport,
-							});
-
-							runActorReconnectTests({
-								...driverTestConfig,
-								transport,
-							});
-
-							runRequestAccessTests({
-								...driverTestConfig,
-								transport,
-							});
-
-							runActorDriverTestsWithTransport({
-								...driverTestConfig,
-								transport,
-							});
-						});
-					}
+					runActorConnTests(driverTestConfig);
+
+					runActorConnStateTests(driverTestConfig);
+
+					runActorConnHibernationTests(driverTestConfig);
+
+					runActorDestroyTests(driverTestConfig);
+
+					runRequestAccessTests(driverTestConfig);
 
 					runActorHandleTests(driverTestConfig);
 
@@ -192,11 +162,17 @@ export async function createTestRuntime(
 		cleanup?: () => Promise<void>;
 	}>,
 ): Promise<DriverDeployOutput> {
-	const {
-		mod: { registry },
-	} = await bundleRequire<{ registry: Registry<any> }>({
-		filepath: registryPath,
-	});
+	// Import using dynamic imports with vitest alias resolution
+	//
+	// Vitest is configured to resolve `import ... from "rivetkit"` to the
+	// appropriate source files
+	//
+	// We need to preserve the `import ... from "rivetkit"` in the fixtures so
+	// targets that run the server separately from the Vitest tests (such as
+	// Cloudflare Workers) still function.
+	const { registry } = (await import(registryPath)) as {
+		registry: Registry<any>;
+	};
 
 	// TODO: Find a cleaner way of flagging an registry as test mode (ideally not in the config itself)
 	// Force enable test

package/src/driver-test-suite/test-inline-client-driver.ts

@@ -5,7 +5,6 @@ import type { WebSocket } from "ws";
 import type { Encoding } from "@/actor/protocol/serde";
 import { assertUnreachable } from "@/actor/utils";
 import { ActorError as ClientActorError } from "@/client/errors";
-import type { Transport } from "@/client/mod";
 import {
 	HEADER_ACTOR_QUERY,
 	HEADER_CONN_PARAMS,
@@ -13,9 +12,9 @@ import {
 	WS_PROTOCOL_ACTOR,
 	WS_PROTOCOL_CONN_PARAMS,
 	WS_PROTOCOL_ENCODING,
-	WS_PROTOCOL_PATH,
+	WS_PROTOCOL_STANDARD,
 	WS_PROTOCOL_TARGET,
-	WS_PROTOCOL_TRANSPORT,
+	WS_TEST_PROTOCOL_PATH,
 } from "@/common/actor-router-consts";
 import type { UniversalEventSource } from "@/common/eventsource-interface";
 import type { DeconstructedError } from "@/common/utils";
@@ -27,6 +26,7 @@ import {
 	type GetOrCreateWithKeyInput,
 	type GetWithKeyInput,
 	HEADER_ACTOR_ID,
+	type ListActorsInput,
 	type ManagerDisplayInformation,
 	type ManagerDriver,
 } from "@/driver-helpers/mod";
@@ -37,7 +37,6 @@ import { logger } from "./log";
 
 export interface TestInlineDriverCallRequest {
 	encoding: Encoding;
-	transport: Transport;
 	method: string;
 	args: unknown[];
 }
@@ -56,46 +55,28 @@ export type TestInlineDriverCallResponse<T> =
 export function createTestInlineClientDriver(
 	endpoint: string,
 	encoding: Encoding,
-	transport: Transport,
 ): ManagerDriver {
 	return {
 		getForId(input: GetForIdInput): Promise<ActorOutput | undefined> {
-			return makeInlineRequest(
-				endpoint,
-				encoding,
-				transport,
-				"getForId",
-				[input],
-			);
+			return makeInlineRequest(endpoint, encoding, "getForId", [input]);
 		},
 		getWithKey(input: GetWithKeyInput): Promise<ActorOutput | undefined> {
-			return makeInlineRequest(
-				endpoint,
-				encoding,
-				transport,
-				"getWithKey",
-				[input],
-			);
+			return makeInlineRequest(endpoint, encoding, "getWithKey", [input]);
 		},
 		getOrCreateWithKey(
 			input: GetOrCreateWithKeyInput,
 		): Promise<ActorOutput> {
-			return makeInlineRequest(
-				endpoint,
-				encoding,
-				transport,
-				"getOrCreateWithKey",
-				[input],
-			);
+			return makeInlineRequest(endpoint, encoding, "getOrCreateWithKey", [
+				input,
+			]);
 		},
 		createActor(input: CreateInput): Promise<ActorOutput> {
-			return makeInlineRequest(
-				endpoint,
-				encoding,
-				transport,
-				"createActor",
-				[input],
-			);
+			return makeInlineRequest(endpoint, encoding, "createActor", [
+				input,
+			]);
+		},
+		listActors(input: ListActorsInput): Promise<ActorOutput[]> {
+			return makeInlineRequest(endpoint, encoding, "listActors", [input]);
 		},
 		async sendRequest(
 			actorId: string,
@@ -153,7 +134,7 @@ export function createTestInlineClientDriver(
 					if (errorData.error) {
 						// Handle both error formats:
 						// 1. { error: { code, message, metadata } } - structured format
-						// 2. { error: "message" } - simple string format (from custom onFetch handlers)
+						// 2. { error: "message" } - simple string format (from custom onRequest handlers)
 						if (typeof errorData.error === "object") {
 							throw new ClientActorError(
 								errorData.error.code,
@@ -162,7 +143,7 @@ export function createTestInlineClientDriver(
 							);
 						}
 						// For simple string errors, just return the response as-is
-						// This allows custom onFetch handlers to return their own error formats
+						// This allows custom onRequest handlers to return their own error formats
 					}
 				} catch (e) {
 					// If it's not our error format, just return the response as-is
@@ -180,8 +161,6 @@ export function createTestInlineClientDriver(
 			actorId: string,
 			encoding: Encoding,
 			params: unknown,
-			connId?: string,
-			connToken?: string,
 		): Promise<UniversalWebSocket> {
 			const WebSocket = await importWebSocket();
 
@@ -202,16 +181,14 @@ export function createTestInlineClientDriver(
 			const wsProtocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
 			const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}`;
 
-			logger().debug({ msg: "connecting to websocket", url: finalWsUrl });
-
 			// Build protocols for the connection
 			const protocols: string[] = [];
+			protocols.push(WS_PROTOCOL_STANDARD);
 			protocols.push(`${WS_PROTOCOL_TARGET}actor`);
-			protocols.push(`${WS_PROTOCOL_ACTOR}${actorId}`);
+			protocols.push(`${WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`);
 			protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
-			protocols.push(`${WS_PROTOCOL_TRANSPORT}${transport}`);
 			protocols.push(
-				`${WS_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`,
+				`${WS_TEST_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`,
 			);
 			if (params !== undefined) {
 				protocols.push(
@@ -219,6 +196,12 @@ export function createTestInlineClientDriver(
 				);
 			}
 
+			logger().debug({
+				msg: "connecting to websocket",
+				url: finalWsUrl,
+				protocols,
+			});
+
 			// Create and return the WebSocket
 			// Node & browser WebSocket types are incompatible
 			const ws = new WebSocket(finalWsUrl, protocols) as any;
@@ -263,7 +246,6 @@ export function createTestInlineClientDriver(
 		// 	return makeInlineRequest<Response>(
 		// 		endpoint,
 		// 		encoding,
-		// 		transport,
 		// 		"action",
 		// 		[undefined, actorQuery, encoding, params, name, args],
 		// 	);
@@ -278,7 +260,6 @@ export function createTestInlineClientDriver(
 		// 	return makeInlineRequest<string>(
 		// 		endpoint,
 		// 		encodingKind,
-		// 		transport,
 		// 		"resolveActorId",
 		// 		[undefined, actorQuery, encodingKind, params],
 		// 	);
@@ -400,7 +381,6 @@ export function createTestInlineClientDriver(
 		// 		actorId,
 		// 		encoding,
 		// 		connectionId,
-		// 		transport,
 		// 	});
 		//
 		// 	const result = await fetch(
@@ -412,7 +392,6 @@ export function createTestInlineClientDriver(
 		// 			},
 		// 			body: JSON.stringify({
 		// 				encoding,
-		// 				transport,
 		// 				method: "sendHttpMessage",
 		// 				args: [
 		// 					undefined,
@@ -483,7 +462,7 @@ export function createTestInlineClientDriver(
 		// 			if (errorData.error) {
 		// 				// Handle both error formats:
 		// 				// 1. { error: { code, message, metadata } } - structured format
-		// 				// 2. { error: "message" } - simple string format (from custom onFetch handlers)
+		// 				// 2. { error: "message" } - simple string format (from custom onRequest handlers)
 		// 				if (typeof errorData.error === "object") {
 		// 					throw new ClientActorError(
 		// 						errorData.error.code,
@@ -492,7 +471,7 @@ export function createTestInlineClientDriver(
 		// 					);
 		// 				}
 		// 				// For simple string errors, just return the response as-is
-		// 				// This allows custom onFetch handlers to return their own error formats
+		// 				// This allows custom onRequest handlers to return their own error formats
 		// 			}
 		// 		} catch (e) {
 		// 			// If it's not our error format, just return the response as-is
@@ -573,14 +552,12 @@ export function createTestInlineClientDriver(
 async function makeInlineRequest<T>(
 	endpoint: string,
 	encoding: Encoding,
-	transport: Transport,
 	method: string,
 	args: unknown[],
 ): Promise<T> {
 	logger().debug({
 		msg: "sending inline request",
 		encoding,
-		transport,
 		method,
 		args,
 	});
@@ -593,7 +570,6 @@ async function makeInlineRequest<T>(
 		},
 		body: cbor.encode({
 			encoding,
-			transport,
 			method,
 			args,
 		} satisfies TestInlineDriverCallRequest),

package/src/driver-test-suite/tests/actor-conn-hibernation.ts

@@ -0,0 +1,150 @@
+import { describe, expect, test, vi } from "vitest";
+import { HIBERNATION_SLEEP_TIMEOUT } from "../../../fixtures/driver-test-suite/hibernation";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest, waitFor } from "../utils";
+
+export function runActorConnHibernationTests(driverTestConfig: DriverTestConfig) {
+	describe.skipIf(driverTestConfig.skip?.hibernation)(
+		"Connection Hibernation",
+		() => {
+			test("basic conn hibernation", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Create actor with connection
+				const hibernatingActor = client.hibernationActor
+					.getOrCreate()
+					.connect();
+
+				// Initial RPC call
+				const ping1 = await hibernatingActor.ping();
+				expect(ping1).toBe("pong");
+
+				// Trigger sleep
+				await hibernatingActor.triggerSleep();
+
+				// Wait for actor to sleep (give it time to hibernate)
+				await waitFor(
+					driverTestConfig,
+					HIBERNATION_SLEEP_TIMEOUT + 100,
+				);
+
+				// Call RPC again - this should wake the actor and work
+				const ping2 = await hibernatingActor.ping();
+				expect(ping2).toBe("pong");
+
+				// Clean up
+				await hibernatingActor.dispose();
+			});
+
+			test("conn state persists through hibernation", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Create actor with connection
+				const hibernatingActor = client.hibernationActor
+					.getOrCreate()
+					.connect();
+
+				// Increment connection count
+				const count1 = await hibernatingActor.connIncrement();
+				expect(count1).toBe(1);
+
+				const count2 = await hibernatingActor.connIncrement();
+				expect(count2).toBe(2);
+
+				// Get initial lifecycle counts
+				const initialLifecycle =
+					await hibernatingActor.getConnLifecycleCounts();
+				expect(initialLifecycle.connectCount).toBe(1);
+				expect(initialLifecycle.disconnectCount).toBe(0);
+
+				// Get initial actor counts
+				const initialActorCounts =
+					await hibernatingActor.getActorCounts();
+				expect(initialActorCounts.wakeCount).toBe(1);
+				expect(initialActorCounts.sleepCount).toBe(0);
+
+				// Trigger sleep
+				await hibernatingActor.triggerSleep();
+
+				// Wait for actor to sleep
+				await waitFor(
+					driverTestConfig,
+					HIBERNATION_SLEEP_TIMEOUT + 100,
+				);
+
+				// Check that connection state persisted
+				const count3 = await hibernatingActor.getConnCount();
+				expect(count3).toBe(2);
+
+				// Verify lifecycle hooks:
+				// - onDisconnect and onConnect should NOT be called during sleep/wake
+				// - onSleep and onWake should be called
+				const finalLifecycle =
+					await hibernatingActor.getConnLifecycleCounts();
+				expect(finalLifecycle.connectCount).toBe(1); // No additional connects
+				expect(finalLifecycle.disconnectCount).toBe(0); // No disconnects
+
+				const finalActorCounts =
+					await hibernatingActor.getActorCounts();
+				expect(finalActorCounts.wakeCount).toBe(2); // Woke up once more
+				expect(finalActorCounts.sleepCount).toBe(1); // Slept once
+
+				// Clean up
+				await hibernatingActor.dispose();
+			});
+
+			test("closing connection during hibernation", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Create actor with first connection
+				const conn1 = client.hibernationActor.getOrCreate().connect();
+
+				// Initial RPC call
+				await conn1.ping();
+
+				// Get connection ID
+				const connectionIds = await conn1.getConnectionIds();
+				expect(connectionIds.length).toBe(1);
+				const conn1Id = connectionIds[0];
+
+				// Trigger sleep
+				await conn1.triggerSleep();
+
+				// Wait for actor to hibernate
+				await waitFor(
+					driverTestConfig,
+					HIBERNATION_SLEEP_TIMEOUT + 100,
+				);
+
+				// Disconnect first connection while actor is sleeping
+				await conn1.dispose();
+
+				// Wait a bit for disconnection to be processed
+				await waitFor(driverTestConfig, 250);
+
+				// Create second connection to verify first connection disconnected
+				const conn2 = client.hibernationActor.getOrCreate().connect();
+
+				// Wait for connection to be established
+				await vi.waitFor(
+					async () => {
+						const newConnectionIds = await conn2.getConnectionIds();
+						expect(newConnectionIds.length).toBe(1);
+						expect(newConnectionIds[0]).not.toBe(conn1Id);
+					},
+					{
+						timeout: 5000,
+						interval: 100,
+					},
+				);
+
+				// Verify onDisconnect was called for the first connection
+				const lifecycle = await conn2.getConnLifecycleCounts();
+				expect(lifecycle.disconnectCount).toBe(0); // Only for conn2, not conn1
+
+				// Clean up
+				await conn2.dispose();
+			});
+		},
+	);
+}

package/src/driver-test-suite/tests/actor-conn-state.ts

@@ -147,10 +147,7 @@ export function runActorConnStateTests(driverTestConfig: DriverTestConfig) {
 		});
 
 		describe("Connection Lifecycle", () => {
-			test.skipIf(
-				driverTestConfig.transport === "sse" &&
-					driverTestConfig.clientType === "inline",
-			)("should track connection and disconnection events", async (c) => {
+			test("should track connection and disconnection events", async (c) => {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				const debugHandle = client.connStateActor.getOrCreate(

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

@@ -1,5 +1,4 @@
 import { describe, expect, test, vi } from "vitest";
-import { SSE_PING_INTERVAL } from "@/actor/router-endpoints";
 import type { DriverTestConfig } from "../mod";
 import { FAKE_TIME, setupDriverTest, waitFor } from "../utils";
 
@@ -247,10 +246,7 @@ export function runActorConnTests(driverTestConfig: DriverTestConfig) {
 		});
 
 		describe("Lifecycle Hooks", () => {
-			test.skipIf(
-				driverTestConfig.transport === "sse" &&
-					driverTestConfig.clientType === "inline",
-			)("should trigger lifecycle hooks", async (c) => {
+			test("should trigger lifecycle hooks", async (c) => {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Create and connect
@@ -265,7 +261,7 @@ export function runActorConnTests(driverTestConfig: DriverTestConfig) {
 				// Verify lifecycle events were triggered
 				const events = await connection.getEvents();
 				expect(events).toEqual([
-					"onStart",
+					"onWake",
 					"onBeforeConnect",
 					"onConnect",
 				]);
@@ -283,18 +279,18 @@ export function runActorConnTests(driverTestConfig: DriverTestConfig) {
 						expect(finalEvents).toBeOneOf([
 							// Still active
 							[
-								"onStart",
+								"onWake",
 								"onBeforeConnect",
 								"onConnect",
 								"onDisconnect",
 							],
 							// Went to sleep and woke back up
 							[
-								"onStart",
+								"onWake",
 								"onBeforeConnect",
 								"onConnect",
 								"onDisconnect",
-								"onStart",
+								"onWake",
 							],
 						]);
 					},