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

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

@@ -6,6 +6,7 @@ import type {
 	SqliteExecuteResult,
 	SqliteNativeMetrics,
 	SqliteTransactionDatabase,
+	SynchronousSqliteTransactionDatabase,
 } from "./config";
 
 type NativeBindNoValues = {
@@ -74,10 +75,15 @@ interface NativeBatchStatement {
 
 export interface JsNativeDatabaseLike {
 	exec(sql: string): Promise<NativeExecResult>;
+	execSync(sql: string): NativeExecResult;
 	execute(
 		sql: string,
 		params?: NativeBindParam[] | null,
 	): Promise<NativeExecuteResult>;
+	executeSync(
+		sql: string,
+		params?: NativeBindParam[] | null,
+	): NativeExecuteResult;
 	executeBatch?(
 		statements: NativeBatchStatement[],
 	): Promise<NativeExecuteResult[]>;
@@ -88,7 +94,11 @@ export interface JsNativeDatabaseLike {
 	beginTransaction(
 		timeoutMs?: number,
 		name?: string,
-	): Promise<JsNativeTransactionLike>;
+	): Promise<JsNativeSynchronousTransactionLike>;
+	beginTransactionSync(
+		timeoutMs?: number,
+		name?: string,
+	): JsNativeSynchronousTransactionLike;
 	query(
 		sql: string,
 		params?: NativeBindParam[] | null,
@@ -110,14 +120,36 @@ export type StateAwareSqliteDatabase = SqliteDatabase & {
 
 export interface JsNativeTransactionLike {
 	exec(sql: string): Promise<NativeExecResult>;
+	execSync(sql: string): NativeExecResult;
 	execute(
 		sql: string,
 		params?: NativeBindParam[] | null,
 	): Promise<NativeExecuteResult>;
+	executeSync(
+		sql: string,
+		params?: NativeBindParam[] | null,
+	): NativeExecuteResult;
 	commit(): Promise<void>;
 	rollback(): Promise<void>;
 }
 
+export interface JsNativeSynchronousTransactionLike
+	extends JsNativeTransactionLike {
+	commitSync(): void;
+	rollbackSync(): void;
+}
+
+function isSynchronousTransaction(
+	transaction: JsNativeTransactionLike,
+): transaction is JsNativeSynchronousTransactionLike {
+	const candidate =
+		transaction as Partial<JsNativeSynchronousTransactionLike>;
+	return (
+		typeof candidate.commitSync === "function" &&
+		typeof candidate.rollbackSync === "function"
+	);
+}
+
 function shouldAttachNativeKvError(message: string): boolean {
 	return /i\/o error|unable to open database file/i.test(message);
 }
@@ -358,6 +390,34 @@ export function wrapJsNativeDatabase(
 			release();
 		}
 	};
+	const executeNativeSync = (
+		sql: string,
+		params?: SqliteBindings,
+	): SqliteExecuteResult => {
+		const lastInsertRowIdColumn = lastInsertRowIdColumnName(sql);
+		if (lastInsertRowIdColumn) {
+			return {
+				columns: [lastInsertRowIdColumn],
+				rows: [[lastInsertRowId ?? 0]],
+				changes: 0,
+				lastInsertRowId,
+			};
+		}
+
+		const release = gate.enter();
+		try {
+			const nativeParams = toNativeBindings(sql, params);
+			const result = database.executeSync(sql, nativeParams);
+			if (result.lastInsertRowId !== undefined) {
+				lastInsertRowId = result.lastInsertRowId;
+			}
+			return result;
+		} catch (error) {
+			enrichNativeDatabaseError(database, error);
+		} finally {
+			release();
+		}
+	};
 
 	return {
 		async exec(
@@ -380,12 +440,34 @@ export function wrapJsNativeDatabase(
 				callback(row, result.columns);
 			}
 		},
+		execSync(
+			sql: string,
+			callback?: (row: unknown[], columns: string[]) => void,
+		): void {
+			const release = gate.enter();
+			let result: NativeExecResult;
+			try {
+				result = database.execSync(sql);
+			} catch (error) {
+				enrichNativeDatabaseError(database, error);
+			} finally {
+				release();
+			}
+			if (callback) {
+				for (const row of result.rows) {
+					callback(row, result.columns);
+				}
+			}
+		},
 		async execute(
 			sql: string,
 			params?: SqliteBindings,
 		): Promise<SqliteExecuteResult> {
 			return await executeNative(sql, params);
 		},
+		executeSync(sql: string, params?: SqliteBindings): SqliteExecuteResult {
+			return executeNativeSync(sql, params);
+		},
 		async executeBatch(
 			statements: SqliteBatchStatement[],
 		): Promise<SqliteExecuteResult[]> {
@@ -435,7 +517,7 @@ export function wrapJsNativeDatabase(
 			name?: string,
 		): Promise<SqliteTransactionDatabase> {
 			const release = gate.enter();
-			let transaction: JsNativeTransactionLike;
+			let transaction: JsNativeSynchronousTransactionLike;
 			try {
 				transaction = await database.beginTransaction(timeoutMs, name);
 			} catch (error) {
@@ -449,6 +531,25 @@ export function wrapJsNativeDatabase(
 				}
 			});
 		},
+		beginTransactionSync(
+			timeoutMs?: number,
+			name?: string,
+		): SynchronousSqliteTransactionDatabase {
+			const release = gate.enter();
+			let transaction: JsNativeSynchronousTransactionLike;
+			try {
+				transaction = database.beginTransactionSync(timeoutMs, name);
+			} catch (error) {
+				enrichNativeDatabaseError(database, error);
+			} finally {
+				release();
+			}
+			return wrapTransaction(database, transaction, gate, (result) => {
+				if (result.lastInsertRowId !== undefined) {
+					lastInsertRowId = result.lastInsertRowId;
+				}
+			});
+		},
 		async beginStateTransaction(
 			timeoutMs?: number,
 			context?: unknown,
@@ -491,13 +592,25 @@ export function wrapJsNativeDatabase(
 	};
 }
 
+function wrapTransaction(
+	database: JsNativeDatabaseLike,
+	transaction: JsNativeSynchronousTransactionLike,
+	gate: NativeCloseGate,
+	onExecute: (result: NativeExecuteResult) => void,
+): SynchronousSqliteTransactionDatabase;
+function wrapTransaction(
+	database: JsNativeDatabaseLike,
+	transaction: JsNativeTransactionLike,
+	gate: NativeCloseGate,
+	onExecute: (result: NativeExecuteResult) => void,
+): SqliteTransactionDatabase;
 function wrapTransaction(
 	database: JsNativeDatabaseLike,
 	transaction: JsNativeTransactionLike,
 	gate: NativeCloseGate,
 	onExecute: (result: NativeExecuteResult) => void,
 ): SqliteTransactionDatabase {
-	return {
+	const wrapped: SqliteTransactionDatabase = {
 		async exec(sql, callback) {
 			const release = gate.enter();
 			let result: NativeExecResult;
@@ -512,6 +625,20 @@ function wrapTransaction(
 				for (const row of result.rows) callback(row, result.columns);
 			}
 		},
+		execSync(sql, callback) {
+			const release = gate.enter();
+			let result: NativeExecResult;
+			try {
+				result = transaction.execSync(sql);
+			} catch (error) {
+				enrichNativeDatabaseError(database, error);
+			} finally {
+				release();
+			}
+			if (callback) {
+				for (const row of result.rows) callback(row, result.columns);
+			}
+		},
 		async execute(sql, params) {
 			const release = gate.enter();
 			try {
@@ -527,6 +654,21 @@ function wrapTransaction(
 				release();
 			}
 		},
+		executeSync(sql, params) {
+			const release = gate.enter();
+			try {
+				const result = transaction.executeSync(
+					sql,
+					toNativeBindings(sql, params),
+				);
+				onExecute(result);
+				return result;
+			} catch (error) {
+				enrichNativeDatabaseError(database, error);
+			} finally {
+				release();
+			}
+		},
 		async commit() {
 			const release = gate.enter();
 			try {
@@ -548,6 +690,33 @@ function wrapTransaction(
 			}
 		},
 	};
+
+	if (isSynchronousTransaction(transaction)) {
+		return Object.assign(wrapped, {
+			commitSync() {
+				const release = gate.enter();
+				try {
+					transaction.commitSync();
+				} catch (error) {
+					enrichNativeDatabaseError(database, error);
+				} finally {
+					release();
+				}
+			},
+			rollbackSync() {
+				const release = gate.enter();
+				try {
+					transaction.rollbackSync();
+				} catch (error) {
+					enrichNativeDatabaseError(database, error);
+				} finally {
+					release();
+				}
+			},
+		}) as SynchronousSqliteTransactionDatabase;
+	}
+
+	return wrapped;
 }
 
 function lastInsertRowIdColumnName(sql: string): string | undefined {

package/src/common/database/shared.ts

@@ -1,4 +1,9 @@
-import type { SqliteBindings } from "./config";
+import type {
+	SqliteBindings,
+	SqliteDatabase,
+	SqliteTransactionOptions,
+	SynchronousSqliteTransactionDatabase,
+} from "./config";
 
 /** Migrations may legitimately do substantially more work than request transactions. */
 export const MIGRATION_TRANSACTION_TIMEOUT_MS = 5 * 60_000;
@@ -24,6 +29,49 @@ export function validateTransactionName(name: string | undefined): void {
 	}
 }
 
+export function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
+	return (typeof value === "object" && value !== null) ||
+		typeof value === "function"
+		? typeof (value as { then?: unknown }).then === "function"
+		: false;
+}
+
+export function runSqliteTransactionSync<T>(
+	database: SqliteDatabase,
+	callback: (transaction: SynchronousSqliteTransactionDatabase) => T,
+	options?: Omit<SqliteTransactionOptions, "experimental">,
+): T {
+	validateTransactionTimeout(options?.timeout);
+	validateTransactionName(options?.name);
+	if (!database.beginTransactionSync) {
+		throw new Error(
+			"Synchronous SQLite transactions are only available in the Node.js native runtime.",
+		);
+	}
+
+	const transaction = database.beginTransactionSync(
+		options?.timeout,
+		options?.name,
+	);
+	try {
+		const result = callback(transaction);
+		if (isPromiseLike(result)) {
+			throw new Error(
+				"db.transactionSync() callback must complete synchronously and must not return a promise.",
+			);
+		}
+		transaction.commitSync();
+		return result;
+	} catch (error) {
+		try {
+			transaction.rollbackSync();
+		} catch {
+			// Preserve the callback or commit error after cleanup failure.
+		}
+		throw error;
+	}
+}
+
 type SqliteBindingObject = Record<string, unknown>;
 
 function isSqliteBindingValue(value: unknown): boolean {

package/src/db/drizzle.test.ts

@@ -6,6 +6,7 @@ import type {
 	SqliteDatabase,
 	SqliteExecuteResult,
 	SqliteTransactionDatabase,
+	SynchronousSqliteTransactionDatabase,
 } from "@/common/database/config";
 import { db } from "./drizzle";
 
@@ -14,7 +15,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.executeCalls.push({ sql });
+		callback?.([1], ["value"]);
+	}
 
 	async execute(
 		sql: string,
@@ -24,6 +38,11 @@ class FakeSqliteDatabase implements SqliteDatabase {
 		return emptyResult();
 	}
 
+	executeSync(sql: string, params?: SqliteBindings): SqliteExecuteResult {
+		this.executeCalls.push({ sql, params });
+		return emptyResult();
+	}
+
 	async executeBatch(
 		statements: SqliteBatchStatement[],
 	): Promise<SqliteExecuteResult[]> {
@@ -47,21 +66,39 @@ class FakeSqliteDatabase implements SqliteDatabase {
 		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.executeCalls.push({ sql: "BEGIN" });
 		return {
 			exec: async () => {},
+			execSync: () => {},
 			execute: async (sql, params) => {
 				this.executeCalls.push({ sql, params });
 				return emptyResult();
 			},
+			executeSync: (sql, params) => {
+				this.executeCalls.push({ sql, params });
+				return emptyResult();
+			},
 			commit: async () => {
 				this.executeCalls.push({ sql: "COMMIT" });
 			},
+			commitSync: () => {
+				this.executeCalls.push({ sql: "COMMIT" });
+			},
 			rollback: async () => {
 				this.executeCalls.push({ sql: "ROLLBACK" });
 			},
+			rollbackSync: () => {
+				this.executeCalls.push({ sql: "ROLLBACK" });
+			},
 		};
 	}
 
@@ -151,6 +188,50 @@ describe("Drizzle database transactions", () => {
 		]);
 	});
 
+	test("exposes synchronous raw queries", 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" },
+		]);
+	});
+
+	test("commits and rolls back synchronous raw transactions", 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-drizzle", timeout: 120_000 },
+		);
+		expect(value).toBe(42);
+		expect(() =>
+			client.transactionSync(() => {
+				throw new Error("callback failed");
+			}),
+		).toThrow("callback failed");
+
+		expect(nativeDb.transactionTimeouts).toEqual([120_000, undefined]);
+		expect(nativeDb.transactionNames).toEqual(["sync-drizzle", undefined]);
+		expect(nativeDb.executeCalls.map(({ sql }) => sql)).toEqual([
+			"BEGIN",
+			"INSERT INTO items(value) VALUES (?)",
+			"COMMIT",
+			"BEGIN",
+			"ROLLBACK",
+		]);
+	});
+
 	test("validates zero, negative, and non-finite transaction timeouts", async () => {
 		const client = await db().createClient(
 			testProviderContext(new FakeSqliteDatabase()),

package/src/db/drizzle.ts

@@ -6,20 +6,22 @@ import {
 import type {
 	DatabaseProvider,
 	DatabaseProviderContext,
-	RawAccess,
-	SqliteProfilingOptions,
-	SqliteTransactionOptions,
 	SqliteDatabase,
+	SqliteProfilingOptions,
 	SqliteTransactionDatabase,
+	SqliteTransactionOptions,
+	SynchronousRawAccess,
+	SynchronousTransactionAccess,
 } from "@/common/database/config";
-import { getLogger } from "@/common/log";
 import {
 	isManualTransactionControl,
 	MIGRATION_TRANSACTION_TIMEOUT_MS,
+	runSqliteTransactionSync,
 	toSqliteBindings,
 	validateTransactionName,
 	validateTransactionTimeout,
 } from "@/common/database/shared";
+import { getLogger } from "@/common/log";
 import { sha256Hex } from "@/utils/crypto";
 
 export type { SQLiteTable } from "drizzle-orm/sqlite-core";
@@ -42,7 +44,7 @@ type DrizzleDatabase<TSchema extends DrizzleSchema> = Omit<
 	SqliteRemoteDatabase<TSchema>,
 	"transaction"
 > &
-	Omit<RawAccess, "transaction"> & {
+	Omit<SynchronousRawAccess, "transaction"> & {
 		transaction: <T>(
 			callback: (tx: DrizzleDatabase<TSchema>) => Promise<T> | T,
 			options?: SqliteTransactionOptions,
@@ -114,6 +116,7 @@ export function db<TSchema extends DrizzleSchema = Record<string, never>>({
 			const nativeDb = await nativeDatabaseProvider.open(ctx.actorId);
 			let closed = false;
 			let manualTransactionWarned = false;
+			let synchronousTransactionActive = false;
 			const ensureOpen = () => {
 				if (closed) {
 					throw new Error(
@@ -121,6 +124,15 @@ export function db<TSchema extends DrizzleSchema = Record<string, never>>({
 					);
 				}
 			};
+			const ensureSynchronousTransactionClient = (
+				transactionScoped: boolean,
+			) => {
+				if (!transactionScoped && synchronousTransactionActive) {
+					throw new Error(
+						"Use the transaction callback's tx value for queries inside db.transactionSync().",
+					);
+				}
+			};
 
 			const createDrizzleClient = (
 				target: SqliteDatabase | SqliteTransactionDatabase,
@@ -132,6 +144,7 @@ export function db<TSchema extends DrizzleSchema = Record<string, never>>({
 					method: "run" | "all" | "values" | "get",
 				) => {
 					ensureOpen();
+					ensureSynchronousTransactionClient(transactionScoped);
 					warnForManualTransaction(query, transactionScoped);
 
 					const start = performance.now();
@@ -186,6 +199,7 @@ export function db<TSchema extends DrizzleSchema = Record<string, never>>({
 					query: string,
 					...args: unknown[]
 				): Promise<TRow[]> => {
+					ensureSynchronousTransactionClient(transactionScoped);
 					return await executeRaw<TRow>(
 						target,
 						ctx,
@@ -196,12 +210,34 @@ export function db<TSchema extends DrizzleSchema = Record<string, never>>({
 							warnForManualTransaction(query, transactionScoped),
 					);
 				};
+				drizzleDb.executeSync = <
+					TRow extends Record<string, unknown> = Record<
+						string,
+						unknown
+					>,
+				>(
+					query: string,
+					...args: unknown[]
+				): TRow[] => {
+					ensureSynchronousTransactionClient(transactionScoped);
+					return executeRawSync<TRow>(
+						target,
+						ctx,
+						ensureOpen,
+						query,
+						args,
+						() =>
+							warnForManualTransaction(query, transactionScoped),
+					);
+				};
 				drizzleDb.transaction = async <T>(
 					transactionCallback: (
 						tx: DrizzleDatabase<TSchema>,
 					) => Promise<T> | T,
 					options?: SqliteTransactionOptions,
 				): Promise<T> => {
+					ensureOpen();
+					ensureSynchronousTransactionClient(transactionScoped);
 					validateTransactionTimeout(options?.timeout);
 					validateTransactionName(options?.name);
 					const transaction = await nativeDb.beginTransaction(
@@ -222,6 +258,38 @@ export function db<TSchema extends DrizzleSchema = Record<string, never>>({
 						throw error;
 					}
 				};
+				drizzleDb.transactionSync = <T>(
+					transactionCallback: (
+						tx: SynchronousTransactionAccess,
+					) => T,
+					options?: Omit<SqliteTransactionOptions, "experimental">,
+				): T => {
+					ensureOpen();
+					if (transactionScoped || synchronousTransactionActive) {
+						throw new Error(
+							"Nested synchronous SQLite transactions are not supported.",
+						);
+					}
+					return runSqliteTransactionSync(
+						nativeDb,
+						(transaction) => {
+							const transactionClient = createDrizzleClient(
+								transaction,
+								true,
+							);
+							const tx: SynchronousTransactionAccess = {
+								executeSync: transactionClient.executeSync,
+							};
+							synchronousTransactionActive = true;
+							try {
+								return transactionCallback(tx);
+							} finally {
+								synchronousTransactionActive = false;
+							}
+						},
+						options,
+					);
+				};
 				drizzleDb.close = async () => {
 					if (!closed) {
 						closed = true;
@@ -248,7 +316,7 @@ export function db<TSchema extends DrizzleSchema = Record<string, never>>({
 				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.",
 				);
 			};
 
@@ -431,3 +499,65 @@ async function executeRaw<TRow extends Record<string, unknown>>(
 		}
 	}
 }
+
+function executeRawSync<TRow extends Record<string, unknown>>(
+	db: SqliteDatabase | SqliteTransactionDatabase,
+	ctx: DatabaseProviderContext,
+	ensureOpen: () => void,
+	query: string,
+	args: unknown[],
+	warnForManualTransaction: () => void,
+): TRow[] {
+	ensureOpen();
+	warnForManualTransaction();
+	if (!db.executeSync) {
+		throw new Error(
+			"Synchronous SQLite queries are only available in the Node.js native runtime.",
+		);
+	}
+
+	const start = performance.now();
+	const kvReadsBefore = ctx.metrics?.totalKvReads ?? 0;
+	const kvWritesBefore = ctx.metrics?.totalKvWrites ?? 0;
+	try {
+		if (args.length > 0) {
+			const { rows, columns } = db.executeSync(
+				query,
+				toSqliteBindings(args),
+			);
+			return rows.map((row) => rowToObject<TRow>(row, columns));
+		}
+
+		if (!hasMultipleStatements(query)) {
+			const { rows, columns } = db.executeSync(query, undefined);
+			return rows.map((row) => rowToObject<TRow>(row, columns));
+		}
+
+		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, columns) => {
+			if (!columnNames) {
+				columnNames = columns;
+			}
+			results.push(rowToObject(row, columnNames));
+		});
+		return results as TRow[];
+	} finally {
+		const durationMs = performance.now() - start;
+		ctx.metrics?.trackSql(query, durationMs);
+		if (ctx.metrics) {
+			ctx.log?.debug({
+				msg: "sql query",
+				query: query.slice(0, 120),
+				durationMs,
+				kvReads: ctx.metrics.totalKvReads - kvReadsBefore,
+				kvWrites: ctx.metrics.totalKvWrites - kvWritesBefore,
+			});
+		}
+	}
+}

package/src/db/mod.ts

@@ -12,5 +12,7 @@ export type {
 	SqliteProfilingOptions,
 	SqliteQueryResult,
 	SqliteTransactionOptions,
+	SynchronousRawAccess,
+	SynchronousTransactionAccess,
 } from "@/common/database/config";
 export { db } from "@/common/database/mod";