rivetkit 2.3.30 → 3.0.0-preview.2

package/src/common/database/mod.test.ts

@@ -1,364 +0,0 @@
-import { pino } from "pino";
-import { beforeEach, describe, expect, test } from "vitest";
-import { configureBaseLogger } from "@/common/log";
-import type {
-	DatabaseProviderContext,
-	SqliteBindings,
-	SqliteDatabase,
-	SqliteExecuteResult,
-	SqliteTransactionDatabase,
-} from "./config";
-import { db, registerNativeStateTransactionOpener } from "./mod";
-
-let logLines: string[];
-
-class FakeSqliteDatabase implements SqliteDatabase {
-	failSql = new Map<string, Error>();
-	executeCalls: { sql: string; params?: SqliteBindings }[] = [];
-	stateTransactionTimeouts: Array<number | undefined> = [];
-	transactionTimeouts: Array<number | undefined> = [];
-	transactionNames: Array<string | undefined> = [];
-
-	async exec(): Promise<void> {}
-
-	async execute(
-		sql: string,
-		params?: SqliteBindings,
-	): Promise<SqliteExecuteResult> {
-		this.record(sql, params);
-		return emptyResult();
-	}
-
-	async beginTransaction(
-		timeoutMs?: number,
-		name?: string,
-	): Promise<SqliteTransactionDatabase> {
-		this.transactionTimeouts.push(timeoutMs);
-		this.transactionNames.push(name);
-		this.record("BEGIN");
-		return {
-			exec: async () => {},
-			execute: async (sql, params) => {
-				this.record(sql, params);
-				return emptyResult();
-			},
-			commit: async () => this.record("COMMIT"),
-			rollback: async () => this.record("ROLLBACK"),
-		};
-	}
-	async beginStateTransaction(
-		timeoutMs?: number,
-	): Promise<SqliteTransactionDatabase> {
-		this.stateTransactionTimeouts.push(timeoutMs);
-		this.record("BEGIN_STATE");
-		return {
-			exec: async () => {},
-			execute: async (sql, params) => {
-				this.record(sql, params);
-				return emptyResult();
-			},
-			commit: async () => this.record("COMMIT"),
-			rollback: async () => this.record("ROLLBACK"),
-		};
-	}
-
-	async executeBatch(
-		statements: Array<{ sql: string; params?: SqliteBindings }>,
-	): Promise<SqliteExecuteResult[]> {
-		const results: SqliteExecuteResult[] = [];
-		for (const statement of statements) {
-			results.push(await this.execute(statement.sql, statement.params));
-		}
-		return results;
-	}
-
-	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> {}
-
-	private record(sql: string, params?: SqliteBindings): void {
-		this.executeCalls.push({ sql, params });
-		const error = this.failSql.get(sql);
-		if (error) throw error;
-	}
-}
-
-function emptyResult(): SqliteExecuteResult {
-	return {
-		columns: [],
-		rows: [],
-		changes: 0,
-		lastInsertRowId: null,
-	};
-}
-
-function testProviderContext(
-	database: FakeSqliteDatabase,
-	includeStateTransactions = false,
-): DatabaseProviderContext {
-	return {
-		actorId: "actor-a",
-		kv: {
-			batchPut: async () => {},
-			batchGet: async (keys) => keys.map(() => null),
-			batchDelete: async () => {},
-			deleteRange: async () => {},
-		},
-		nativeDatabaseProvider: includeStateTransactions
-			? registerNativeStateTransactionOpener(
-					{ open: async () => database },
-					async (timeoutMs?: number) =>
-						await database.beginStateTransaction(timeoutMs),
-				)
-			: { open: async () => database },
-	};
-}
-
-describe("db", () => {
-	beforeEach(() => {
-		logLines = [];
-		configureBaseLogger(
-			pino(
-				{ level: "warn", base: {}, timestamp: false },
-				{ write: (line: string) => logLines.push(line) },
-			),
-		);
-	});
-
-	test("runs onMigrate through the shared transaction handle", 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.executeCalls.map(({ sql }) => sql)).toEqual([
-			"BEGIN",
-			"SAVEPOINT __rivet_on_migrate",
-			"CREATE TABLE items(id INTEGER PRIMARY KEY)",
-			"RELEASE SAVEPOINT __rivet_on_migrate",
-			"COMMIT",
-		]);
-		expect(nativeDb.transactionTimeouts).toEqual([300_000]);
-		expect(nativeDb.transactionNames).toEqual(["rivetkit-migration"]);
-	});
-
-	test("exposes profiling controls to the actor runtime", () => {
-		const provider = db({
-			profiling: {
-				enabled: false,
-				maxTrackedStatementFingerprints: 12,
-				baselineSampleRate: 0.25,
-			},
-		});
-
-		expect(provider.sqliteProfiling).toEqual({
-			enabled: false,
-			maxTrackedStatementFingerprints: 12,
-			baselineSampleRate: 0.25,
-		});
-	});
-
-	test("rolls back migrations when onMigrate fails", async () => {
-		const nativeDb = new FakeSqliteDatabase();
-		const provider = db({
-			onMigrate: async () => {
-				throw new Error("migration failed");
-			},
-		});
-		const client = await provider.createClient(
-			testProviderContext(nativeDb),
-		);
-		await expect(provider.onMigrate(client)).rejects.toThrow(
-			"migration failed",
-		);
-		expect(nativeDb.executeCalls.map(({ sql }) => sql)).toEqual([
-			"BEGIN",
-			"SAVEPOINT __rivet_on_migrate",
-			"ROLLBACK TO SAVEPOINT __rivet_on_migrate",
-			"RELEASE SAVEPOINT __rivet_on_migrate",
-			"ROLLBACK",
-		]);
-	});
-
-	test("commits transaction work and forwards timeout", async () => {
-		const nativeDb = new FakeSqliteDatabase();
-		const client = await db().createClient(testProviderContext(nativeDb));
-		const value = await client.transaction(
-			async (tx) => {
-				await tx.execute(
-					"INSERT INTO items(value) VALUES (?)",
-					"inside",
-				);
-				return 42;
-			},
-			{ name: "insert-item", timeout: 120_000 },
-		);
-		expect(value).toBe(42);
-		expect(nativeDb.transactionTimeouts).toEqual([120_000]);
-		expect(nativeDb.transactionNames).toEqual(["insert-item"]);
-		expect(nativeDb.executeCalls.map(({ sql }) => sql)).toEqual([
-			"BEGIN",
-			"INSERT INTO items(value) VALUES (?)",
-			"COMMIT",
-		]);
-	});
-
-	test("validates transaction names", async () => {
-		const client = await db().createClient(
-			testProviderContext(new FakeSqliteDatabase()),
-		);
-		await expect(
-			client.transaction(async () => {}, { name: "" }),
-		).rejects.toThrow("must not be empty");
-	});
-
-	test("defers the configured transaction name byte limit to the runtime", async () => {
-		const nativeDb = new FakeSqliteDatabase();
-		const client = await db().createClient(testProviderContext(nativeDb));
-		const name = "x".repeat(129);
-
-		await client.transaction(async () => {}, { name });
-
-		expect(nativeDb.transactionNames).toEqual([name]);
-	});
-
-	test("rolls back a transaction when the callback throws", async () => {
-		const nativeDb = new FakeSqliteDatabase();
-		const client = await db().createClient(testProviderContext(nativeDb));
-		await expect(
-			client.transaction(async (tx) => {
-				await tx.execute(
-					"INSERT INTO items(value) VALUES (?)",
-					"inside",
-				);
-				throw new Error("callback failed");
-			}),
-		).rejects.toThrow("callback failed");
-		expect(nativeDb.executeCalls.map(({ sql }) => sql)).toEqual([
-			"BEGIN",
-			"INSERT INTO items(value) VALUES (?)",
-			"ROLLBACK",
-		]);
-	});
-
-	test("uses the state-aware transaction bridge when explicitly requested", async () => {
-		const nativeDb = new FakeSqliteDatabase();
-		const client = await db().createClient(
-			testProviderContext(nativeDb, true),
-		);
-
-		await client.transaction(
-			async (tx) => {
-				await tx.execute(
-					"INSERT INTO items(value) VALUES (?)",
-					"inside",
-				);
-			},
-			{
-				timeout: 120_000,
-				experimental: { includeState: true },
-			},
-		);
-
-		expect(nativeDb.transactionTimeouts).toEqual([]);
-		expect(nativeDb.stateTransactionTimeouts).toEqual([120_000]);
-		expect(nativeDb.executeCalls.map(({ sql }) => sql)).toEqual([
-			"BEGIN_STATE",
-			"INSERT INTO items(value) VALUES (?)",
-			"COMMIT",
-		]);
-	});
-
-	test("rolls back state-aware transactions when the callback throws", async () => {
-		const nativeDb = new FakeSqliteDatabase();
-		const client = await db().createClient(
-			testProviderContext(nativeDb, true),
-		);
-
-		await expect(
-			client.transaction(
-				async (tx) => {
-					await tx.execute(
-						"INSERT INTO items(value) VALUES (?)",
-						"inside",
-					);
-					throw new Error("callback failed");
-				},
-				{ experimental: { includeState: true } },
-			),
-		).rejects.toThrow("callback failed");
-		expect(nativeDb.executeCalls.map(({ sql }) => sql)).toEqual([
-			"BEGIN_STATE",
-			"INSERT INTO items(value) VALUES (?)",
-			"ROLLBACK",
-		]);
-	});
-
-	test("rejects nested state-aware transactions", async () => {
-		const nativeDb = new FakeSqliteDatabase();
-		const client = await db().createClient(
-			testProviderContext(nativeDb, true),
-		);
-
-		await expect(
-			client.transaction(
-				async (tx) => {
-					await tx.transaction(async () => {}, {
-						experimental: { includeState: true },
-					});
-				},
-				{ experimental: { includeState: true } },
-			),
-		).rejects.toThrow("not supported for nested transactions");
-		expect(nativeDb.executeCalls.map(({ sql }) => sql)).toEqual([
-			"BEGIN_STATE",
-			"ROLLBACK",
-		]);
-	});
-
-	test("validates 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");
-		}
-	});
-
-	test("warns once for manual cross-call transactions and names the opt-out", async () => {
-		const client = await db().createClient(
-			testProviderContext(new FakeSqliteDatabase()),
-		);
-		await client.execute("BEGIN");
-		await client.execute("COMMIT");
-		expect(logLines).toHaveLength(1);
-		expect(JSON.parse(logLines[0] ?? "{}").msg).toContain(
-			"Set warnOnManualTransactions: false",
-		);
-	});
-
-	test("can suppress the manual transaction warning", async () => {
-		const client = await db({
-			warnOnManualTransactions: false,
-		}).createClient(testProviderContext(new FakeSqliteDatabase()));
-		await client.execute("BEGIN");
-		expect(logLines).toHaveLength(0);
-	});
-});

