@rivetkit/cloudflare-workers 2.0.2 → 2.0.4-rc.1

package/src/handler.ts

@@ -1,13 +1,13 @@
 import { env } from "cloudflare:workers";
-import type { Registry, RunConfig } from "@rivetkit/core";
-import type { Client } from "@rivetkit/core/client";
-import { Hono } from "hono";
+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 { ConfigSchema, type InputConfig } from "./config";
+import { type Config, ConfigSchema, type InputConfig } from "./config";
 import { CloudflareActorsManagerDriver } from "./manager-driver";
 import { upgradeWebSocket } from "./websocket";
 
@@ -26,69 +26,120 @@ export function getCloudflareAmbientEnv(): Bindings {
 	return env as unknown as Bindings;
 }
 
-interface Handler {
-	handler: ExportedHandler<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;
 }
 
-interface SetupOutput<A extends Registry<any>> {
-	client: Client<A>;
-	createHandler: (hono?: Hono) => Handler;
+export interface HandlerOutput {
+	handler: ExportedHandler<Bindings>;
+	ActorHandler: DurableObjectConstructor;
 }
 
-export function createServerHandler<R extends Registry<any>>(
+/**
+ * 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,
-): Handler {
-	const { createHandler } = createServer(registry, inputConfig);
-	return createHandler();
-}
+): 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: "" };
 
-export function createServer<R extends Registry<any>>(
-	registry: R,
-	inputConfig?: InputConfig,
-): SetupOutput<R> {
+	// Parse config
 	const config = ConfigSchema.parse(inputConfig);
 
-	// Create config
-	const runConfig = {
-		...config,
-		// The worker acts as a server and doesn't run actors
-		role: "server",
-		driver: {
-			name: "cloudflare-workers",
-			manager: () => new CloudflareActorsManagerDriver(),
-			// HACK: We can't build the actor driver until we're inside the Durable Object
-			actor: undefined as any,
-		},
-		getUpgradeWebSocket: () => upgradeWebSocket,
-	} satisfies RunConfig;
-
 	// Create Durable Object
-	const ActorHandler = createActorDurableObject(registry, runConfig);
+	const ActorHandler = createActorDurableObject(
+		registry,
+		() => upgradeWebSocket,
+	);
 
-	// Create server
-	const serverOutput = registry.createServer(runConfig);
+	// 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();
 
-	return {
-		client: serverOutput.client as Client<R>,
-		createHandler: (hono) => {
-			// Build base router
-			const app = hono ?? new Hono();
+	// Create manager driver
+	const managerDriver = new CloudflareActorsManagerDriver();
 
-			// Mount registry router at /registry
-			if (!hono) {
-				app.route("/registry", serverOutput.hono);
-			}
+	// Build the manager router (has actor management endpoints like /actors)
+	const { router } = buildManagerRouter(
+		parsedConfig,
+		managerDriver,
+		() => upgradeWebSocket,
+	);
+
+	// Create client using the manager driver
+	const client = createClientWithDriver<R>(managerDriver);
 
-			// Create Cloudflare handler
-			const handler = {
-				fetch: (request, env, ctx) => {
-					return app.fetch(request, env, ctx);
-				},
-			} satisfies ExportedHandler<Bindings>;
+	return { client, fetch: router.fetch.bind(router), config, ActorHandler };
+}
 
-			return { handler, 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<R extends Registry<any>>(
+	registry: R,
+	inputConfig?: InputConfig,
+): HandlerOutput {
+	const { client, fetch, config, ActorHandler } = createInlineClient(
+		registry,
+		inputConfig,
+	);
+
+	// 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,7 +1,5 @@
-import { getLogger } from "@rivetkit/core/log";
-
-export const LOGGER_NAME = "driver-cloudflare-workers";
+import { getLogger } from "rivetkit/log";
 
 export function logger() {
-	return getLogger(LOGGER_NAME);
+	return getLogger("driver-cloudflare-workers");
 }