rivetkit 2.0.24-rc.1 → 2.0.24

package/src/actor/persisted.ts

@@ -1,49 +0,0 @@
-/** State object that gets automatically persisted to storage. */
-export interface PersistedActor<S, CP, CS, I> {
-	input?: I;
-	hasInitiated: boolean;
-	state: S;
-	connections: PersistedConn<CP, CS>[];
-	scheduledEvents: PersistedScheduleEvent[];
-	hibernatableWebSocket: PersistedHibernatableWebSocket[];
-}
-
-/** Object representing connection that gets persisted to storage. */
-export interface PersistedConn<CP, CS> {
-	connId: string;
-	token: string;
-	params: CP;
-	state: CS;
-	subscriptions: PersistedSubscription[];
-
-	/** Last time the socket was seen. This is set when disconnected so we can determine when we need to clean this up. */
-	lastSeen: number;
-
-	/** Request ID of the hibernatable WebSocket. See PersistedActor.hibernatableWebSocket */
-	hibernatableRequestId?: ArrayBuffer;
-}
-
-export interface PersistedSubscription {
-	eventName: string;
-}
-
-export interface GenericPersistedScheduleEvent {
-	actionName: string;
-	args: ArrayBuffer | null;
-}
-
-export type PersistedScheduleEventKind = {
-	generic: GenericPersistedScheduleEvent;
-};
-
-export interface PersistedScheduleEvent {
-	eventId: string;
-	timestamp: number;
-	kind: PersistedScheduleEventKind;
-}
-
-export interface PersistedHibernatableWebSocket {
-	requestId: ArrayBuffer;
-	lastSeenTimestamp: bigint;
-	msgIndex: bigint;
-}

package/src/actor/unstable-react.ts

@@ -1,110 +0,0 @@
-//// @ts-expect-error we do not have types for this lib
-//import { renderToPipeableStream } from "@jogit/tmp-react-server-dom-nodeless";
-//import getStream from "get-stream";
-//import { isValidElement } from "react";
-//import { Actor } from  "./actor";
-//
-///**
-// * A React Server Components (RSC) actor.
-// *
-// * Supports rendering React elements as action responses.
-// *
-// * @see [Documentation](https://rivet.dev/docs/client/react)
-// * @experimental
-// */
-//export class RscActor<
-//	State = undefined,
-//	ConnParams = undefined,
-//	ConnState = undefined,
-//> extends Actor<State, ConnParams, ConnState> {
-//	/**
-//	 * Updates the RSCs for all connected clients.
-//	 */
-//	public _updateRsc() {
-//		// Broadcast a message to all connected clients, telling them to re-render
-//		this._broadcast("__rsc");
-//	}
-//
-//	/**
-//	 * Overrides default behavior to update the RSCs when the state changes.
-//	 * @private
-//	 * @internal
-//	 */
-//	override _onStateChange() {
-//		this._updateRsc();
-//	}
-//
-//	/**
-//	 * Overrides default behavior to render React elements as RSC response.
-//	 * @private
-//	 * @internal
-//	 */
-//	protected override _onBeforeActionResponse<Out>(
-//		_name: string,
-//		_args: unknown[],
-//		output: Out,
-//	): Out {
-//		if (!isValidElement(output)) {
-//			return super._onBeforeActionResponse(_name, _args, output);
-//		}
-//
-//		// The output is a React element, so we need to transform it into a valid rsc message
-//		const { readable, ...writable } = nodeStreamToWebStream();
-//
-//		const stream = renderToPipeableStream(output);
-//
-//		stream.pipe(writable);
-//
-//		return getStream(readable) as Out;
-//	}
-//}
-//
-//function nodeStreamToWebStream() {
-//	const buffer: Uint8Array[] = [];
-//	let writer: WritableStreamDefaultWriter<Uint8Array> | null = null;
-//
-//	const writable = new WritableStream<Uint8Array>({
-//		write(chunk) {
-//			buffer.push(chunk);
-//		},
-//		close() {},
-//	});
-//
-//	const readable = new ReadableStream<Uint8Array>({
-//		start() {},
-//		async pull(controller) {
-//			if (buffer.length > 0) {
-//				const chunk = buffer.shift(); // Get the next chunk from the buffer
-//				if (chunk) {
-//					controller.enqueue(chunk); // Push it to the readable stream
-//				}
-//			} else {
-//				if (writable.locked) {
-//					await new Promise((resolve) => setTimeout(resolve, 10));
-//					return this.pull?.(controller);
-//				}
-//				return controller.close();
-//			}
-//		},
-//		cancel() {},
-//	});
-//
-//	return {
-//		readable,
-//		on: (str: string, fn: () => void) => {
-//			if (str === "drain") {
-//				writer = writable.getWriter();
-//				fn();
-//			}
-//		},
-//		write(chunk: Uint8Array) {
-//			writer?.write(chunk);
-//		},
-//		flush() {
-//			writer?.close();
-//		},
-//		end() {
-//			writer?.releaseLock();
-//		},
-//	};
-//}

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

