rivetkit 0.0.0-stack-chore-sync-engine-changes-from-enterprise-mszropyy.677d526 → 0.0.0-sync-sqlite.527e186

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

@@ -7,6 +7,7 @@ import type {
 	SqliteDatabase,
 	SqliteExecuteResult,
 	SqliteTransactionDatabase,
+	SynchronousSqliteTransactionDatabase,
 } from "./config";
 import { db, registerNativeStateTransactionOpener } from "./mod";
 
@@ -19,7 +20,20 @@ class FakeSqliteDatabase implements SqliteDatabase {
 	transactionTimeouts: Array<number | undefined> = [];
 	transactionNames: Array<string | undefined> = [];
 
-	async exec(): Promise<void> {}
+	async exec(
+		sql: string,
+		callback?: (row: unknown[], columns: string[]) => void,
+	): Promise<void> {
+		this.execSync(sql, callback);
+	}
+
+	execSync(
+		sql: string,
+		callback?: (row: unknown[], columns: string[]) => void,
+	): void {
+		this.record(sql);
+		callback?.([1], ["value"]);
+	}
 
 	async execute(
 		sql: string,
@@ -29,21 +43,40 @@ class FakeSqliteDatabase implements SqliteDatabase {
 		return emptyResult();
 	}
 
+	executeSync(sql: string, params?: SqliteBindings): SqliteExecuteResult {
+		this.record(sql, params);
+		return emptyResult();
+	}
+
 	async beginTransaction(
 		timeoutMs?: number,
 		name?: string,
 	): Promise<SqliteTransactionDatabase> {
+		return this.beginTransactionSync(timeoutMs, name);
+	}
+
+	beginTransactionSync(
+		timeoutMs?: number,
+		name?: string,
+	): SynchronousSqliteTransactionDatabase {
 		this.transactionTimeouts.push(timeoutMs);
 		this.transactionNames.push(name);
 		this.record("BEGIN");
 		return {
 			exec: async () => {},
+			execSync: () => {},
 			execute: async (sql, params) => {
 				this.record(sql, params);
 				return emptyResult();
 			},
+			executeSync: (sql, params) => {
+				this.record(sql, params);
+				return emptyResult();
+			},
 			commit: async () => this.record("COMMIT"),
+			commitSync: () => this.record("COMMIT"),
 			rollback: async () => this.record("ROLLBACK"),
+			rollbackSync: () => this.record("ROLLBACK"),
 		};
 	}
 	async beginStateTransaction(
@@ -53,10 +86,15 @@ class FakeSqliteDatabase implements SqliteDatabase {
 		this.record("BEGIN_STATE");
 		return {
 			exec: async () => {},
+			execSync: () => {},
 			execute: async (sql, params) => {
 				this.record(sql, params);
 				return emptyResult();
 			},
+			executeSync: (sql, params) => {
+				this.record(sql, params);
+				return emptyResult();
+			},
 			commit: async () => this.record("COMMIT"),
 			rollback: async () => this.record("ROLLBACK"),
 		};
@@ -173,6 +211,129 @@ describe("db", () => {
 		});
 	});
 
+	test("exposes synchronous raw queries on the built-in client", async () => {
+		const nativeDb = new FakeSqliteDatabase();
+		const client = await db().createClient(testProviderContext(nativeDb));
+
+		client.executeSync("SELECT ?", 42);
+		expect(
+			client.executeSync<{ value: number }>("SELECT 1; SELECT 2"),
+		).toEqual([{ value: 1 }]);
+
+		expect(nativeDb.executeCalls).toEqual([
+			{
+				sql: "SELECT ?",
+				params: [42],
+			},
+			{
+				sql: "SELECT 1; SELECT 2",
+				params: undefined,
+			},
+		]);
+	});
+
+	test("commits synchronous transaction work before returning", async () => {
+		const nativeDb = new FakeSqliteDatabase();
+		const client = await db().createClient(testProviderContext(nativeDb));
+
+		const value = client.transactionSync(
+			(tx) => {
+				tx.executeSync("INSERT INTO items(value) VALUES (?)", "inside");
+				return 42;
+			},
+			{ name: "sync-insert", timeout: 120_000 },
+		);
+
+		expect(value).toBe(42);
+		expect(nativeDb.transactionTimeouts).toEqual([120_000]);
+		expect(nativeDb.transactionNames).toEqual(["sync-insert"]);
+		expect(nativeDb.executeCalls.map(({ sql }) => sql)).toEqual([
+			"BEGIN",
+			"INSERT INTO items(value) VALUES (?)",
+			"COMMIT",
+		]);
+	});
+
+	test("rolls back synchronous transactions on callback and commit errors", async () => {
+		const callbackDb = new FakeSqliteDatabase();
+		const callbackClient = await db().createClient(
+			testProviderContext(callbackDb),
+		);
+		expect(() =>
+			callbackClient.transactionSync(() => {
+				throw new Error("callback failed");
+			}),
+		).toThrow("callback failed");
+		expect(callbackDb.executeCalls.map(({ sql }) => sql)).toEqual([
+			"BEGIN",
+			"ROLLBACK",
+		]);
+
+		const commitDb = new FakeSqliteDatabase();
+		commitDb.failSql.set("COMMIT", new Error("commit failed"));
+		const commitClient = await db().createClient(
+			testProviderContext(commitDb),
+		);
+		expect(() => commitClient.transactionSync(() => 1)).toThrow(
+			"commit failed",
+		);
+		expect(commitDb.executeCalls.map(({ sql }) => sql)).toEqual([
+			"BEGIN",
+			"COMMIT",
+			"ROLLBACK",
+		]);
+	});
+
+	test("rejects async synchronous-transaction callbacks and outer-client queries", async () => {
+		const nativeDb = new FakeSqliteDatabase();
+		const client = await db().createClient(testProviderContext(nativeDb));
+
+		expect(() => client.transactionSync(async () => undefined)).toThrow(
+			"must not return a promise",
+		);
+		expect(nativeDb.executeCalls.map(({ sql }) => sql)).toEqual([
+			"BEGIN",
+			"ROLLBACK",
+		]);
+
+		nativeDb.executeCalls = [];
+		let outerQuery: Promise<Record<string, unknown>[]> | undefined;
+		client.transactionSync((tx) => {
+			expect(Object.keys(tx)).toEqual(["executeSync"]);
+			expect(() => client.executeSync("SELECT 1")).toThrow(
+				"transaction callback's tx value",
+			);
+			outerQuery = client.execute("SELECT 1");
+			expect(() => client.transactionSync(() => undefined)).toThrow(
+				"Nested synchronous SQLite transactions",
+			);
+			tx.executeSync("SELECT 2");
+		});
+		await expect(outerQuery).rejects.toThrow(
+			"transaction callback's tx value",
+		);
+		expect(nativeDb.executeCalls.map(({ sql }) => sql)).toEqual([
+			"BEGIN",
+			"SELECT 2",
+			"COMMIT",
+		]);
+	});
+
+	test("validates synchronous transaction options before beginning", async () => {
+		const nativeDb = new FakeSqliteDatabase();
+		const client = await db().createClient(testProviderContext(nativeDb));
+
+		for (const timeout of [0, -1, Number.NaN, Number.POSITIVE_INFINITY]) {
+			expect(() =>
+				client.transactionSync(() => undefined, { timeout }),
+			).toThrow("positive finite");
+		}
+		expect(() =>
+			client.transactionSync(() => undefined, { name: "" }),
+		).toThrow("must not be empty");
+		expect(nativeDb.executeCalls).toEqual([]);
+	});
+
 	test("rolls back migrations when onMigrate fails", async () => {
 		const nativeDb = new FakeSqliteDatabase();
 		const provider = db({

package/src/common/database/mod.ts

@@ -7,17 +7,20 @@ import type {
 	SqliteProfilingOptions,
 	SqliteTransactionDatabase,
 	SqliteTransactionOptions,
+	SynchronousRawAccess,
+	SynchronousTransactionAccess,
 } from "./config";
 import {
 	isManualTransactionControl,
 	isSqliteBindingObject,
 	MIGRATION_TRANSACTION_TIMEOUT_MS,
+	runSqliteTransactionSync,
 	toSqliteBindings,
 	validateTransactionName,
 	validateTransactionTimeout,
 } from "./shared";
 
-export type { RawAccess } from "./config";
+export type { RawAccess, SynchronousRawAccess } from "./config";
 
 export interface DatabaseFactoryConfig {
 	onMigrate?: (db: RawAccess) => Promise<void> | void;
@@ -84,8 +87,8 @@ export function db({
 	onMigrate,
 	warnOnManualTransactions = true,
 	profiling,
-}: DatabaseFactoryConfig = {}): DatabaseProvider<RawAccess> {
-	const provider: DatabaseProvider<RawAccess> = {
+}: DatabaseFactoryConfig = {}): DatabaseProvider<SynchronousRawAccess> {
+	const provider: DatabaseProvider<SynchronousRawAccess> = {
 		sqliteProfiling: profiling,
 		createClient: async (ctx) => {
 			const nativeDatabaseProvider = ctx.nativeDatabaseProvider;
@@ -98,6 +101,7 @@ export function db({
 			const db = await nativeDatabaseProvider.open(ctx.actorId);
 			let closed = false;
 			let manualTransactionWarned = false;
+			let synchronousTransactionActive = false;
 			const ensureOpen = () => {
 				if (closed) {
 					throw new Error(
@@ -105,13 +109,22 @@ export function db({
 					);
 				}
 			};
+			const ensureSynchronousTransactionClient = (
+				transactionScoped: boolean,
+			) => {
+				if (!transactionScoped && synchronousTransactionActive) {
+					throw new Error(
+						"Use the transaction callback's tx value for queries inside db.transactionSync().",
+					);
+				}
+			};
 
 			const createClient = (
 				target: SqliteDatabase | SqliteTransactionDatabase,
 				transactionScoped = false,
 				stateTransactionContext?: NativeStateTransactionContext,
-			): RawAccess => {
-				const client: RawAccess = {
+			): SynchronousRawAccess => {
+				const client: SynchronousRawAccess = {
 					execute: async <
 						TRow extends Record<string, unknown> = Record<
 							string,
@@ -122,6 +135,7 @@ export function db({
 						...args: unknown[]
 					): Promise<TRow[]> => {
 						ensureOpen();
+						ensureSynchronousTransactionClient(transactionScoped);
 						if (
 							!transactionScoped &&
 							warnOnManualTransactions &&
@@ -132,7 +146,7 @@ export function db({
 							manualTransactionWarned = true;
 							getLogger("database").warn(
 								{ actorId: ctx.actorId },
-								"Manual cross-call SQLite transactions can interleave with other actor work. Use db.transaction() for coordinated transactions. Set warnOnManualTransactions: false in your db(...) configuration to disable this warning.",
+								"Manual cross-call SQLite transactions can interleave with other actor work. Use db.transaction() or db.transactionSync() for coordinated transactions. Set warnOnManualTransactions: false in your db(...) configuration to disable this warning.",
 							);
 						}
 
@@ -188,10 +202,91 @@ export function db({
 							}
 						}
 					},
+					executeSync: <
+						TRow extends Record<string, unknown> = Record<
+							string,
+							unknown
+						>,
+					>(
+						query: string,
+						...args: unknown[]
+					): TRow[] => {
+						ensureOpen();
+						ensureSynchronousTransactionClient(transactionScoped);
+						if (!target.executeSync) {
+							throw new Error(
+								"Synchronous SQLite queries are only available in the Node.js native runtime.",
+							);
+						}
+						if (
+							!transactionScoped &&
+							warnOnManualTransactions &&
+							!manualTransactionWarned &&
+							!hasMultipleStatements(query) &&
+							isManualTransactionControl(query)
+						) {
+							manualTransactionWarned = true;
+							getLogger("database").warn(
+								{ actorId: ctx.actorId },
+								"Manual cross-call SQLite transactions can interleave with other actor work. Use db.transaction() or db.transactionSync() for coordinated transactions. Set warnOnManualTransactions: false in your db(...) configuration to disable this warning.",
+							);
+						}
+
+						const kvReadsBefore = ctx.metrics?.totalKvReads ?? 0;
+						const kvWritesBefore = ctx.metrics?.totalKvWrites ?? 0;
+						const start = performance.now();
+
+						try {
+							if (args.length > 0) {
+								const bindings =
+									args.length === 1 &&
+									isSqliteBindingObject(args[0])
+										? toSqliteBindings(args[0])
+										: toSqliteBindings(args);
+								const { rows, columns } = target.executeSync(
+									query,
+									bindings,
+								);
+								return rows.map((row) =>
+									rowToObject<TRow>(row, columns),
+								);
+							}
+
+							if (!hasMultipleStatements(query)) {
+								const { rows, columns } = target.executeSync(
+									query,
+									undefined,
+								);
+								return rows.map((row) =>
+									rowToObject<TRow>(row, columns),
+								);
+							}
+
+							return execMultiStatementSync<TRow>(target, query);
+						} finally {
+							const durationMs = performance.now() - start;
+							ctx.metrics?.trackSql(query, durationMs);
+							if (ctx.metrics) {
+								const kvReads =
+									ctx.metrics.totalKvReads - kvReadsBefore;
+								const kvWrites =
+									ctx.metrics.totalKvWrites - kvWritesBefore;
+								ctx.log?.debug({
+									msg: "sql query",
+									query: query.slice(0, 120),
+									durationMs,
+									kvReads,
+									kvWrites,
+								});
+							}
+						}
+					},
 					transaction: async <T>(
 						callback: (tx: RawAccess) => Promise<T> | T,
 						options?: SqliteTransactionOptions,
 					): Promise<T> => {
+						ensureOpen();
+						ensureSynchronousTransactionClient(transactionScoped);
 						validateTransactionTimeout(options?.timeout);
 						validateTransactionName(options?.name);
 						if (
@@ -249,6 +344,39 @@ export function db({
 							}
 						}
 					},
+					transactionSync: <T>(
+						callback: (tx: SynchronousTransactionAccess) => T,
+						options?: Omit<
+							SqliteTransactionOptions,
+							"experimental"
+						>,
+					): T => {
+						ensureOpen();
+						if (transactionScoped || synchronousTransactionActive) {
+							throw new Error(
+								"Nested synchronous SQLite transactions are not supported.",
+							);
+						}
+						return runSqliteTransactionSync(
+							db,
+							(transaction) => {
+								const transactionClient = createClient(
+									transaction,
+									true,
+								);
+								const tx: SynchronousTransactionAccess = {
+									executeSync: transactionClient.executeSync,
+								};
+								synchronousTransactionActive = true;
+								try {
+									return callback(tx);
+								} finally {
+									synchronousTransactionActive = false;
+								}
+							},
+							options,
+						);
+					},
 					close: async () => {
 						if (!closed) {
 							closed = true;
@@ -304,6 +432,26 @@ async function execMultiStatement<TRow extends Record<string, unknown>>(
 	return results as TRow[];
 }
 
+function execMultiStatementSync<TRow extends Record<string, unknown>>(
+	db: Pick<SqliteDatabase, "execSync">,
+	query: string,
+): TRow[] {
+	if (!db.execSync) {
+		throw new Error(
+			"Synchronous SQLite queries are only available in the Node.js native runtime.",
+		);
+	}
+	const results: Record<string, unknown>[] = [];
+	let columnNames: string[] | null = null;
+	db.execSync(query, (row: unknown[], columns: string[]) => {
+		if (!columnNames) {
+			columnNames = columns;
+		}
+		results.push(rowToObject(row, columnNames));
+	});
+	return results as TRow[];
+}
+
 async function withMigrationSavepoint<T>(
 	client: RawAccess,
 	callback: (leased: RawAccess) => Promise<T> | T,

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

@@ -20,28 +20,66 @@ function deferred<T>() {
 
 class FakeNativeDatabase implements JsNativeDatabaseLike {
 	async beginTransaction() {
+		this.transactionEvents.push("BEGIN");
+		return this.#transaction();
+	}
+
+	beginTransactionSync() {
+		this.transactionEvents.push("BEGIN_SYNC");
+		return this.#transaction();
+	}
+
+	#transaction() {
 		return {
 			exec: async (_sql: string) => this.exec(),
+			execSync: (_sql: string) => this.execSync(),
 			execute: async (sql: string, params?: NativeParams) =>
 				this.execute(sql, params),
-			commit: async () => {},
-			rollback: async () => {},
+			executeSync: (sql: string, params?: NativeParams) =>
+				this.executeSync(sql, params),
+			commit: async () => {
+				this.transactionEvents.push("COMMIT");
+			},
+			commitSync: () => {
+				this.transactionEvents.push("COMMIT_SYNC");
+			},
+			rollback: async () => {
+				this.transactionEvents.push("ROLLBACK");
+			},
+			rollbackSync: () => {
+				this.transactionEvents.push("ROLLBACK_SYNC");
+			},
 		};
 	}
 	active = 0;
 	maxActive = 0;
 	closed = false;
 	executeCalls: { sql: string; params?: NativeParams; write: boolean }[] = [];
+	transactionEvents: string[] = [];
 	#pending: ReturnType<typeof deferred<NativeExecuteResult>>[] = [];
 
 	async exec() {
 		return { columns: [], rows: [] };
 	}
 
+	execSync() {
+		return { columns: ["value"], rows: [[1], [2]] };
+	}
+
 	async execute(sql: string, params?: NativeParams) {
 		return await this.#startExecute(sql, params, false);
 	}
 
+	executeSync(sql: string, params?: NativeParams): NativeExecuteResult {
+		this.executeCalls.push({ sql, params, write: false });
+		return {
+			columns: ["value"],
+			rows: [[1]],
+			changes: 0,
+			lastInsertRowId: null,
+		};
+	}
+
 	async query(sql: string, params?: NativeParams) {
 		const { columns, rows } = await this.execute(sql, params);
 		return { columns, rows };
@@ -155,6 +193,47 @@ describe("wrapJsNativeDatabase", () => {
 		});
 	});
 
+	test("executes synchronously with normalized bindings", () => {
+		const native = new FakeNativeDatabase();
+		const db = wrapJsNativeDatabase(native);
+
+		const result = db.executeSync?.("SELECT ?, ?", [true, "text"]);
+		const execRows: unknown[][] = [];
+		db.execSync?.("SELECT 1; SELECT 2", (row) => execRows.push(row));
+
+		expect(native.executeCalls[0]?.params).toEqual([
+			{ kind: "int", intValue: 1 },
+			{ kind: "text", textValue: "text" },
+		]);
+		expect(result).toMatchObject({
+			columns: ["value"],
+			rows: [[1]],
+		});
+		expect(execRows).toEqual([[1], [2]]);
+	});
+
+	test("wraps synchronous transaction lifecycle methods", () => {
+		const native = new FakeNativeDatabase();
+		const db = wrapJsNativeDatabase(native);
+
+		const committed = db.beginTransactionSync?.(1_000, "commit");
+		if (!committed)
+			throw new Error("missing synchronous transaction support");
+		committed.executeSync("SELECT 1");
+		committed.commitSync();
+		const rolledBack = db.beginTransactionSync?.(1_000, "rollback");
+		if (!rolledBack)
+			throw new Error("missing synchronous transaction support");
+		rolledBack.rollbackSync();
+
+		expect(native.transactionEvents).toEqual([
+			"BEGIN_SYNC",
+			"COMMIT_SYNC",
+			"BEGIN_SYNC",
+			"ROLLBACK_SYNC",
+		]);
+	});
+
 	test("returns native execute metadata", async () => {
 		const native = new FakeNativeDatabase();
 		const db = wrapJsNativeDatabase(native);