rivetkit 2.0.27 → 2.0.29-rc.1

package/src/schemas/actor-persist/versioned.ts

@@ -1,66 +1,138 @@
-import {
-	createVersionedDataHandler,
-	type MigrationFn,
-} from "@/common/versioned-data";
-import type * as v1 from "../../../dist/schemas/actor-persist/v1";
-import type * as v2 from "../../../dist/schemas/actor-persist/v2";
+import { createVersionedDataHandler } from "vbare";
+import * as v1 from "../../../dist/schemas/actor-persist/v1";
+import * as v2 from "../../../dist/schemas/actor-persist/v2";
 import * as v3 from "../../../dist/schemas/actor-persist/v3";
 
 export const CURRENT_VERSION = 3;
 
-const migrations = new Map<number, MigrationFn<any, any>>([
-	[
-		1,
-		(v1Data: v1.PersistedActor): v2.PersistedActor => ({
-			...v1Data,
-			connections: v1Data.connections.map((conn) => ({
-				...conn,
-				hibernatableRequestId: null,
-			})),
-			hibernatableWebSockets: [],
-		}),
-	],
-	[
-		2,
-		(v2Data: v2.PersistedActor): v3.Actor => {
-			// Transform scheduled events from nested structure to flat structure
-			const scheduledEvents: v3.ScheduleEvent[] =
-				v2Data.scheduledEvents.map((event) => {
-					// Extract action and args from the kind wrapper
-					if (event.kind.tag === "GenericPersistedScheduleEvent") {
-						return {
-							eventId: event.eventId,
-							timestamp: event.timestamp,
-							action: event.kind.val.action,
-							args: event.kind.val.args,
-						};
-					}
-					// Fallback for unknown kinds
-					throw new Error(
-						`Unknown schedule event kind: ${event.kind.tag}`,
-					);
-				});
+// Converter from v1 to v2
+const v1ToV2 = (v1Data: v1.PersistedActor): v2.PersistedActor => ({
+	...v1Data,
+	connections: v1Data.connections.map((conn) => ({
+		...conn,
+		hibernatableRequestId: null,
+	})),
+	hibernatableWebSockets: [],
+});
 
-			return {
-				input: v2Data.input,
-				hasInitialized: v2Data.hasInitialized,
-				state: v2Data.state,
-				scheduledEvents,
-			};
+// Converter from v2 to v3
+const v2ToV3 = (v2Data: v2.PersistedActor): v3.Actor => {
+	// Transform scheduled events from nested structure to flat structure
+	const scheduledEvents: v3.ScheduleEvent[] = v2Data.scheduledEvents.map(
+		(event) => {
+			// Extract action and args from the kind wrapper
+			if (event.kind.tag === "GenericPersistedScheduleEvent") {
+				return {
+					eventId: event.eventId,
+					timestamp: event.timestamp,
+					action: event.kind.val.action,
+					args: event.kind.val.args,
+				};
+			}
+			// Fallback for unknown kinds
+			throw new Error(`Unknown schedule event kind: ${event.kind.tag}`);
 		},
-	],
-]);
+	);
+
+	return {
+		input: v2Data.input,
+		hasInitialized: v2Data.hasInitialized,
+		state: v2Data.state,
+		scheduledEvents,
+	};
+};
+
+// Converter from v3 to v2
+const v3ToV2 = (v3Data: v3.Actor): v2.PersistedActor => {
+	// Transform scheduled events from flat structure back to nested structure
+	const scheduledEvents: v2.PersistedScheduleEvent[] = v3Data.scheduledEvents.map(
+		(event) => ({
+			eventId: event.eventId,
+			timestamp: event.timestamp,
+			kind: {
+				tag: "GenericPersistedScheduleEvent" as const,
+				val: {
+					action: event.action,
+					args: event.args,
+				},
+			},
+		}),
+	);
+
+	return {
+		input: v3Data.input,
+		hasInitialized: v3Data.hasInitialized,
+		state: v3Data.state,
+		scheduledEvents,
+		connections: [],
+		hibernatableWebSockets: [],
+	};
+};
+
+// Converter from v2 to v1
+const v2ToV1 = (v2Data: v2.PersistedActor): v1.PersistedActor => {
+	return {
+		input: v2Data.input,
+		hasInitialized: v2Data.hasInitialized,
+		state: v2Data.state,
+		scheduledEvents: v2Data.scheduledEvents,
+		connections: v2Data.connections.map((conn) => {
+			const { hibernatableRequestId, ...rest } = conn;
+			return rest;
+		}),
+	};
+};
 
 export const ACTOR_VERSIONED = createVersionedDataHandler<v3.Actor>({
-	currentVersion: CURRENT_VERSION,
-	migrations,
-	serializeVersion: (data) => v3.encodeActor(data),
-	deserializeVersion: (bytes) => v3.decodeActor(bytes),
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 1:
+				return v1.decodePersistedActor(bytes);
+			case 2:
+				return v2.decodePersistedActor(bytes);
+			case 3:
+				return v3.decodeActor(bytes);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	serializeVersion: (data, version) => {
+		switch (version) {
+			case 1:
+				return v1.encodePersistedActor(data as v1.PersistedActor);
+			case 2:
+				return v2.encodePersistedActor(data as v2.PersistedActor);
+			case 3:
+				return v3.encodeActor(data as v3.Actor);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeConverters: () => [v1ToV2, v2ToV3],
+	serializeConverters: () => [v3ToV2, v2ToV1],
 });
 
 export const CONN_VERSIONED = createVersionedDataHandler<v3.Conn>({
-	currentVersion: CURRENT_VERSION,
-	migrations: new Map(),
-	serializeVersion: (data) => v3.encodeConn(data),
-	deserializeVersion: (bytes) => v3.decodeConn(bytes),
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 3:
+				return v3.decodeConn(bytes);
+			default:
+				throw new Error(
+					`Conn type only exists in version 3+, got version ${version}`,
+				);
+		}
+	},
+	serializeVersion: (data, version) => {
+		switch (version) {
+			case 3:
+				return v3.encodeConn(data as v3.Conn);
+			default:
+				throw new Error(
+					`Conn type only exists in version 3+, got version ${version}`,
+				);
+		}
+	},
+	deserializeConverters: () => [],
+	serializeConverters: () => [],
 });

package/src/schemas/client-protocol/versioned.ts

@@ -1,16 +1,11 @@
-import {
-	createVersionedDataHandler,
-	type MigrationFn,
-} from "@/common/versioned-data";
-import type * as v1 from "../../../dist/schemas/client-protocol/v1";
+import { createVersionedDataHandler } from "vbare";
+import * as v1 from "../../../dist/schemas/client-protocol/v1";
 import * as v2 from "../../../dist/schemas/client-protocol/v2";
 
 export const CURRENT_VERSION = 2;
 
-const migrations = new Map<number, MigrationFn<any, any>>();
-
-// Migration from v1 to v2: Remove connectionToken from Init message
-migrations.set(1, (v1Data: v1.ToClient): v2.ToClient => {
+// Converter from v1 to v2: Remove connectionToken from Init message
+const v1ToV2 = (v1Data: v1.ToClient): v2.ToClient => {
 	// Handle Init message specifically to remove connectionToken
 	if (v1Data.body.tag === "Init") {
 		const { actorId, connectionId } = v1Data.body.val as v1.Init;
@@ -26,58 +21,194 @@ migrations.set(1, (v1Data: v1.ToClient): v2.ToClient => {
 	}
 	// All other messages are unchanged
 	return v1Data as unknown as v2.ToClient;
-});
+};
+
+// Converter from v2 to v1: Add empty connectionToken to Init message
+const v2ToV1 = (v2Data: v2.ToClient): v1.ToClient => {
+	// Handle Init message specifically to add connectionToken
+	if (v2Data.body.tag === "Init") {
+		const { actorId, connectionId } = v2Data.body.val;
+		return {
+			body: {
+				tag: "Init",
+				val: {
+					actorId,
+					connectionId,
+					connectionToken: "", // Add empty connectionToken for v1 compatibility
+				},
+			},
+		};
+	}
+	// All other messages are unchanged
+	return v2Data as unknown as v1.ToClient;
+};
 
 export const TO_SERVER_VERSIONED = createVersionedDataHandler<v2.ToServer>({
-	currentVersion: CURRENT_VERSION,
-	migrations,
-	serializeVersion: (data) => v2.encodeToServer(data),
-	deserializeVersion: (bytes) => v2.decodeToServer(bytes),
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 1:
+				return v1.decodeToServer(bytes);
+			case 2:
+				return v2.decodeToServer(bytes);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	serializeVersion: (data, version) => {
+		switch (version) {
+			case 1:
+				return v1.encodeToServer(data as v1.ToServer);
+			case 2:
+				return v2.encodeToServer(data as v2.ToServer);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeConverters: () => [v1ToV2],
+	serializeConverters: () => [v2ToV1],
 });
 
 export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v2.ToClient>({
-	currentVersion: CURRENT_VERSION,
-	migrations,
-	serializeVersion: (data) => v2.encodeToClient(data),
-	deserializeVersion: (bytes) => v2.decodeToClient(bytes),
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 1:
+				return v1.decodeToClient(bytes);
+			case 2:
+				return v2.decodeToClient(bytes);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	serializeVersion: (data, version) => {
+		switch (version) {
+			case 1:
+				return v1.encodeToClient(data as v1.ToClient);
+			case 2:
+				return v2.encodeToClient(data as v2.ToClient);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeConverters: () => [v1ToV2],
+	serializeConverters: () => [v2ToV1],
 });
 
 export const HTTP_ACTION_REQUEST_VERSIONED =
 	createVersionedDataHandler<v2.HttpActionRequest>({
-		currentVersion: CURRENT_VERSION,
-		migrations,
-		serializeVersion: (data) => v2.encodeHttpActionRequest(data),
-		deserializeVersion: (bytes) => v2.decodeHttpActionRequest(bytes),
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeHttpActionRequest(bytes);
+				case 2:
+					return v2.decodeHttpActionRequest(bytes);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 1:
+					return v1.encodeHttpActionRequest(
+						data as v1.HttpActionRequest,
+					);
+				case 2:
+					return v2.encodeHttpActionRequest(
+						data as v2.HttpActionRequest,
+					);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
 	});
 
 export const HTTP_ACTION_RESPONSE_VERSIONED =
 	createVersionedDataHandler<v2.HttpActionResponse>({
-		currentVersion: CURRENT_VERSION,
-		migrations,
-		serializeVersion: (data) => v2.encodeHttpActionResponse(data),
-		deserializeVersion: (bytes) => v2.decodeHttpActionResponse(bytes),
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeHttpActionResponse(bytes);
+				case 2:
+					return v2.decodeHttpActionResponse(bytes);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 1:
+					return v1.encodeHttpActionResponse(
+						data as v1.HttpActionResponse,
+					);
+				case 2:
+					return v2.encodeHttpActionResponse(
+						data as v2.HttpActionResponse,
+					);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
 	});
 
 export const HTTP_RESPONSE_ERROR_VERSIONED =
 	createVersionedDataHandler<v2.HttpResponseError>({
-		currentVersion: CURRENT_VERSION,
-		migrations,
-		serializeVersion: (data) => v2.encodeHttpResponseError(data),
-		deserializeVersion: (bytes) => v2.decodeHttpResponseError(bytes),
-	});
-
-export const HTTP_RESOLVE_REQUEST_VERSIONED =
-	createVersionedDataHandler<v2.HttpResolveRequest>({
-		currentVersion: CURRENT_VERSION,
-		migrations,
-		serializeVersion: (_) => new Uint8Array(),
-		deserializeVersion: (bytes) => null,
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeHttpResponseError(bytes);
+				case 2:
+					return v2.decodeHttpResponseError(bytes);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 1:
+					return v1.encodeHttpResponseError(
+						data as v1.HttpResponseError,
+					);
+				case 2:
+					return v2.encodeHttpResponseError(
+						data as v2.HttpResponseError,
+					);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
 	});
 
 export const HTTP_RESOLVE_RESPONSE_VERSIONED =
 	createVersionedDataHandler<v2.HttpResolveResponse>({
-		currentVersion: CURRENT_VERSION,
-		migrations,
-		serializeVersion: (data) => v2.encodeHttpResolveResponse(data),
-		deserializeVersion: (bytes) => v2.decodeHttpResolveResponse(bytes),
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeHttpResolveResponse(bytes);
+				case 2:
+					return v2.decodeHttpResolveResponse(bytes);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 1:
+					return v1.encodeHttpResolveResponse(
+						data as v1.HttpResolveResponse,
+					);
+				case 2:
+					return v2.encodeHttpResolveResponse(
+						data as v2.HttpResolveResponse,
+					);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
 	});

package/src/schemas/file-system-driver/mod.ts

@@ -1 +1 @@
-export * from "../../../dist/schemas/file-system-driver/v2";
+export * from "../../../dist/schemas/file-system-driver/v3";

package/src/schemas/file-system-driver/versioned.ts

@@ -1,51 +1,135 @@
-import {
-	createVersionedDataHandler,
-	type MigrationFn,
-} from "@/common/versioned-data";
+import { createVersionedDataHandler } from "vbare";
 import { bufferToArrayBuffer } from "@/utils";
-import type * as v1 from "../../../dist/schemas/file-system-driver/v1";
+import * as v1 from "../../../dist/schemas/file-system-driver/v1";
 import * as v2 from "../../../dist/schemas/file-system-driver/v2";
+import * as v3 from "../../../dist/schemas/file-system-driver/v3";
 
-export const CURRENT_VERSION = 2;
-
-const migrations = new Map<number, MigrationFn<any, any>>([
-	[
-		2,
-		(v1State: v1.ActorState): v2.ActorState => {
-			// Create a new kvStorage list with the legacy persist data
-			const kvStorage: v2.ActorKvEntry[] = [];
-
-			// Store the legacy persist data under key [1]
-			if (v1State.persistedData) {
-				// Key [1] as Uint8Array
-				const key = new Uint8Array([1]);
-				kvStorage.push({
-					key: bufferToArrayBuffer(key),
-					value: v1State.persistedData,
-				});
-			}
-
-			return {
-				actorId: v1State.actorId,
-				name: v1State.name,
-				key: v1State.key,
-				kvStorage,
-				createdAt: v1State.createdAt,
-			};
-		},
-	],
-]);
-
-export const ACTOR_STATE_VERSIONED = createVersionedDataHandler<v2.ActorState>({
-	currentVersion: CURRENT_VERSION,
-	migrations,
-	serializeVersion: (data) => v2.encodeActorState(data),
-	deserializeVersion: (bytes) => v2.decodeActorState(bytes),
+export const CURRENT_VERSION = 3;
+
+// Converter from v1 to v2
+const v1ToV2 = (v1State: v1.ActorState): v2.ActorState => {
+	// Create a new kvStorage list with the legacy persist data
+	const kvStorage: v2.ActorKvEntry[] = [];
+
+	// Store the legacy persist data under key [1]
+	if (v1State.persistedData) {
+		// Key [1] as Uint8Array
+		const key = new Uint8Array([1]);
+		kvStorage.push({
+			key: bufferToArrayBuffer(key),
+			value: v1State.persistedData,
+		});
+	}
+
+	return {
+		actorId: v1State.actorId,
+		name: v1State.name,
+		key: v1State.key,
+		kvStorage,
+		createdAt: v1State.createdAt,
+	};
+};
+
+// Converter from v2 to v3
+const v2ToV3 = (v2State: v2.ActorState): v3.ActorState => {
+	// Migrate from v2 to v3 by adding the new optional timestamp fields
+	return {
+		actorId: v2State.actorId,
+		name: v2State.name,
+		key: v2State.key,
+		kvStorage: v2State.kvStorage,
+		createdAt: v2State.createdAt,
+		startTs: null,
+		connectableTs: null,
+		sleepTs: null,
+		destroyTs: null,
+	};
+};
+
+// Converter from v3 to v2
+const v3ToV2 = (v3State: v3.ActorState): v2.ActorState => {
+	// Downgrade from v3 to v2 by removing the timestamp fields
+	return {
+		actorId: v3State.actorId,
+		name: v3State.name,
+		key: v3State.key,
+		kvStorage: v3State.kvStorage,
+		createdAt: v3State.createdAt,
+	};
+};
+
+// Converter from v2 to v1
+const v2ToV1 = (v2State: v2.ActorState): v1.ActorState => {
+	// Downgrade from v2 to v1 by converting kvStorage back to persistedData
+	// Find the persist data entry (key [1])
+	const persistDataEntry = v2State.kvStorage.find((entry) => {
+		const key = new Uint8Array(entry.key);
+		return key.length === 1 && key[0] === 1;
+	});
+
+	return {
+		actorId: v2State.actorId,
+		name: v2State.name,
+		key: v2State.key,
+		persistedData: persistDataEntry?.value || new ArrayBuffer(0),
+		createdAt: v2State.createdAt,
+	};
+};
+
+export const ACTOR_STATE_VERSIONED = createVersionedDataHandler<v3.ActorState>({
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 1:
+				return v1.decodeActorState(bytes);
+			case 2:
+				return v2.decodeActorState(bytes);
+			case 3:
+				return v3.decodeActorState(bytes);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	serializeVersion: (data, version) => {
+		switch (version) {
+			case 1:
+				return v1.encodeActorState(data as v1.ActorState);
+			case 2:
+				return v2.encodeActorState(data as v2.ActorState);
+			case 3:
+				return v3.encodeActorState(data as v3.ActorState);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeConverters: () => [v1ToV2, v2ToV3],
+	serializeConverters: () => [v3ToV2, v2ToV1],
 });
 
-export const ACTOR_ALARM_VERSIONED = createVersionedDataHandler<v2.ActorAlarm>({
-	currentVersion: CURRENT_VERSION,
-	migrations,
-	serializeVersion: (data) => v2.encodeActorAlarm(data),
-	deserializeVersion: (bytes) => v2.decodeActorAlarm(bytes),
+export const ACTOR_ALARM_VERSIONED = createVersionedDataHandler<v3.ActorAlarm>({
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 1:
+				return v1.decodeActorAlarm(bytes);
+			case 2:
+				return v2.decodeActorAlarm(bytes);
+			case 3:
+				return v3.decodeActorAlarm(bytes);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	serializeVersion: (data, version) => {
+		switch (version) {
+			case 1:
+				return v1.encodeActorAlarm(data as v1.ActorAlarm);
+			case 2:
+				return v2.encodeActorAlarm(data as v2.ActorAlarm);
+			case 3:
+				return v3.encodeActorAlarm(data as v3.ActorAlarm);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeConverters: () => [],
+	serializeConverters: () => [],
 });

package/src/serde.ts

@@ -2,7 +2,7 @@ import * as cbor from "cbor-x";
 import invariant from "invariant";
 import type { z } from "zod";
 import { assertUnreachable } from "@/common/utils";
-import type { VersionedDataHandler } from "@/common/versioned-data";
+import type { VersionedDataHandler } from "vbare";
 import type { Encoding } from "@/mod";
 import { jsonParseCompat, jsonStringifyCompat } from "./actor/protocol/serde";
 
@@ -57,6 +57,7 @@ export function serializeWithEncoding<TBare, TJson, T = TBare>(
 	encoding: Encoding,
 	value: T,
 	versionedDataHandler: VersionedDataHandler<TBare> | undefined,
+	version: number | undefined,
 	zodSchema: z.ZodType<TJson>,
 	toJson: (value: T) => TJson,
 	toBare: (value: T) => TBare,
@@ -75,8 +76,14 @@ export function serializeWithEncoding<TBare, TJson, T = TBare>(
 				"VersionedDataHandler is required for 'bare' encoding",
 			);
 		}
+		if (version === undefined) {
+			throw new Error("version is required for 'bare' encoding");
+		}
 		const bareValue = toBare(value);
-		return versionedDataHandler.serializeWithEmbeddedVersion(bareValue);
+		return versionedDataHandler.serializeWithEmbeddedVersion(
+			bareValue,
+			version,
+		);
 	} else {
 		assertUnreachable(encoding);
 	}

package/src/test/config.ts

@@ -1,16 +1,17 @@
 import { z } from "zod";
 import { RunnerConfigSchema } from "@/registry/run-config";
 
-export const ConfigSchema = RunnerConfigSchema.removeDefault()
-	.extend({
-		hostname: z
-			.string()
-			.optional()
-			.default(process.env.HOSTNAME ?? "127.0.0.1"),
-		port: z
-			.number()
-			.optional()
-			.default(Number.parseInt(process.env.PORT ?? "8080")),
-	})
-	.default({});
+const ConfigSchemaBase = RunnerConfigSchema.removeDefault().extend({
+	hostname: z
+		.string()
+		.optional()
+		.default(process.env.HOSTNAME ?? "127.0.0.1"),
+	port: z
+		.number()
+		.optional()
+		.default(Number.parseInt(process.env.PORT ?? "8080")),
+});
+export const ConfigSchema = ConfigSchemaBase.default(() =>
+	ConfigSchemaBase.parse({}),
+);
 export type InputConfig = z.input<typeof ConfigSchema>;