rivetkit 2.0.41 → 2.0.43-rc.1

package/src/driver-test-suite/tests/conn-error-serialization.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from "vitest";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest } from "../utils";
+
+export function runConnErrorSerializationTests(driverTestConfig: DriverTestConfig) {
+	describe("Connection Error Serialization Tests", () => {
+		test("error thrown in createConnState preserves group and code through WebSocket serialization", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = `test-error-serialization-${Date.now()}`;
+
+			// Create actor handle with params that will trigger error in createConnState
+			const actor = client.connErrorSerializationActor.getOrCreate(
+				[actorKey],
+				{ params: { shouldThrow: true } },
+			);
+
+			// Try to connect, which will trigger error in createConnState
+			const conn = actor.connect();
+
+			// Wait for connection to fail
+			let caughtError: any;
+			try {
+				// Try to call an action, which should fail because connection couldn't be established
+				await conn.getValue();
+			} catch (err) {
+				caughtError = err;
+			}
+
+			// Verify the error was caught
+			expect(caughtError).toBeDefined();
+
+			// Verify the error has the correct group and code from the original error
+			// Original error: new CustomConnectionError("...") with group="connection", code="custom_error"
+			expect(caughtError.group).toBe("connection");
+			expect(caughtError.code).toBe("custom_error");
+
+			// Clean up
+			await conn.dispose();
+		});
+
+		test("successful createConnState does not throw error", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = `test-no-error-${Date.now()}`;
+
+			// Create actor handle with params that will NOT trigger error
+			const actor = client.connErrorSerializationActor.getOrCreate(
+				[actorKey],
+				{ params: { shouldThrow: false } },
+			);
+
+			// Connect without triggering error
+			const conn = actor.connect();
+
+			// This should succeed
+			const value = await conn.getValue();
+			expect(value).toBe(0);
+
+			// Clean up
+			await conn.dispose();
+		});
+	});
+}

package/src/drivers/engine/actor-driver.ts

