@rivetkit/cloudflare-workers 2.2.2-rc.1 → 2.3.0-rc.14

package/src/handler.ts

@@ -1,150 +0,0 @@
-import { env } from "cloudflare:workers";
-import type { Client, Registry } from "rivetkit";
-import { createClientWithDriver } from "rivetkit";
-import { buildManagerRouter } from "rivetkit/driver-helpers";
-import {
-	type ActorHandlerInterface,
-	createActorDurableObject,
-	type DurableObjectConstructor,
-} from "./actor-handler-do";
-import { type Config, ConfigSchema, type InputConfig } from "./config";
-import { CloudflareActorsManagerDriver } from "./manager-driver";
-import { upgradeWebSocket } from "./websocket";
-
-/** Cloudflare Workers env */
-export interface Bindings {
-	ACTOR_KV: KVNamespace;
-	ACTOR_DO: DurableObjectNamespace<ActorHandlerInterface>;
-}
-
-/**
- * Stores the env for the current request. Required since some contexts like the inline client driver does not have access to the Hono context.
- *
- * Use getCloudflareAmbientEnv unless using CF_AMBIENT_ENV.run.
- */
-export function getCloudflareAmbientEnv(): Bindings {
-	return env as unknown as Bindings;
-}
-
-export interface InlineOutput<A extends Registry<any>> {
-	/** Client to communicate with the actors. */
-	client: Client<A>;
-
-	/** Fetch handler to manually route requests to the Rivet manager API. */
-	fetch: (request: Request, ...args: any) => Response | Promise<Response>;
-
-	config: Config;
-
-	ActorHandler: DurableObjectConstructor;
-}
-
-export interface HandlerOutput {
-	handler: ExportedHandler<Bindings>;
-	ActorHandler: DurableObjectConstructor;
-}
-
-/**
- * Creates an inline client for accessing Rivet Actors privately without a public manager API.
- *
- * If you want to expose a public manager API, either:
- *
- * - Use `createHandler` to expose the Rivet API on `/api/rivet`
- * - Forward Rivet API requests to `InlineOutput::fetch`
- */
-export function createInlineClient<R extends Registry<any>>(
-	registry: R,
-	inputConfig?: InputConfig,
-): InlineOutput<R> {
-	// HACK: Cloudflare does not support using `crypto.randomUUID()` before start, so we pass a default value
-	//
-	// Runner key is not used on Cloudflare
-	inputConfig = { ...inputConfig, runnerKey: "" };
-
-	// Parse config
-	const config = ConfigSchema.parse(inputConfig);
-
-	// Create Durable Object
-	const ActorHandler = createActorDurableObject(
-		registry,
-		() => upgradeWebSocket,
-	);
-
-	// Configure registry for cloudflare-workers
-	registry.config.noWelcome = true;
-	// Disable inspector since it's not supported on Cloudflare Workers
-	registry.config.inspector = {
-		enabled: false,
-		token: () => "",
-	};
-	// Set manager base path to "/" since the cloudflare handler strips the /api/rivet prefix
-	registry.config.managerBasePath = "/";
-	const parsedConfig = registry.parseConfig();
-
-	// Create manager driver
-	const managerDriver = new CloudflareActorsManagerDriver();
-
-	// Build the manager router (has actor management endpoints like /actors)
-	const { router } = buildManagerRouter(
-		parsedConfig,
-		managerDriver,
-		() => upgradeWebSocket,
-	);
-
-	// Create client using the manager driver
-	// Avoid excessive generic expansion in DTS generation.
-	const client = (createClientWithDriver as any)(managerDriver) as Client<R>;
-
-	return { client, fetch: router.fetch.bind(router), config, ActorHandler };
-}
-
-/**
- * Creates a handler to be exported from a Cloudflare Worker.
- *
- * This will automatically expose the Rivet manager API on `/api/rivet`.
- *
- * This includes a `fetch` handler and `ActorHandler` Durable Object.
- */
-export function createHandler(
-	registry: Registry<any>,
-	inputConfig?: InputConfig,
-): HandlerOutput {
-	const inline = (createInlineClient as any)(registry, inputConfig);
-	const client = inline.client as any;
-	const fetch = inline.fetch as (
-		request: Request,
-		...args: any
-	) => Response | Promise<Response>;
-	const config = inline.config as Config;
-	const ActorHandler = inline.ActorHandler as DurableObjectConstructor;
-
-	// Create Cloudflare handler
-	const handler = {
-		fetch: async (request, cfEnv, ctx) => {
-			const url = new URL(request.url);
-
-			// Inject Rivet env
-			const env = Object.assign({ RIVET: client }, cfEnv);
-
-			// Mount Rivet manager API
-			if (url.pathname.startsWith(config.managerPath)) {
-				const strippedPath = url.pathname.substring(
-					config.managerPath.length,
-				);
-				url.pathname = strippedPath;
-				const modifiedRequest = new Request(url.toString(), request);
-				return fetch(modifiedRequest, env, ctx);
-			}
-
-			if (config.fetch) {
-				return config.fetch(request, env, ctx);
-			} else {
-				return new Response(
-					"This is a RivetKit server.\n\nLearn more at https://rivet.dev\n",
-					{ status: 200 },
-				);
-			}
-		},
-	} satisfies ExportedHandler<Bindings>;
-
-	return { handler, ActorHandler };
-}

