rivetkit 2.0.2 → 2.0.4

package/src/actor/router.ts

@@ -0,0 +1,265 @@
+import { Hono, type Context as HonoContext } from "hono";
+import { cors } from "hono/cors";
+import invariant from "invariant";
+import { EncodingSchema } from "@/actor/protocol/serde";
+import {
+	type ActionOpts,
+	type ActionOutput,
+	type ConnectSseOpts,
+	type ConnectSseOutput,
+	type ConnectWebSocketOpts,
+	type ConnectWebSocketOutput,
+	type ConnsMessageOpts,
+	HEADER_AUTH_DATA,
+	HEADER_CONN_ID,
+	HEADER_CONN_PARAMS,
+	HEADER_CONN_TOKEN,
+	HEADER_ENCODING,
+	handleAction,
+	handleConnectionMessage,
+	handleRawWebSocketHandler,
+	handleSseConnect,
+	handleWebSocketConnect,
+} from "@/actor/router-endpoints";
+import {
+	handleRouteError,
+	handleRouteNotFound,
+	loggerMiddleware,
+} from "@/common/router";
+import { noopNext } from "@/common/utils";
+import {
+	type ActorInspectorRouterEnv,
+	createActorInspectorRouter,
+} from "@/inspector/actor";
+import { secureInspector } from "@/inspector/utils";
+import type { RunConfig } from "@/registry/run-config";
+import type { ActorDriver } from "./driver";
+import { InternalError } from "./errors";
+import { loggerWithoutContext } from "./log";
+
+export const PATH_CONNECT_WEBSOCKET = "/connect/websocket";
+export const PATH_RAW_WEBSOCKET_PREFIX = "/raw/websocket/";
+
+export type {
+	ConnectWebSocketOpts,
+	ConnectWebSocketOutput,
+	ConnectSseOpts,
+	ConnectSseOutput,
+	ActionOpts,
+	ActionOutput,
+	ConnsMessageOpts,
+};
+
+interface ActorRouterBindings {
+	actorId: string;
+}
+
+export type ActorRouter = Hono<{ Bindings: ActorRouterBindings }>;
+
+/**
+ * Creates a router that runs on the partitioned instance.
+ */
+export function createActorRouter(
+	runConfig: RunConfig,
+	actorDriver: ActorDriver,
+): ActorRouter {
+	const router = new Hono<{ Bindings: ActorRouterBindings }>({ strict: false });
+
+	router.use("*", loggerMiddleware(loggerWithoutContext()));
+
+	router.get("/", (c) => {
+		return c.text(
+			"This is an RivetKit actor.\n\nLearn more at https://rivetkit.org",
+		);
+	});
+
+	router.get("/health", (c) => {
+		return c.text("ok");
+	});
+
+	router.get(PATH_CONNECT_WEBSOCKET, async (c) => {
+		const upgradeWebSocket = runConfig.getUpgradeWebSocket?.();
+		if (upgradeWebSocket) {
+			return upgradeWebSocket(async (c) => {
+				const encodingRaw = c.req.header(HEADER_ENCODING);
+				const connParamsRaw = c.req.header(HEADER_CONN_PARAMS);
+				const authDataRaw = c.req.header(HEADER_AUTH_DATA);
+
+				const encoding = EncodingSchema.parse(encodingRaw);
+				const connParams = connParamsRaw
+					? JSON.parse(connParamsRaw)
+					: undefined;
+				const authData = authDataRaw ? JSON.parse(authDataRaw) : undefined;
+
+				return await handleWebSocketConnect(
+					c.req.raw,
+					runConfig,
+					actorDriver,
+					c.env.actorId,
+					encoding,
+					connParams,
+					authData,
+				);
+			})(c, noopNext());
+		} else {
+			return c.text(
+				"WebSockets are not enabled for this driver. Use SSE instead.",
+				400,
+			);
+		}
+	});
+
+	router.get("/connect/sse", async (c) => {
+		const authDataRaw = c.req.header(HEADER_AUTH_DATA);
+		let authData: unknown;
+		if (authDataRaw) {
+			authData = JSON.parse(authDataRaw);
+		}
+
+		return handleSseConnect(c, runConfig, actorDriver, c.env.actorId, authData);
+	});
+
+	router.post("/action/:action", async (c) => {
+		const actionName = c.req.param("action");
+
+		const authDataRaw = c.req.header(HEADER_AUTH_DATA);
+		let authData: unknown;
+		if (authDataRaw) {
+			authData = JSON.parse(authDataRaw);
+		}
+
+		return handleAction(
+			c,
+			runConfig,
+			actorDriver,
+			actionName,
+			c.env.actorId,
+			authData,
+		);
+	});
+
+	router.post("/connections/message", async (c) => {
+		const connId = c.req.header(HEADER_CONN_ID);
+		const connToken = c.req.header(HEADER_CONN_TOKEN);
+		if (!connId || !connToken) {
+			throw new Error("Missing required parameters");
+		}
+		return handleConnectionMessage(
+			c,
+			runConfig,
+			actorDriver,
+			connId,
+			connToken,
+			c.env.actorId,
+		);
+	});
+
+	// Raw HTTP endpoints - /http/*
+	router.all("/raw/http/*", async (c) => {
+		const authDataRaw = c.req.header(HEADER_AUTH_DATA);
+		let authData: unknown;
+		if (authDataRaw) {
+			authData = JSON.parse(authDataRaw);
+		}
+
+		const actor = await actorDriver.loadActor(c.env.actorId);
+
+		// TODO: This is not a clean way of doing this since `/http/` might exist mid-path
+		// Strip the /http prefix from the URL to get the original path
+		const url = new URL(c.req.url);
+		const originalPath = url.pathname.replace(/^\/raw\/http/, "") || "/";
+
+		// Create a new request with the corrected URL
+		const correctedUrl = new URL(originalPath + url.search, url.origin);
+		const correctedRequest = new Request(correctedUrl, {
+			method: c.req.method,
+			headers: c.req.raw.headers,
+			body: c.req.raw.body,
+		});
+
+		loggerWithoutContext().debug({
+			msg: "rewriting http url",
+			from: c.req.url,
+			to: correctedRequest.url,
+		});
+
+		// Call the actor's onFetch handler - it will throw appropriate errors
+		const response = await actor.handleFetch(correctedRequest, {
+			auth: authData,
+		});
+
+		// This should never happen now since handleFetch throws errors
+		if (!response) {
+			throw new InternalError("handleFetch returned void unexpectedly");
+		}
+
+		return response;
+	});
+
+	// Raw WebSocket endpoint - /websocket/*
+	router.get(`${PATH_RAW_WEBSOCKET_PREFIX}*`, async (c) => {
+		const upgradeWebSocket = runConfig.getUpgradeWebSocket?.();
+		if (upgradeWebSocket) {
+			return upgradeWebSocket(async (c) => {
+				const encodingRaw = c.req.header(HEADER_ENCODING);
+				const connParamsRaw = c.req.header(HEADER_CONN_PARAMS);
+				const authDataRaw = c.req.header(HEADER_AUTH_DATA);
+
+				const encoding = EncodingSchema.parse(encodingRaw);
+				const connParams = connParamsRaw
+					? JSON.parse(connParamsRaw)
+					: undefined;
+				const authData = authDataRaw ? JSON.parse(authDataRaw) : undefined;
+
+				const url = new URL(c.req.url);
+				const pathWithQuery = c.req.path + url.search;
+
+				loggerWithoutContext().debug({
+					msg: "actor router raw websocket",
+					path: c.req.path,
+					url: c.req.url,
+					search: url.search,
+					pathWithQuery,
+				});
+
+				return await handleRawWebSocketHandler(
+					c.req.raw,
+					pathWithQuery,
+					actorDriver,
+					c.env.actorId,
+					authData,
+				);
+			})(c, noopNext());
+		} else {
+			return c.text(
+				"WebSockets are not enabled for this driver. Use SSE instead.",
+				400,
+			);
+		}
+	});
+
+	if (runConfig.inspector.enabled) {
+		router.route(
+			"/inspect",
+			new Hono<ActorInspectorRouterEnv & { Bindings: ActorRouterBindings }>()
+				.use(
+					cors(runConfig.inspector.cors),
+					secureInspector(runConfig),
+					async (c, next) => {
+						const inspector = (await actorDriver.loadActor(c.env.actorId))
+							.inspector;
+						invariant(inspector, "inspector not supported on this platform");
+
+						c.set("inspector", inspector);
+						return next();
+					},
+				)
+				.route("/", createActorInspectorRouter()),
+		);
+	}
+
+	router.notFound(handleRouteNotFound);
+	router.onError(handleRouteError);
+
+	return router;
+}

