rivetkit 2.0.2 → 2.0.4-rc.1

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

@@ -0,0 +1,330 @@
+import { createVersionedDataHandler } from "vbare";
+import * as v1 from "../../../dist/schemas/client-protocol/v1";
+import * as v2 from "../../../dist/schemas/client-protocol/v2";
+import * as v3 from "../../../dist/schemas/client-protocol/v3";
+
+export const CURRENT_VERSION = 3;
+
+// 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;
+		return {
+			body: {
+				tag: "Init",
+				val: {
+					actorId,
+					connectionId,
+				},
+			},
+		};
+	}
+	// 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;
+};
+
+// Converter from v2 to v3: No changes needed for ToClient
+const v2ToV3 = (v2Data: v2.ToClient): v3.ToClient => {
+	return v2Data as unknown as v3.ToClient;
+};
+
+// Converter from v3 to v2: No changes needed for ToClient
+const v3ToV2 = (v3Data: v3.ToClient): v2.ToClient => {
+	return v3Data as unknown as v2.ToClient;
+};
+
+// ToServer identity converters (ToServer is identical across v1, v2, and v3)
+const v1ToServerV2 = (v1Data: v1.ToServer): v2.ToServer => {
+	return v1Data as unknown as v2.ToServer;
+};
+
+const v2ToServerV3 = (v2Data: v2.ToServer): v3.ToServer => {
+	return v2Data as unknown as v3.ToServer;
+};
+
+const v3ToServerV2 = (v3Data: v3.ToServer): v2.ToServer => {
+	return v3Data as unknown as v2.ToServer;
+};
+
+const v2ToServerV1 = (v2Data: v2.ToServer): v1.ToServer => {
+	return v2Data as unknown as v1.ToServer;
+};
+
+export const TO_SERVER_VERSIONED = createVersionedDataHandler<v3.ToServer>({
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 1:
+				return v1.decodeToServer(bytes);
+			case 2:
+				return v2.decodeToServer(bytes);
+			case 3:
+				return v3.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);
+			case 3:
+				return v3.encodeToServer(data as v3.ToServer);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeConverters: () => [v1ToServerV2, v2ToServerV3],
+	serializeConverters: () => [v3ToServerV2, v2ToServerV1],
+});
+
+export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v3.ToClient>({
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 1:
+				return v1.decodeToClient(bytes);
+			case 2:
+				return v2.decodeToClient(bytes);
+			case 3:
+				return v3.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);
+			case 3:
+				return v3.encodeToClient(data as v3.ToClient);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeConverters: () => [v1ToV2, v2ToV3],
+	serializeConverters: () => [v3ToV2, v2ToV1],
+});
+
+export const HTTP_ACTION_REQUEST_VERSIONED =
+	createVersionedDataHandler<v3.HttpActionRequest>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeHttpActionRequest(bytes);
+				case 2:
+					return v2.decodeHttpActionRequest(bytes);
+				case 3:
+					return v3.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,
+					);
+				case 3:
+					return v3.encodeHttpActionRequest(
+						data as v3.HttpActionRequest,
+					);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
+	});
+
+export const HTTP_ACTION_RESPONSE_VERSIONED =
+	createVersionedDataHandler<v3.HttpActionResponse>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeHttpActionResponse(bytes);
+				case 2:
+					return v2.decodeHttpActionResponse(bytes);
+				case 3:
+					return v3.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,
+					);
+				case 3:
+					return v3.encodeHttpActionResponse(
+						data as v3.HttpActionResponse,
+					);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
+	});
+
+export const HTTP_QUEUE_SEND_REQUEST_VERSIONED =
+	createVersionedDataHandler<v3.HttpQueueSendRequest>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 3:
+					return v3.decodeHttpQueueSendRequest(bytes);
+				default:
+					throw new Error(
+						`HttpQueueSendRequest only exists in version 3+, got version ${version}`,
+					);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 3:
+					return v3.encodeHttpQueueSendRequest(
+						data as v3.HttpQueueSendRequest,
+					);
+				default:
+					throw new Error(
+						`HttpQueueSendRequest only exists in version 3+, got version ${version}`,
+					);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
+	});
+
+export const HTTP_QUEUE_SEND_RESPONSE_VERSIONED =
+	createVersionedDataHandler<v3.HttpQueueSendResponse>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 3:
+					return v3.decodeHttpQueueSendResponse(bytes);
+				default:
+					throw new Error(
+						`HttpQueueSendResponse only exists in version 3+, got version ${version}`,
+					);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 3:
+					return v3.encodeHttpQueueSendResponse(
+						data as v3.HttpQueueSendResponse,
+					);
+				default:
+					throw new Error(
+						`HttpQueueSendResponse only exists in version 3+, got version ${version}`,
+					);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
+	});
+
+export const HTTP_RESPONSE_ERROR_VERSIONED =
+	createVersionedDataHandler<v3.HttpResponseError>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeHttpResponseError(bytes);
+				case 2:
+					return v2.decodeHttpResponseError(bytes);
+				case 3:
+					return v3.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,
+					);
+				case 3:
+					return v3.encodeHttpResponseError(
+						data as v3.HttpResponseError,
+					);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
+	});
+
+export const HTTP_RESOLVE_RESPONSE_VERSIONED =
+	createVersionedDataHandler<v3.HttpResolveResponse>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeHttpResolveResponse(bytes);
+				case 2:
+					return v2.decodeHttpResolveResponse(bytes);
+				case 3:
+					return v3.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,
+					);
+				case 3:
+					return v3.encodeHttpResolveResponse(
+						data as v3.HttpResolveResponse,
+					);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
+	});

