rivetkit 2.3.4 → 2.3.5-rc.1

package/src/registry/napi-runtime.ts

@@ -15,6 +15,8 @@ import type {
 	RegistryHandle,
 	RuntimeActorConfig,
 	RuntimeBytes,
+	RuntimeCronFire,
+	RuntimeCronJobInfo,
 	RuntimeHttpRequest,
 	RuntimeKvEntry,
 	RuntimeKvListOptions,
@@ -27,9 +29,11 @@ import type {
 	RuntimeRegistryRouteResponse,
 	RuntimeRequestSaveOpts,
 	RuntimeServeConfig,
+	RuntimeScheduledEventInfo,
 	RuntimeServerlessRequest,
 	RuntimeServerlessResponseHead,
 	RuntimeServerlessStreamCallback,
+	RuntimeSqlBatchStatement,
 	RuntimeSqlBindParam,
 	RuntimeSqlBindParams,
 	RuntimeSqlExecResult,
@@ -38,6 +42,8 @@ import type {
 	RuntimeSqlRunResult,
 	RuntimeStateDeltaPayload,
 	RuntimeWebSocketEvent,
+	RuntimeWorkflowKvWrite,
+	SqliteTransactionHandle,
 	WebSocketHandle,
 } from "./runtime";
 import { normalizeRuntimeSqlExecuteResult } from "./runtime";
@@ -45,6 +51,12 @@ import { normalizeRuntimeSqlExecuteResult } from "./runtime";
 type NativeBindings = typeof import("@rivetkit/rivetkit-napi");
 type NapiSqlDatabase = ReturnType<NativeActorContext["sql"]>;
 type NapiSqlBindParams = Parameters<NapiSqlDatabase["execute"]>[1];
+type NapiSqlBatchStatement = Parameters<
+	NapiSqlDatabase["executeBatch"]
+>[0][number];
+type NapiSqlTransaction = Awaited<
+	ReturnType<NapiSqlDatabase["beginTransaction"]>
+>;
 
 function asNativeRegistry(handle: RegistryHandle): NativeCoreRegistry {
 	return handle as unknown as NativeCoreRegistry;
@@ -66,6 +78,12 @@ function asNativeWebSocket(handle: WebSocketHandle): NativeWebSocket {
 	return handle as unknown as NativeWebSocket;
 }
 
+function asNativeSqlTransaction(
+	handle: SqliteTransactionHandle,
+): NapiSqlTransaction {
+	return handle as unknown as NapiSqlTransaction;
+}
+
 function asNativeCancellationToken(
 	handle: CancellationTokenHandle,
 ): NativeCancellationToken {
@@ -104,6 +122,15 @@ function toNapiSqlBindParams(params?: RuntimeSqlBindParams): NapiSqlBindParams {
 	return params.map((param) => toNapiSqlBindParam(param));
 }
 
+function toNapiSqlBatchStatement(
+	statement: RuntimeSqlBatchStatement,
+): NapiSqlBatchStatement {
+	return {
+		sql: statement.sql,
+		params: toNapiSqlBindParams(statement.params) ?? undefined,
+	};
+}
+
 function toNapiBuffer(value: RuntimeBytes): Buffer {
 	return Buffer.from(value);
 }
@@ -288,16 +315,24 @@ export class NapiCoreRuntime implements CoreRuntime {
 		return new this.#bindings.CancellationToken() as unknown as CancellationTokenHandle;
 	}
 
-	createTestActorContext(
-		actorId: string,
-		name: string,
-		region: string,
-	): ActorContextHandle {
-		return new this.#bindings.ActorContext(
-			actorId,
-			name,
-			region,
-		) as unknown as ActorContextHandle;
+	decodeInspectorRequest(
+		bytes: RuntimeBytes,
+		advertisedVersion: number,
+	): RuntimeBytes {
+		return this.#bindings.decodeInspectorRequest(
+			toNapiBuffer(bytes),
+			advertisedVersion,
+		);
+	}
+
+	encodeInspectorResponse(
+		bytes: RuntimeBytes,
+		targetVersion: number,
+	): RuntimeBytes {
+		return this.#bindings.encodeInspectorResponse(
+			toNapiBuffer(bytes),
+			targetVersion,
+		);
 	}
 
 	cancellationTokenAborted(token: CancellationTokenHandle): boolean {
@@ -407,6 +442,18 @@ export class NapiCoreRuntime implements CoreRuntime {
 		);
 	}
 
+	async actorSaveStateAndWorkflowBatch(
+		ctx: ActorContextHandle,
+		writes: RuntimeWorkflowKvWrite[],
+	): Promise<void> {
+		await asNativeActorContext(ctx).saveStateAndWorkflowBatch(
+			writes.map((write) => ({
+				key: toNapiBuffer(write.key),
+				value: toNapiBuffer(write.value),
+			})),
+		);
+	}
+
 	actorId(ctx: ActorContextHandle): string {
 		return asNativeActorContext(ctx).actorId();
 	}
@@ -614,6 +661,56 @@ export class NapiCoreRuntime implements CoreRuntime {
 		return normalizeRuntimeSqlExecuteResult(result);
 	}
 
+	async actorSqlExecuteBatch(
+		ctx: ActorContextHandle,
+		statements: RuntimeSqlBatchStatement[],
+	): Promise<RuntimeSqlExecuteResult[]> {
+		const results = await this.#actorSql(ctx).executeBatch(
+			statements.map(toNapiSqlBatchStatement),
+		);
+		return results.map(normalizeRuntimeSqlExecuteResult);
+	}
+
+	async actorSqlBeginTransaction(
+		ctx: ActorContextHandle,
+		timeoutMs?: number,
+	): Promise<SqliteTransactionHandle> {
+		return (await this.#actorSql(ctx).beginTransaction(
+			timeoutMs,
+		)) as unknown as SqliteTransactionHandle;
+	}
+
+	async actorSqlTransactionExec(
+		transaction: SqliteTransactionHandle,
+		sql: string,
+	): Promise<RuntimeSqlExecResult> {
+		return await asNativeSqlTransaction(transaction).exec(sql);
+	}
+
+	async actorSqlTransactionExecute(
+		transaction: SqliteTransactionHandle,
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlExecuteResult> {
+		const result = await asNativeSqlTransaction(transaction).execute(
+			sql,
+			toNapiSqlBindParams(params),
+		);
+		return normalizeRuntimeSqlExecuteResult(result);
+	}
+
+	async actorSqlTransactionCommit(
+		transaction: SqliteTransactionHandle,
+	): Promise<void> {
+		await asNativeSqlTransaction(transaction).commit();
+	}
+
+	async actorSqlTransactionRollback(
+		transaction: SqliteTransactionHandle,
+	): Promise<void> {
+		await asNativeSqlTransaction(transaction).rollback();
+	}
+
 	async actorSqlQuery(
 		ctx: ActorContextHandle,
 		sql: string,
@@ -652,6 +749,10 @@ export class NapiCoreRuntime implements CoreRuntime {
 		await database.close();
 	}
 
+	async actorRuntimeSocketProvision(ctx: ActorContextHandle) {
+		return await asNativeActorContext(ctx).provisionActorRuntimeSocket();
+	}
+
 	async actorQueueSend(
 		ctx: ActorContextHandle,
 		name: string,
@@ -749,28 +850,115 @@ export class NapiCoreRuntime implements CoreRuntime {
 		await asNativeActorContext(ctx).queue().reset();
 	}
 
-	actorScheduleAfter(
+	async actorScheduleAfter(
 		ctx: ActorContextHandle,
 		durationMs: number,
 		actionName: string,
 		args: RuntimeBytes,
-	): void {
-		asNativeActorContext(ctx)
+	): Promise<string> {
+		return await asNativeActorContext(ctx)
 			.schedule()
 			.after(durationMs, actionName, toNapiBuffer(args));
 	}
 
-	actorScheduleAt(
+	async actorScheduleAt(
 		ctx: ActorContextHandle,
 		timestampMs: number,
 		actionName: string,
 		args: RuntimeBytes,
-	): void {
-		asNativeActorContext(ctx)
+	): Promise<string> {
+		return await asNativeActorContext(ctx)
 			.schedule()
 			.at(timestampMs, actionName, toNapiBuffer(args));
 	}
 
+	async actorScheduleCancel(ctx: ActorContextHandle, id: string) {
+		return await asNativeActorContext(ctx).schedule().cancel(id);
+	}
+
+	async actorScheduleGet(
+		ctx: ActorContextHandle,
+		id: string,
+	): Promise<RuntimeScheduledEventInfo | undefined> {
+		return (
+			(await asNativeActorContext(ctx).schedule().get(id)) ?? undefined
+		);
+	}
+
+	async actorScheduleList(ctx: ActorContextHandle) {
+		return await asNativeActorContext(ctx).schedule().list();
+	}
+
+	async actorCronSet(
+		ctx: ActorContextHandle,
+		name: string,
+		expression: string,
+		timezone: string | undefined,
+		actionName: string,
+		args: RuntimeBytes,
+		maxHistory: number | undefined,
+	) {
+		await asNativeActorContext(ctx)
+			.schedule()
+			.cronSet(
+				name,
+				expression,
+				timezone,
+				actionName,
+				toNapiBuffer(args),
+				maxHistory,
+			);
+	}
+
+	async actorCronEvery(
+		ctx: ActorContextHandle,
+		name: string,
+		intervalMs: number,
+		actionName: string,
+		args: RuntimeBytes,
+		maxHistory: number | undefined,
+	) {
+		await asNativeActorContext(ctx)
+			.schedule()
+			.cronEvery(
+				name,
+				intervalMs,
+				actionName,
+				toNapiBuffer(args),
+				maxHistory,
+			);
+	}
+
+	async actorCronGet(
+		ctx: ActorContextHandle,
+		name: string,
+	): Promise<RuntimeCronJobInfo | undefined> {
+		return ((await asNativeActorContext(ctx).schedule().cronGet(name)) ??
+			undefined) as RuntimeCronJobInfo | undefined;
+	}
+
+	async actorCronList(
+		ctx: ActorContextHandle,
+	): Promise<RuntimeCronJobInfo[]> {
+		return (await asNativeActorContext(ctx)
+			.schedule()
+			.cronList()) as RuntimeCronJobInfo[];
+	}
+
+	async actorCronDelete(ctx: ActorContextHandle, name: string) {
+		return await asNativeActorContext(ctx).schedule().cronDelete(name);
+	}
+
+	async actorCronHistory(
+		ctx: ActorContextHandle,
+		name: string,
+		limit: number | undefined,
+	): Promise<RuntimeCronFire[]> {
+		return (await asNativeActorContext(ctx)
+			.schedule()
+			.cronHistory(name, limit)) as RuntimeCronFire[];
+	}
+
 	connId(conn: ConnHandle): string {
 		return asNativeConn(conn).id();
 	}

package/src/registry/native.ts

@@ -6,6 +6,13 @@ import {
 	getRunFunction,
 	getRunInspectorConfig,
 	RAW_STATE_SYMBOL,
+	type ActorCron,
+	type ActorCronEveryOptions,
+	type ActorCronSetOptions,
+	type ActorSchedule,
+	type CronFire,
+	type CronJobInfo,
+	type ScheduledEventInfo,
 	type WorkflowInspectorConfig,
 } from "@/actor/config";
 import type { AnyActorDefinition } from "@/actor/definition";
@@ -79,7 +86,11 @@ import type {
 	RuntimeBytes,
 	RuntimeHttpResponse,
 	RuntimeInspectorTabEntry,
+	RuntimeCronFire,
+	RuntimeCronJobInfo,
 	RuntimeQueueMessage,
+	RuntimeScheduledEventInfo,
+	RuntimeScheduledFireInfo,
 	RuntimeServeConfig,
 	RuntimeStateDeltaPayload,
 	WebSocketHandle,
@@ -512,6 +523,27 @@ function getOrCreateNativeSqlDatabase(
 	const database = wrapJsNativeDatabase({
 		exec: (sql) => runtime.actorSqlExec(ctx, sql),
 		execute: (sql, params) => runtime.actorSqlExecute(ctx, sql, params),
+		executeBatch: (statements) =>
+			runtime.actorSqlExecuteBatch(ctx, statements),
+		beginTransaction: async (timeoutMs) => {
+			const transaction = await runtime.actorSqlBeginTransaction(
+				ctx,
+				timeoutMs,
+			);
+			return {
+				exec: (sql) =>
+					runtime.actorSqlTransactionExec(transaction, sql),
+				execute: (sql, params) =>
+					runtime.actorSqlTransactionExecute(
+						transaction,
+						sql,
+						params,
+					),
+				commit: () => runtime.actorSqlTransactionCommit(transaction),
+				rollback: () =>
+					runtime.actorSqlTransactionRollback(transaction),
+			};
+		},
 		query: (sql, params) => runtime.actorSqlQuery(ctx, sql, params),
 		run: (sql, params) => runtime.actorSqlRun(ctx, sql, params),
 		metrics: () => runtime.actorSqlMetrics(ctx),
@@ -732,13 +764,6 @@ function callNativeSync<T>(invoke: () => T): T {
 	}
 }
 
-function actorAbortedError(): Error & { group: string; code: string } {
-	return Object.assign(new Error("Actor aborted"), {
-		group: "actor",
-		code: "aborted",
-	});
-}
-
 type NativeWorkflowInspectorConfig = WorkflowInspectorConfig<ArrayBuffer> & {
 	getState?: () => Promise<unknown> | unknown;
 };
@@ -1319,7 +1344,7 @@ class NativeConnAdapter {
 	}
 }
 
-class NativeScheduleAdapter {
+class NativeScheduleAdapter implements ActorSchedule {
 	#runtime: CoreRuntime;
 	#ctx: ActorContextHandle;
 
@@ -1332,14 +1357,12 @@ class NativeScheduleAdapter {
 		duration: number,
 		action: string,
 		...args: unknown[]
-	): Promise<void> {
-		callNativeSync(() =>
-			this.#runtime.actorScheduleAfter(
-				this.#ctx,
-				duration,
-				action,
-				encodeValue(args),
-			),
+	): Promise<string> {
+		return await this.#runtime.actorScheduleAfter(
+			this.#ctx,
+			duration,
+			action,
+			encodeValue(args),
 		);
 	}
 
@@ -1347,16 +1370,129 @@ class NativeScheduleAdapter {
 		timestamp: number,
 		action: string,
 		...args: unknown[]
-	): Promise<void> {
-		callNativeSync(() =>
-			this.#runtime.actorScheduleAt(
-				this.#ctx,
-				timestamp,
-				action,
-				encodeValue(args),
-			),
+	): Promise<string> {
+		return await this.#runtime.actorScheduleAt(
+			this.#ctx,
+			timestamp,
+			action,
+			encodeValue(args),
+		);
+	}
+
+	async cancel(id: string): Promise<boolean> {
+		return await this.#runtime.actorScheduleCancel(this.#ctx, id);
+	}
+
+	async get(id: string): Promise<ScheduledEventInfo | undefined> {
+		const event = await this.#runtime.actorScheduleGet(this.#ctx, id);
+		return event ? decodeScheduledEventInfo(event) : undefined;
+	}
+
+	async list(): Promise<ScheduledEventInfo[]> {
+		return (await this.#runtime.actorScheduleList(this.#ctx)).map(
+			decodeScheduledEventInfo,
+		);
+	}
+}
+
+class NativeCronAdapter implements ActorCron {
+	#runtime: CoreRuntime;
+	#ctx: ActorContextHandle;
+
+	constructor(runtime: CoreRuntime, ctx: ActorContextHandle) {
+		this.#runtime = runtime;
+		this.#ctx = ctx;
+	}
+
+	async set(options: ActorCronSetOptions): Promise<void> {
+		await this.#runtime.actorCronSet(
+			this.#ctx,
+			options.name,
+			options.expression,
+			options.timezone,
+			options.action,
+			encodeValue(options.args ?? []),
+			options.maxHistory,
+		);
+	}
+
+	async every(options: ActorCronEveryOptions): Promise<void> {
+		await this.#runtime.actorCronEvery(
+			this.#ctx,
+			options.name,
+			options.interval,
+			options.action,
+			encodeValue(options.args ?? []),
+			options.maxHistory,
 		);
 	}
+
+	async get(name: string): Promise<CronJobInfo | undefined> {
+		const job = await this.#runtime.actorCronGet(this.#ctx, name);
+		return job ? decodeCronJobInfo(job) : undefined;
+	}
+
+	async list(): Promise<CronJobInfo[]> {
+		return (await this.#runtime.actorCronList(this.#ctx)).map(
+			decodeCronJobInfo,
+		);
+	}
+
+	async delete(name: string): Promise<boolean> {
+		return await this.#runtime.actorCronDelete(this.#ctx, name);
+	}
+
+	async history(
+		name: string,
+		options?: { limit?: number },
+	): Promise<CronFire[]> {
+		return (
+			await this.#runtime.actorCronHistory(
+				this.#ctx,
+				name,
+				options?.limit,
+			)
+		).map(decodeCronFire);
+	}
+}
+
+function decodeScheduledEventInfo(
+	event: RuntimeScheduledEventInfo,
+): ScheduledEventInfo {
+	return {
+		id: event.id,
+		action: event.action,
+		args: decodeArgs(event.args),
+		runAt: event.runAt,
+	};
+}
+
+function decodeCronJobInfo(job: RuntimeCronJobInfo): CronJobInfo {
+	const base = {
+		name: job.name,
+		action: job.action,
+		args: decodeArgs(job.args),
+		nextRunAt: job.nextRunAt,
+		lastRunAt: job.lastRunAt,
+		maxHistory: job.maxHistory,
+	};
+	if (job.kind === "cron") {
+		return {
+			...base,
+			kind: "cron",
+			expression: job.expression as string,
+			timezone: job.timezone as string,
+		};
+	}
+	return {
+		...base,
+		kind: "every",
+		interval: job.intervalMs as number,
+	};
+}
+
+function decodeCronFire(fire: RuntimeCronFire): CronFire {
+	return { ...fire };
 }
 
 class NativeKvAdapter {
@@ -2414,6 +2550,7 @@ export class ActorContextHandleAdapter {
 	#client?: AnyClient;
 	#clientFactory?: () => AnyClient;
 	#connMap?: NativeConnectionMap;
+	#cron?: NativeCronAdapter;
 	#databaseProvider?: Exclude<AnyDatabaseProvider, undefined>;
 	#db?: unknown;
 	#dispatchCancelToken?: CancellationTokenHandle;
@@ -2473,6 +2610,12 @@ export class ActorContextHandleAdapter {
 		return this.#sql;
 	}
 
+	async actorRuntimeSocket(): Promise<{ path: string }> {
+		return await callNative(() =>
+			this.#runtime.actorRuntimeSocketProvision(this.#ctx),
+		);
+	}
+
 	get db() {
 		if (!this.#databaseProvider) {
 			throw databaseNotConfiguredError();
@@ -2582,6 +2725,13 @@ export class ActorContextHandleAdapter {
 		return this.#schedule;
 	}
 
+	get cron(): NativeCronAdapter {
+		if (!this.#cron) {
+			this.#cron = new NativeCronAdapter(this.#runtime, this.#ctx);
+		}
+		return this.#cron;
+	}
+
 	get actorId(): string {
 		return callNativeSync(() => this.#runtime.actorId(this.#ctx));
 	}
@@ -2796,6 +2946,14 @@ export class ActorContextHandleAdapter {
 		);
 	}
 
+	async saveStateAndWorkflowBatch(
+		writes: Array<{ key: Uint8Array; value: Uint8Array }>,
+	): Promise<void> {
+		await callNative(() =>
+			this.#runtime.actorSaveStateAndWorkflowBatch(this.#ctx, writes),
+		);
+	}
+
 	serializeForTick(reason: SerializeStateReason): RuntimeStateDeltaPayload {
 		void reason;
 		const actorState = getNativePersistState(this.#runtime, this.#ctx);
@@ -3150,6 +3308,9 @@ class NativeWorkflowRuntimeAdapter {
 			immediate?: boolean;
 			maxWait?: number;
 		}) => Promise<void>;
+		saveStateAndWorkflowBatch: (
+			writes: Array<{ key: Uint8Array; value: Uint8Array }>,
+		) => Promise<void>;
 	};
 
 	constructor(ctx: ActorContextHandleAdapter) {
@@ -3225,6 +3386,9 @@ class NativeWorkflowRuntimeAdapter {
 			saveState: async (opts) => {
 				await this.#ctx.saveState(opts);
 			},
+			saveStateAndWorkflowBatch: async (writes) => {
+				await this.#ctx.saveStateAndWorkflowBatch(writes);
+			},
 		};
 	}
 
@@ -3311,14 +3475,15 @@ function buildActorConfig(
 	const config = definition.config as unknown as Record<string, unknown>;
 	const options = (config.options ?? {}) as Record<string, unknown>;
 	const canHibernate = options.canHibernateWebSocket;
+	const usesRemoteSqlite =
+		sqliteBackendForConfig(registryConfig) === "remote";
 
 	return {
 		name: options.name as string | undefined,
 		icon: options.icon as string | undefined,
-		hasDatabase: config.db !== undefined,
-		remoteSqlite:
-			config.db !== undefined &&
-			sqliteBackendForConfig(registryConfig) === "remote",
+		hasDatabase: config.db !== undefined || usesRemoteSqlite,
+		remoteSqlite: usesRemoteSqlite,
+		enableActorRuntimeSocket: options.enableActorRuntimeSocket === true,
 		hasState:
 			config.state !== undefined ||
 			typeof config.createState === "function",
@@ -3345,6 +3510,7 @@ function buildActorConfig(
 			| number
 			| undefined,
 		maxQueueSize: options.maxQueueSize as number | undefined,
+		maxSchedules: options.maxSchedules as number | undefined,
 		maxQueueMessageSize: options.maxQueueMessageSize as number | undefined,
 		maxIncomingMessageSize: registryConfig.maxIncomingMessageSize as
 			| number
@@ -3726,7 +3892,9 @@ export function buildNativeFactory(
 						400,
 					);
 				}
-				const cbor = encodeCborCompat((body.body ?? null) as JsonCompatValue);
+				const cbor = encodeCborCompat(
+					(body.body ?? null) as JsonCompatValue,
+				);
 				const message = await runtime.actorQueueSend(ctx, name, cbor);
 				return jsonResponse({
 					id: message.id().toString(),
@@ -4691,10 +4859,11 @@ export function buildNativeFactory(
 							conn: ConnHandle | null;
 							name: string;
 							args: RuntimeBytes;
+							scheduledFire?: RuntimeScheduledFireInfo;
 							cancelToken?: CancellationTokenHandle;
 						},
 					) => {
-						const { ctx, conn, args, cancelToken } =
+						const { ctx, conn, args, scheduledFire, cancelToken } =
 							unwrapTsfnPayload(error, payload);
 						const actorCtx =
 							conn != null
@@ -4709,6 +4878,7 @@ export function buildNativeFactory(
 										name,
 										decodeArgs(args),
 									),
+									...(scheduledFire ? [scheduledFire] : []),
 								),
 							);
 						} finally {