package/src/common/database/native-database.test.ts

@@ -1,220 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { BRIDGE_RIVET_ERROR_PREFIX } from "@/actor/errors";
-import {
-	type JsNativeDatabaseLike,
-	wrapJsNativeDatabase,
-} from "./native-database";
-
-type NativeParams = Parameters<JsNativeDatabaseLike["execute"]>[1];
-type NativeExecuteResult = Awaited<ReturnType<JsNativeDatabaseLike["execute"]>>;
-
-function deferred<T>() {
-	let resolve!: (value: T) => void;
-	let reject!: (error: unknown) => void;
-	const promise = new Promise<T>((resolvePromise, rejectPromise) => {
-		resolve = resolvePromise;
-		reject = rejectPromise;
-	});
-	return { promise, resolve, reject };
-}
-
-class FakeNativeDatabase implements JsNativeDatabaseLike {
-	async beginTransaction() {
-		return {
-			exec: async (_sql: string) => this.exec(),
-			execute: async (sql: string, params?: NativeParams) =>
-				this.execute(sql, params),
-			commit: async () => {},
-			rollback: async () => {},
-		};
-	}
-	active = 0;
-	maxActive = 0;
-	closed = false;
-	executeCalls: { sql: string; params?: NativeParams; write: boolean }[] = [];
-	#pending: ReturnType<typeof deferred<NativeExecuteResult>>[] = [];
-
-	async exec() {
-		return { columns: [], rows: [] };
-	}
-
-	async execute(sql: string, params?: NativeParams) {
-		return await this.#startExecute(sql, params, false);
-	}
-
-	async query(sql: string, params?: NativeParams) {
-		const { columns, rows } = await this.execute(sql, params);
-		return { columns, rows };
-	}
-
-	async run(sql: string, params?: NativeParams) {
-		const { changes } = await this.execute(sql, params);
-		return { changes };
-	}
-
-	takeLastKvError() {
-		return null;
-	}
-
-	async close() {
-		this.closed = true;
-	}
-
-	resolveNext(result: Partial<NativeExecuteResult> = {}) {
-		const pending = this.#pending.shift();
-		if (!pending) {
-			throw new Error("no pending native execute call");
-		}
-		pending.resolve({
-			columns: [],
-			rows: [],
-			changes: 0,
-			lastInsertRowId: null,
-			...result,
-		});
-	}
-
-	rejectNext(error: unknown) {
-		const pending = this.#pending.shift();
-		if (!pending) {
-			throw new Error("no pending native execute call");
-		}
-		pending.reject(error);
-	}
-
-	async #startExecute(
-		sql: string,
-		params: NativeParams,
-		write: boolean,
-	): Promise<NativeExecuteResult> {
-		this.executeCalls.push({ sql, params, write });
-		this.active++;
-		this.maxActive = Math.max(this.maxActive, this.active);
-		const pending = deferred<NativeExecuteResult>();
-		this.#pending.push(pending);
-		try {
-			return await pending.promise;
-		} finally {
-			this.active--;
-		}
-	}
-}
-
-describe("wrapJsNativeDatabase", () => {
-	test("admits Promise.all read queries concurrently", async () => {
-		const native = new FakeNativeDatabase();
-		const db = wrapJsNativeDatabase(native);
-
-		const first = db.query("SELECT 1");
-		const second = db.query("SELECT 2");
-
-		expect(native.maxActive).toBe(2);
-		native.resolveNext({ columns: ["value"], rows: [[1]] });
-		native.resolveNext({ columns: ["value"], rows: [[2]] });
-
-		await expect(first).resolves.toEqual({
-			columns: ["value"],
-			rows: [[1]],
-		});
-		await expect(second).resolves.toEqual({
-			columns: ["value"],
-			rows: [[2]],
-		});
-	});
-
-	test("normalizes supported sqlite bind values", async () => {
-		const native = new FakeNativeDatabase();
-		const db = wrapJsNativeDatabase(native);
-		const blob = new Uint8Array([1, 2, 3]);
-
-		const query = db.query("SELECT ?, ?, ?, ?, ?, ?, ?", [
-			1n,
-			true,
-			"text",
-			1.5,
-			null,
-			undefined,
-			blob,
-		]);
-
-		expect(native.executeCalls[0]?.params).toEqual([
-			{ kind: "int", intValue: 1 },
-			{ kind: "int", intValue: 1 },
-			{ kind: "text", textValue: "text" },
-			{ kind: "float", floatValue: 1.5 },
-			{ kind: "null" },
-			{ kind: "null" },
-			{ kind: "blob", blobValue: Buffer.from(blob) },
-		]);
-
-		native.resolveNext({ columns: ["value"], rows: [[1]] });
-
-		await expect(query).resolves.toEqual({
-			columns: ["value"],
-			rows: [[1]],
-		});
-	});
-
-	test("returns native execute metadata", async () => {
-		const native = new FakeNativeDatabase();
-		const db = wrapJsNativeDatabase(native);
-
-		const write = db.execute("INSERT INTO test VALUES (1)");
-		native.resolveNext({ changes: 1, lastInsertRowId: 7 });
-		await expect(write).resolves.toMatchObject({
-			changes: 1,
-			lastInsertRowId: 7,
-		});
-
-		const fallback = db.execute("SELECT last_insert_rowid()");
-		await expect(fallback).resolves.toMatchObject({
-			rows: [[7]],
-		});
-	});
-
-	test("close waits for admitted native calls and rejects new work", async () => {
-		const native = new FakeNativeDatabase();
-		const db = wrapJsNativeDatabase(native);
-
-		const query = db.query("SELECT 1");
-		const close = db.close();
-		await Promise.resolve();
-
-		expect(native.closed).toBe(false);
-		native.resolveNext({ columns: ["value"], rows: [[1]] });
-
-		await query;
-		await close;
-
-		expect(native.closed).toBe(true);
-		await expect(db.query("SELECT 2")).rejects.toThrow(
-			"Database is closed",
-		);
-	});
-
-	test("decodes sanitized native bridge errors without logging", async () => {
-		const native = new FakeNativeDatabase();
-		const db = wrapJsNativeDatabase(native);
-		const query = db.execute("SELECT broken", [1, "two"]);
-		const bridgeReason = `${BRIDGE_RIVET_ERROR_PREFIX}${JSON.stringify({
-			group: "rivetkit",
-			code: "internal_error",
-			message: "An internal error occurred",
-			statusCode: 500,
-		})}`;
-
-		native.rejectNext(new Error(bridgeReason));
-
-		await expect(query).rejects.toMatchObject({
-			name: "RivetError",
-			group: "rivetkit",
-			code: "internal_error",
-			message: "An internal error occurred",
-		});
-
-		await query.catch((error) => {
-			expect(error.stack).toContain("decodeBridgeRivetError");
-			expect(error.stack).toContain("enrichNativeDatabaseError");
-		});
-	});
-});