@@ -153,7 +153,7 @@ export class EngineActorDriver implements ActorDriver {
 			onConnected: () => {
 				this.#runnerStarted.resolve(undefined);
 			},
-			onDisconnected: (_code, _reason) => {},
+			onDisconnected: (_code, _reason) => { },
 			onShutdown: () => {
 				this.#runnerStopped.resolve(undefined);
 				this.#isRunnerStopped = true;
@@ -358,7 +358,7 @@ export class EngineActorDriver implements ActorDriver {
 	async serverlessHandleStart(c: HonoContext): Promise<Response> {
 		return streamSSE(c, async (stream) => {
 			// NOTE: onAbort does not work reliably
-			stream.onAbort(() => {});
+			stream.onAbort(() => { });
 			c.req.raw.signal.addEventListener("abort", () => {
 				logger().debug("SSE aborted, shutting down runner");
 
@@ -490,7 +490,26 @@ export class EngineActorDriver implements ActorDriver {
 		this.#actorStopIntent.delete(actorId);
 
 		const handler = this.#actors.get(actorId);
-		if (handler?.actor) {
+		if (!handler) {
+			logger().debug({ msg: "no runner actor handler to stop", actorId, reason });
+			return;
+		}
+
+		if (handler.actorStartPromise) {
+			try {
+				logger().debug({ msg: "runner actor stopping before it started, waiting", actorId, generation });
+				await handler.actorStartPromise.promise;
+			} catch (err) {
+				// Start failed, but we still want to clean up the handler
+				logger().debug({
+					msg: "actor start failed during stop, cleaning up handler",
+					actorId,
+					err: stringifyError(err),
+				});
+			}
+		}
+
+		if (handler.actor) {
 			try {
 				await handler.actor.onStop(reason);
 			} catch (err) {
@@ -499,9 +518,10 @@ export class EngineActorDriver implements ActorDriver {
 					err: stringifyError(err),
 				});
 			}
-			this.#actors.delete(actorId);
 		}
 
+		this.#actors.delete(actorId);
+
 		logger().debug({ msg: "runner actor stopped", actorId, reason });
 	}
 

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

@@ -0,0 +1,147 @@
+import { serve as honoServe } from "@hono/node-server";
+import { createNodeWebSocket } from "@hono/node-ws";
+import { createServer } from "node:net";
+import { fileURLToPath } from "node:url";
+import invariant from "invariant";
+import { buildManagerRouter } from "@/manager/router";
+import { createFileSystemOrMemoryDriver } from "@/drivers/file-system/mod";
+import { logger } from "@/driver-test-suite/log";
+import { registry } from "../../fixtures/driver-test-suite/registry";
+
+export interface ServeTestSuiteResult {
+	endpoint: string;
+	namespace: string;
+	runnerName: string;
+	close(): Promise<void>;
+}
+
+async function getPort(): Promise<number> {
+	const MIN_PORT = 10000;
+	const MAX_PORT = 65535;
+	const getRandomPort = () =>
+		Math.floor(Math.random() * (MAX_PORT - MIN_PORT + 1)) + MIN_PORT;
+
+	let port = getRandomPort();
+	let maxAttempts = 10;
+
+	while (maxAttempts > 0) {
+		try {
+			const server = await new Promise<any>((resolve, reject) => {
+				const server = createServer();
+
+				server.once("error", (err: Error & { code?: string }) => {
+					if (err.code === "EADDRINUSE") {
+						reject(new Error(`Port ${port} is in use`));
+					} else {
+						reject(err);
+					}
+				});
+
+				server.once("listening", () => {
+					resolve(server);
+				});
+
+				server.listen(port);
+			});
+
+			await new Promise<void>((resolve) => {
+				server.close(() => resolve());
+			});
+
+			return port;
+		} catch {
+			maxAttempts--;
+			if (maxAttempts <= 0) {
+				break;
+			}
+			port = getRandomPort();
+		}
+	}
+
+	throw new Error("Could not find an available port after multiple attempts");
+}
+
+export async function serveTestSuite(): Promise<ServeTestSuiteResult> {
+	registry.config.test = { ...registry.config.test, enabled: true };
+	registry.config.inspector = {
+		enabled: true,
+		token: () => "token",
+	};
+	const port = await getPort();
+	registry.config.managerPort = port;
+	registry.config.serverless = {
+		...registry.config.serverless,
+		publicEndpoint: `http://127.0.0.1:${port}`,
+	};
+
+	const driver = await createFileSystemOrMemoryDriver(
+		true,
+		`/tmp/rivetkit-test-suite-${crypto.randomUUID()}`,
+	);
+	registry.config.driver = driver;
+
+	let upgradeWebSocket: any;
+
+	const parsedConfig = registry.parseConfig();
+	const managerDriver = driver.manager?.(parsedConfig);
+	invariant(managerDriver, "missing manager driver");
+	const { router } = buildManagerRouter(
+		parsedConfig,
+		managerDriver,
+		() => upgradeWebSocket,
+	);
+
+	const nodeWebSocket = createNodeWebSocket({ app: router });
+	upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
+	managerDriver.setGetUpgradeWebSocket(() => upgradeWebSocket);
+
+	const server = honoServe({
+		fetch: router.fetch,
+		hostname: "127.0.0.1",
+		port,
+	});
+	invariant(
+		nodeWebSocket.injectWebSocket !== undefined,
+		"should have injectWebSocket",
+	);
+	nodeWebSocket.injectWebSocket(server);
+	const endpoint = `http://127.0.0.1:${port}`;
+
+	logger().info({ msg: "test suite server listening", port });
+
+	return {
+		endpoint,
+		namespace: "default",
+		runnerName: "default",
+		close: async () => {
+			await new Promise((resolve) => server.close(() => resolve(undefined)));
+		},
+	};
+}
+
+async function runCli() {
+	const result = await serveTestSuite();
+	process.stdout.write(
+		`${JSON.stringify({
+			endpoint: result.endpoint,
+			namespace: result.namespace,
+			runnerName: result.runnerName,
+		})}\n`,
+	);
+
+	const shutdown = async () => {
+		await result.close();
+		process.exit(0);
+	};
+
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+}
+
+const mainPath = process.argv[1];
+if (mainPath && mainPath === fileURLToPath(import.meta.url)) {
+	runCli().catch((err) => {
+		logger().error({ msg: "serve-test-suite failed", error: err });
+		process.exit(1);
+	});
+}

package/dist/schemas/actor-persist/v1.js

@@ -1,167 +0,0 @@
-// @generated - post-processed by compile-bare.ts
-import * as bare from "@rivetkit/bare-ts";
-const config = /* @__PURE__ */ bare.Config({});
-export function readPersistedSubscription(bc) {
-    return {
-        eventName: bare.readString(bc),
-    };
-}
-export function writePersistedSubscription(bc, x) {
-    bare.writeString(bc, x.eventName);
-}
-function read0(bc) {
-    const len = bare.readUintSafe(bc);
-    if (len === 0) {
-        return [];
-    }
-    const result = [readPersistedSubscription(bc)];
-    for (let i = 1; i < len; i++) {
-        result[i] = readPersistedSubscription(bc);
-    }
-    return result;
-}
-function write0(bc, x) {
-    bare.writeUintSafe(bc, x.length);
-    for (let i = 0; i < x.length; i++) {
-        writePersistedSubscription(bc, x[i]);
-    }
-}
-export function readPersistedConnection(bc) {
-    return {
-        id: bare.readString(bc),
-        token: bare.readString(bc),
-        parameters: bare.readData(bc),
-        state: bare.readData(bc),
-        subscriptions: read0(bc),
-        lastSeen: bare.readU64(bc),
-    };
-}
-export function writePersistedConnection(bc, x) {
-    bare.writeString(bc, x.id);
-    bare.writeString(bc, x.token);
-    bare.writeData(bc, x.parameters);
-    bare.writeData(bc, x.state);
-    write0(bc, x.subscriptions);
-    bare.writeU64(bc, x.lastSeen);
-}
-function read1(bc) {
-    return bare.readBool(bc)
-        ? bare.readData(bc)
-        : null;
-}
-function write1(bc, x) {
-    bare.writeBool(bc, x !== null);
-    if (x !== null) {
-        bare.writeData(bc, x);
-    }
-}
-export function readGenericPersistedScheduleEvent(bc) {
-    return {
-        action: bare.readString(bc),
-        args: read1(bc),
-    };
-}
-export function writeGenericPersistedScheduleEvent(bc, x) {
-    bare.writeString(bc, x.action);
-    write1(bc, x.args);
-}
-export function readPersistedScheduleEventKind(bc) {
-    const offset = bc.offset;
-    const tag = bare.readU8(bc);
-    switch (tag) {
-        case 0:
-            return { tag: "GenericPersistedScheduleEvent", val: readGenericPersistedScheduleEvent(bc) };
-        default: {
-            bc.offset = offset;
-            throw new bare.BareError(offset, "invalid tag");
-        }
-    }
-}
-export function writePersistedScheduleEventKind(bc, x) {
-    switch (x.tag) {
-        case "GenericPersistedScheduleEvent": {
-            bare.writeU8(bc, 0);
-            writeGenericPersistedScheduleEvent(bc, x.val);
-            break;
-        }
-    }
-}
-export function readPersistedScheduleEvent(bc) {
-    return {
-        eventId: bare.readString(bc),
-        timestamp: bare.readU64(bc),
-        kind: readPersistedScheduleEventKind(bc),
-    };
-}
-export function writePersistedScheduleEvent(bc, x) {
-    bare.writeString(bc, x.eventId);
-    bare.writeU64(bc, x.timestamp);
-    writePersistedScheduleEventKind(bc, x.kind);
-}
-function read2(bc) {
-    const len = bare.readUintSafe(bc);
-    if (len === 0) {
-        return [];
-    }
-    const result = [readPersistedConnection(bc)];
-    for (let i = 1; i < len; i++) {
-        result[i] = readPersistedConnection(bc);
-    }
-    return result;
-}
-function write2(bc, x) {
-    bare.writeUintSafe(bc, x.length);
-    for (let i = 0; i < x.length; i++) {
-        writePersistedConnection(bc, x[i]);
-    }
-}
-function read3(bc) {
-    const len = bare.readUintSafe(bc);
-    if (len === 0) {
-        return [];
-    }
-    const result = [readPersistedScheduleEvent(bc)];
-    for (let i = 1; i < len; i++) {
-        result[i] = readPersistedScheduleEvent(bc);
-    }
-    return result;
-}
-function write3(bc, x) {
-    bare.writeUintSafe(bc, x.length);
-    for (let i = 0; i < x.length; i++) {
-        writePersistedScheduleEvent(bc, x[i]);
-    }
-}
-export function readPersistedActor(bc) {
-    return {
-        input: read1(bc),
-        hasInitialized: bare.readBool(bc),
-        state: bare.readData(bc),
-        connections: read2(bc),
-        scheduledEvents: read3(bc),
-    };
-}
-export function writePersistedActor(bc, x) {
-    write1(bc, x.input);
-    bare.writeBool(bc, x.hasInitialized);
-    bare.writeData(bc, x.state);
-    write2(bc, x.connections);
-    write3(bc, x.scheduledEvents);
-}
-export function encodePersistedActor(x) {
-    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
-    writePersistedActor(bc, x);
-    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
-}
-export function decodePersistedActor(bytes) {
-    const bc = new bare.ByteCursor(bytes, config);
-    const result = readPersistedActor(bc);
-    if (bc.offset < bc.view.byteLength) {
-        throw new bare.BareError(bc.offset, "remaining bytes");
-    }
-    return result;
-}
-function assert(condition, message) {
-    if (!condition)
-        throw new Error(message ?? "Assertion failed");
-}

package/dist/schemas/actor-persist/v2.js

@@ -1,200 +0,0 @@
-// @generated - post-processed by compile-bare.ts
-import * as bare from "@rivetkit/bare-ts";
-const config = /* @__PURE__ */ bare.Config({});
-export function readPersistedSubscription(bc) {
-    return {
-        eventName: bare.readString(bc),
-    };
-}
-export function writePersistedSubscription(bc, x) {
-    bare.writeString(bc, x.eventName);
-}
-function read0(bc) {
-    const len = bare.readUintSafe(bc);
-    if (len === 0) {
-        return [];
-    }
-    const result = [readPersistedSubscription(bc)];
-    for (let i = 1; i < len; i++) {
-        result[i] = readPersistedSubscription(bc);
-    }
-    return result;
-}
-function write0(bc, x) {
-    bare.writeUintSafe(bc, x.length);
-    for (let i = 0; i < x.length; i++) {
-        writePersistedSubscription(bc, x[i]);
-    }
-}
-function read1(bc) {
-    return bare.readBool(bc)
-        ? bare.readData(bc)
-        : null;
-}
-function write1(bc, x) {
-    bare.writeBool(bc, x !== null);
-    if (x !== null) {
-        bare.writeData(bc, x);
-    }
-}
-export function readPersistedConnection(bc) {
-    return {
-        id: bare.readString(bc),
-        token: bare.readString(bc),
-        parameters: bare.readData(bc),
-        state: bare.readData(bc),
-        subscriptions: read0(bc),
-        lastSeen: bare.readI64(bc),
-        hibernatableRequestId: read1(bc),
-    };
-}
-export function writePersistedConnection(bc, x) {
-    bare.writeString(bc, x.id);
-    bare.writeString(bc, x.token);
-    bare.writeData(bc, x.parameters);
-    bare.writeData(bc, x.state);
-    write0(bc, x.subscriptions);
-    bare.writeI64(bc, x.lastSeen);
-    write1(bc, x.hibernatableRequestId);
-}
-export function readGenericPersistedScheduleEvent(bc) {
-    return {
-        action: bare.readString(bc),
-        args: read1(bc),
-    };
-}
-export function writeGenericPersistedScheduleEvent(bc, x) {
-    bare.writeString(bc, x.action);
-    write1(bc, x.args);
-}
-export function readPersistedScheduleEventKind(bc) {
-    const offset = bc.offset;
-    const tag = bare.readU8(bc);
-    switch (tag) {
-        case 0:
-            return { tag: "GenericPersistedScheduleEvent", val: readGenericPersistedScheduleEvent(bc) };
-        default: {
-            bc.offset = offset;
-            throw new bare.BareError(offset, "invalid tag");
-        }
-    }
-}
-export function writePersistedScheduleEventKind(bc, x) {
-    switch (x.tag) {
-        case "GenericPersistedScheduleEvent": {
-            bare.writeU8(bc, 0);
-            writeGenericPersistedScheduleEvent(bc, x.val);
-            break;
-        }
-    }
-}
-export function readPersistedScheduleEvent(bc) {
-    return {
-        eventId: bare.readString(bc),
-        timestamp: bare.readI64(bc),
-        kind: readPersistedScheduleEventKind(bc),
-    };
-}
-export function writePersistedScheduleEvent(bc, x) {
-    bare.writeString(bc, x.eventId);
-    bare.writeI64(bc, x.timestamp);
-    writePersistedScheduleEventKind(bc, x.kind);
-}
-export function readPersistedHibernatableWebSocket(bc) {
-    return {
-        requestId: bare.readData(bc),
-        lastSeenTimestamp: bare.readI64(bc),
-        msgIndex: bare.readI64(bc),
-    };
-}
-export function writePersistedHibernatableWebSocket(bc, x) {
-    bare.writeData(bc, x.requestId);
-    bare.writeI64(bc, x.lastSeenTimestamp);
-    bare.writeI64(bc, x.msgIndex);
-}
-function read2(bc) {
-    const len = bare.readUintSafe(bc);
-    if (len === 0) {
-        return [];
-    }
-    const result = [readPersistedConnection(bc)];
-    for (let i = 1; i < len; i++) {
-        result[i] = readPersistedConnection(bc);
-    }
-    return result;
-}
-function write2(bc, x) {
-    bare.writeUintSafe(bc, x.length);
-    for (let i = 0; i < x.length; i++) {
-        writePersistedConnection(bc, x[i]);
-    }
-}
-function read3(bc) {
-    const len = bare.readUintSafe(bc);
-    if (len === 0) {
-        return [];
-    }
-    const result = [readPersistedScheduleEvent(bc)];
-    for (let i = 1; i < len; i++) {
-        result[i] = readPersistedScheduleEvent(bc);
-    }
-    return result;
-}
-function write3(bc, x) {
-    bare.writeUintSafe(bc, x.length);
-    for (let i = 0; i < x.length; i++) {
-        writePersistedScheduleEvent(bc, x[i]);
-    }
-}
-function read4(bc) {
-    const len = bare.readUintSafe(bc);
-    if (len === 0) {
-        return [];
-    }
-    const result = [readPersistedHibernatableWebSocket(bc)];
-    for (let i = 1; i < len; i++) {
-        result[i] = readPersistedHibernatableWebSocket(bc);
-    }
-    return result;
-}
-function write4(bc, x) {
-    bare.writeUintSafe(bc, x.length);
-    for (let i = 0; i < x.length; i++) {
-        writePersistedHibernatableWebSocket(bc, x[i]);
-    }
-}
-export function readPersistedActor(bc) {
-    return {
-        input: read1(bc),
-        hasInitialized: bare.readBool(bc),
-        state: bare.readData(bc),
-        connections: read2(bc),
-        scheduledEvents: read3(bc),
-        hibernatableWebSockets: read4(bc),
-    };
-}
-export function writePersistedActor(bc, x) {
-    write1(bc, x.input);
-    bare.writeBool(bc, x.hasInitialized);
-    bare.writeData(bc, x.state);
-    write2(bc, x.connections);
-    write3(bc, x.scheduledEvents);
-    write4(bc, x.hibernatableWebSockets);
-}
-export function encodePersistedActor(x) {
-    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
-    writePersistedActor(bc, x);
-    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
-}
-export function decodePersistedActor(bytes) {
-    const bc = new bare.ByteCursor(bytes, config);
-    const result = readPersistedActor(bc);
-    if (bc.offset < bc.view.byteLength) {
-        throw new bare.BareError(bc.offset, "remaining bytes");
-    }
-    return result;
-}
-function assert(condition, message) {
-    if (!condition)
-        throw new Error(message ?? "Assertion failed");
-}