rivetkit 2.3.30 → 3.0.0-preview.2

package/src/db/drizzle.test.ts

@@ -1,164 +0,0 @@
-import { describe, expect, test } from "vitest";
-import type {
-	DatabaseProviderContext,
-	SqliteBatchStatement,
-	SqliteBindings,
-	SqliteDatabase,
-	SqliteExecuteResult,
-	SqliteTransactionDatabase,
-} from "@/common/database/config";
-import { db } from "./drizzle";
-
-class FakeSqliteDatabase implements SqliteDatabase {
-	executeCalls: Array<{ sql: string; params?: SqliteBindings }> = [];
-	transactionTimeouts: Array<number | undefined> = [];
-	transactionNames: Array<string | undefined> = [];
-
-	async exec(): Promise<void> {}
-
-	async execute(
-		sql: string,
-		params?: SqliteBindings,
-	): Promise<SqliteExecuteResult> {
-		this.executeCalls.push({ sql, params });
-		return emptyResult();
-	}
-
-	async executeBatch(
-		statements: SqliteBatchStatement[],
-	): Promise<SqliteExecuteResult[]> {
-		const transaction = await this.beginTransaction();
-		try {
-			const results: SqliteExecuteResult[] = [];
-			for (const statement of statements) {
-				results.push(
-					await transaction.execute(statement.sql, statement.params),
-				);
-			}
-			await transaction.commit();
-			return results;
-		} catch (error) {
-			await transaction.rollback();
-			throw error;
-		}
-	}
-
-	async beginTransaction(
-		timeoutMs?: number,
-		name?: string,
-	): Promise<SqliteTransactionDatabase> {
-		this.transactionTimeouts.push(timeoutMs);
-		this.transactionNames.push(name);
-		this.executeCalls.push({ sql: "BEGIN" });
-		return {
-			exec: async () => {},
-			execute: async (sql, params) => {
-				this.executeCalls.push({ sql, params });
-				return emptyResult();
-			},
-			commit: async () => {
-				this.executeCalls.push({ sql: "COMMIT" });
-			},
-			rollback: async () => {
-				this.executeCalls.push({ sql: "ROLLBACK" });
-			},
-		};
-	}
-
-	async run(sql: string, params?: SqliteBindings): Promise<void> {
-		await this.execute(sql, params);
-	}
-
-	async query(sql: string, params?: SqliteBindings) {
-		const { columns, rows } = await this.execute(sql, params);
-		return { columns, rows };
-	}
-
-	async close(): Promise<void> {}
-}
-
-function emptyResult(): SqliteExecuteResult {
-	return {
-		columns: [],
-		rows: [],
-		changes: 0,
-		lastInsertRowId: null,
-	};
-}
-
-function testProviderContext(
-	database: SqliteDatabase,
-): DatabaseProviderContext {
-	return {
-		actorId: "actor-a",
-		kv: {
-			batchPut: async () => {},
-			batchGet: async (keys) => keys.map(() => null),
-			batchDelete: async () => {},
-			deleteRange: async () => {},
-		},
-		nativeDatabaseProvider: { open: async () => database },
-	};
-}
-
-describe("Drizzle database transactions", () => {
-	test("runs migrations in the shared transaction with a generous timeout", async () => {
-		const nativeDb = new FakeSqliteDatabase();
-		const provider = db({
-			onMigrate: async (client) => {
-				await client.execute(
-					"CREATE TABLE items(id INTEGER PRIMARY KEY)",
-				);
-			},
-		});
-		const client = await provider.createClient(
-			testProviderContext(nativeDb),
-		);
-		await provider.onMigrate(client);
-
-		expect(nativeDb.transactionTimeouts).toEqual([300_000]);
-		expect(nativeDb.transactionNames).toEqual([
-			"rivetkit-drizzle-migration",
-		]);
-		expect(nativeDb.executeCalls.map(({ sql }) => sql)).toEqual([
-			"BEGIN",
-			"SAVEPOINT __rivet_on_migrate",
-			"CREATE TABLE items(id INTEGER PRIMARY KEY)",
-			"RELEASE SAVEPOINT __rivet_on_migrate",
-			"COMMIT",
-		]);
-	});
-
-	test("routes transaction work through the transaction handle", async () => {
-		const nativeDb = new FakeSqliteDatabase();
-		const client = await db().createClient(testProviderContext(nativeDb));
-		await client.transaction(
-			async (tx) => {
-				await tx.execute(
-					"INSERT INTO items(value) VALUES (?)",
-					"inside",
-				);
-			},
-			{ name: "drizzle-insert", timeout: 120_000 },
-		);
-
-		expect(nativeDb.transactionTimeouts).toEqual([120_000]);
-		expect(nativeDb.transactionNames).toEqual(["drizzle-insert"]);
-		expect(nativeDb.executeCalls.map(({ sql }) => sql)).toEqual([
-			"BEGIN",
-			"INSERT INTO items(value) VALUES (?)",
-			"COMMIT",
-		]);
-	});
-
-	test("validates zero, negative, and non-finite transaction timeouts", async () => {
-		const client = await db().createClient(
-			testProviderContext(new FakeSqliteDatabase()),
-		);
-		for (const timeout of [0, -1, Number.NaN, Number.POSITIVE_INFINITY]) {
-			await expect(
-				client.transaction(async () => {}, { timeout }),
-			).rejects.toThrow("positive finite");
-		}
-	});
-});

