rivetkit 2.0.19 → 2.0.21

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

@@ -15,11 +15,14 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			test("should respond to ping", async (c) => {
 				const { endpoint } = await setupDriverTest(c, driverTestConfig);
 
-				const http = createManagerInspectorClient(`${endpoint}/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
+				const http = createManagerInspectorClient(
+					`${endpoint}/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+						},
 					},
-				});
+				);
 
 				const response = await http.ping.$get();
 				expect(response.status).toBe(200);
@@ -29,17 +32,23 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			});
 
 			test("should get actors with pagination", async (c) => {
-				const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+				const { client, endpoint } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
 
 				// Create some actors first
 				await client.counter.create(["test-actor-1"]);
 				await client.counter.create(["test-actor-2"]);
 
-				const http = createManagerInspectorClient(`${endpoint}/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
+				const http = createManagerInspectorClient(
+					`${endpoint}/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+						},
 					},
-				});
+				);
 
 				const response = await http.actors.$get({
 					query: { limit: "1" },
@@ -56,7 +65,10 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			});
 
 			test("should get all actors with pagination", async (c) => {
-				const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+				const { client, endpoint } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
 
 				const actorKey1 = ["test-cursor-1"];
 				const actorKey2 = ["test-cursor-2"];
@@ -65,11 +77,14 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 				await client.counter.create(actorKey1);
 				await client.counter.create(actorKey2);
 
-				const http = createManagerInspectorClient(`${endpoint}/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
+				const http = createManagerInspectorClient(
+					`${endpoint}/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+						},
 					},
-				});
+				);
 
 				const response = await http.actors.$get({
 					query: { limit: "5" },
@@ -94,11 +109,14 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			test("should handle invalid limit parameter", async (c) => {
 				const { endpoint } = await setupDriverTest(c, driverTestConfig);
 
-				const http = createManagerInspectorClient(`${endpoint}/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
+				const http = createManagerInspectorClient(
+					`${endpoint}/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+						},
 					},
-				});
+				);
 
 				const response = await http.actors.$get({
 					query: { limit: "0" },
@@ -109,11 +127,14 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			test("should create a new actor", async (c) => {
 				const { endpoint } = await setupDriverTest(c, driverTestConfig);
 
-				const http = createManagerInspectorClient(`${endpoint}/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
+				const http = createManagerInspectorClient(
+					`${endpoint}/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+						},
 					},
-				});
+				);
 
 				const response = await http.actors.$post({
 					json: {
@@ -137,11 +158,14 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			test("should get builds", async (c) => {
 				const { endpoint } = await setupDriverTest(c, driverTestConfig);
 
-				const http = createManagerInspectorClient(`${endpoint}/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
+				const http = createManagerInspectorClient(
+					`${endpoint}/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+						},
 					},
-				});
+				);
 
 				const response = await http.builds.$get();
 				expect(response.status).toBe(200);
@@ -155,17 +179,23 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			});
 
 			test("should get actor by id", async (c) => {
-				const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+				const { client, endpoint } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
 
 				// Create an actor and get its ID
 				const handle = await client.counter.create(["test-get-by-id"]);
 				const actorId = await handle.resolve();
 
-				const http = createManagerInspectorClient(`${endpoint}/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
+				const http = createManagerInspectorClient(
+					`${endpoint}/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+						},
 					},
-				});
+				);
 
 				const response = await http.actor[":id"].$get({
 					param: { id: actorId },
@@ -179,11 +209,14 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			test("should return 404 for non-existent actor", async (c) => {
 				const { endpoint } = await setupDriverTest(c, driverTestConfig);
 
-				const http = createManagerInspectorClient(`${endpoint}/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
+				const http = createManagerInspectorClient(
+					`${endpoint}/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+						},
 					},
-				});
+				);
 
 				const response = await http.actor[":id"].$get({
 					param: { id: "non-existent-id" },
@@ -195,18 +228,24 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			});
 
 			test("should get bootstrap data", async (c) => {
-				const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+				const { client, endpoint } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
 
 				// Create at least one actor to ensure bootstrap has data
 				// Create an actor and get its ID
 				const handle = await client.counter.create(["test-bootstrap"]);
 				await handle.resolve();
 
-				const http = createManagerInspectorClient(`${endpoint}/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
+				const http = createManagerInspectorClient(
+					`${endpoint}/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+						},
 					},
-				});
+				);
 
 				const response = await http.bootstrap.$get();
 				expect(response.status).toBe(200);