package/src/schemas/client-protocol-zod/mod.ts

@@ -0,0 +1,118 @@
+import { z } from "zod/v4";
+
+// Helper schemas
+const UintSchema = z.bigint();
+const OptionalUintSchema = UintSchema.nullable();
+
+// MARK: Message To Client
+export const InitSchema = z.object({
+	actorId: z.string(),
+	connectionId: z.string(),
+});
+export type Init = z.infer<typeof InitSchema>;
+
+export const ErrorSchema = z.object({
+	group: z.string(),
+	code: z.string(),
+	message: z.string(),
+	metadata: z.unknown().optional(),
+	actionId: OptionalUintSchema,
+});
+export type Error = z.infer<typeof ErrorSchema>;
+
+export const ActionResponseSchema = z.object({
+	id: UintSchema,
+	output: z.unknown(),
+});
+export type ActionResponse = z.infer<typeof ActionResponseSchema>;
+
+export const EventSchema = z.object({
+	name: z.string(),
+	args: z.unknown(),
+});
+export type Event = z.infer<typeof EventSchema>;
+
+export const ToClientBodySchema = z.discriminatedUnion("tag", [
+	z.object({ tag: z.literal("Init"), val: InitSchema }),
+	z.object({ tag: z.literal("Error"), val: ErrorSchema }),
+	z.object({ tag: z.literal("ActionResponse"), val: ActionResponseSchema }),
+	z.object({ tag: z.literal("Event"), val: EventSchema }),
+]);
+export type ToClientBody = z.infer<typeof ToClientBodySchema>;
+
+export const ToClientSchema = z.object({
+	body: ToClientBodySchema,
+});
+export type ToClient = z.infer<typeof ToClientSchema>;
+
+// MARK: Message To Server
+export const ActionRequestSchema = z.object({
+	id: UintSchema,
+	name: z.string(),
+	args: z.unknown(),
+});
+export type ActionRequest = z.infer<typeof ActionRequestSchema>;
+
+export const SubscriptionRequestSchema = z.object({
+	eventName: z.string(),
+	subscribe: z.boolean(),
+});
+export type SubscriptionRequest = z.infer<typeof SubscriptionRequestSchema>;
+
+export const ToServerBodySchema = z.discriminatedUnion("tag", [
+	z.object({ tag: z.literal("ActionRequest"), val: ActionRequestSchema }),
+	z.object({
+		tag: z.literal("SubscriptionRequest"),
+		val: SubscriptionRequestSchema,
+	}),
+]);
+export type ToServerBody = z.infer<typeof ToServerBodySchema>;
+
+export const ToServerSchema = z.object({
+	body: ToServerBodySchema,
+});
+export type ToServer = z.infer<typeof ToServerSchema>;
+
+// MARK: HTTP Action
+export const HttpActionRequestSchema = z.object({
+	args: z.unknown(),
+});
+export type HttpActionRequest = z.infer<typeof HttpActionRequestSchema>;
+
+export const HttpActionResponseSchema = z.object({
+	output: z.unknown(),
+});
+export type HttpActionResponse = z.infer<typeof HttpActionResponseSchema>;
+
+// MARK: HTTP Queue
+export const HttpQueueSendRequestSchema = z.object({
+	body: z.unknown(),
+	name: z.string().optional(),
+	wait: z.boolean().optional(),
+	timeout: z.number().optional(),
+});
+export type HttpQueueSendRequest = z.infer<typeof HttpQueueSendRequestSchema>;
+
+export const HttpQueueSendResponseSchema = z.object({
+	status: z.enum(["completed", "timedOut"]),
+	response: z.unknown().optional(),
+});
+export type HttpQueueSendResponse = z.infer<typeof HttpQueueSendResponseSchema>;
+
+// MARK: HTTP Error
+export const HttpResponseErrorSchema = z.object({
+	group: z.string(),
+	code: z.string(),
+	message: z.string(),
+	metadata: z.unknown().optional(),
+});
+export type HttpResponseError = z.infer<typeof HttpResponseErrorSchema>;
+
+// MARK: HTTP Resolve
+export const HttpResolveRequestSchema = z.null();
+export type HttpResolveRequest = z.infer<typeof HttpResolveRequestSchema>;
+
+export const HttpResolveResponseSchema = z.object({
+	actorId: z.string(),
+});
+export type HttpResolveResponse = z.infer<typeof HttpResolveResponseSchema>;

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

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

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

@@ -0,0 +1,135 @@
+import { createVersionedDataHandler } from "vbare";
+import { bufferToArrayBuffer } from "@/utils";
+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 = 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<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/schemas/persist/mod.ts

@@ -0,0 +1 @@
+export * from "../../../dist/schemas/persist/v1";

package/src/schemas/transport/mod.ts

@@ -0,0 +1 @@
+export * from "../../../dist/schemas/transport/v1";