rivetkit 2.0.3 → 2.0.5

package/src/driver-test-suite/tests/actor-error-handling.ts

@@ -63,18 +63,10 @@ export function runActorErrorHandlingTests(driverTestConfig: DriverTestConfig) {
 					// If we get here, the test should fail
 					expect(true).toBe(false); // This should not be reached
 				} catch (error: any) {
-					if (driverTestConfig.clientType === "http") {
-						// Verify the error is converted to a safe format
-						expect(error.code).toBe(INTERNAL_ERROR_CODE);
-						// Original error details should not be exposed
-						expect(error.message).toBe(INTERNAL_ERROR_DESCRIPTION);
-					} else if (driverTestConfig.clientType === "inline") {
-						// Verify that original error is preserved
-						expect(error.code).toBe(INTERNAL_ERROR_CODE);
-						expect(error.message).toBe("This is an internal error");
-					} else {
-						assertUnreachable(driverTestConfig.clientType);
-					}
+					// Verify the error is converted to a safe format
+					expect(error.code).toBe(INTERNAL_ERROR_CODE);
+					// Original error details should not be exposed
+					expect(error.message).toBe(INTERNAL_ERROR_DESCRIPTION);
 				}
 			});
 		});

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/actor-inspector.ts

@@ -9,7 +9,8 @@ import type { DriverTestConfig } from "../mod";
 import { setupDriverTest } from "../utils";
 
 export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
