rivetkit 2.0.19 → 2.0.21

package/src/driver-test-suite/tests/action-features.ts

@@ -38,7 +38,9 @@ export function runActionFeaturesTests(driverTestConfig: DriverTestConfig) {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Synchronous action should not be affected by timeout
-				const result = await client.syncTimeoutActor.getOrCreate().syncAction();
+				const result = await client.syncTimeoutActor
+					.getOrCreate()
+					.syncAction();
 				expect(result).toBe("sync response");
 			});
 
@@ -105,7 +107,9 @@ export function runActionFeaturesTests(driverTestConfig: DriverTestConfig) {
 					await instance.asyncWithError(true);
 					expect.fail("did not error");
 				} catch (error) {
-					expect((error as ActorError).message).toBe("Intentional error");
+					expect((error as ActorError).message).toBe(
+						"Intentional error",
+					);
 				}
 			});
 

package/src/driver-test-suite/tests/actor-conn-state.ts

@@ -9,7 +9,9 @@ export function runActorConnStateTests(driverTestConfig: DriverTestConfig) {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Connect to the actor
-				const connection = client.connStateActor.getOrCreate().connect();
+				const connection = client.connStateActor
+					.getOrCreate()
+					.connect();
 
 				// Get the connection state
 				const connState = await connection.getConnectionState();
@@ -151,9 +153,12 @@ export function runActorConnStateTests(driverTestConfig: DriverTestConfig) {
 			)("should track connection and disconnection events", async (c) => {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
-				const debugHandle = client.connStateActor.getOrCreate(undefined, {
-					params: { noCount: true },
-				});
+				const debugHandle = client.connStateActor.getOrCreate(
+					undefined,
+					{
+						params: { noCount: true },
+					},
+				);
 
 				// Create a connection
 				const conn = client.connStateActor.getOrCreate().connect();
@@ -169,7 +174,8 @@ export function runActorConnStateTests(driverTestConfig: DriverTestConfig) {
 
 				// Initial disconnection count
 				await vi.waitFor(async () => {
-					const disconnects = await debugHandle.getDisconnectionCount();
+					const disconnects =
+						await debugHandle.getDisconnectionCount();
 					expect(disconnects).toBe(0);
 				});
 
@@ -180,7 +186,8 @@ export function runActorConnStateTests(driverTestConfig: DriverTestConfig) {
 				await vi.waitFor(
 					async () => {
 						console.log("disconnects before");
-						const disconnects = await debugHandle.getDisconnectionCount();
+						const disconnects =
+							await debugHandle.getDisconnectionCount();
 						console.log("disconnects", disconnects);
 						expect(disconnects).toBe(1);
 					},
@@ -208,7 +215,8 @@ export function runActorConnStateTests(driverTestConfig: DriverTestConfig) {
 				await vi.waitFor(
 					async () => {
 						console.log("A");
-						const disconnects = await debugHandle.getDisconnectionCount();
+						const disconnects =
+							await debugHandle.getDisconnectionCount();
 						console.log(`B ${disconnects}`);
 						expect(disconnects).toBe(2);
 					},
@@ -281,7 +289,9 @@ export function runActorConnStateTests(driverTestConfig: DriverTestConfig) {
 					// Verify message was received
 					expect(receivedMessages.length).toBe(1);
 					expect(receivedMessages[0].from).toBe(state1.id);
-					expect(receivedMessages[0].message).toBe("Hello from conn1");
+					expect(receivedMessages[0].message).toBe(
+						"Hello from conn1",
+					);
 				});
 
 				// Clean up

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

@@ -48,7 +48,9 @@ export function runActorConnTests(driverTestConfig: DriverTestConfig) {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Get or create actor and connect
-				const handle = client.counter.getOrCreate(["test-get-or-create"]);
+				const handle = client.counter.getOrCreate([
+					"test-get-or-create",
+				]);
 				const connection = handle.connect();
 
 				// Verify connection works
@@ -80,7 +82,9 @@ export function runActorConnTests(driverTestConfig: DriverTestConfig) {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Create actor
-				const handle = client.counter.getOrCreate(["test-mixed-rpc-ws"]);
+				const handle = client.counter.getOrCreate([
+					"test-mixed-rpc-ws",
+				]);
 				const connection = handle.connect();
 
 				// Set up event listener
@@ -176,9 +180,12 @@ export function runActorConnTests(driverTestConfig: DriverTestConfig) {
 
 				// Set up event listener with unsubscribe
 				const receivedEvents: number[] = [];
-				const unsubscribe = connection.on("newCount", (count: number) => {
-					receivedEvents.push(count);
-				});
+				const unsubscribe = connection.on(
+					"newCount",
+					(count: number) => {
+						receivedEvents.push(count);
+					},
+				);
 
 				// TODO: SSE has race condition with subscriptions & publishing messages
 				// Trigger first event
@@ -206,12 +213,18 @@ export function runActorConnTests(driverTestConfig: DriverTestConfig) {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Create two connections with different params
-				const handle1 = client.counterWithParams.getOrCreate(["test-params"], {
-					params: { name: "user1" },
-				});
-				const handle2 = client.counterWithParams.getOrCreate(["test-params"], {
-					params: { name: "user2" },
-				});
+				const handle1 = client.counterWithParams.getOrCreate(
+					["test-params"],
+					{
+						params: { name: "user1" },
+					},
+				);
+				const handle2 = client.counterWithParams.getOrCreate(
+					["test-params"],
+					{
+						params: { name: "user2" },
+					},
+				);
 
 				const conn1 = handle1.connect();
 				const conn2 = handle2.connect();
@@ -251,7 +264,11 @@ export function runActorConnTests(driverTestConfig: DriverTestConfig) {
 
 				// Verify lifecycle events were triggered
 				const events = await connection.getEvents();
-				expect(events).toEqual(["onStart", "onBeforeConnect", "onConnect"]);
+				expect(events).toEqual([
+					"onStart",
+					"onBeforeConnect",
+					"onConnect",
+				]);
 
 				// Disconnect should trigger onDisconnect
 				await connection.dispose();
@@ -265,7 +282,12 @@ export function runActorConnTests(driverTestConfig: DriverTestConfig) {
 						const finalEvents = await handle.getEvents();
 						expect(finalEvents).toBeOneOf([
 							// Still active
-							["onStart", "onBeforeConnect", "onConnect", "onDisconnect"],
+							[
+								"onStart",
+								"onBeforeConnect",
+								"onConnect",
+								"onDisconnect",
+							],
 							// Went to sleep and woke back up
 							[
 								"onStart",

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

@@ -27,7 +27,9 @@ export function runActorHandleTests(driverTestConfig: DriverTestConfig) {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Create a actor first to get its ID
-				const handle = client.counter.getOrCreate(["test-get-for-id-handle"]);
+				const handle = client.counter.getOrCreate([
+					"test-get-for-id-handle",
+				]);
 				await handle.increment(3);
 				const actorId = await handle.resolve();
 
@@ -66,7 +68,9 @@ export function runActorHandleTests(driverTestConfig: DriverTestConfig) {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Create actor and get handle
-				const handle = await client.counter.create(["test-create-handle"]);
+				const handle = await client.counter.create([
+					"test-create-handle",
+				]);
 
 				// Verify Action works
 				const count = await handle.increment(9);
@@ -101,7 +105,9 @@ export function runActorHandleTests(driverTestConfig: DriverTestConfig) {
 
 				try {
 					await client.counter.get([missingId]).resolve();
-					expect.fail("did not error for get().resolve() on missing actor");
+					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");
@@ -113,7 +119,9 @@ export function runActorHandleTests(driverTestConfig: DriverTestConfig) {
 			test("should call actions directly on the handle", async (c) => {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
-				const handle = client.counter.getOrCreate(["test-action-handle"]);
+				const handle = client.counter.getOrCreate([
+					"test-action-handle",
+				]);
 
 				// Call multiple actions in sequence
 				const count1 = await handle.increment(3);
@@ -130,7 +138,9 @@ export function runActorHandleTests(driverTestConfig: DriverTestConfig) {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Create two handles to the same actor
-				const handle1 = client.counter.getOrCreate(["test-multiple-handles"]);
+				const handle1 = client.counter.getOrCreate([
+					"test-multiple-handles",
+				]);
 				const handle2 = client.counter.get(["test-multiple-handles"]);
 
 				// Call actions on both handles
@@ -228,13 +238,15 @@ export function runActorHandleTests(driverTestConfig: DriverTestConfig) {
 
 				// Each should have count 1
 				expect(
-					eventsAfterAction.filter((e) => e === "onBeforeConnect").length,
+					eventsAfterAction.filter((e) => e === "onBeforeConnect")
+						.length,
+				).toBe(1);
+				expect(
+					eventsAfterAction.filter((e) => e === "onConnect").length,
 				).toBe(1);
-				expect(eventsAfterAction.filter((e) => e === "onConnect").length).toBe(
-					1,
-				);
 				expect(
-					eventsAfterAction.filter((e) => e === "onDisconnect").length,
+					eventsAfterAction.filter((e) => e === "onDisconnect")
+						.length,
 				).toBe(1);
 
 				// Make another Action call
@@ -245,13 +257,17 @@ export function runActorHandleTests(driverTestConfig: DriverTestConfig) {
 
 				// Each hook should now have count 2
 				expect(
-					eventsAfterSecondAction.filter((e) => e === "onBeforeConnect").length,
+					eventsAfterSecondAction.filter(
+						(e) => e === "onBeforeConnect",
+					).length,
 				).toBe(2);
 				expect(
-					eventsAfterSecondAction.filter((e) => e === "onConnect").length,
+					eventsAfterSecondAction.filter((e) => e === "onConnect")
+						.length,
 				).toBe(2);
 				expect(
-					eventsAfterSecondAction.filter((e) => e === "onDisconnect").length,
+					eventsAfterSecondAction.filter((e) => e === "onDisconnect")
+						.length,
 				).toBe(2);
 			});
 
@@ -283,9 +299,13 @@ export function runActorHandleTests(driverTestConfig: DriverTestConfig) {
 
 				// Should have 1 onStart, 2 each of onBeforeConnect, onConnect, and onDisconnect
 				expect(events.filter((e) => e === "onStart").length).toBe(1);
-				expect(events.filter((e) => e === "onBeforeConnect").length).toBe(2);
+				expect(
+					events.filter((e) => e === "onBeforeConnect").length,
+				).toBe(2);
 				expect(events.filter((e) => e === "onConnect").length).toBe(2);
-				expect(events.filter((e) => e === "onDisconnect").length).toBe(2);
+				expect(events.filter((e) => e === "onDisconnect").length).toBe(
+					2,
+				);
 			});
 		});
 	});

package/src/driver-test-suite/tests/actor-inline-client.ts

@@ -9,9 +9,9 @@ export function runActorInlineClientTests(driverTestConfig: DriverTestConfig) {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Create the inline client actor
-				const inlineClientHandle = client.inlineClientActor.getOrCreate([
-					"inline-client-test",
-				]);
+				const inlineClientHandle = client.inlineClientActor.getOrCreate(
+					["inline-client-test"],
+				);
 
 				// Test calling counter.increment via inline client
 				const result = await inlineClientHandle.callCounterIncrement(5);
@@ -24,7 +24,9 @@ export function runActorInlineClientTests(driverTestConfig: DriverTestConfig) {
 				// Check that messages were logged
 				const messages = await inlineClientHandle.getMessages();
 				expect(messages).toHaveLength(2);
-				expect(messages[0]).toContain("Called counter.increment(5), result: 5");
+				expect(messages[0]).toContain(
+					"Called counter.increment(5), result: 5",
+				);
 				expect(messages[1]).toContain("Got counter state: 5");
 			});
 
@@ -32,16 +34,18 @@ export function runActorInlineClientTests(driverTestConfig: DriverTestConfig) {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Create the inline client actor
-				const inlineClientHandle = client.inlineClientActor.getOrCreate([
-					"inline-client-multi",
-				]);
+				const inlineClientHandle = client.inlineClientActor.getOrCreate(
+					["inline-client-multi"],
+				);
 
 				// Clear any existing messages
 				await inlineClientHandle.clearMessages();
 
 				// Make multiple calls
-				const result1 = await inlineClientHandle.callCounterIncrement(3);
-				const result2 = await inlineClientHandle.callCounterIncrement(7);
+				const result1 =
+					await inlineClientHandle.callCounterIncrement(3);
+				const result2 =
+					await inlineClientHandle.callCounterIncrement(7);
 				const finalState = await inlineClientHandle.getCounterState();
 
 				expect(result1).toBe(3);
@@ -51,7 +55,9 @@ export function runActorInlineClientTests(driverTestConfig: DriverTestConfig) {
 				// Check messages
 				const messages = await inlineClientHandle.getMessages();
 				expect(messages).toHaveLength(3);
-				expect(messages[0]).toContain("Called counter.increment(3), result: 3");
+				expect(messages[0]).toContain(
+					"Called counter.increment(3), result: 3",
+				);
 				expect(messages[1]).toContain(
 					"Called counter.increment(7), result: 10",
 				);
@@ -64,15 +70,16 @@ export function runActorInlineClientTests(driverTestConfig: DriverTestConfig) {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Create the inline client actor
-				const inlineClientHandle = client.inlineClientActor.getOrCreate([
-					"inline-client-stateful",
-				]);
+				const inlineClientHandle = client.inlineClientActor.getOrCreate(
+					["inline-client-stateful"],
+				);
 
 				// Clear any existing messages
 				await inlineClientHandle.clearMessages();
 
 				// Test stateful connection with events
-				const result = await inlineClientHandle.connectToCounterAndIncrement(4);
+				const result =
+					await inlineClientHandle.connectToCounterAndIncrement(4);
 
 				expect(result.result1).toBe(4);
 				expect(result.result2).toBe(12); // 4 + 8
@@ -92,15 +99,16 @@ export function runActorInlineClientTests(driverTestConfig: DriverTestConfig) {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Create the inline client actor
-				const inlineClientHandle = client.inlineClientActor.getOrCreate([
-					"inline-client-independent",
-				]);
+				const inlineClientHandle = client.inlineClientActor.getOrCreate(
+					["inline-client-independent"],
+				);
 
 				// Clear any existing messages
 				await inlineClientHandle.clearMessages();
 
 				// Test with different increment values
-				const result = await inlineClientHandle.connectToCounterAndIncrement(2);
+				const result =
+					await inlineClientHandle.connectToCounterAndIncrement(2);
 
 				expect(result.result1).toBe(2);
 				expect(result.result2).toBe(6); // 2 + 4
@@ -120,16 +128,17 @@ export function runActorInlineClientTests(driverTestConfig: DriverTestConfig) {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Create the inline client actor
-				const inlineClientHandle = client.inlineClientActor.getOrCreate([
-					"inline-client-mixed",
-				]);
+				const inlineClientHandle = client.inlineClientActor.getOrCreate(
+					["inline-client-mixed"],
+				);
 
 				// Clear any existing messages
 				await inlineClientHandle.clearMessages();
 
 				// Start with stateless calls
 				await inlineClientHandle.callCounterIncrement(1);
-				const statelessResult = await inlineClientHandle.getCounterState();
+				const statelessResult =
+					await inlineClientHandle.getCounterState();
 				expect(statelessResult).toBe(1);
 
 				// Then do stateful call
@@ -141,7 +150,9 @@ export function runActorInlineClientTests(driverTestConfig: DriverTestConfig) {
 				// Check all messages were logged
 				const messages = await inlineClientHandle.getMessages();
 				expect(messages).toHaveLength(3);
-				expect(messages[0]).toContain("Called counter.increment(1), result: 1");
+				expect(messages[0]).toContain(
+					"Called counter.increment(1), result: 1",
+				);
 				expect(messages[1]).toContain("Got counter state: 1");
 				expect(messages[2]).toContain(
 					"Connected to counter, incremented by 3 and 6",