rivetkit 2.0.42 → 2.1.0-rc.1

package/src/client/client.ts

@@ -514,10 +514,8 @@ function createActorProxy<AD extends AnyActorDefinition>(
 
 		// Support for 'in' operator
 		has(target: ActorHandleRaw, prop: string | symbol) {
-			// All string properties are potentially action functions
-			if (typeof prop === "string") {
-				return true;
-			}
+			// All string properties are potentially action functions.
+			if (typeof prop === "string") return true;
 			// For symbols, defer to the target's own has behavior
 			return Reflect.has(target, prop);
 		},

package/src/client/config.ts

@@ -1,4 +1,4 @@
-import z from "zod";
+import z from "zod/v4";
 import { EncodingSchema } from "@/actor/protocol/serde";
 import { type GetUpgradeWebSocket } from "@/utils";
 import {

package/src/client/mod.browser.ts

@@ -0,0 +1,2 @@
+// Browser-safe client exports (all client functionality is browser-compatible)
+export * from "./mod";

package/src/client/mod.ts

@@ -8,10 +8,7 @@ import {
 } from "./client";
 import { ClientConfigSchema } from "./config";
 
-export {
-	ActorDefinition,
-	type AnyActorDefinition,
-} from "@/actor/definition";
+export type { ActorDefinition, AnyActorDefinition } from "@/actor/definition";
 export type { Encoding } from "@/actor/protocol/serde";
 export {
 	ActorClientError,

package/src/client/queue.ts

@@ -0,0 +1,146 @@
+import * as cbor from "cbor-x";
+import type { Encoding } from "@/actor/protocol/serde";
+import { HEADER_CONN_PARAMS, HEADER_ENCODING } from "@/driver-helpers/mod";
+import type * as protocol from "@/schemas/client-protocol/mod";
+import {
+	CURRENT_VERSION as CLIENT_PROTOCOL_CURRENT_VERSION,
+	HTTP_QUEUE_SEND_REQUEST_VERSIONED,
+	HTTP_QUEUE_SEND_RESPONSE_VERSIONED,
+} from "@/schemas/client-protocol/versioned";
+import {
+	type HttpQueueSendRequest as HttpQueueSendRequestJson,
+	HttpQueueSendRequestSchema,
+	type HttpQueueSendResponse as HttpQueueSendResponseJson,
+	HttpQueueSendResponseSchema,
+} from "@/schemas/client-protocol-zod/mod";
+import { bufferToArrayBuffer } from "@/utils";
+import { sendHttpRequest } from "./utils";
+
+export interface QueueSender {
+	send(
+		name: string,
+		body: unknown,
+		options: QueueSendWaitOptions,
+	): Promise<QueueSendResult>;
+	send(
+		name: string,
+		body: unknown,
+		options?: QueueSendNoWaitOptions,
+	): Promise<void>;
+}
+
+export interface QueueSendWaitOptions {
+	wait: true;
+	timeout?: number;
+	signal?: AbortSignal;
+}
+
+export interface QueueSendNoWaitOptions {
+	wait?: false;
+	timeout?: never;
+	signal?: AbortSignal;
+}
+
+export type QueueSendOptions = QueueSendWaitOptions | QueueSendNoWaitOptions;
+
+export interface QueueSendResult {
+	status: "completed" | "timedOut";
+	response?: unknown;
+}
+
+interface QueueSenderOptions {
+	encoding: Encoding;
+	params: unknown;
+	customFetch: (request: Request) => Promise<Response>;
+}
+
+export function createQueueSender(senderOptions: QueueSenderOptions): QueueSender {
+	async function send(
+		name: string,
+		body: unknown,
+		options: QueueSendWaitOptions,
+	): Promise<QueueSendResult>;
+	async function send(
+		name: string,
+		body: unknown,
+		options?: QueueSendNoWaitOptions,
+	): Promise<void>;
+	async function send(
+		name: string,
+		body: unknown,
+		options?: QueueSendOptions,
+	): Promise<QueueSendResult | void> {
+		const wait = options?.wait ?? false;
+		const timeout = options?.timeout;
+
+		const result = await sendHttpRequest<
+			protocol.HttpQueueSendRequest,
+			protocol.HttpQueueSendResponse,
+			HttpQueueSendRequestJson,
+			HttpQueueSendResponseJson,
+			{ body: unknown; wait?: boolean; timeout?: number; name?: string },
+			QueueSendResult
+		>({
+			url: `http://actor/queue/${encodeURIComponent(name)}`,
+			method: "POST",
+			headers: {
+				[HEADER_ENCODING]: senderOptions.encoding,
+				...(senderOptions.params !== undefined
+					? {
+							[HEADER_CONN_PARAMS]: JSON.stringify(
+								senderOptions.params,
+							),
+						}
+					: {}),
+			},
+			body: { body, wait, timeout },
+			encoding: senderOptions.encoding,
+			customFetch: senderOptions.customFetch,
+			signal: options?.signal,
+			requestVersion: CLIENT_PROTOCOL_CURRENT_VERSION,
+			requestVersionedDataHandler: HTTP_QUEUE_SEND_REQUEST_VERSIONED,
+			responseVersion: CLIENT_PROTOCOL_CURRENT_VERSION,
+			responseVersionedDataHandler:
+				HTTP_QUEUE_SEND_RESPONSE_VERSIONED,
+			requestZodSchema: HttpQueueSendRequestSchema,
+			responseZodSchema: HttpQueueSendResponseSchema,
+			requestToJson: (value): HttpQueueSendRequestJson => ({
+				...value,
+				name,
+			}),
+			requestToBare: (value): protocol.HttpQueueSendRequest => ({
+				name: value.name ?? name,
+				body: bufferToArrayBuffer(cbor.encode(value.body)),
+				wait: value.wait ?? false,
+				timeout: value.timeout !== undefined ? BigInt(value.timeout) : null,
+			}),
+			responseFromJson: (json): QueueSendResult => {
+				if (json.response === undefined) {
+					return { status: json.status as "completed" | "timedOut" };
+				}
+				return {
+					status: json.status as "completed" | "timedOut",
+					response: json.response,
+				};
+			},
+			responseFromBare: (bare): QueueSendResult => {
+				if (bare.response === null || bare.response === undefined) {
+					return { status: bare.status as "completed" | "timedOut" };
+				}
+				return {
+					status: bare.status as "completed" | "timedOut",
+					response: cbor.decode(new Uint8Array(bare.response)),
+				};
+			},
+		});
+
+		if (wait) {
+			return result;
+		}
+		return;
+	}
+
+	return {
+		send,
+	};
+}

package/src/client/utils.ts

@@ -1,7 +1,7 @@
 import * as cbor from "cbor-x";
 import invariant from "invariant";
 import type { VersionedDataHandler } from "vbare";
-import type { z } from "zod";
+import type { z } from "zod/v4";
 import type { Encoding } from "@/actor/protocol/serde";
 import { assertUnreachable } from "@/common/utils";
 import type { HttpResponseError } from "@/schemas/client-protocol/mod";

package/src/common/log.ts

@@ -4,7 +4,7 @@ import {
 	pino,
 	stdTimeFunctions,
 } from "pino";
-import { z } from "zod";
+import { z } from "zod/v4";
 import { getLogLevel, getLogTarget, getLogTimestamp } from "@/utils/env-vars";
 import {
 	castToLogValue,

package/src/common/utils.ts

@@ -253,7 +253,7 @@ export function deconstructError(
 		} else {
 			statusCode = 500;
 			public_ = false;
-			group = "internal";
+			group = "rivetkit";
 			code = errors.INTERNAL_ERROR_CODE;
 			message = getErrorMessage(error);
 
@@ -270,7 +270,7 @@ export function deconstructError(
 	} else {
 		statusCode = 500;
 		public_ = false;
-		group = "internal";
+		group = "rivetkit";
 		code = errors.INTERNAL_ERROR_CODE;
 		message = errors.INTERNAL_ERROR_DESCRIPTION;
 		metadata = {
@@ -335,5 +335,5 @@ function getErrorMessage(err: unknown): string {
 
 /** Generates a `Next` handler to pass to middleware in order to be able to call arbitrary middleware. */
 export function noopNext(): Next {
-	return async () => {};
+	return async () => { };
 }

package/src/db/config.ts

@@ -0,0 +1,100 @@
+import type { SqliteVfs } from "@rivetkit/sqlite-vfs";
+
+export type AnyDatabaseProvider = DatabaseProvider<any> | undefined;
+
+/**
+ * Context provided to database providers for creating database clients
+ */
+export interface DatabaseProviderContext {
+	/**
+	 * Actor ID
+	 */
+	actorId: string;
+
+	/**
+	 * Override the default raw database client (optional).
+	 * If not provided, a KV-backed client will be constructed.
+	 */
+	overrideRawDatabaseClient?: () => Promise<RawDatabaseClient | undefined>;
+
+	/**
+	 * Override the default Drizzle database client (optional).
+	 * If not provided, a KV-backed client will be constructed.
+	 */
+	overrideDrizzleDatabaseClient?: () => Promise<
+		DrizzleDatabaseClient | undefined
+	>;
+
+	/**
+	 * KV operations for constructing KV-backed database clients
+	 */
+	kv: {
+		batchPut: (entries: [Uint8Array, Uint8Array][]) => Promise<void>;
+		batchGet: (keys: Uint8Array[]) => Promise<(Uint8Array | null)[]>;
+		batchDelete: (keys: Uint8Array[]) => Promise<void>;
+	};
+
+	/**
+	 * SQLite VFS instance for creating KV-backed databases.
+	 * This should be actor-scoped because @rivetkit/sqlite is not re-entrant per
+	 * module instance.
+	 */
+	sqliteVfs?: SqliteVfs;
+}
+
+export type DatabaseProvider<DB extends RawAccess> = {
+	/**
+	 * Creates a new database client for the actor.
+	 * The result is passed to the actor context as `c.db`.
+	 * @experimental
+	 */
+	createClient: (ctx: DatabaseProviderContext) => Promise<DB>;
+	/**
+	 * Runs before the actor has started.
+	 * Use this to run migrations or other setup tasks.
+	 * @experimental
+	 */
+	onMigrate: (client: DB) => void | Promise<void>;
+	/**
+	 * Runs when the actor is being destroyed.
+	 * Use this to clean up database connections and release resources.
+	 * @experimental
+	 */
+	onDestroy?: (client: DB) => void | Promise<void>;
+};
+
+/**
+ * Raw database client with basic exec method
+ */
+export interface RawDatabaseClient {
+	exec: <TRow extends Record<string, unknown> = Record<string, unknown>>(
+		query: string,
+		...args: unknown[]
+	) => Promise<TRow[]> | TRow[];
+}
+
+/**
+ * Drizzle database client interface (will be extended by drizzle-orm types)
+ */
+export interface DrizzleDatabaseClient {
+	// This will be extended by BaseSQLiteDatabase from drizzle-orm
+	// For now, just a marker interface
+}
+
+type ExecuteFunction = <
+	TRow extends Record<string, unknown> = Record<string, unknown>,
+>(
+	query: string,
+	...args: unknown[]
+) => Promise<TRow[]>;
+
+export type RawAccess = {
+	/**
+	 * Executes a raw SQL query.
+	 */
+	execute: ExecuteFunction;
+	/**
+	 * Closes the database connection and releases resources.
+	 */
+	close: () => Promise<void>;
+};

package/src/db/drizzle/mod.ts

@@ -0,0 +1,226 @@
+import type { Database } from "@rivetkit/sqlite-vfs";
+import {
+	drizzle as proxyDrizzle,
+	type SqliteRemoteDatabase,
+} from "drizzle-orm/sqlite-proxy";
+import type { DatabaseProvider, RawAccess } from "../config";
+import { AsyncMutex, createActorKvStore, toSqliteBindings } from "../shared";
+
+export * from "./sqlite-core";
+
+import { type Config, defineConfig as originalDefineConfig } from "drizzle-kit";
+
+export function defineConfig(
+	config: Partial<Config & { driver: "durable-sqlite" }>,
+): Config {
+	return originalDefineConfig({
+		dialect: "sqlite",
+		driver: "durable-sqlite",
+		...config,
+	});
+}
+
+interface DatabaseFactoryConfig<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+> {
+	schema?: TSchema;
+	migrations?: any;
+}
+
+/**
+ * Create a sqlite-proxy async callback from a @rivetkit/sqlite Database
+ */
+function createProxyCallback(
+	waDb: Database,
+	mutex: AsyncMutex,
+	isClosed: () => boolean,
+) {
+	return async (
+		sql: string,
+		params: any[],
+		method: "run" | "all" | "values" | "get",
+	): Promise<{ rows: any }> => {
+		return mutex.run(async () => {
+			if (isClosed()) {
+				throw new Error("database is closed");
+			}
+
+			if (method === "run") {
+				await waDb.run(sql, toSqliteBindings(params));
+				return { rows: [] };
+			}
+
+			// For all/get/values, use parameterized query
+			const result = await waDb.query(sql, toSqliteBindings(params));
+
+			// drizzle's mapResultRow accesses rows by column index (positional arrays)
+			// so we return raw arrays for all methods
+			if (method === "get") {
+				return { rows: result.rows[0] };
+			}
+
+			return { rows: result.rows };
+		});
+	};
+}
+
+/**
+ * Run inline migrations via the @rivetkit/sqlite Database.
+ * Migrations use the same embedded format as drizzle-orm's durable-sqlite.
+ */
+async function runInlineMigrations(
+	waDb: Database,
+	mutex: AsyncMutex,
+	migrations: any,
+): Promise<void> {
+	// Create migrations table
+	await mutex.run(() =>
+		waDb.exec(`
+		CREATE TABLE IF NOT EXISTS __drizzle_migrations (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			hash TEXT NOT NULL,
+			created_at INTEGER
+		)
+	`),
+	);
+
+	// Get the last applied migration
+	let lastCreatedAt = 0;
+	await mutex.run(() =>
+		waDb.exec(
+			"SELECT id, hash, created_at FROM __drizzle_migrations ORDER BY created_at DESC LIMIT 1",
+			(row) => {
+				lastCreatedAt = Number(row[2]) || 0;
+			},
+		),
+	);
+
+	// Apply pending migrations from journal entries
+	const journal = migrations.journal;
+	if (!journal?.entries) return;
+
+	for (const entry of journal.entries) {
+		if (entry.when <= lastCreatedAt) continue;
+
+		// Find the migration SQL from the migrations map
+		// The key format is "m" + zero-padded index (e.g. "m0000")
+		const migrationKey = `m${String(entry.idx).padStart(4, "0")}`;
+		const sql = migrations.migrations[migrationKey];
+		if (!sql) continue;
+
+		// Execute migration SQL
+		await mutex.run(() => waDb.exec(sql));
+
+		// Record migration
+		await mutex.run(() =>
+			waDb.run(
+				"INSERT INTO __drizzle_migrations (hash, created_at) VALUES (?, ?)",
+				[entry.tag, entry.when],
+			),
+		);
+	}
+}
+
+export function db<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+>(
+	config?: DatabaseFactoryConfig<TSchema>,
+): DatabaseProvider<SqliteRemoteDatabase<TSchema> & RawAccess> {
+	// Store the @rivetkit/sqlite Database instance alongside the drizzle client
+	let waDbInstance: Database | null = null;
+	const mutex = new AsyncMutex();
+
+	return {
+		createClient: async (ctx) => {
+			// Construct KV-backed client using actor driver's KV operations
+			if (!ctx.sqliteVfs) {
+				throw new Error(
+					"SqliteVfs instance not provided in context. The driver must provide a sqliteVfs instance.",
+				);
+			}
+
+			const kvStore = createActorKvStore(ctx.kv);
+			const waDb = await ctx.sqliteVfs.open(ctx.actorId, kvStore);
+			waDbInstance = waDb;
+			let closed = false;
+			const ensureOpen = () => {
+				if (closed) {
+					throw new Error("database is closed");
+				}
+			};
+
+			// Create the async proxy callback
+			const callback = createProxyCallback(waDb, mutex, () => closed);
+
+			// Create the drizzle instance using sqlite-proxy
+			const client = proxyDrizzle<TSchema>(callback, config);
+
+			return Object.assign(client, {
+				execute: async <
+					TRow extends Record<string, unknown> = Record<string, unknown>,
+				>(
+					query: string,
+					...args: unknown[]
+				): Promise<TRow[]> => {
+					return mutex.run(async () => {
+						ensureOpen();
+
+						if (args.length > 0) {
+							const result = await waDb.query(
+								query,
+								toSqliteBindings(args),
+							);
+							return result.rows.map((row: unknown[]) => {
+								const obj: Record<string, unknown> = {};
+								for (let i = 0; i < result.columns.length; i++) {
+									obj[result.columns[i]] = row[i];
+								}
+								return obj;
+							}) as TRow[];
+						}
+						// Use exec for non-parameterized queries since
+						// @rivetkit/sqlite's query() can crash on some statements.
+						const results: Record<string, unknown>[] = [];
+						let columnNames: string[] | null = null;
+						await waDb.exec(
+							query,
+							(row: unknown[], columns: string[]) => {
+								if (!columnNames) {
+									columnNames = columns;
+								}
+								const obj: Record<string, unknown> = {};
+								for (let i = 0; i < row.length; i++) {
+									obj[columnNames[i]] = row[i];
+								}
+								results.push(obj);
+							},
+						);
+						return results as TRow[];
+					});
+				},
+				close: async () => {
+					await mutex.run(async () => {
+						if (closed) {
+							return;
+						}
+						closed = true;
+						await waDb.close();
+						waDbInstance = null;
+					});
+				},
+			} satisfies RawAccess);
+		},
+		onMigrate: async (_client) => {
+			if (config?.migrations && waDbInstance) {
+				await runInlineMigrations(
+					waDbInstance,
+					mutex,
+					config.migrations,
+				);
+			}
+		},
+		onDestroy: async (client) => {
+			await client.close();
+		},
+	};
+}

package/src/db/drizzle/sqlite-core.ts

@@ -0,0 +1,22 @@
+export * from "drizzle-orm/sqlite-core";
+export {
+	blob,
+	check,
+	extractUsedTable,
+	foreignKey,
+	getTableConfig,
+	getViewConfig,
+	index,
+	integer,
+	numeric,
+	primaryKey,
+	real,
+	sqliteTable,
+	sqliteTableCreator,
+	sqliteView,
+	text,
+	unique,
+	uniqueIndex,
+	uniqueKeyName,
+	view,
+} from "drizzle-orm/sqlite-core";

package/src/db/mod.ts

@@ -0,0 +1,125 @@
+import type { DatabaseProvider, RawAccess } from "./config";
+import { AsyncMutex, createActorKvStore, toSqliteBindings } from "./shared";
+
+export type { RawAccess } from "./config";
+
+interface DatabaseFactoryConfig {
+	onMigrate?: (db: RawAccess) => Promise<void> | void;
+}
+
+export function db({
+	onMigrate,
+}: DatabaseFactoryConfig = {}): DatabaseProvider<RawAccess> {
+	return {
+		createClient: async (ctx) => {
+			// Check if override is provided
+			const override = ctx.overrideRawDatabaseClient
+				? await ctx.overrideRawDatabaseClient()
+				: undefined;
+
+			if (override) {
+				// Use the override
+				return {
+					execute: async <
+						TRow extends Record<string, unknown> = Record<string, unknown>,
+					>(
+						query: string,
+						...args: unknown[]
+					): Promise<TRow[]> => {
+						return await override.exec<TRow>(query, ...args);
+					},
+					close: async () => {
+						// Override clients don't need cleanup
+					},
+				} satisfies RawAccess;
+			}
+
+			// Construct KV-backed client using actor driver's KV operations
+			if (!ctx.sqliteVfs) {
+				throw new Error("SqliteVfs instance not provided in context. The driver must provide a sqliteVfs instance.");
+			}
+
+			const kvStore = createActorKvStore(ctx.kv);
+			const db = await ctx.sqliteVfs.open(ctx.actorId, kvStore);
+			let closed = false;
+			const mutex = new AsyncMutex();
+			const ensureOpen = () => {
+				if (closed) {
+					throw new Error("database is closed");
+				}
+			};
+
+			return {
+				execute: async <
+					TRow extends Record<string, unknown> = Record<string, unknown>,
+				>(
+					query: string,
+					...args: unknown[]
+				): Promise<TRow[]> => {
+					return await mutex.run(async () => {
+						ensureOpen();
+
+						// `db.exec` does not support binding `?` placeholders.
+						// Use `db.query` for statements that return rows and `db.run` for
+						// statements that mutate data when parameters are provided.
+						// Keep using `db.exec` for non-parameterized SQL because it
+						// supports multi-statement migrations.
+						if (args.length > 0) {
+							const bindings = toSqliteBindings(args);
+							const token = query.trimStart().slice(0, 16).toUpperCase();
+							const returnsRows =
+								token.startsWith("SELECT") ||
+								token.startsWith("PRAGMA") ||
+								token.startsWith("WITH");
+
+							if (returnsRows) {
+								const { rows, columns } = await db.query(query, bindings);
+								return rows.map((row: unknown[]) => {
+									const rowObj: Record<string, unknown> = {};
+									for (let i = 0; i < columns.length; i++) {
+										rowObj[columns[i]] = row[i];
+									}
+									return rowObj;
+								}) as TRow[];
+							}
+
+							await db.run(query, bindings);
+							return [] as TRow[];
+						}
+
+						const results: Record<string, unknown>[] = [];
+						let columnNames: string[] | null = null;
+						await db.exec(query, (row: unknown[], columns: string[]) => {
+							if (!columnNames) {
+								columnNames = columns;
+							}
+							const rowObj: Record<string, unknown> = {};
+							for (let i = 0; i < row.length; i++) {
+								rowObj[columnNames[i]] = row[i];
+							}
+							results.push(rowObj);
+						});
+						return results as TRow[];
+					});
+				},
+				close: async () => {
+					await mutex.run(async () => {
+						if (closed) {
+							return;
+						}
+						closed = true;
+						await db.close();
+					});
+				},
+			} satisfies RawAccess;
+		},
+		onMigrate: async (client) => {
+			if (onMigrate) {
+				await onMigrate(client);
+			}
+		},
+		onDestroy: async (client) => {
+			await client.close();
+		},
+	};
+}