package/src/registry/config/index.test.ts

@@ -1,25 +0,0 @@
-import { afterEach, describe, expect, test } from "vitest";
-import { RegistryConfigSchema } from "./index";
-
-const ORIGINAL_RIVET_TOKEN = process.env.RIVET_TOKEN;
-
-afterEach(() => {
-	if (ORIGINAL_RIVET_TOKEN === undefined) {
-		delete process.env.RIVET_TOKEN;
-	} else {
-		process.env.RIVET_TOKEN = ORIGINAL_RIVET_TOKEN;
-	}
-});
-
-describe("RegistryConfigSchema", () => {
-	test("defaults local Engine token", () => {
-		delete process.env.RIVET_TOKEN;
-
-		const config = RegistryConfigSchema.parse({
-			use: {},
-			startEngine: true,
-		});
-
-		expect(config.token).toBe("default");
-	});
-});

package/src/registry/run-handler-coordinator.test.ts

@@ -1,252 +0,0 @@
-import { describe, expect, test, vi } from "vitest";
-import { defineRunHandler, type RunControl } from "@/actor/config";
-import { RunHandlerCoordinator } from "./run-handler-coordinator";
-
-class Deferred<T = void> {
-	readonly promise: Promise<T>;
-	resolve!: (value: T | PromiseLike<T>) => void;
-	reject!: (reason?: unknown) => void;
-
-	constructor() {
-		this.promise = new Promise<T>((resolve, reject) => {
-			this.resolve = resolve;
-			this.reject = reject;
-		});
-	}
-}
-
-function createCoordinator() {
-	let control: RunControl | undefined;
-	const dispose = vi.fn();
-	const createInspector = vi.fn((context: { control: RunControl }) => {
-		control = context.control;
-		return {
-			inspector: {
-				workflow: {
-					getHistory: () => null,
-					getState: async () => null,
-					onHistoryUpdated: () => () => {},
-					replayFromStep: async () => null,
-				},
-			},
-			dispose,
-		};
-	});
-	const run = defineRunHandler(async () => {}, {
-		inspectorKind: "workflow",
-		createInspector,
-	});
-	const coordinator = new RunHandlerCoordinator(run);
-	const restart = vi.fn();
-	const inspector = coordinator.getInspector("actor-1", restart);
-
-	return {
-		control: control as unknown as RunControl,
-		coordinator,
-		createInspector,
-		dispose,
-		inspector,
-		restart,
-	};
-}
-
-describe("RunHandlerCoordinator", () => {
-	test("fails explicitly when a JavaScript factory omits required workflow controls", async () => {
-		const coordinator = new RunHandlerCoordinator(
-			defineRunHandler(async () => {}, {
-				inspectorKind: "workflow",
-				createInspector: (() => ({
-					inspector: { workflow: { getHistory: () => null } },
-				})) as never,
-			}),
-		);
-
-		await expect(
-			coordinator.run(
-				"actor-1",
-				() => {},
-				async () => {},
-			),
-		).rejects.toThrow(
-			"createInspector returned an invalid workflow adapter for actor actor-1",
-		);
-	});
-
-	test("initializes and disposes Inspector state even when it is never queried", async () => {
-		const dispose = vi.fn();
-		const createInspector = vi.fn(() => ({
-			inspector: {
-				workflow: {
-					getHistory: () => null,
-					getState: async () => null,
-					onHistoryUpdated: () => () => {},
-					replayFromStep: async () => null,
-				},
-			},
-			dispose,
-		}));
-		const coordinator = new RunHandlerCoordinator(
-			defineRunHandler(async () => {}, {
-				inspectorKind: "workflow",
-				createInspector,
-			}),
-		);
-
-		await coordinator.run(
-			"actor-1",
-			() => {},
-			async () => {},
-		);
-		expect(createInspector).toHaveBeenCalledOnce();
-		coordinator.destroy("actor-1");
-		expect(dispose).toHaveBeenCalledOnce();
-	});
-
-	test("creates one inspector per live actor and disposes it exactly once", () => {
-		const subject = createCoordinator();
-		expect(
-			subject.coordinator.getInspector("actor-1", subject.restart),
-		).toBe(subject.inspector);
-		expect(subject.createInspector).toHaveBeenCalledOnce();
-
-		subject.coordinator.destroy("actor-1");
-		subject.coordinator.destroy("actor-1");
-		expect(subject.dispose).toHaveBeenCalledOnce();
-
-		const recreated = subject.coordinator.getInspector(
-			"actor-1",
-			subject.restart,
-		);
-		expect(recreated).not.toBe(subject.inspector);
-		expect(subject.createInspector).toHaveBeenCalledTimes(2);
-	});
-
-	test("rejects replay while a run is active", async () => {
-		const subject = createCoordinator();
-		const active = new Deferred();
-		const started = new Deferred();
-		const running = subject.coordinator.run(
-			"actor-1",
-			subject.restart,
-			async () => {
-				started.resolve();
-				await active.promise;
-			},
-		);
-		await started.promise;
-
-		await expect(
-			subject.control.run.withInactive(
-				{ restartOnSuccess: true },
-				async () => {},
-			),
-		).rejects.toMatchObject({
-			group: "actor",
-			code: "run_handler_unavailable",
-		});
-
-		active.resolve();
-		await running;
-	});
-
-	test("uses a start queued during replay as the single restart", async () => {
-		const subject = createCoordinator();
-		const replay = new Deferred();
-		const replayStarted = new Deferred();
-		const events: string[] = [];
-		subject.restart.mockImplementation(() => {
-			events.push("restart");
-		});
-
-		const exclusive = subject.control.run.withInactive(
-			{ restartOnSuccess: true },
-			async () => {
-				events.push("replay");
-				replayStarted.resolve();
-				await replay.promise;
-			},
-		);
-		await replayStarted.promise;
-
-		const queued = subject.coordinator.run(
-			"actor-1",
-			subject.restart,
-			async () => {
-				events.push("run");
-			},
-		);
-		await Promise.resolve();
-		expect(events).toEqual(["replay"]);
-
-		replay.resolve();
-		await exclusive;
-		await queued;
-		expect(events).toEqual(["replay", "run"]);
-		expect(subject.restart).not.toHaveBeenCalled();
-	});
-
-	test("drops starts queued behind a failed replay and leaves the run inactive", async () => {
-		const subject = createCoordinator();
-		const replay = new Deferred();
-		const replayStarted = new Deferred();
-		const run = vi.fn();
-		const expected = new Error("rewrite failed");
-
-		const exclusive = subject.control.run.withInactive(
-			{ restartOnSuccess: true },
-			async () => {
-				replayStarted.resolve();
-				await replay.promise;
-				throw expected;
-			},
-		);
-		await replayStarted.promise;
-		const queued = subject.coordinator.run("actor-1", subject.restart, run);
-
-		replay.resolve();
-		await expect(exclusive).rejects.toBe(expected);
-		await expect(queued).resolves.toBe("suppressed");
-		expect(run).not.toHaveBeenCalled();
-		expect(subject.restart).not.toHaveBeenCalled();
-	});
-
-	test("restores a durable wake suppressed by a failed replay", async () => {
-		const subject = createCoordinator();
-		const replay = new Deferred();
-		const replayStarted = new Deferred();
-		const run = vi.fn();
-
-		const exclusive = subject.control.run.withInactive({}, async () => {
-			replayStarted.resolve();
-			await replay.promise;
-			throw new Error("rewrite failed");
-		});
-		await replayStarted.promise;
-		const queued = subject.coordinator.run("actor-1", subject.restart, run);
-
-		replay.resolve();
-		await expect(exclusive).rejects.toThrow("rewrite failed");
-		await expect(queued).resolves.toBe("suppressed");
-		expect(run).not.toHaveBeenCalled();
-	});
-
-	test("allows only one concurrent replay and closes old controls on destroy", async () => {
-		const subject = createCoordinator();
-		const replay = new Deferred();
-		const first = subject.control.run.withInactive({}, async () => {
-			await replay.promise;
-		});
-
-		await expect(
-			subject.control.run.withInactive({}, async () => {}),
-		).rejects.toMatchObject({ code: "run_handler_unavailable" });
-		subject.coordinator.destroy("actor-1");
-		replay.resolve();
-		await expect(first).rejects.toMatchObject({
-			code: "run_handler_unavailable",
-		});
-		await expect(
-			subject.control.run.withInactive({}, async () => {}),
-		).rejects.toMatchObject({ code: "run_handler_unavailable" });
-	});
-});

