rivetkit 2.0.3 → 2.0.4

package/src/common/router.ts

@@ -7,7 +7,7 @@ import {
 } from "@/actor/router-endpoints";
 import { HttpResponseError } from "@/schemas/client-protocol/mod";
 import { HTTP_RESPONSE_ERROR_VERSIONED } from "@/schemas/client-protocol/versioned";
-import { serializeWithEncoding } from "@/serde";
+import { encodingIsBinary, serializeWithEncoding } from "@/serde";
 import { bufferToArrayBuffer } from "@/utils";
 import { getLogger, type Logger } from "./log";
 import { deconstructError, stringifyError } from "./utils";
@@ -25,7 +25,8 @@ export function loggerMiddleware(logger: Logger) {
 		await next();
 
 		const duration = Date.now() - startTime;
-		logger.debug("http request", {
+		logger.debug({
+			msg: "http request",
 			method,
 			path,
 			status: c.res.status,
@@ -41,19 +42,10 @@ export function handleRouteNotFound(c: HonoContext) {
 	return c.text("Not Found (RivetKit)", 404);
 }
 
-export interface HandleRouterErrorOpts {
-	enableExposeInternalError?: boolean;
-}
-
-export function handleRouteError(
-	opts: HandleRouterErrorOpts,
-	error: unknown,
-	c: HonoContext,
-) {
-	const exposeInternalError =
-		opts.enableExposeInternalError && getRequestExposeInternalError(c.req.raw);
+export function handleRouteError(error: unknown, c: HonoContext) {
+	const exposeInternalError = getRequestExposeInternalError(c.req.raw);
 
-	const { statusCode, code, message, metadata } = deconstructError(
+	const { statusCode, group, code, message, metadata } = deconstructError(
 		error,
 		logger(),
 		{
@@ -66,19 +58,20 @@ export function handleRouteError(
 	let encoding: Encoding;
 	try {
 		encoding = getRequestEncoding(c.req);
-	} catch (err) {
-		logger().debug("failed to extract encoding", {
-			error: stringifyError(err),
-		});
+	} catch (_) {
 		encoding = "json";
 	}
 
 	const output = serializeWithEncoding(
 		encoding,
 		{
+			group,
 			code,
 			message,
-			metadata: bufferToArrayBuffer(cbor.encode(metadata)),
+			// TODO: Cannot serialize non-binary meta since it requires ArrayBuffer atm
+			metadata: encodingIsBinary(encoding)
+				? bufferToArrayBuffer(cbor.encode(metadata))
+				: null,
 		},
 		HTTP_RESPONSE_ERROR_VERSIONED,
 	);

package/src/common/utils.ts

@@ -186,6 +186,7 @@ export interface DeconstructedError {
 	__type: "ActorError";
 	statusCode: ContentfulStatusCode;
 	public: boolean;
+	group: string;
 	code: string;
 	message: string;
 	metadata?: unknown;
@@ -203,6 +204,7 @@ export function deconstructError(
 	// We log the error here instead of after generating the code & message because we need to log the original error, not the masked internal error.
 	let statusCode: ContentfulStatusCode;
 	let public_: boolean;
+	let group: string;
 	let code: string;
 	let message: string;
 	let metadata: unknown;
@@ -212,60 +214,71 @@ export function deconstructError(
 			"statusCode" in error && error.statusCode ? error.statusCode : 400
 		) as ContentfulStatusCode;
 		public_ = true;
+		group = error.group;
 		code = error.code;
 		message = getErrorMessage(error);
 		metadata = error.metadata;
 
-		logger.info("public error", {
+		logger.info({
+			msg: "public error",
+			group,
 			code,
 			message,
-			issues: "https://github.com/rivet-gg/rivetkit/issues",
-			support: "https://rivet.gg/discord",
+			issues: "https://github.com/rivet-dev/rivetkit/issues",
+			support: "https://rivet.dev/discord",
 			...extraLog,
 		});
 	} else if (exposeInternalError) {
 		if (errors.ActorError.isActorError(error)) {
 			statusCode = 500;
 			public_ = false;
+			group = error.group;
 			code = error.code;
 			message = getErrorMessage(error);
 			metadata = error.metadata;
 
-			logger.info("internal error", {
+			logger.info({
+				msg: "internal error",
+				group,
 				code,
 				message,
-				issues: "https://github.com/rivet-gg/rivetkit/issues",
-				support: "https://rivet.gg/discord",
+				issues: "https://github.com/rivet-dev/rivetkit/issues",
+				support: "https://rivet.dev/discord",
 				...extraLog,
 			});
 		} else {
 			statusCode = 500;
 			public_ = false;
+			group = "internal";
 			code = errors.INTERNAL_ERROR_CODE;
 			message = getErrorMessage(error);
 
-			logger.info("internal error", {
+			logger.info({
+				msg: "internal error",
+				group,
 				code,
 				message,
-				issues: "https://github.com/rivet-gg/rivetkit/issues",
-				support: "https://rivet.gg/discord",
+				issues: "https://github.com/rivet-dev/rivetkit/issues",
+				support: "https://rivet.dev/discord",
 				...extraLog,
 			});
 		}
 	} else {
 		statusCode = 500;
 		public_ = false;
+		group = "internal";
 		code = errors.INTERNAL_ERROR_CODE;
 		message = errors.INTERNAL_ERROR_DESCRIPTION;
 		metadata = {
-			//url: `https://hub.rivet.gg/projects/${actorMetadata.project.slug}/environments/${actorMetadata.environment.slug}/actors?actorId=${actorMetadata.actor.id}`,
+			//url: `https://hub.rivet.dev/projects/${actorMetadata.project.slug}/environments/${actorMetadata.environment.slug}/actors?actorId=${actorMetadata.actor.id}`,
 		} satisfies errors.InternalErrorMetadata;
 
-		logger.warn("internal error", {
+		logger.warn({
+			msg: "internal error",
 			error: getErrorMessage(error),
 			stack: (error as Error)?.stack,
-			issues: "https://github.com/rivet-gg/rivetkit/issues",
-			support: "https://rivet.gg/discord",
+			issues: "https://github.com/rivet-dev/rivetkit/issues",
+			support: "https://rivet.dev/discord",
 			...extraLog,
 		});
 	}
@@ -274,6 +287,7 @@ export function deconstructError(
 		__type: "ActorError",
 		statusCode,
 		public: public_,
+		group,
 		code,
 		message,
 		metadata,

package/src/common/websocket.ts

@@ -16,7 +16,6 @@ export async function importWebSocket(): Promise<typeof WebSocket> {
 		if (typeof WebSocket !== "undefined") {
 			// Browser environment
 			_WebSocket = WebSocket as unknown as typeof WebSocket;
-			logger().debug("using native websocket");
 		} else {
 			// Node.js environment
 			try {

package/src/driver-helpers/mod.ts

@@ -8,7 +8,6 @@ export {
 	HEADER_CONN_PARAMS,
 	HEADER_CONN_TOKEN,
 	HEADER_ENCODING,
-	HEADER_EXPOSE_INTERNAL_ERROR,
 } from "@/actor/router-endpoints";
 export type {
 	ActorOutput,
@@ -16,6 +15,7 @@ export type {
 	GetForIdInput,
 	GetOrCreateWithKeyInput,
 	GetWithKeyInput,
+	ManagerDisplayInformation,
 	ManagerDriver,
 } from "@/manager/driver";
 export { DriverConfigSchema, RunConfigSchema } from "@/registry/run-config";

package/src/driver-test-suite/log.ts

@@ -1,7 +1,5 @@
 import { getLogger } from "@/common/log";
 
-export const LOGGER_NAME = "test-suite";
-
 export function logger() {
-	return getLogger(LOGGER_NAME);
+	return getLogger("test-suite");
 }

package/src/driver-test-suite/mod.ts

@@ -4,13 +4,12 @@ import { bundleRequire } from "bundle-require";
 import invariant from "invariant";
 import { describe } from "vitest";
 import type { Transport } from "@/client/mod";
-import { createInlineClientDriver } from "@/inline-client-driver/mod";
 import { createManagerRouter } from "@/manager/router";
 import type { DriverConfig, Registry, RunConfig } from "@/mod";
 import { RunConfigSchema } from "@/registry/run-config";
 import { getPort } from "@/test/mod";
+import { logger } from "./log";
 import { runActionFeaturesTests } from "./tests/action-features";
-import { runActorAuthTests } from "./tests/actor-auth";
 import { runActorConnTests } from "./tests/actor-conn";
 import { runActorConnStateTests } from "./tests/actor-conn-state";
 import {
@@ -26,10 +25,8 @@ import { runActorOnStateChangeTests } from "./tests/actor-onstatechange";
 import { runActorVarsTests } from "./tests/actor-vars";
 import { runManagerDriverTests } from "./tests/manager-driver";
 import { runRawHttpTests } from "./tests/raw-http";
-import { runRawHttpDirectRegistryTests } from "./tests/raw-http-direct-registry";
 import { runRawHttpRequestPropertiesTests } from "./tests/raw-http-request-properties";
 import { runRawWebSocketTests } from "./tests/raw-websocket";
-import { runRawWebSocketDirectRegistryTests } from "./tests/raw-websocket-direct-registry";
 import { runRequestAccessTests } from "./tests/request-access";
 
 export interface SkipTests {
@@ -68,6 +65,8 @@ type ClientType = "http" | "inline";
 
 export interface DriverDeployOutput {
 	endpoint: string;
+	namespace: string;
+	runnerName: string;
 
 	/** Cleans up the test. */
 	cleanup(): Promise<void>;
@@ -114,8 +113,6 @@ export function runDriverTests(
 
 			runActorErrorHandlingTests(driverTestConfig);
 
-			runActorAuthTests(driverTestConfig);
-
 			runActorInlineClientTests(driverTestConfig);
 
 			runRawHttpTests(driverTestConfig);
@@ -124,9 +121,11 @@ export function runDriverTests(
 
 			runRawWebSocketTests(driverTestConfig);
 
-			runRawHttpDirectRegistryTests(driverTestConfig);
+			// TODO: re-expose this once we can have actor queries on the gateway
+			// runRawHttpDirectRegistryTests(driverTestConfig);
 
-			runRawWebSocketDirectRegistryTests(driverTestConfig);
+			// TODO: re-expose this once we can have actor queries on the gateway
+			// runRawWebSocketDirectRegistryTests(driverTestConfig);
 
 			runActorInspectorTests(driverTestConfig);
 		});
@@ -141,6 +140,7 @@ export function runDriverTests(
 export async function createTestRuntime(
 	registryPath: string,
 	driverFactory: (registry: Registry<any>) => Promise<{
+		rivetEngine?: { endpoint: string; namespace: string; runnerName: string };
 		driver: DriverConfig;
 		cleanup?: () => Promise<void>;
 	}>,
@@ -156,58 +156,84 @@ export async function createTestRuntime(
 	registry.config.test.enabled = true;
 
 	// Build drivers
-	const { driver, cleanup: driverCleanup } = await driverFactory(registry);
-
-	// Build driver config
-	let injectWebSocket: NodeWebSocket["injectWebSocket"] | undefined;
-	let upgradeWebSocket: any;
-	const config: RunConfig = RunConfigSchema.parse({
+	const {
 		driver,
-		getUpgradeWebSocket: () => upgradeWebSocket!,
-		inspector: {
-			enabled: true,
-			token: () => "token",
-		},
-	});
+		cleanup: driverCleanup,
+		rivetEngine,
+	} = await driverFactory(registry);
 
-	// Create router
-	const managerDriver = driver.manager(registry.config, config);
-	const inlineDriver = createInlineClientDriver(managerDriver);
-	const { router } = createManagerRouter(
-		registry.config,
-		config,
-		inlineDriver,
-		managerDriver,
-		false,
-	);
-
-	// Inject WebSocket
-	const nodeWebSocket = createNodeWebSocket({ app: router });
-	upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
-	injectWebSocket = nodeWebSocket.injectWebSocket;
-
-	// Start server
-	const port = await getPort();
-	const server = honoServe({
-		fetch: router.fetch,
-		hostname: "127.0.0.1",
-		port,
-	});
-	invariant(injectWebSocket !== undefined, "should have injectWebSocket");
-	injectWebSocket(server);
-	const endpoint = `http://127.0.0.1:${port}`;
-
-	// Cleanup
-	const cleanup = async () => {
-		// Stop server
-		await new Promise((resolve) => server.close(() => resolve(undefined)));
-
-		// Extra cleanup
-		await driverCleanup?.();
-	};
-
-	return {
-		endpoint,
-		cleanup,
-	};
+	if (rivetEngine) {
+		// TODO: We don't need createTestRuntime fort his
+		// Using external Rivet engine
+
+		const cleanup = async () => {
+			await driverCleanup?.();
+		};
+
+		return {
+			endpoint: rivetEngine.endpoint,
+			namespace: rivetEngine.namespace,
+			runnerName: rivetEngine.runnerName,
+			cleanup,
+		};
+	} else {
+		// Start server for Rivet engine
+
+		// Build driver config
+		// biome-ignore lint/style/useConst: Assigned later
+		let upgradeWebSocket: any;
+		const config: RunConfig = RunConfigSchema.parse({
+			driver,
+			getUpgradeWebSocket: () => upgradeWebSocket!,
+			inspector: {
+				enabled: true,
+				token: () => "token",
+			},
+		});
+
+		// Create router
+		const managerDriver = driver.manager(registry.config, config);
+		const { router } = createManagerRouter(
+			registry.config,
+			config,
+			managerDriver,
+			false,
+		);
+
+		// Inject WebSocket
+		const nodeWebSocket = createNodeWebSocket({ app: router });
+		upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
+
+		// Start server
+		const port = await getPort();
+		const server = honoServe({
+			fetch: router.fetch,
+			hostname: "127.0.0.1",
+			port,
+		});
+		invariant(
+			nodeWebSocket.injectWebSocket !== undefined,
+			"should have injectWebSocket",
+		);
+		nodeWebSocket.injectWebSocket(server);
+		const serverEndpoint = `http://127.0.0.1:${port}`;
+
+		logger().info({ msg: "test serer listening", port });
+
+		// Cleanup
+		const cleanup = async () => {
+			// Stop server
+			await new Promise((resolve) => server.close(() => resolve(undefined)));
+
+			// Extra cleanup
+			await driverCleanup?.();
+		};
+
+		return {
+			endpoint: serverEndpoint,
+			namespace: "default",
+			runnerName: "rivetkit",
+			cleanup,
+		};
+	}
 }

package/src/driver-test-suite/tests/actor-handle.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "vitest";
+import type { ActorError } from "@/client/mod";
 import type { DriverTestConfig } from "../mod";
 import { setupDriverTest } from "../utils";
 
@@ -74,6 +75,38 @@ export function runActorHandleTests(driverTestConfig: DriverTestConfig) {
 				const retrievedCount = await handle.getCount();
 				expect(retrievedCount).toBe(9);
 			});
+
+			test("errors when calling create twice with the same key", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				const key = ["duplicate-create-handle", crypto.randomUUID()];
+
+				// First create should succeed
+				await client.counter.create(key);
+
+				// Second create with same key should throw ActorAlreadyExists
+				try {
+					await client.counter.create(key);
+					expect.fail("did not error on duplicate create");
+				} catch (err) {
+					expect((err as ActorError).group).toBe("actor");
+					expect((err as ActorError).code).toBe("already_exists");
+				}
+			});
+
+			test(".get().resolve() errors for non-existent actor", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				const missingId = `nonexistent-${crypto.randomUUID()}`;
+
+				try {
+					await client.counter.get([missingId]).resolve();
+					expect.fail("did not error for get().resolve() on missing actor");
+				} catch (err) {
+					expect((err as ActorError).group).toBe("actor");
+					expect((err as ActorError).code).toBe("not_found");
+				}
+			});
 		});
 
 		describe("Action Functionality", () => {

package/src/driver-test-suite/tests/manager-driver.ts

@@ -39,7 +39,8 @@ export function runManagerDriverTests(driverTestConfig: DriverTestConfig) {
 					await client.counter.create(uniqueKey);
 					expect.fail("did not error on duplicate create");
 				} catch (err) {
-					expect((err as ActorError).code).toBe("actor_already_exists");
+					expect((err as ActorError).group).toBe("actor");
+					expect((err as ActorError).code).toBe("already_exists");
 				}
 
 				// Verify the original actor still works and has its state
@@ -60,7 +61,8 @@ export function runManagerDriverTests(driverTestConfig: DriverTestConfig) {
 					await client.counter.get([nonexistentId]).resolve();
 					expect.fail("did not error for get");
 				} catch (err) {
-					expect((err as ActorError).code).toBe("actor_not_found");
+					expect((err as ActorError).group).toBe("actor");
+					expect((err as ActorError).code).toBe("not_found");
 				}
 
 				// Create the actor
@@ -319,7 +321,7 @@ export function runManagerDriverTests(driverTestConfig: DriverTestConfig) {
 		});
 
 		describe("Multiple Actor Instances", () => {
-			// TODO: This test is flakey https://github.com/rivet-gg/rivetkit/issues/873
+			// TODO: This test is flakey https://github.com/rivet-dev/rivetkit/issues/873
 			test("creates multiple actor instances of the same type", async (c) => {
 				const { client } = await setupDriverTest(c, driverTestConfig);