@@ -229,32 +268,41 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 
 				const actorId = "non-existing";
 
-				const http = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
-						[HEADER_ACTOR_QUERY]: JSON.stringify({
-							getForId: { name: "counter", actorId },
-						} satisfies ActorQuery),
+				const http = createActorInspectorClient(
+					`${endpoint}/actors/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+							[HEADER_ACTOR_QUERY]: JSON.stringify({
+								getForId: { name: "counter", actorId },
+							} satisfies ActorQuery),
+						},
 					},
-				});
+				);
 
 				const response = await http.ping.$get();
 				expect(response.ok).toBe(false);
 			});
 			test("should respond to ping", async (c) => {
-				const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+				const { client, endpoint } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
 
 				const handle = await client.counter.create(["test-ping"]);
 				const actorId = await handle.resolve();
 
-				const http = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
-						[HEADER_ACTOR_QUERY]: JSON.stringify({
-							getForId: { name: "counter", actorId },
-						} satisfies ActorQuery),
+				const http = createActorInspectorClient(
+					`${endpoint}/actors/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+							[HEADER_ACTOR_QUERY]: JSON.stringify({
+								getForId: { name: "counter", actorId },
+							} satisfies ActorQuery),
+						},
 					},
-				});
+				);
 
 				const response = await http.ping.$get();
 				expect(response.status).toBe(200);
@@ -264,7 +312,10 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			});
 
 			test("should get actor state", async (c) => {
-				const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+				const { client, endpoint } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
 
 				const handle = await client.counter.create(["test-state"]);
 				const actorId = await handle.resolve();
@@ -272,14 +323,17 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 				// Increment the counter to set some state
 				await handle.increment(5);
 
-				const http = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
-						[HEADER_ACTOR_QUERY]: JSON.stringify({
-							getForId: { name: "counter", actorId },
-						} satisfies ActorQuery),
+				const http = createActorInspectorClient(
+					`${endpoint}/actors/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+							[HEADER_ACTOR_QUERY]: JSON.stringify({
+								getForId: { name: "counter", actorId },
+							} satisfies ActorQuery),
+						},
 					},
-				});
+				);
 
 				const response = await http.state.$get();
 				expect(response.status).toBe(200);
@@ -294,19 +348,27 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			});
 
 			test("should update actor state with replace", async (c) => {
-				const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+				const { client, endpoint } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
 
-				const handle = await client.counter.create(["test-state-replace"]);
+				const handle = await client.counter.create([
+					"test-state-replace",
+				]);
 				const actorId = await handle.resolve();
 
-				const http = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
-						[HEADER_ACTOR_QUERY]: JSON.stringify({
-							getForId: { name: "counter", actorId },
-						} satisfies ActorQuery),
+				const http = createActorInspectorClient(
+					`${endpoint}/actors/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+							[HEADER_ACTOR_QUERY]: JSON.stringify({
+								getForId: { name: "counter", actorId },
+							} satisfies ActorQuery),
+						},
 					},
-				});
+				);
 
 				// Replace the entire state
 				const response = await http.state.$patch({
@@ -324,22 +386,30 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			});
 
 			test("should update actor state with patch", async (c) => {
-				const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+				const { client, endpoint } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
 
-				const handle = await client.counter.create(["test-state-patch"]);
+				const handle = await client.counter.create([
+					"test-state-patch",
+				]);
 				const actorId = await handle.resolve();
 
 				// Set initial state
 				await handle.increment(3);
 
-				const http = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
-						[HEADER_ACTOR_QUERY]: JSON.stringify({
-							getForId: { name: "counter", actorId },
-						} satisfies ActorQuery),
+				const http = createActorInspectorClient(
+					`${endpoint}/actors/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+							[HEADER_ACTOR_QUERY]: JSON.stringify({
+								getForId: { name: "counter", actorId },
+							} satisfies ActorQuery),
+						},
 					},
-				});
+				);
 
 				// Patch the state
 				const response = await http.state.$patch({
@@ -365,21 +435,29 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			});
 
 			test("should get actor connections", async (c) => {
-				const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+				const { client, endpoint } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
 
-				const handle = await client.counter.create(["test-connections"]);
+				const handle = await client.counter.create([
+					"test-connections",
+				]);
 				const actorId = await handle.resolve();
 				handle.connect();
 				await handle.increment(10);
 
-				const http = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
-						[HEADER_ACTOR_QUERY]: JSON.stringify({
-							getForId: { name: "counter", actorId },
-						} satisfies ActorQuery),
+				const http = createActorInspectorClient(
+					`${endpoint}/actors/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+							[HEADER_ACTOR_QUERY]: JSON.stringify({
+								getForId: { name: "counter", actorId },
+							} satisfies ActorQuery),
+						},
 					},
-				});
+				);
 
 				const response = await http.connections.$get();
 				expect(response.status).toBe(200);
