rivetkit 0.0.0-sqlite-uds.37f9e48 → 0.0.0-sqlite-profiling-compat.4a9a623

package/src/db/drizzle.ts

@@ -28,17 +28,8 @@ export {
 } from "drizzle-orm/sqlite-core";
 
 type DrizzleSchema = Record<string, unknown>;
-type DrizzleDatabase<TSchema extends DrizzleSchema> = Omit<
-	SqliteRemoteDatabase<TSchema>,
-	"transaction"
-> &
-	Omit<RawAccess, "transaction"> & {
-		transaction: <T>(
-			callback: (tx: DrizzleDatabase<TSchema>) => Promise<T> | T,
-		) => Promise<T>;
-	};
-
-const MIGRATION_LEASE_TIMEOUT_MS = 60_000;
+type DrizzleDatabase<TSchema extends DrizzleSchema> =
+	SqliteRemoteDatabase<TSchema> & RawAccess;
 
 interface DrizzleMigrationJournalEntry {
 	idx: number;
@@ -99,7 +90,6 @@ export function db<TSchema extends DrizzleSchema = Record<string, never>>({
 
 			const nativeDb = await nativeDatabaseProvider.open(ctx.actorId);
 			let closed = false;
-			let transactionActive = false;
 			const ensureOpen = () => {
 				if (closed) {
 					throw new Error(
@@ -108,192 +98,107 @@ export function db<TSchema extends DrizzleSchema = Record<string, never>>({
 				}
 			};
 
-			const createDrizzleClient = (lease?: {
-				key: string;
-				timeoutMs?: number;
-			}): DrizzleDatabase<TSchema> => {
-				const runSql = async (
-					query: string,
-					params: unknown[],
-					method: "run" | "all" | "values" | "get",
-				) => {
-					ensureOpen();
-					if (!lease && transactionActive) {
-						throw new Error(
-							"Use the tx argument inside db.transaction(); the outer database client cannot run work from the transaction callback.",
-						);
-					}
-
-					const start = performance.now();
-					const kvReadsBefore = ctx.metrics?.totalKvReads ?? 0;
-					const kvWritesBefore = ctx.metrics?.totalKvWrites ?? 0;
-					try {
-						const { rows } = await nativeDb.execute(
-							query,
-							toSqliteBindings(params),
-							lease,
-						);
-						if (method === "run") {
-							return { rows: [] };
-						}
-						if (method === "get") {
-							return { rows: rows[0] };
-						}
-						return { rows };
-					} 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,
-							});
-						}
-					}
-				};
+			const runSql = async (
+				query: string,
+				params: unknown[],
+				method: "run" | "all" | "values" | "get",
+			) => {
+				ensureOpen();
 
-				const callback: RemoteCallback = async (
-					query,
-					params,
-					method,
-				) => {
-					return await runSql(query, params, method);
-				};
-
-				const drizzleDb = drizzle(callback, {
-					schema,
-				}) as unknown as DrizzleDatabase<TSchema>;
-				drizzleDb.execute = async <
-					TRow extends Record<string, unknown> = Record<
-						string,
-						unknown
-					>,
-				>(
-					query: string,
-					...args: unknown[]
-				): Promise<TRow[]> => {
-					return await executeRaw<TRow>(
-						nativeDb,
-						ctx,
-						ensureOpen,
+				const start = performance.now();
+				const kvReadsBefore = ctx.metrics?.totalKvReads ?? 0;
+				const kvWritesBefore = ctx.metrics?.totalKvWrites ?? 0;
+				try {
+					const { rows } = await nativeDb.execute(
 						query,
-						args,
-						lease,
+						toSqliteBindings(params),
 					);
-				};
-				drizzleDb.transaction = async <T>(
-					transactionCallback: (
-						tx: DrizzleDatabase<TSchema>,
-					) => Promise<T> | T,
-				): Promise<T> => {
-					if (lease || transactionActive) {
-						throw new Error(
-							"Nested or concurrent db.transaction() calls are not supported.",
-						);
+					if (method === "run") {
+						return { rows: [] };
 					}
-					const transactionLease = { key: crypto.randomUUID() };
-					const tx = createDrizzleClient(transactionLease);
-					await nativeDb.execute(
-						"BEGIN",
-						undefined,
-						transactionLease,
-					);
-					transactionActive = true;
-					try {
-						const result = await transactionCallback(tx);
-						await nativeDb.execute(
-							"COMMIT",
-							undefined,
-							transactionLease,
-						);
-						return result;
-					} catch (error) {
-						try {
-							await nativeDb.execute(
-								"ROLLBACK",
-								undefined,
-								transactionLease,
-							);
-						} catch {
-							// Preserve the callback or commit error after lease poisoning.
-						}
-						throw error;
-					} finally {
-						transactionActive = false;
+					if (method === "get") {
+						return { rows: rows[0] };
 					}
-				};
-				drizzleDb.__withSqliteLease = async <T>(
-					timeoutMs: number,
-					leaseCallback: (leased: RawAccess) => Promise<T> | T,
-				): Promise<T> => {
-					const internalLease = {
-						key: crypto.randomUUID(),
-						timeoutMs,
-					};
-					return await leaseCallback(
-						createDrizzleClient(internalLease),
-					);
-				};
-				drizzleDb.close = async () => {
-					if (!closed) {
-						closed = true;
-						await nativeDb.close();
+					return { rows };
+				} 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,
+						});
 					}
-				};
+				}
+			};
 
-				return drizzleDb;
+			const callback: RemoteCallback = async (query, params, method) => {
+				return await runSql(query, params, method);
 			};
 
-			return createDrizzleClient();
+			const drizzleDb = drizzle(callback, {
+				schema,
+			}) as DrizzleDatabase<TSchema>;
+			drizzleDb.execute = async <
+				TRow extends Record<string, unknown> = Record<string, unknown>,
+			>(
+				query: string,
+				...args: unknown[]
+			): Promise<TRow[]> => {
+				return await executeRaw<TRow>(
+					nativeDb,
+					ctx,
+					ensureOpen,
+					query,
+					args,
+				);
+			};
+			drizzleDb.close = async () => {
+				if (!closed) {
+					closed = true;
+					await nativeDb.close();
+				}
+			};
+
+			return drizzleDb;
 		},
 		onMigrate: async (client) => {
 			if (!migrations && !onMigrate) {
 				return;
 			}
-			await withMigrationSavepoint(client, async (leased) => {
+			await withMigrationSavepoint(client, async () => {
 				if (migrations) {
-					await runMigrations(leased, migrations);
+					await runMigrations(client, migrations);
 				}
 				if (onMigrate) {
-					await onMigrate(leased);
+					await onMigrate(client);
 				}
 			});
 		},
 	};
 }
 
-async function withMigrationSavepoint<TSchema extends DrizzleSchema, T>(
-	client: DrizzleDatabase<TSchema>,
-	callback: (leased: DrizzleDatabase<TSchema>) => Promise<T> | T,
+async function withMigrationSavepoint<T>(
+	client: RawAccess,
+	callback: () => Promise<T> | T,
 ): Promise<T> {
-	return await client.__withSqliteLease(
-		MIGRATION_LEASE_TIMEOUT_MS,
-		async (leasedAccess) => {
-			const leased = leasedAccess as DrizzleDatabase<TSchema>;
-			await leased.execute("SAVEPOINT __rivet_on_migrate");
-			try {
-				const result = await callback(leased);
-				await leased.execute("RELEASE SAVEPOINT __rivet_on_migrate");
-				return result;
-			} catch (error) {
-				try {
-					await leased.execute(
-						"ROLLBACK TO SAVEPOINT __rivet_on_migrate",
-					);
-				} finally {
-					await leased.execute(
-						"RELEASE SAVEPOINT __rivet_on_migrate",
-					);
-				}
-				throw error;
-			}
-		},
-	);
+	await client.execute("SAVEPOINT __rivet_on_migrate");
+	try {
+		const result = await callback();
+		await client.execute("RELEASE SAVEPOINT __rivet_on_migrate");
+		return result;
+	} catch (error) {
+		try {
+			await client.execute("ROLLBACK TO SAVEPOINT __rivet_on_migrate");
+		} finally {
+			await client.execute("RELEASE SAVEPOINT __rivet_on_migrate");
+		}
+		throw error;
+	}
 }
 
 async function runMigrations<TSchema extends DrizzleSchema>(
@@ -381,7 +286,6 @@ async function executeRaw<TRow extends Record<string, unknown>>(
 	ensureOpen: () => void,
 	query: string,
 	args: unknown[],
-	lease?: { key: string; timeoutMs?: number },
 ): Promise<TRow[]> {
 	ensureOpen();
 
@@ -393,28 +297,23 @@ async function executeRaw<TRow extends Record<string, unknown>>(
 			const { rows, columns } = await db.execute(
 				query,
 				toSqliteBindings(args),
-				lease,
 			);
 			return rows.map((row) => rowToObject<TRow>(row, columns));
 		}
 
 		if (!hasMultipleStatements(query)) {
-			const { rows, columns } = await db.execute(query, undefined, lease);
+			const { rows, columns } = await db.execute(query);
 			return rows.map((row) => rowToObject<TRow>(row, columns));
 		}
 
 		const results: Record<string, unknown>[] = [];
 		let columnNames: string[] | null = null;
-		await db.exec(
-			query,
-			(row, columns) => {
-				if (!columnNames) {
-					columnNames = columns;
-				}
-				results.push(rowToObject(row, columnNames));
-			},
-			lease,
-		);
+		await db.exec(query, (row, columns) => {
+			if (!columnNames) {
+				columnNames = columns;
+			}
+			results.push(rowToObject(row, columnNames));
+		});
 		return results as TRow[];
 	} finally {
 		const durationMs = performance.now() - start;

package/src/db/mod.ts

@@ -8,6 +8,7 @@ export type {
 	SqliteBindings,
 	SqliteDatabase,
 	SqliteNativeMetrics,
+	SqliteProfilingOptions,
 	SqliteQueryResult,
 } from "@/common/database/config";
 export { db } from "@/common/database/mod";

package/src/inspector/client.browser.ts

@@ -3,17 +3,16 @@ import * as v1 from "@/common/bare/generated/inspector/v1";
 import * as v2 from "@/common/bare/generated/inspector/v2";
 import * as v3 from "@/common/bare/generated/inspector/v3";
 import * as v4 from "@/common/bare/generated/inspector/v4";
-import * as v5 from "@/common/bare/generated/inspector/v5";
 import {
 	decodeWorkflowHistoryTransport,
 	encodeWorkflowHistoryTransport,
 } from "@/common/inspector-transport";
 
-export * from "@/common/bare/generated/inspector/v5";
+export * from "@/common/bare/generated/inspector/v4";
 export { decodeWorkflowHistoryTransport, encodeWorkflowHistoryTransport };
 export type { WorkflowHistory as TransportWorkflowHistory } from "@/common/bare/transport/v1";
 
-export const CURRENT_VERSION = 5;
+export const CURRENT_VERSION = 4;
 
 const EVENTS_DROPPED_ERROR = "inspector.events_dropped";
 const WORKFLOW_HISTORY_DROPPED_ERROR = "inspector.workflow_history_dropped";
@@ -157,42 +156,6 @@ const v4ToClientToV3 = (v4Data: v4.ToClient): v3.ToClient => {
 	return v4Data as unknown as v3.ToClient;
 };
 
-const v4ToClientToV5 = (v4Data: v4.ToClient): v5.ToClient => {
-	if (v4Data.body.tag === "Init") {
-		// A v4 runtime predates tab config in Init; default to an empty list.
-		// The client reads that as "no custom tabs" (built-in tabs only).
-		const init = v4Data.body.val;
-		return {
-			body: {
-				tag: "Init",
-				val: { ...init, tabConfig: [] },
-			},
-		};
-	}
-
-	return v4Data as unknown as v5.ToClient;
-};
-
-const v5ToClientToV4 = (v5Data: v5.ToClient): v4.ToClient => {
-	if (v5Data.body.tag === "Init") {
-		const { tabConfig: _tabConfig, ...rest } = v5Data.body.val;
-		return {
-			body: {
-				tag: "Init",
-				val: rest,
-			},
-		};
-	}
-
-	return v5Data as unknown as v4.ToClient;
-};
-
-const v4ToServerToV5 = (v4Data: v4.ToServer): v5.ToServer =>
-	v4Data as unknown as v5.ToServer;
-
-const v5ToServerToV4 = (v5Data: v5.ToServer): v4.ToServer =>
-	v5Data as unknown as v4.ToServer;
-
 const v1ToServerToV2 = (v1Data: v1.ToServer): v2.ToServer => {
 	if (
 		v1Data.body.tag === "EventsRequest" ||
@@ -243,7 +206,7 @@ const v4ToServerToV3 = (v4Data: v4.ToServer): v3.ToServer => {
 	return v4Data as unknown as v3.ToServer;
 };
 
-export const TO_SERVER_VERSIONED = createVersionedDataHandler<v5.ToServer>({
+export const TO_SERVER_VERSIONED = createVersionedDataHandler<v4.ToServer>({
 	serializeVersion: (data, version) => {
 		switch (version) {
 			case 1:
@@ -253,9 +216,7 @@ export const TO_SERVER_VERSIONED = createVersionedDataHandler<v5.ToServer>({
 			case 3:
 				return v3.encodeToServer(data as unknown as v3.ToServer);
 			case 4:
-				return v4.encodeToServer(data as unknown as v4.ToServer);
-			case 5:
-				return v5.encodeToServer(data);
+				return v4.encodeToServer(data);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
@@ -263,15 +224,13 @@ export const TO_SERVER_VERSIONED = createVersionedDataHandler<v5.ToServer>({
 	deserializeVersion: (bytes, version) => {
 		switch (version) {
 			case 1:
-				return v1.decodeToServer(bytes) as unknown as v5.ToServer;
+				return v1.decodeToServer(bytes) as unknown as v4.ToServer;
 			case 2:
-				return v2.decodeToServer(bytes) as unknown as v5.ToServer;
+				return v2.decodeToServer(bytes) as unknown as v4.ToServer;
 			case 3:
-				return v3.decodeToServer(bytes) as unknown as v5.ToServer;
+				return v3.decodeToServer(bytes) as unknown as v4.ToServer;
 			case 4:
-				return v4.decodeToServer(bytes) as unknown as v5.ToServer;
-			case 5:
-				return v5.decodeToServer(bytes);
+				return v4.decodeToServer(bytes);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
@@ -280,17 +239,11 @@ export const TO_SERVER_VERSIONED = createVersionedDataHandler<v5.ToServer>({
 		v1ToServerToV2,
 		v2ToServerToV3,
 		v3ToServerToV4,
-		v4ToServerToV5,
-	],
-	serializeConverters: () => [
-		v5ToServerToV4,
-		v4ToServerToV3,
-		v3ToServerToV2,
-		v2ToServerToV1,
 	],
+	serializeConverters: () => [v4ToServerToV3, v3ToServerToV2, v2ToServerToV1],
 });
 
-export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v5.ToClient>({
+export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v4.ToClient>({
 	serializeVersion: (data, version) => {
 		switch (version) {
 			case 1:
@@ -300,9 +253,7 @@ export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v5.ToClient>({
 			case 3:
 				return v3.encodeToClient(data as unknown as v3.ToClient);
 			case 4:
-				return v4.encodeToClient(data as unknown as v4.ToClient);
-			case 5:
-				return v5.encodeToClient(data);
+				return v4.encodeToClient(data);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
@@ -310,15 +261,13 @@ export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v5.ToClient>({
 	deserializeVersion: (bytes, version) => {
 		switch (version) {
 			case 1:
-				return v1.decodeToClient(bytes) as unknown as v5.ToClient;
+				return v1.decodeToClient(bytes) as unknown as v4.ToClient;
 			case 2:
-				return v2.decodeToClient(bytes) as unknown as v5.ToClient;
+				return v2.decodeToClient(bytes) as unknown as v4.ToClient;
 			case 3:
-				return v3.decodeToClient(bytes) as unknown as v5.ToClient;
+				return v3.decodeToClient(bytes) as unknown as v4.ToClient;
 			case 4:
-				return v4.decodeToClient(bytes) as unknown as v5.ToClient;
-			case 5:
-				return v5.decodeToClient(bytes);
+				return v4.decodeToClient(bytes);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
@@ -327,12 +276,6 @@ export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v5.ToClient>({
 		v1ToClientToV2,
 		v2ToClientToV3,
 		v3ToClientToV4,
-		v4ToClientToV5,
-	],
-	serializeConverters: () => [
-		v5ToClientToV4,
-		v4ToClientToV3,
-		v3ToClientToV2,
-		v2ToClientToV1,
 	],
+	serializeConverters: () => [v4ToClientToV3, v3ToClientToV2, v2ToClientToV1],
 });

package/src/inspector/mod.ts

@@ -1,4 +1,4 @@
-export * from "@/common/bare/generated/inspector/v5";
+export * from "@/common/bare/generated/inspector/v4";
 export type { WorkflowHistory as TransportWorkflowHistory } from "@/common/bare/transport/v1";
 export {
 	decodeWorkflowHistoryTransport,

package/src/inspector-tab/mod.ts

@@ -280,6 +280,18 @@ export const InspectorQueueResponseSchema = z.object({
 	messages: z.array(InspectorQueueMessageSchema),
 });
 
+/** `GET /inspector/tab-config` response shape. */
+export const InspectorTabConfigResponseSchema = z.object({
+	tabs: z.array(
+		z.object({
+			id: z.string(),
+			label: z.string().optional(),
+			icon: z.string().nullable().optional(),
+			hidden: z.boolean().optional(),
+		}),
+	),
+});
+
 export type InspectorStateResponse = z.infer<
 	typeof InspectorStateResponseSchema
 >;
@@ -298,3 +310,6 @@ export type InspectorQueueMessage = z.infer<typeof InspectorQueueMessageSchema>;
 export type InspectorQueueResponse = z.infer<
 	typeof InspectorQueueResponseSchema
 >;
+export type InspectorTabConfigResponse = z.infer<
+	typeof InspectorTabConfigResponseSchema
+>;

package/src/registry/index.ts

@@ -1,5 +1,4 @@
 import { isLocalEngineEndpoint } from "@/common/engine";
-import { configureBaseLogger } from "@/common/log";
 import { configureServerlessPool } from "@/serverless/configure";
 import { VERSION } from "@/utils";
 import {
@@ -83,9 +82,6 @@ export class Registry<A extends RegistryActors> {
 
 	constructor(config: RegistryConfigInput<A>, deps?: Partial<RegistryDeps>) {
 		this.#config = config;
-		if (config.logging?.baseLogger) {
-			configureBaseLogger(config.logging.baseLogger);
-		}
 		this.#buildConfiguredRegistry =
 			deps?.buildConfiguredRegistry ?? buildConfiguredRegistry;
 		this.routes = {

package/src/registry/napi-runtime.ts

@@ -34,7 +34,6 @@ import type {
 	RuntimeSqlBindParams,
 	RuntimeSqlExecResult,
 	RuntimeSqlExecuteResult,
-	RuntimeSqlLeaseOptions,
 	RuntimeSqlQueryResult,
 	RuntimeSqlRunResult,
 	RuntimeStateDeltaPayload,
@@ -599,26 +598,18 @@ export class NapiCoreRuntime implements CoreRuntime {
 	async actorSqlExec(
 		ctx: ActorContextHandle,
 		sql: string,
-		lease?: RuntimeSqlLeaseOptions,
 	): Promise<RuntimeSqlExecResult> {
-		return await this.#actorSql(ctx).exec(
-			sql,
-			lease?.key,
-			lease?.timeoutMs,
-		);
+		return await this.#actorSql(ctx).exec(sql);
 	}
 
 	async actorSqlExecute(
 		ctx: ActorContextHandle,
 		sql: string,
 		params?: RuntimeSqlBindParams,
-		lease?: RuntimeSqlLeaseOptions,
 	): Promise<RuntimeSqlExecuteResult> {
 		const result = await this.#actorSql(ctx).execute(
 			sql,
 			toNapiSqlBindParams(params),
-			lease?.key,
-			lease?.timeoutMs,
 		);
 		return normalizeRuntimeSqlExecuteResult(result);
 	}
@@ -661,10 +652,6 @@ export class NapiCoreRuntime implements CoreRuntime {
 		await database.close();
 	}
 
-	async actorUdsProvision(ctx: ActorContextHandle) {
-		return await asNativeActorContext(ctx).provisionActorUds();
-	}
-
 	async actorQueueSend(
 		ctx: ActorContextHandle,
 		name: string,
@@ -758,10 +745,6 @@ export class NapiCoreRuntime implements CoreRuntime {
 		return await asNativeActorContext(ctx).queue().inspectMessages();
 	}
 
-	async actorQueueReset(ctx: ActorContextHandle): Promise<void> {
-		await asNativeActorContext(ctx).queue().reset();
-	}
-
 	actorScheduleAfter(
 		ctx: ActorContextHandle,
 		durationMs: number,
@@ -845,13 +828,6 @@ export async function loadNapiRuntime(): Promise<{
 	bindings: NapiBindings;
 	runtime: NapiCoreRuntime;
 }> {
-	// LOAD-BEARING: the specifier is computed (`.join("/")`) on purpose. Do NOT
-	// "simplify" it to a literal `import("@rivetkit/rivetkit-napi")`. Edge
-	// adapters (e.g. @rivetkit/supabase) pre-bundle this module for Deno; a
-	// literal dynamic import is statically resolvable, so Deno's eszip bundler
-	// would snapshot the native `.node` addon into the deploy and 413. The
-	// computed specifier keeps it opaque to static analysis so it is never
-	// bundled. Enforced by scripts/ci/check-edge-native-closure.mjs.
 	const bindings = await import(["@rivetkit", "rivetkit-napi"].join("/"));
 	return {
 		bindings,