package/src/common/inline-websocket-adapter.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, test, vi } from "vitest";
-import { InlineWebSocketAdapter } from "./inline-websocket-adapter";
-
-describe("InlineWebSocketAdapter", () => {
-	test("buffers client messages until open completes", async () => {
-		const events: string[] = [];
-		const adapter = new InlineWebSocketAdapter({
-			onOpen: () => {
-				events.push("handler.open");
-			},
-			onMessage: (event: {
-				data: string;
-				rivetMessageIndex?: number;
-			}) => {
-				events.push(
-					`handler.message:${event.data}:${event.rivetMessageIndex ?? "none"}`,
-				);
-			},
-			onClose: () => {},
-			onError: () => {},
-		});
-
-		adapter.clientWebSocket.addEventListener("open", () => {
-			events.push("client.open");
-		});
-		adapter.actorWebSocket.addEventListener("open", () => {
-			events.push("actor.open");
-		});
-		adapter.actorWebSocket.addEventListener(
-			"message",
-			(event: { data: string; rivetMessageIndex?: number }) => {
-				events.push(
-					`actor.message:${event.data}:${event.rivetMessageIndex ?? "none"}`,
-				);
-			},
-		);
-
-		adapter.dispatchClientMessageWithMetadata("hello", 7);
-		expect(events).toEqual([]);
-
-		await vi.waitFor(() => {
-			expect(events).toEqual([
-				"handler.open",
-				"client.open",
-				"actor.open",
-				"handler.message:hello:7",
-				"actor.message:hello:7",
-			]);
-		});
-	});
-});