package/src/registry/runtime.test.ts

@@ -1,124 +0,0 @@
-import { describe, expect, test } from "vitest";
-import type { RegistryConfig } from "./config";
-import { loadAutoRuntime, type RuntimeLoaders } from "./native";
-import {
-	type CoreRuntime,
-	normalizeRuntimeSqlExecuteResult,
-	type RuntimeSqlBindParam,
-	type RuntimeSqlBindParams,
-} from "./runtime";
-
-describe("runtime SQL boundary", () => {
-	test("accepts exact bind param variants", () => {
-		const blob = new Uint8Array([1, 2, 3]);
-		const params = [
-			{ kind: "null" },
-			{ kind: "int", intValue: 1 },
-			{ kind: "float", floatValue: 1.5 },
-			{ kind: "text", textValue: "text" },
-			{ kind: "blob", blobValue: blob },
-		] satisfies RuntimeSqlBindParams;
-
-		expect(params).toEqual([
-			{ kind: "null" },
-			{ kind: "int", intValue: 1 },
-			{ kind: "float", floatValue: 1.5 },
-			{ kind: "text", textValue: "text" },
-			{ kind: "blob", blobValue: blob },
-		]);
-	});
-
-	test("rejects bind params with mismatched value fields at typecheck time", () => {
-		const invalidIntParamCandidate = {
-			kind: "int",
-			intValue: 1,
-			textValue: "extra",
-		} as const;
-		// @ts-expect-error Runtime SQL int params must only carry intValue.
-		const invalidIntParam: RuntimeSqlBindParam = invalidIntParamCandidate;
-
-		expect(invalidIntParam.kind).toBe("int");
-	});
-
-	test("normalizes execute result metadata", () => {
-		const base = {
-			columns: ["value"],
-			rows: [[1]],
-			changes: 1,
-			lastInsertRowId: null,
-		};
-
-		expect(normalizeRuntimeSqlExecuteResult(base)).toEqual(base);
-	});
-});
-
-describe("loadAutoRuntime failure reporting", () => {
-	const wasmRuntime = { kind: "wasm" } as unknown as CoreRuntime;
-	const nativeRuntime = { kind: "napi" } as unknown as CoreRuntime;
-	const config = {} as RegistryConfig;
-
-	function loaders(overrides: Partial<RuntimeLoaders>): RuntimeLoaders {
-		return {
-			detectHost: () => "node-like",
-			loadNative: async () => ({ runtime: nativeRuntime }) as never,
-			loadWasm: async () => ({ runtime: wasmRuntime }) as never,
-			...overrides,
-		};
-	}
-
-	test("prefers native when it loads", async () => {
-		const runtime = await loadAutoRuntime(config, loaders({}));
-		expect(runtime).toBe(nativeRuntime);
-	});
-
-	test("falls back to wasm when native fails", async () => {
-		const runtime = await loadAutoRuntime(
-			config,
-			loaders({
-				loadNative: async () => {
-					throw new Error("missing platform binding");
-				},
-			}),
-		);
-		expect(runtime).toBe(wasmRuntime);
-	});
-
-	test("reports the native cause when both runtimes fail", async () => {
-		// The native failure is the actionable one. Before this was reported,
-		// a skipped platform binding surfaced only as the wasm loader's
-		// unrelated `file://` fetch error.
-		const promise = loadAutoRuntime(
-			config,
-			loaders({
-				loadNative: async () => {
-					throw new Error(
-						"Cannot find module '@rivetkit/rivetkit-napi-linux-x64-musl'",
-					);
-				},
-				loadWasm: async () => {
-					throw new Error("fetch failed");
-				},
-			}),
-		);
-		await expect(promise).rejects.toThrow(/rivetkit-napi-linux-x64-musl/);
-		await expect(promise).rejects.toThrow(/fetch failed/);
-	});
-
-	test("uses wasm directly on an edge-like host without touching native", async () => {
-		let nativeCalls = 0;
-		const runtime = await loadAutoRuntime(
-			config,
-			loaders({
-				detectHost: () => "edge-like",
-				loadNative: async () => {
-					nativeCalls += 1;
-					throw new Error(
-						"native must not be attempted on edge hosts",
-					);
-				},
-			}),
-		);
-		expect(runtime).toBe(wasmRuntime);
-		expect(nativeCalls).toBe(0);
-	});
-});