package/src/log.ts

@@ -1,5 +0,0 @@
-import { getLogger } from "rivetkit/log";
-
-export function logger() {
-	return getLogger("driver-cloudflare-workers");
-}

package/src/manager-driver.ts

@@ -1,444 +0,0 @@
-import type { Hono, Context as HonoContext } from "hono";
-import type { Encoding, RegistryConfig, UniversalWebSocket } from "rivetkit";
-import {
-	type ActorOutput,
-	type CreateInput,
-	type GetForIdInput,
-	type GetOrCreateWithKeyInput,
-	type GetWithKeyInput,
-	type ListActorsInput,
-	type ManagerDisplayInformation,
-	type ManagerDriver,
-	WS_PROTOCOL_ACTOR,
-	WS_PROTOCOL_CONN_PARAMS,
-	WS_PROTOCOL_ENCODING,
-	WS_PROTOCOL_STANDARD,
-	WS_PROTOCOL_TARGET,
-} from "rivetkit/driver-helpers";
-import {
-	ActorDuplicateKey,
-	ActorNotFound,
-	InternalError,
-} from "rivetkit/errors";
-import { assertUnreachable } from "rivetkit/utils";
-import { parseActorId } from "./actor-id";
-import { getCloudflareAmbientEnv } from "./handler";
-import { logger } from "./log";
-import type { Bindings } from "./mod";
-import { serializeNameAndKey } from "./util";
-
-const STANDARD_WEBSOCKET_HEADERS = [
-	"connection",
-	"upgrade",
-	"sec-websocket-key",
-	"sec-websocket-version",
-	"sec-websocket-protocol",
-	"sec-websocket-extensions",
-];
-
-export class CloudflareActorsManagerDriver implements ManagerDriver {
-	async sendRequest(
-		actorId: string,
-		actorRequest: Request,
-	): Promise<Response> {
-		const env = getCloudflareAmbientEnv();
-
-		// Parse actor ID to get DO ID
-		const [doId] = parseActorId(actorId);
-
-		logger().debug({
-			msg: "sending request to durable object",
-			actorId,
-			doId,
-			method: actorRequest.method,
-			url: actorRequest.url,
-		});
-
-		const id = env.ACTOR_DO.idFromString(doId);
-		const stub = env.ACTOR_DO.get(id);
-
-		return await stub.fetch(actorRequest);
-	}
-
-	async openWebSocket(
-		path: string,
-		actorId: string,
-		encoding: Encoding,
-		params: unknown,
-	): Promise<UniversalWebSocket> {
-		const env = getCloudflareAmbientEnv();
-
-		// Parse actor ID to get DO ID
-		const [doId] = parseActorId(actorId);
-
-		logger().debug({
-			msg: "opening websocket to durable object",
-			actorId,
-			doId,
-			path,
-		});
-
-		// Make a fetch request to the Durable Object with WebSocket upgrade
-		const id = env.ACTOR_DO.idFromString(doId);
-		const stub = env.ACTOR_DO.get(id);
-
-		const protocols: string[] = [];
-		protocols.push(WS_PROTOCOL_STANDARD);
-		protocols.push(`${WS_PROTOCOL_TARGET}actor`);
-		protocols.push(`${WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`);
-		protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
-		if (params) {
-			protocols.push(
-				`${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`,
-			);
-		}
-
-		const headers: Record<string, string> = {
-			Upgrade: "websocket",
-			Connection: "Upgrade",
-			"sec-websocket-protocol": protocols.join(", "),
-		};
-
-		// Use the path parameter to determine the URL
-		const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-		const url = `http://actor${normalizedPath}`;
-
-		logger().debug({ msg: "rewriting websocket url", from: path, to: url });
-
-		const response = await stub.fetch(url, {
-			headers,
-		});
-		const webSocket = response.webSocket;
-
-		if (!webSocket) {
-			throw new InternalError(
-				`missing websocket connection in response from DO\n\nStatus: ${response.status}\nResponse: ${await response.text()}`,
-			);
-		}
-
-		logger().debug({
-			msg: "durable object websocket connection open",
-			actorId,
-		});
-
-		webSocket.accept();
-
-		// TODO: Is this still needed?
-		// HACK: Cloudflare does not call onopen automatically, so we need
-		// to call this on the next tick
-		setTimeout(() => {
-			const event = new Event("open");
-			(webSocket as any).onopen?.(event);
-			(webSocket as any).dispatchEvent(event);
-		}, 0);
-
-		return webSocket as unknown as UniversalWebSocket;
-	}
-
-	async buildGatewayUrl(actorId: string): Promise<string> {
-		return `http://actor/gateway/${encodeURIComponent(actorId)}`;
-	}
-
-	async proxyRequest(
-		c: HonoContext<{ Bindings: Bindings }>,
-		actorRequest: Request,
-		actorId: string,
-	): Promise<Response> {
-		const env = getCloudflareAmbientEnv();
-
-		// Parse actor ID to get DO ID
-		const [doId] = parseActorId(actorId);
-
-		logger().debug({
-			msg: "forwarding request to durable object",
-			actorId,
-			doId,
-			method: actorRequest.method,
-			url: actorRequest.url,
-		});
-
-		const id = env.ACTOR_DO.idFromString(doId);
-		const stub = env.ACTOR_DO.get(id);
-
-		return await stub.fetch(actorRequest);
-	}
-
-	async proxyWebSocket(
-		c: HonoContext<{ Bindings: Bindings }>,
-		path: string,
-		actorId: string,
-		encoding: Encoding,
-		params: unknown,
-	): Promise<Response> {
-		logger().debug({
-			msg: "forwarding websocket to durable object",
-			actorId,
-			path,
-		});
-
-		// Validate upgrade
-		const upgradeHeader = c.req.header("Upgrade");
-		if (!upgradeHeader || upgradeHeader !== "websocket") {
-			return new Response("Expected Upgrade: websocket", {
-				status: 426,
-			});
-		}
-
-		const newUrl = new URL(`http://actor${path}`);
-		const actorRequest = new Request(newUrl, c.req.raw);
-
-		logger().debug({
-			msg: "rewriting websocket url",
-			from: c.req.url,
-			to: actorRequest.url,
-		});
-
-		// Always build fresh request to prevent forwarding unwanted headers
-		// HACK: Since we can't build a new request, we need to remove
-		// non-standard headers manually
-		const headerKeys: string[] = [];
-		actorRequest.headers.forEach((v, k) => {
-			headerKeys.push(k);
-		});
-		for (const k of headerKeys) {
-			if (!STANDARD_WEBSOCKET_HEADERS.includes(k)) {
-				actorRequest.headers.delete(k);
-			}
-		}
-
-		// Build protocols for WebSocket connection
-		const protocols: string[] = [];
-		protocols.push(WS_PROTOCOL_STANDARD);
-		protocols.push(`${WS_PROTOCOL_TARGET}actor`);
-		protocols.push(`${WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`);
-		protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
-		if (params) {
-			protocols.push(
-				`${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`,
-			);
-		}
-		actorRequest.headers.set(
-			"sec-websocket-protocol",
-			protocols.join(", "),
-		);
-
-		// Parse actor ID to get DO ID
-		const env = getCloudflareAmbientEnv();
-		const [doId] = parseActorId(actorId);
-		const id = env.ACTOR_DO.idFromString(doId);
-		const stub = env.ACTOR_DO.get(id);
-
-		return await stub.fetch(actorRequest);
-	}
-
-	async getForId({
-		c,
-		name,
-		actorId,
-	}: GetForIdInput<{ Bindings: Bindings }>): Promise<
-		ActorOutput | undefined
-	> {
-		const env = getCloudflareAmbientEnv();
-
-		// Parse actor ID to get DO ID and expected generation
-		const [doId, expectedGeneration] = parseActorId(actorId);
-
-		// Get the Durable Object stub
-		const id = env.ACTOR_DO.idFromString(doId);
-		const stub = env.ACTOR_DO.get(id);
-
-		// Call the DO's getMetadata method
-		const result = await stub.getMetadata();
-
-		if (!result) {
-			logger().debug({
-				msg: "getForId: actor not found",
-				actorId,
-			});
-			return undefined;
-		}
-
-		// Check if the actor IDs match in order to check if the generation matches
-		if (result.actorId !== actorId) {
-			logger().debug({
-				msg: "getForId: generation mismatch",
-				requestedActorId: actorId,
-				actualActorId: result.actorId,
-			});
-			return undefined;
-		}
-
-		if (result.destroying) {
-			throw new ActorNotFound(actorId);
-		}
-
-		return {
-			actorId: result.actorId,
-			name: result.name,
-			key: result.key,
-		};
-	}
-
-	async getWithKey({
-		c,
-		name,
-		key,
-	}: GetWithKeyInput<{ Bindings: Bindings }>): Promise<
-		ActorOutput | undefined
-	> {
-		const env = getCloudflareAmbientEnv();
-
-		logger().debug({ msg: "getWithKey: searching for actor", name, key });
-
-		// Generate deterministic ID from the name and key
-		const nameKeyString = serializeNameAndKey(name, key);
-		const doId = env.ACTOR_DO.idFromName(nameKeyString).toString();
-
-		// Try to get the Durable Object to see if it exists
-		const id = env.ACTOR_DO.idFromString(doId);
-		const stub = env.ACTOR_DO.get(id);
-
-		// Check if actor exists without creating it
-		const result = await stub.getMetadata();
-
-		if (result) {
-			logger().debug({
-				msg: "getWithKey: found actor with matching name and key",
-				actorId: result.actorId,
-				name: result.name,
-				key: result.key,
-			});
-			return {
-				actorId: result.actorId,
-				name: result.name,
-				key: result.key,
-			};
-		} else {
-			logger().debug({
-				msg: "getWithKey: no actor found with matching name and key",
-				name,
-				key,
-				doId,
-			});
-			return undefined;
-		}
-	}
-
-	async getOrCreateWithKey({
-		c,
-		name,
-		key,
-		input,
-	}: GetOrCreateWithKeyInput<{ Bindings: Bindings }>): Promise<ActorOutput> {
-		const env = getCloudflareAmbientEnv();
-
-		// Create a deterministic ID from the actor name and key
-		// This ensures that actors with the same name and key will have the same ID
-		const nameKeyString = serializeNameAndKey(name, key);
-		const doId = env.ACTOR_DO.idFromName(nameKeyString);
-
-		// Get or create actor using the Durable Object's method
-		const actor = env.ACTOR_DO.get(doId);
-		const result = await actor.create({
-			name,
-			key,
-			input,
-			allowExisting: true,
-		});
-		if ("success" in result) {
-			const { actorId, created } = result.success;
-			logger().debug({
-				msg: "getOrCreateWithKey result",
-				actorId,
-				name,
-				key,
-				created,
-			});
-
-			return {
-				actorId,
-				name,
-				key,
-			};
-		} else if ("error" in result) {
-			throw new Error(`Error: ${JSON.stringify(result.error)}`);
-		} else {
-			assertUnreachable(result);
-		}
-	}
-
-	async createActor({
-		c,
-		name,
-		key,
-		input,
-	}: CreateInput<{ Bindings: Bindings }>): Promise<ActorOutput> {
-		const env = getCloudflareAmbientEnv();
-
-		// Create a deterministic ID from the actor name and key
-		// This ensures that actors with the same name and key will have the same ID
-		const nameKeyString = serializeNameAndKey(name, key);
-		const doId = env.ACTOR_DO.idFromName(nameKeyString);
-
-		// Create actor - this will fail if it already exists
-		const actor = env.ACTOR_DO.get(doId);
-		const result = await actor.create({
-			name,
-			key,
-			input,
-			allowExisting: false,
-		});
-
-		if ("success" in result) {
-			const { actorId } = result.success;
-			return {
-				actorId,
-				name,
-				key,
-			};
-		} else if ("error" in result) {
-			if (result.error.actorAlreadyExists) {
-				throw new ActorDuplicateKey(name, key);
-			}
-
-			throw new InternalError(
-				`Unknown error creating actor: ${JSON.stringify(result.error)}`,
-			);
-		} else {
-			assertUnreachable(result);
-		}
-	}
-
-	async listActors({ c, name }: ListActorsInput): Promise<ActorOutput[]> {
-		logger().warn({
-			msg: "listActors not fully implemented for Cloudflare Workers",
-			name,
-		});
-		return [];
-	}
-
-	displayInformation(): ManagerDisplayInformation {
-		return {
-			properties: {
-				Driver: "Cloudflare Workers",
-			},
-		};
-	}
-
-	setGetUpgradeWebSocket(): void {
-		// No-op for Cloudflare Workers - WebSocket upgrades are handled by the DO
-	}
-
-	async kvGet(actorId: string, key: Uint8Array): Promise<string | null> {
-		const env = getCloudflareAmbientEnv();
-
-		// Parse actor ID to get DO ID
-		const [doId] = parseActorId(actorId);
-
-		const id = env.ACTOR_DO.idFromString(doId);
-		const stub = env.ACTOR_DO.get(id);
-
-		const value = await stub.managerKvGet(key);
-		return value !== null ? new TextDecoder().decode(value) : null;
-	}
-}