@@ -395,7 +473,10 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			});
 
 			test("should get actor events", async (c) => {
-				const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+				const { client, endpoint } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
 
 				const handle = await client.counter.create(["test-events"]);
 				const actorId = await handle.resolve();
@@ -403,14 +484,17 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 				handle.connect();
 				await handle.increment(10);
 
-				const http = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
-						[HEADER_ACTOR_QUERY]: JSON.stringify({
-							getForId: { name: "counter", actorId },
-						} satisfies ActorQuery),
+				const http = createActorInspectorClient(
+					`${endpoint}/actors/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+							[HEADER_ACTOR_QUERY]: JSON.stringify({
+								getForId: { name: "counter", actorId },
+							} satisfies ActorQuery),
+						},
 					},
-				});
+				);
 
 				const response = await http.events.$get();
 				expect(response.status).toBe(200);
@@ -427,22 +511,30 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			});
 
 			test("should clear actor events", async (c) => {
-				const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+				const { client, endpoint } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
 
-				const handle = await client.counter.create(["test-events-clear"]);
+				const handle = await client.counter.create([
+					"test-events-clear",
+				]);
 				const actorId = await handle.resolve();
 
 				handle.connect();
 				await handle.increment(10);
 
-				const http = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
-						[HEADER_ACTOR_QUERY]: JSON.stringify({
-							getForId: { name: "counter", actorId },
-						} satisfies ActorQuery),
+				const http = createActorInspectorClient(
+					`${endpoint}/actors/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+							[HEADER_ACTOR_QUERY]: JSON.stringify({
+								getForId: { name: "counter", actorId },
+							} satisfies ActorQuery),
+						},
 					},
-				});
+				);
 
 				{
 					const response = await http.events.$get();
@@ -464,19 +556,25 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			});
 
 			test("should get actor rpcs", async (c) => {
-				const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+				const { client, endpoint } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
 
 				const handle = await client.counter.create(["test-rpcs"]);
 				const actorId = await handle.resolve();
 
-				const http = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
-						[HEADER_ACTOR_QUERY]: JSON.stringify({
-							getForId: { name: "counter", actorId },
-						} satisfies ActorQuery),
+				const http = createActorInspectorClient(
+					`${endpoint}/actors/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+							[HEADER_ACTOR_QUERY]: JSON.stringify({
+								getForId: { name: "counter", actorId },
+							} satisfies ActorQuery),
+						},
 					},
-				});
+				);
 
 				const response = await http.rpcs.$get();
 				expect(response.status).toBe(200);
@@ -491,19 +589,25 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 
 			// database is not officially supported yet
 			test.skip("should get actor database info", async (c) => {
-				const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+				const { client, endpoint } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
 
 				const handle = await client.counter.create(["test-db"]);
 				const actorId = await handle.resolve();
 
-				const http = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
-						[HEADER_ACTOR_QUERY]: JSON.stringify({
-							getForId: { name: "counter", actorId },
-						} satisfies ActorQuery),
+				const http = createActorInspectorClient(
+					`${endpoint}/actors/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+							[HEADER_ACTOR_QUERY]: JSON.stringify({
+								getForId: { name: "counter", actorId },
+							} satisfies ActorQuery),
+						},
 					},
-				});
+				);
 
 				const response = await http.db.$get();
 				expect(response.status).toBe(200);