@@ -1,170 +0,0 @@
-import { describe, expect, test, vi } from "vitest";
-import type { ActorConnRaw } from "@/client/actor-conn";
-import type { DriverTestConfig } from "../mod";
-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,
-			);
-
-			// Create actor and connect
-			const handle = client.counterConn.getOrCreate(["test-reconnect"]);
-			const connection = handle.connect();
-
-			// Set an initial count on the connection
-			await connection.increment(5);
-
-			// Verify connection count is 1
-			const connCount1 = await connection.getConnectionCount();
-			expect(connCount1).toBe(1);
-
-			// Force disconnect (non-clean) - simulates network failure
-			const connRaw = connection as unknown as ActorConnRaw;
-			await forceUncleanDisconnect(
-				endpoint,
-				connRaw.actorId!,
-				connRaw.connectionId!,
-			);
-
-			// Wait a bit for the disconnection to be processed
-			await vi.waitFor(
-				async () => {
-					const countAfterReconnect = await connection.getCount();
-					expect(countAfterReconnect).toBe(5); // Should preserve the count
-				},
-				{ timeout: 5000, interval: 100 },
-			);
-
-			// Verify connection count is still 1 (same connection reconnected)
-			const connCount2 = await connection.getConnectionCount();
-			expect(connCount2).toBe(1);
-
-			// Verify we can still increment the counter
-			const newCount = await connection.getCount();
-			expect(newCount).toBe(5);
-
-			// Clean up
-			await connection.dispose();
-		});
-
-		test("should not preserve connection state after clean disconnect", async (c) => {
-			const { client } = await setupDriverTest(c, driverTestConfig);
-
-			// Create actor and connect
-			const handle = client.counterConn.getOrCreate([
-				"test-clean-disconnect",
-			]);
-			const connection = handle.connect();
-
-			// Set an initial count on the connection
-			await connection.increment(10);
-
-			// Verify connection count is 1
-			const connCount1 = await connection.getConnectionCount();
-			expect(connCount1).toBe(1);
-
-			// Clean disconnect
-			await connection.dispose();
-
-			// Wait a bit to ensure disconnection is processed
-			await vi.waitFor(
-				async () => {
-					// Check that connection count is now 0
-					const handle2 = client.counterConn.get([
-						"test-clean-disconnect",
-					]);
-					const connCount = await handle2.getConnectionCount();
-					// This counts the current action caller
-					expect(connCount).toBe(1);
-				},
-				{ timeout: 5000 },
-			);
-
-			// Create a new connection
-			const connection2 = handle.connect();
-
-			// The count should be reset since it's a new connection
-			const countNewConnection = await connection2.getCount();
-			expect(countNewConnection).toBe(0); // Should be reset
-
-			// Verify connection count is 1 again (new connection)
-			const connCount3 = await connection2.getConnectionCount();
-			expect(connCount3).toBe(1);
-
-			// Clean up
-			await connection2.dispose();
-		});
-
-		test("should handle multiple non-clean disconnects and reconnects", async (c) => {
-			const { client, endpoint } = await setupDriverTest(
-				c,
-				driverTestConfig,
-			);
-
-			// Create actor and connect
-			const handle = client.counterConn.getOrCreate([
-				"test-multiple-reconnect",
-			]);
-			const connection = handle.connect();
-
-			// Set an initial count
-			await connection.setCount(100);
-
-			// Perform multiple disconnect-reconnect cycles
-			for (let i = 0; i < 3; i++) {
-				// Increment before disconnect
-				await connection.increment(1);
-
-				// Force disconnect
-				const connRaw = connection as unknown as ActorConnRaw;
-				await forceUncleanDisconnect(
-					endpoint,
-					connRaw.actorId!,
-					connRaw.connectionId!,
-				);
-
-				// Wait for reconnection and verify state is preserved
-				await vi.waitFor(
-					async () => {
-						const countAfter = await connection.getCount();
-						expect(countAfter).toBe(101 + i);
-					},
-					{ timeout: 5000 },
-				);
-
-				// Verify connection count remains 1
-				const connCount = await connection.getConnectionCount();
-				expect(connCount).toBe(1);
-			}
-
-			// Final verification
-			const finalCount = await connection.getCount();
-			expect(finalCount).toBe(103);
-
-			// Clean up
-			await connection.dispose();
-		});
-	});
-}
-
-async function forceUncleanDisconnect(
-	endpoint: string,
-	actorId: string,
-	connId: string,
-): Promise<void> {
-	const response = await fetch(
-		`${endpoint}/.test/force-disconnect?actor=${actorId}&conn=${connId}`,
-		{
-			method: "POST",
-		},
-	);
-
-	if (!response.ok) {
-		const text = await response.text();
-		throw new Error(`Failed to force disconnect: ${text}`);
-	}
-}

package/src/drivers/engine/kv.ts

@@ -1,3 +0,0 @@
-export const KEYS = {
-	PERSIST_DATA: Uint8Array.from([1]),
-};