package/src/actor/schedule.ts

@@ -0,0 +1,17 @@
+import type { AnyActorInstance } from "./instance";
+
+export class Schedule {
+	#actor: AnyActorInstance;
+
+	constructor(actor: AnyActorInstance) {
+		this.#actor = actor;
+	}
+
+	async after(duration: number, fn: string, ...args: unknown[]) {
+		await this.#actor.scheduleEvent(Date.now() + duration, fn, args);
+	}
+
+	async at(timestamp: number, fn: string, ...args: unknown[]) {
+		await this.#actor.scheduleEvent(timestamp, fn, args);
+	}
+}

package/src/actor/unstable-react.ts

@@ -0,0 +1,110 @@
+//// @ts-ignore we do not have types for this lib
+//import { renderToPipeableStream } from "@jogit/tmp-react-server-dom-nodeless";
+//import getStream from "get-stream";
+//import { isValidElement } from "react";
+//import { Actor } from  "./actor";
+//
+///**
+// * A React Server Components (RSC) actor.
+// *
+// * Supports rendering React elements as action responses.
+// *
+// * @see [Documentation](https://rivet.dev/docs/client/react)
+// * @experimental
+// */
+//export class RscActor<
+//	State = undefined,
+//	ConnParams = undefined,
+//	ConnState = undefined,
+//> extends Actor<State, ConnParams, ConnState> {
+//	/**
+//	 * Updates the RSCs for all connected clients.
+//	 */
+//	public _updateRsc() {
+//		// Broadcast a message to all connected clients, telling them to re-render
+//		this._broadcast("__rsc");
+//	}
+//
+//	/**
+//	 * Overrides default behavior to update the RSCs when the state changes.
+//	 * @private
+//	 * @internal
+//	 */
+//	override _onStateChange() {
+//		this._updateRsc();
+//	}
+//
+//	/**
+//	 * Overrides default behavior to render React elements as RSC response.
+//	 * @private
+//	 * @internal
+//	 */
+//	protected override _onBeforeActionResponse<Out>(
+//		_name: string,
+//		_args: unknown[],
+//		output: Out,
+//	): Out {
+//		if (!isValidElement(output)) {
+//			return super._onBeforeActionResponse(_name, _args, output);
+//		}
+//
+//		// The output is a React element, so we need to transform it into a valid rsc message
+//		const { readable, ...writable } = nodeStreamToWebStream();
+//
+//		const stream = renderToPipeableStream(output);
+//
+//		stream.pipe(writable);
+//
+//		return getStream(readable) as Out;
+//	}
+//}
+//
+//function nodeStreamToWebStream() {
+//	const buffer: Uint8Array[] = [];
+//	let writer: WritableStreamDefaultWriter<Uint8Array> | null = null;
+//
+//	const writable = new WritableStream<Uint8Array>({
+//		write(chunk) {
+//			buffer.push(chunk);
+//		},
+//		close() {},
+//	});
+//
+//	const readable = new ReadableStream<Uint8Array>({
+//		start() {},
+//		async pull(controller) {
+//			if (buffer.length > 0) {
+//				const chunk = buffer.shift(); // Get the next chunk from the buffer
+//				if (chunk) {
+//					controller.enqueue(chunk); // Push it to the readable stream
+//				}
+//			} else {
+//				if (writable.locked) {
+//					await new Promise((resolve) => setTimeout(resolve, 10));
+//					return this.pull?.(controller);
+//				}
+//				return controller.close();
+//			}
+//		},
+//		cancel() {},
+//	});
+//
+//	return {
+//		readable,
+//		on: (str: string, fn: () => void) => {
+//			if (str === "drain") {
+//				writer = writable.getWriter();
+//				fn();
+//			}
+//		},
+//		write(chunk: Uint8Array) {
+//			writer?.write(chunk);
+//		},
+//		flush() {
+//			writer?.close();
+//		},
+//		end() {
+//			writer?.releaseLock();
+//		},
+//	};
+//}