-	describe("Actor Inspector Tests", () => {
+	// TODO: Add back
+	describe.skip("Actor Inspector Tests", () => {
 		describe("Manager Inspector", () => {
 			test("should respond to ping", async (c) => {
 				const { endpoint } = await setupDriverTest(c, driverTestConfig);

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);
 

package/src/driver-test-suite/tests/raw-http-direct-registry.ts

@@ -1,226 +1,227 @@
-import { describe, expect, test } from "vitest";
-import {
-	HEADER_ACTOR_QUERY,
-	HEADER_CONN_PARAMS,
-} from "@/actor/router-endpoints";
-import type { ActorQuery } from "@/manager/protocol/query";
-import type { DriverTestConfig } from "../mod";
-import { setupDriverTest } from "../utils";
-
-export function runRawHttpDirectRegistryTests(
-	driverTestConfig: DriverTestConfig,
-) {
-	describe("raw http - direct registry access", () => {
-		test("should handle direct fetch requests to registry with proper headers", async (c) => {
-			const { endpoint } = await setupDriverTest(c, driverTestConfig);
-
-			// Build the actor query
-			const actorQuery: ActorQuery = {
-				getOrCreateForKey: {
-					name: "rawHttpActor",
-					key: ["direct-test"],
-				},
-			};
-
-			// Make a direct fetch request to the registry
-			const response = await fetch(
-				`${endpoint}/registry/actors/raw/http/api/hello`,
-				{
-					method: "GET",
-					headers: {
-						[HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
-					},
-				},
-			);
-
-			expect(response.ok).toBe(true);
-			expect(response.status).toBe(200);
-			const data = await response.json();
-			expect(data).toEqual({ message: "Hello from actor!" });
-		});
-
-		test("should handle POST requests with body to registry", async (c) => {
-			const { endpoint } = await setupDriverTest(c, driverTestConfig);
-
-			const actorQuery: ActorQuery = {
-				getOrCreateForKey: {
-					name: "rawHttpActor",
-					key: ["direct-post-test"],
-				},
-			};
-
-			const testData = { test: "direct", number: 456 };
-			const response = await fetch(
-				`${endpoint}/registry/actors/raw/http/api/echo`,
-				{
-					method: "POST",
-					headers: {
-						[HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
-						"Content-Type": "application/json",
-					},
-					body: JSON.stringify(testData),
-				},
-			);
-
-			expect(response.ok).toBe(true);
-			expect(response.status).toBe(200);
-			const data = await response.json();
-			expect(data).toEqual(testData);
-		});
-
-		test("should pass custom headers through to actor", async (c) => {
-			const { endpoint } = await setupDriverTest(c, driverTestConfig);
-
-			const actorQuery: ActorQuery = {
-				getOrCreateForKey: {
-					name: "rawHttpActor",
-					key: ["direct-headers-test"],
-				},
-			};
-
-			const customHeaders = {
-				"X-Custom-Header": "direct-test-value",
-				"X-Another-Header": "another-direct-value",
-			};
-
-			const response = await fetch(
-				`${endpoint}/registry/actors/raw/http/api/headers`,
-				{
-					method: "GET",
-					headers: {
-						[HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
-						...customHeaders,
-					},
-				},
-			);
-
-			expect(response.ok).toBe(true);
-			const headers = (await response.json()) as Record<string, string>;
-			expect(headers["x-custom-header"]).toBe("direct-test-value");
-			expect(headers["x-another-header"]).toBe("another-direct-value");
-		});
-
-		test("should handle connection parameters for authentication", async (c) => {
-			const { endpoint } = await setupDriverTest(c, driverTestConfig);
-
-			const actorQuery: ActorQuery = {
-				getOrCreateForKey: {
-					name: "rawHttpActor",
-					key: ["direct-auth-test"],
-				},
-			};
-
-			const connParams = { token: "test-auth-token", userId: "user123" };
-
-			const response = await fetch(
-				`${endpoint}/registry/actors/raw/http/api/hello`,
-				{
-					method: "GET",
-					headers: {
-						[HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
-						[HEADER_CONN_PARAMS]: JSON.stringify(connParams),
-					},
-				},
-			);
-
-			expect(response.ok).toBe(true);
-			const data = await response.json();
-			expect(data).toEqual({ message: "Hello from actor!" });
-		});
-
-		test("should return 404 for actors without onFetch handler", async (c) => {
-			const { endpoint } = await setupDriverTest(c, driverTestConfig);
-
-			const actorQuery: ActorQuery = {
-				getOrCreateForKey: {
-					name: "rawHttpNoHandlerActor",
-					key: ["direct-no-handler"],
-				},
-			};
-
-			const response = await fetch(
-				`${endpoint}/registry/actors/raw/http/api/anything`,
-				{
-					method: "GET",
-					headers: {
-						[HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
-					},
-				},
-			);
-
-			expect(response.ok).toBe(false);
-			expect(response.status).toBe(404);
-		});
-
-		test("should handle different HTTP methods", async (c) => {
-			const { endpoint } = await setupDriverTest(c, driverTestConfig);
-
-			const actorQuery: ActorQuery = {
-				getOrCreateForKey: {
-					name: "rawHttpActor",
-					key: ["direct-methods-test"],
-				},
-			};
-
-			// Test various HTTP methods
-			const methods = ["GET", "POST", "PUT", "DELETE", "PATCH"] as const;
-
-			for (const method of methods) {
-				const response = await fetch(
-					`${endpoint}/registry/actors/raw/http/api/echo`,
-					{
-						method,
-						headers: {
-							[HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
-							...(method !== "GET"
-								? { "Content-Type": "application/json" }
-								: {}),
-						},
-						body: ["POST", "PUT", "PATCH"].includes(method)
-							? JSON.stringify({ method })
-							: undefined,
-					},
-				);
-
-				// Echo endpoint only handles POST, others should fall through to 404
-				if (method === "POST") {
-					expect(response.ok).toBe(true);
-					const data = await response.json();
-					expect(data).toEqual({ method });
-				} else {
-					expect(response.status).toBe(404);
-				}
-			}
-		});
-
-		test("should handle binary data", async (c) => {
-			const { endpoint } = await setupDriverTest(c, driverTestConfig);
-
-			const actorQuery: ActorQuery = {
-				getOrCreateForKey: {
-					name: "rawHttpActor",
-					key: ["direct-binary-test"],
-				},
-			};
-
-			// Send binary data
-			const binaryData = new Uint8Array([1, 2, 3, 4, 5]);
-			const response = await fetch(
-				`${endpoint}/registry/actors/raw/http/api/echo`,
-				{
-					method: "POST",
-					headers: {
-						[HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
-						"Content-Type": "application/octet-stream",
-					},
-					body: binaryData,
-				},
-			);
-
-			expect(response.ok).toBe(true);
-			const responseBuffer = await response.arrayBuffer();
-			const responseArray = new Uint8Array(responseBuffer);
-			expect(Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
-		});
-	});
-}
+// TODO: re-expose this once we can have actor queries on the gateway
+// import { describe, expect, test } from "vitest";
+// import {
+// 	HEADER_ACTOR_QUERY,
+// 	HEADER_CONN_PARAMS,
+// } from "@/actor/router-endpoints";
+// import type { ActorQuery } from "@/manager/protocol/query";
+// import type { DriverTestConfig } from "../mod";
+// import { setupDriverTest } from "../utils";
+//
+// export function runRawHttpDirectRegistryTests(
+// 	driverTestConfig: DriverTestConfig,
+// ) {
+// 	describe("raw http - direct registry access", () => {
+// 		test("should handle direct fetch requests to registry with proper headers", async (c) => {
+// 			const { endpoint } = await setupDriverTest(c, driverTestConfig);
+//
+// 			// Build the actor query
+// 			const actorQuery: ActorQuery = {
+// 				getOrCreateForKey: {
+// 					name: "rawHttpActor",
+// 					key: ["direct-test"],
+// 				},
+// 			};
+//
+// 			// Make a direct fetch request to the registry
+// 			const response = await fetch(
+// 				`${endpoint}/registry/actors/raw/http/api/hello`,
+// 				{
+// 					method: "GET",
+// 					headers: {
+// 						[HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
+// 					},
+// 				},
+// 			);
+//
+// 			expect(response.ok).toBe(true);
+// 			expect(response.status).toBe(200);
+// 			const data = await response.json();
+// 			expect(data).toEqual({ message: "Hello from actor!" });
+// 		});
+//
+// 		test("should handle POST requests with body to registry", async (c) => {
+// 			const { endpoint } = await setupDriverTest(c, driverTestConfig);
+//
+// 			const actorQuery: ActorQuery = {
+// 				getOrCreateForKey: {
+// 					name: "rawHttpActor",
+// 					key: ["direct-post-test"],
+// 				},
+// 			};
+//
+// 			const testData = { test: "direct", number: 456 };
+// 			const response = await fetch(
+// 				`${endpoint}/registry/actors/raw/http/api/echo`,
+// 				{
+// 					method: "POST",
+// 					headers: {
+// 						[HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
+// 						"Content-Type": "application/json",
+// 					},
+// 					body: JSON.stringify(testData),
+// 				},
+// 			);
+//
+// 			expect(response.ok).toBe(true);
+// 			expect(response.status).toBe(200);
+// 			const data = await response.json();
+// 			expect(data).toEqual(testData);
+// 		});
+//
+// 		test("should pass custom headers through to actor", async (c) => {
+// 			const { endpoint } = await setupDriverTest(c, driverTestConfig);
+//
+// 			const actorQuery: ActorQuery = {
+// 				getOrCreateForKey: {
+// 					name: "rawHttpActor",
+// 					key: ["direct-headers-test"],
+// 				},
+// 			};
+//
+// 			const customHeaders = {
+// 				"X-Custom-Header": "direct-test-value",
+// 				"X-Another-Header": "another-direct-value",
+// 			};
+//
+// 			const response = await fetch(
+// 				`${endpoint}/registry/actors/raw/http/api/headers`,
+// 				{
+// 					method: "GET",
+// 					headers: {
+// 						[HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
+// 						...customHeaders,
+// 					},
+// 				},
+// 			);
+//
+// 			expect(response.ok).toBe(true);
+// 			const headers = (await response.json()) as Record<string, string>;
+// 			expect(headers["x-custom-header"]).toBe("direct-test-value");
+// 			expect(headers["x-another-header"]).toBe("another-direct-value");
+// 		});
+//
+// 		test("should handle connection parameters for authentication", async (c) => {
+// 			const { endpoint } = await setupDriverTest(c, driverTestConfig);
+//
+// 			const actorQuery: ActorQuery = {
+// 				getOrCreateForKey: {
+// 					name: "rawHttpActor",
+// 					key: ["direct-auth-test"],
+// 				},
+// 			};
+//
+// 			const connParams = { token: "test-auth-token", userId: "user123" };
+//
+// 			const response = await fetch(
+// 				`${endpoint}/registry/actors/raw/http/api/hello`,
+// 				{
+// 					method: "GET",
+// 					headers: {
+// 						[HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
+// 						[HEADER_CONN_PARAMS]: JSON.stringify(connParams),
+// 					},
+// 				},
+// 			);
+//
+// 			expect(response.ok).toBe(true);
+// 			const data = await response.json();
+// 			expect(data).toEqual({ message: "Hello from actor!" });
+// 		});
+//
+// 		test("should return 404 for actors without onFetch handler", async (c) => {
+// 			const { endpoint } = await setupDriverTest(c, driverTestConfig);
+//
+// 			const actorQuery: ActorQuery = {
+// 				getOrCreateForKey: {
+// 					name: "rawHttpNoHandlerActor",
+// 					key: ["direct-no-handler"],
+// 				},
+// 			};
+//
+// 			const response = await fetch(
+// 				`${endpoint}/registry/actors/raw/http/api/anything`,
+// 				{
+// 					method: "GET",
+// 					headers: {
+// 						[HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
+// 					},
+// 				},
+// 			);
+//
+// 			expect(response.ok).toBe(false);
+// 			expect(response.status).toBe(404);
+// 		});
+//
+// 		test("should handle different HTTP methods", async (c) => {
+// 			const { endpoint } = await setupDriverTest(c, driverTestConfig);
+//
+// 			const actorQuery: ActorQuery = {
+// 				getOrCreateForKey: {
+// 					name: "rawHttpActor",
+// 					key: ["direct-methods-test"],
+// 				},
+// 			};
+//
+// 			// Test various HTTP methods
+// 			const methods = ["GET", "POST", "PUT", "DELETE", "PATCH"] as const;
+//
+// 			for (const method of methods) {
+// 				const response = await fetch(
+// 					`${endpoint}/registry/actors/raw/http/api/echo`,
+// 					{
+// 						method,
+// 						headers: {
+// 							[HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
+// 							...(method !== "GET"
+// 								? { "Content-Type": "application/json" }
+// 								: {}),
+// 						},
+// 						body: ["POST", "PUT", "PATCH"].includes(method)
+// 							? JSON.stringify({ method })
+// 							: undefined,
+// 					},
+// 				);
+//
+// 				// Echo endpoint only handles POST, others should fall through to 404
+// 				if (method === "POST") {
+// 					expect(response.ok).toBe(true);
+// 					const data = await response.json();
+// 					expect(data).toEqual({ method });
+// 				} else {
+// 					expect(response.status).toBe(404);
+// 				}
+// 			}
+// 		});
+//
+// 		test("should handle binary data", async (c) => {
+// 			const { endpoint } = await setupDriverTest(c, driverTestConfig);
+//
+// 			const actorQuery: ActorQuery = {
+// 				getOrCreateForKey: {
+// 					name: "rawHttpActor",
+// 					key: ["direct-binary-test"],
+// 				},
+// 			};
+//
+// 			// Send binary data
+// 			const binaryData = new Uint8Array([1, 2, 3, 4, 5]);
+// 			const response = await fetch(
+// 				`${endpoint}/registry/actors/raw/http/api/echo`,
+// 				{
+// 					method: "POST",
+// 					headers: {
+// 						[HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
+// 						"Content-Type": "application/octet-stream",
+// 					},
+// 					body: binaryData,
+// 				},
+// 			);
+//
+// 			expect(response.ok).toBe(true);
+// 			const responseBuffer = await response.arrayBuffer();
+// 			const responseArray = new Uint8Array(responseBuffer);
+// 			expect(Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
+// 		});
+// 	});
+// }