package/src/mod.ts

@@ -1,11 +0,0 @@
-export type { Client } from "rivetkit";
-export type { DriverContext } from "./actor-driver";
-export { createActorDurableObject } from "./actor-handler-do";
-export type { InputConfig as Config } from "./config";
-export {
-	type Bindings,
-	createHandler,
-	createInlineClient,
-	HandlerOutput,
-	InlineOutput,
-} from "./handler";

package/src/util.ts

@@ -1,104 +0,0 @@
-// Constants for key handling
-export const EMPTY_KEY = "(none)";
-export const KEY_SEPARATOR = ",";
-
-/**
- * Serializes an array of key strings into a single string for use with idFromName
- *
- * @param name The actor name
- * @param key Array of key strings to serialize
- * @returns A single string containing the serialized name and key
- */
-export function serializeNameAndKey(name: string, key: string[]): string {
-	// Escape colons in the name
-	const escapedName = name.replace(/:/g, "\\:");
-
-	// For empty keys, just return the name and a marker
-	if (key.length === 0) {
-		return `${escapedName}:${EMPTY_KEY}`;
-	}
-
-	// Serialize the key array
-	const serializedKey = serializeKey(key);
-
-	// Combine name and serialized key
-	return `${escapedName}:${serializedKey}`;
-}
-
-/**
- * Serializes an array of key strings into a single string
- *
- * @param key Array of key strings to serialize
- * @returns A single string containing the serialized key
- */
-export function serializeKey(key: string[]): string {
-	// Use a special marker for empty key arrays
-	if (key.length === 0) {
-		return EMPTY_KEY;
-	}
-
-	// Escape each key part to handle the separator and the empty key marker
-	const escapedParts = key.map((part) => {
-		// First check if it matches our empty key marker
-		if (part === EMPTY_KEY) {
-			return `\\${EMPTY_KEY}`;
-		}
-
-		// Escape backslashes first, then commas
-		let escaped = part.replace(/\\/g, "\\\\");
-		escaped = escaped.replace(/,/g, "\\,");
-		return escaped;
-	});
-
-	return escapedParts.join(KEY_SEPARATOR);
-}
-
-/**
- * Deserializes a key string back into an array of key strings
- *
- * @param keyString The serialized key string
- * @returns Array of key strings
- */
-export function deserializeKey(keyString: string): string[] {
-	// Handle empty values
-	if (!keyString) {
-		return [];
-	}
-
-	// Check for special empty key marker
-	if (keyString === EMPTY_KEY) {
-		return [];
-	}
-
-	// Split by unescaped commas and unescape the escaped characters
-	const parts: string[] = [];
-	let currentPart = "";
-	let escaping = false;
-
-	for (let i = 0; i < keyString.length; i++) {
-		const char = keyString[i];
-
-		if (escaping) {
-			// This is an escaped character, add it directly
-			currentPart += char;
-			escaping = false;
-		} else if (char === "\\") {
-			// Start of an escape sequence
-			escaping = true;
-		} else if (char === KEY_SEPARATOR) {
-			// This is a separator
-			parts.push(currentPart);
-			currentPart = "";
-		} else {
-			// Regular character
-			currentPart += char;
-		}
-	}
-
-	// Add the last part if it exists
-	if (currentPart || parts.length > 0) {
-		parts.push(currentPart);
-	}
-
-	return parts;
-}