@@ -522,19 +626,25 @@ export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
 			});
 
 			test.skip("should execute database query when database is enabled", async (c) => {
-				const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+				const { client, endpoint } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
 
 				const handle = await client.counter.create(["test-db-query"]);
 				const actorId = await handle.resolve();
 
-				const http = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-					headers: {
-						Authorization: `Bearer token`,
-						[HEADER_ACTOR_QUERY]: JSON.stringify({
-							getForId: { name: "counter", actorId },
-						} satisfies ActorQuery),
+				const http = createActorInspectorClient(
+					`${endpoint}/actors/inspect`,
+					{
+						headers: {
+							Authorization: `Bearer token`,
+							[HEADER_ACTOR_QUERY]: JSON.stringify({
+								getForId: { name: "counter", actorId },
+							} satisfies ActorQuery),
+						},
 					},
-				});
+				);
 
 				// First check if database is enabled
 				const dbInfoResponse = await http.db.$get();

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

@@ -6,7 +6,10 @@ import { setupDriverTest } from "../utils";
 export function runActorReconnectTests(driverTestConfig: DriverTestConfig) {
 	describe("Actor Reconnection Tests", () => {
 		test("should reconnect and preserve connection state after non-clean disconnect", async (c) => {
-			const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+			const { client, endpoint } = await setupDriverTest(
+				c,
+				driverTestConfig,
+			);
 
 			// Create actor and connect
 			const handle = client.counterConn.getOrCreate(["test-reconnect"]);
@@ -52,7 +55,9 @@ export function runActorReconnectTests(driverTestConfig: DriverTestConfig) {
 			const { client } = await setupDriverTest(c, driverTestConfig);
 
 			// Create actor and connect
-			const handle = client.counterConn.getOrCreate(["test-clean-disconnect"]);
+			const handle = client.counterConn.getOrCreate([
+				"test-clean-disconnect",
+			]);
 			const connection = handle.connect();
 
 			// Set an initial count on the connection
@@ -69,7 +74,9 @@ export function runActorReconnectTests(driverTestConfig: DriverTestConfig) {
 			await vi.waitFor(
 				async () => {
 					// Check that connection count is now 0
-					const handle2 = client.counterConn.get(["test-clean-disconnect"]);
+					const handle2 = client.counterConn.get([
+						"test-clean-disconnect",
+					]);
 					const connCount = await handle2.getConnectionCount();
 					// This counts the current action caller
 					expect(connCount).toBe(1);
@@ -93,7 +100,10 @@ export function runActorReconnectTests(driverTestConfig: DriverTestConfig) {
 		});
 
 		test("should handle multiple non-clean disconnects and reconnects", async (c) => {
-			const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+			const { client, endpoint } = await setupDriverTest(
+				c,
+				driverTestConfig,
+			);
 
 			// Create actor and connect
 			const handle = client.counterConn.getOrCreate([

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

@@ -10,7 +10,10 @@ export function runActorScheduleTests(driverTestConfig: DriverTestConfig) {
 
 			describe("Scheduled Alarms", () => {
 				test("executes c.schedule.at() with specific timestamp", async (c) => {
-					const { client } = await setupDriverTest(c, driverTestConfig);
+					const { client } = await setupDriverTest(
+						c,
+						driverTestConfig,
+					);
 
 					// Create instance
 					const scheduled = client.scheduled.getOrCreate();
@@ -31,7 +34,10 @@ export function runActorScheduleTests(driverTestConfig: DriverTestConfig) {
 				});
 
 				test("executes c.schedule.after() with delay", async (c) => {
-					const { client } = await setupDriverTest(c, driverTestConfig);
+					const { client } = await setupDriverTest(
+						c,
+						driverTestConfig,
+					);
 
 					// Create instance
 					const scheduled = client.scheduled.getOrCreate();
@@ -51,7 +57,10 @@ export function runActorScheduleTests(driverTestConfig: DriverTestConfig) {
 				});
 
 				test("multiple scheduled tasks execute in order", async (c) => {
-					const { client } = await setupDriverTest(c, driverTestConfig);
+					const { client } = await setupDriverTest(
+						c,
+						driverTestConfig,
+					);
 
 					// Create instance
 					const scheduled = client.scheduled.getOrCreate();