@rivetkit/cloudflare-workers 0.9.0 → 0.9.2

package/src/manager-driver.ts

@@ -1,22 +1,22 @@
+import type { Encoding } from "@rivetkit/core";
 import {
-	type ManagerDriver,
-	type GetForIdInput,
-	type GetWithKeyInput,
 	type ActorOutput,
 	type CreateInput,
+	type GetForIdInput,
 	type GetOrCreateWithKeyInput,
-	type ConnRoutingHandler,
-	HEADER_EXPOSE_INTERNAL_ERROR,
-	HEADER_ENCODING,
-	HEADER_CONN_PARAMS,
+	type GetWithKeyInput,
 	HEADER_AUTH_DATA,
+	HEADER_CONN_PARAMS,
+	HEADER_ENCODING,
+	HEADER_EXPOSE_INTERNAL_ERROR,
+	type ManagerDriver,
 } from "@rivetkit/core/driver-helpers";
 import { ActorAlreadyExists, InternalError } from "@rivetkit/core/errors";
-import { Bindings } from "./mod";
-import { logger } from "./log";
-import { serializeNameAndKey, serializeKey } from "./util";
+import type { Context as HonoContext } from "hono";
 import { getCloudflareAmbientEnv } from "./handler";
-import { Encoding } from "@rivetkit/core";
+import { logger } from "./log";
+import type { Bindings } from "./mod";
+import { serializeKey, serializeNameAndKey } from "./util";
 
 // Actor metadata structure
 interface ActorData {
@@ -48,149 +48,156 @@ const STANDARD_WEBSOCKET_HEADERS = [
 ];
 
 export class CloudflareActorsManagerDriver implements ManagerDriver {
-	connRoutingHandler: ConnRoutingHandler;
-
-	constructor() {
-		this.connRoutingHandler = {
-			custom: {
-				sendRequest: async (actorId, actorRequest): Promise<Response> => {
-					const env = getCloudflareAmbientEnv();
-
-					logger().debug("sending request to durable object", {
-						actorId,
-						method: actorRequest.method,
-						url: actorRequest.url,
-					});
-
-					const id = env.ACTOR_DO.idFromString(actorId);
-					const stub = env.ACTOR_DO.get(id);
-
-					return await stub.fetch(actorRequest);
-				},
-
-				openWebSocket: async (
-					actorId,
-					encodingKind: Encoding,
-					params: unknown,
-				): Promise<WebSocket> => {
-					const env = getCloudflareAmbientEnv();
-
-					logger().debug("opening websocket to durable object", { actorId });
-
-					// Make a fetch request to the Durable Object with WebSocket upgrade
-					const id = env.ACTOR_DO.idFromString(actorId);
-					const stub = env.ACTOR_DO.get(id);
-
-					const headers: Record<string, string> = {
-						Upgrade: "websocket",
-						Connection: "Upgrade",
-						[HEADER_EXPOSE_INTERNAL_ERROR]: "true",
-						[HEADER_ENCODING]: encodingKind,
-					};
-					if (params) {
-						headers[HEADER_CONN_PARAMS] = JSON.stringify(params);
-					}
-					// HACK: See packages/platforms/cloudflare-workers/src/websocket.ts
-					headers["sec-websocket-protocol"] = "rivetkit";
-
-					const response = await stub.fetch("http://actor/connect/websocket", {
-						headers,
-					});
-					const webSocket = response.webSocket;
-
-					if (!webSocket) {
-						throw new InternalError(
-							"missing websocket connection in response from DO",
-						);
-					}
-
-					logger().debug("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(() => {
-						(webSocket as any).onopen?.(new Event("open"));
-					}, 0);
-
-					return webSocket as unknown as WebSocket;
-				},
-
-				proxyRequest: async (c, actorRequest, actorId): Promise<Response> => {
-					logger().debug("forwarding request to durable object", {
-						actorId,
-						method: actorRequest.method,
-						url: actorRequest.url,
-					});
-
-					const id = c.env.ACTOR_DO.idFromString(actorId);
-					const stub = c.env.ACTOR_DO.get(id);
-
-					return await stub.fetch(actorRequest);
-				},
-				proxyWebSocket: async (
-					c,
-					path,
-					actorId,
-					encoding,
-					params,
-					authData,
-				) => {
-					logger().debug("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,
-						});
-					}
-
-					// TODO: strip headers
-					const newUrl = new URL(`http://actor${path}`);
-					const actorRequest = new Request(newUrl, c.req.raw);
-
-					// 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);
-						}
-					}
-
-					// Add RivetKit headers
-					actorRequest.headers.set(HEADER_EXPOSE_INTERNAL_ERROR, "true");
-					actorRequest.headers.set(HEADER_ENCODING, encoding);
-					if (params) {
-						actorRequest.headers.set(
-							HEADER_CONN_PARAMS,
-							JSON.stringify(params),
-						);
-					}
-					if (authData) {
-						actorRequest.headers.set(
-							HEADER_AUTH_DATA,
-							JSON.stringify(authData),
-						);
-					}
-
-					const id = c.env.ACTOR_DO.idFromString(actorId);
-					const stub = c.env.ACTOR_DO.get(id);
-
-					return await stub.fetch(actorRequest);
-				},
-			},
+	async sendRequest(actorId: string, actorRequest: Request): Promise<Response> {
+		const env = getCloudflareAmbientEnv();
+
+		logger().debug("sending request to durable object", {
+			actorId,
+			method: actorRequest.method,
+			url: actorRequest.url,
+		});
+
+		const id = env.ACTOR_DO.idFromString(actorId);
+		const stub = env.ACTOR_DO.get(id);
+
+		return await stub.fetch(actorRequest);
+	}
+
+	async openWebSocket(
+		path: string,
+		actorId: string,
+		encoding: Encoding,
+		params: unknown,
+	): Promise<WebSocket> {
+		const env = getCloudflareAmbientEnv();
+
+		logger().debug("opening websocket to durable object", { actorId, path });
+
+		// Make a fetch request to the Durable Object with WebSocket upgrade
+		const id = env.ACTOR_DO.idFromString(actorId);
+		const stub = env.ACTOR_DO.get(id);
+
+		const headers: Record<string, string> = {
+			Upgrade: "websocket",
+			Connection: "Upgrade",
+			[HEADER_EXPOSE_INTERNAL_ERROR]: "true",
+			[HEADER_ENCODING]: encoding,
 		};
+		if (params) {
+			headers[HEADER_CONN_PARAMS] = JSON.stringify(params);
+		}
+		// HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
+		headers["sec-websocket-protocol"] = "rivetkit";
+
+		// Use the path parameter to determine the URL
+		const url = `http://actor${path}`;
+
+		logger().debug("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",
+			);
+		}
+
+		logger().debug("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 WebSocket;
+	}
+
+	async proxyRequest(
+		c: HonoContext<{ Bindings: Bindings }>,
+		actorRequest: Request,
+		actorId: string,
+	): Promise<Response> {
+		logger().debug("forwarding request to durable object", {
+			actorId,
+			method: actorRequest.method,
+			url: actorRequest.url,
+		});
+
+		const id = c.env.ACTOR_DO.idFromString(actorId);
+		const stub = c.env.ACTOR_DO.get(id);
+
+		return await stub.fetch(actorRequest);
+	}
+
+	async proxyWebSocket(
+		c: HonoContext<{ Bindings: Bindings }>,
+		path: string,
+		actorId: string,
+		encoding: Encoding,
+		params: unknown,
+		authData: unknown,
+	): Promise<Response> {
+		logger().debug("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,
+			});
+		}
+
+		// TODO: strip headers
+		const newUrl = new URL(`http://actor${path}`);
+		const actorRequest = new Request(newUrl, c.req.raw);
+
+		logger().debug("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);
+			}
+		}
+
+		// Add RivetKit headers
+		actorRequest.headers.set(HEADER_EXPOSE_INTERNAL_ERROR, "true");
+		actorRequest.headers.set(HEADER_ENCODING, encoding);
+		if (params) {
+			actorRequest.headers.set(HEADER_CONN_PARAMS, JSON.stringify(params));
+		}
+		if (authData) {
+			actorRequest.headers.set(HEADER_AUTH_DATA, JSON.stringify(authData));
+		}
+
+		const id = c.env.ACTOR_DO.idFromString(actorId);
+		const stub = c.env.ACTOR_DO.get(id);
+
+		return await stub.fetch(actorRequest);
 	}
 
 	async getForId({

package/src/mod.ts

@@ -1,2 +1,2 @@
-export { type Bindings, createServer, createServerHandler } from "./handler";
 export type { InputConfig as Config } from "./config";
+export { type Bindings, createServer, createServerHandler } from "./handler";

package/src/util.ts

@@ -4,102 +4,101 @@ 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, "\\:");
+	// 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}`;
-  }
+	// 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);
+	// Serialize the key array
+	const serializedKey = serializeKey(key);
 
-  // Combine name and serialized key
-  return `${escapedName}:${serializedKey}`;
+	// 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);
+	// 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;
+	// 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;
 }
-

package/src/websocket.ts

@@ -2,8 +2,8 @@
 //
 // This version calls the open event by default
 
-import { WSContext, defineWebSocketHelper } from "hono/ws";
 import type { UpgradeWebSocket, WSEvents, WSReadyState } from "hono/ws";
+import { defineWebSocketHelper, WSContext } from "hono/ws";
 
 // Based on https://github.com/honojs/hono/issues/1153#issuecomment-1767321332
 export const upgradeWebSocket: UpgradeWebSocket<