package/src/actor/utils.ts

@@ -0,0 +1,102 @@
+import * as errors from "./errors";
+import { loggerWithoutContext } from "./log";
+
+export function assertUnreachable(x: never): never {
+	loggerWithoutContext().error({
+		msg: "unreachable",
+		value: `${x}`,
+		stack: new Error().stack,
+	});
+	throw new errors.Unreachable(x);
+}
+
+export const throttle = <
+	// biome-ignore lint/suspicious/noExplicitAny: we want to allow any function
+	Fn extends (...args: any) => any,
+>(
+	fn: Fn,
+	delay: number,
+) => {
+	let lastRan = false;
+	let lastArgs: Parameters<Fn> | null = null;
+
+	return (...args: Parameters<Fn>) => {
+		if (!lastRan) {
+			fn.apply(this, args);
+			lastRan = true;
+			const timer = () =>
+				setTimeout(() => {
+					lastRan = false;
+					if (lastArgs) {
+						fn.apply(this, lastArgs);
+						lastRan = true;
+						lastArgs = null;
+						timer();
+					}
+				}, delay);
+			timer();
+		} else lastArgs = args;
+	};
+};
+
+export class DeadlineError extends Error {
+	constructor() {
+		super("Promise did not complete before deadline.");
+	}
+}
+
+export function deadline<T>(promise: Promise<T>, timeout: number): Promise<T> {
+	const controller = new AbortController();
+	const signal = controller.signal;
+
+	// Set a timeout to abort the operation
+	const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+	return Promise.race<T>([
+		promise,
+		new Promise<T>((_, reject) => {
+			signal.addEventListener("abort", () => reject(new DeadlineError()));
+		}),
+	]).finally(() => {
+		clearTimeout(timeoutId);
+	});
+}
+
+export class Lock<T> {
+	private _locked = false;
+	private _waiting: Array<() => void> = [];
+
+	constructor(private _value: T) {}
+
+	async lock(fn: (value: T) => Promise<void>): Promise<void> {
+		if (this._locked) {
+			await new Promise<void>((resolve) => this._waiting.push(resolve));
+		}
+		this._locked = true;
+
+		try {
+			await fn(this._value);
+		} finally {
+			this._locked = false;
+			const next = this._waiting.shift();
+			if (next) next();
+		}
+	}
+}
+
+export function generateSecureToken(length = 32) {
+	const array = new Uint8Array(length);
+	crypto.getRandomValues(array);
+	return btoa(String.fromCharCode(...array));
+}
+
+export function generateRandomString(length = 32) {
+	const characters =
+		"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+	let result = "";
+	for (let i = 0; i < length; i++) {
+		const randomIndex = Math.floor(Math.random() * characters.length);
+		result += characters[randomIndex];
+	}
+	return result;
+}

package/src/client/actor-common.ts

@@ -0,0 +1,30 @@
+import type { ActorDefinition, AnyActorDefinition } from "@/actor/definition";
+
+/**
+ * Action function returned by Actor connections and handles.
+ *
+ * @typedef {Function} ActorActionFunction
+ * @template Args
+ * @template Response
+ * @param {...Args} args - Arguments for the action function.
+ * @returns {Promise<Response>}
+ */
+export type ActorActionFunction<
+	Args extends Array<unknown> = unknown[],
+	Response = unknown,
+> = (
+	...args: Args extends [unknown, ...infer Rest] ? Rest : Args
+) => Promise<Response>;
+
+/**
+ * Maps action methods from actor definition to typed function signatures.
+ */
+export type ActorDefinitionActions<AD extends AnyActorDefinition> =
+	// biome-ignore lint/suspicious/noExplicitAny: safe to use any here
+	AD extends ActorDefinition<any, any, any, any, any, any, infer R>
+		? {
+				[K in keyof R]: R[K] extends (...args: infer Args) => infer Return
+					? ActorActionFunction<Args, Return>
+					: never;
+			}
+		: never;