@rivetkit/cloudflare-workers 0.9.0

package/src/util.ts

@@ -0,0 +1,105 @@
+// 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;
+}
+

package/src/websocket.ts

@@ -0,0 +1,70 @@
+// Modified from https://github.com/honojs/hono/blob/40ea0eee58e39b31053a0246c595434f1094ad31/src/adapter/cloudflare-workers/websocket.ts#L17
+//
+// This version calls the open event by default
+
+import { WSContext, defineWebSocketHelper } from "hono/ws";
+import type { UpgradeWebSocket, WSEvents, WSReadyState } from "hono/ws";
+
+// Based on https://github.com/honojs/hono/issues/1153#issuecomment-1767321332
+export const upgradeWebSocket: UpgradeWebSocket<
+	WebSocket,
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	any,
+	WSEvents<WebSocket>
+> = defineWebSocketHelper(async (c, events) => {
+	const upgradeHeader = c.req.header("Upgrade");
+	if (upgradeHeader !== "websocket") {
+		return;
+	}
+
+	const webSocketPair = new WebSocketPair();
+	const client: WebSocket = webSocketPair[0];
+	const server: WebSocket = webSocketPair[1];
+
+	const wsContext = new WSContext<WebSocket>({
+		close: (code, reason) => server.close(code, reason),
+		get protocol() {
+			return server.protocol;
+		},
+		raw: server,
+		get readyState() {
+			return server.readyState as WSReadyState;
+		},
+		url: server.url ? new URL(server.url) : null,
+		send: (source) => server.send(source),
+	});
+
+	if (events.onClose) {
+		server.addEventListener("close", (evt: CloseEvent) =>
+			events.onClose?.(evt, wsContext),
+		);
+	}
+	if (events.onMessage) {
+		server.addEventListener("message", (evt: MessageEvent) =>
+			events.onMessage?.(evt, wsContext),
+		);
+	}
+	if (events.onError) {
+		server.addEventListener("error", (evt: Event) =>
+			events.onError?.(evt, wsContext),
+		);
+	}
+
+	server.accept?.();
+
+	// note: cloudflare actors doesn't support 'open' event, so we call it immediately with a fake event
+	//
+	// we have to do this after `server.accept() is called`
+	events.onOpen?.(new Event("open"), wsContext);
+
+	return new Response(null, {
+		status: 101,
+		headers: {
+			// HACK: Required in order for Cloudflare to not error with "Network connection lost"
+			//
+			// This bug undocumented. Cannot easily reproduce outside of RivetKit.
+			"Sec-WebSocket-Protocol": "rivetkit",
+		},
+		webSocket: client,
+	});
+});