rivetkit 2.3.0-rc.5 → 2.3.0-rc.7

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

@@ -2,8 +2,9 @@ import { createVersionedDataHandler } from "vbare";
 import * as v1 from "./bare/generated/client-protocol/v1";
 import * as v2 from "./bare/generated/client-protocol/v2";
 import * as v3 from "./bare/generated/client-protocol/v3";
+import * as v4 from "./bare/generated/client-protocol/v4";
 
-export const CURRENT_VERSION = 3;
+export const CURRENT_VERSION = 4;
 
 // Converter from v1 to v2: Remove connectionToken from Init message
 const v1ToV2 = (v1Data: v1.ToClient): v2.ToClient => {
@@ -44,17 +45,45 @@ const v2ToV1 = (v2Data: v2.ToClient): v1.ToClient => {
 	return v2Data as unknown as v1.ToClient;
 };
 
-// Converter from v2 to v3: No changes needed for 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 v3ToV4 = (v3Data: v3.ToClient): v4.ToClient => {
+	if (v3Data.body.tag === "Error") {
+		return {
+			body: {
+				tag: "Error",
+				val: {
+					...v3Data.body.val,
+					actor: null,
+				},
+			},
+		};
+	}
+	return v3Data as unknown as v4.ToClient;
+};
+
+const v4ToV3 = (v4Data: v4.ToClient): v3.ToClient => {
+	if (v4Data.body.tag === "Error") {
+		const { actor: _, ...val } = v4Data.body.val;
+		return {
+			body: {
+				tag: "Error",
+				val,
+			},
+		};
+	}
+	return v4Data 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)
+// ToServer identity converters.
 const v1ToServerV2 = (v1Data: v1.ToServer): v2.ToServer => {
 	return v1Data as unknown as v2.ToServer;
 };
@@ -63,6 +92,14 @@ const v2ToServerV3 = (v2Data: v2.ToServer): v3.ToServer => {
 	return v2Data as unknown as v3.ToServer;
 };
 
+const v3ToServerV4 = (v3Data: v3.ToServer): v4.ToServer => {
+	return v3Data as unknown as v4.ToServer;
+};
+
+const v4ToServerV3 = (v4Data: v4.ToServer): v3.ToServer => {
+	return v4Data as unknown as v3.ToServer;
+};
+
 const v3ToServerV2 = (v3Data: v3.ToServer): v2.ToServer => {
 	return v3Data as unknown as v2.ToServer;
 };
@@ -71,7 +108,21 @@ const v2ToServerV1 = (v2Data: v2.ToServer): v1.ToServer => {
 	return v2Data as unknown as v1.ToServer;
 };
 
-export const CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler<v3.ToServer>({
+const v3HttpResponseErrorToV4 = (
+	v3Data: v3.HttpResponseError,
+): v4.HttpResponseError => ({
+	...v3Data,
+	actor: null,
+});
+
+const v4HttpResponseErrorToV3 = (
+	v4Data: v4.HttpResponseError,
+): v3.HttpResponseError => {
+	const { actor: _, ...rest } = v4Data;
+	return rest;
+};
+
+export const CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler<v4.ToServer>({
 	deserializeVersion: (bytes, version) => {
 		switch (version) {
 			case 1:
@@ -80,6 +131,8 @@ export const CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler<v3.ToServer>
 				return v2.decodeToServer(bytes);
 			case 3:
 				return v3.decodeToServer(bytes);
+			case 4:
+				return v4.decodeToServer(bytes);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
@@ -92,15 +145,17 @@ export const CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler<v3.ToServer>
 				return v2.encodeToServer(data as v2.ToServer);
 			case 3:
 				return v3.encodeToServer(data as v3.ToServer);
+			case 4:
+				return v4.encodeToServer(data as v4.ToServer);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
 	},
-	deserializeConverters: () => [v1ToServerV2, v2ToServerV3],
-	serializeConverters: () => [v3ToServerV2, v2ToServerV1],
+	deserializeConverters: () => [v1ToServerV2, v2ToServerV3, v3ToServerV4],
+	serializeConverters: () => [v4ToServerV3, v3ToServerV2, v2ToServerV1],
 });
 
-export const CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler<v3.ToClient>({
+export const CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler<v4.ToClient>({
 	deserializeVersion: (bytes, version) => {
 		switch (version) {
 			case 1:
@@ -109,6 +164,8 @@ export const CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler<v3.ToClient>
 				return v2.decodeToClient(bytes);
 			case 3:
 				return v3.decodeToClient(bytes);
+			case 4:
+				return v4.decodeToClient(bytes);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
@@ -121,16 +178,18 @@ export const CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler<v3.ToClient>
 				return v2.encodeToClient(data as v2.ToClient);
 			case 3:
 				return v3.encodeToClient(data as v3.ToClient);
+			case 4:
+				return v4.encodeToClient(data as v4.ToClient);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
 	},
-	deserializeConverters: () => [v1ToV2, v2ToV3],
-	serializeConverters: () => [v3ToV2, v2ToV1],
+	deserializeConverters: () => [v1ToV2, v2ToV3, v3ToV4],
+	serializeConverters: () => [v4ToV3, v3ToV2, v2ToV1],
 });
 
 export const HTTP_ACTION_REQUEST_VERSIONED =
-	createVersionedDataHandler<v3.HttpActionRequest>({
+	createVersionedDataHandler<v4.HttpActionRequest>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 1:
@@ -139,6 +198,8 @@ export const HTTP_ACTION_REQUEST_VERSIONED =
 					return v2.decodeHttpActionRequest(bytes);
 				case 3:
 					return v3.decodeHttpActionRequest(bytes);
+				case 4:
+					return v4.decodeHttpActionRequest(bytes);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -157,6 +218,10 @@ export const HTTP_ACTION_REQUEST_VERSIONED =
 					return v3.encodeHttpActionRequest(
 						data as v3.HttpActionRequest,
 					);
+				case 4:
+					return v4.encodeHttpActionRequest(
+						data as v4.HttpActionRequest,
+					);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -166,7 +231,7 @@ export const HTTP_ACTION_REQUEST_VERSIONED =
 	});
 
 export const HTTP_ACTION_RESPONSE_VERSIONED =
-	createVersionedDataHandler<v3.HttpActionResponse>({
+	createVersionedDataHandler<v4.HttpActionResponse>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 1:
@@ -175,6 +240,8 @@ export const HTTP_ACTION_RESPONSE_VERSIONED =
 					return v2.decodeHttpActionResponse(bytes);
 				case 3:
 					return v3.decodeHttpActionResponse(bytes);
+				case 4:
+					return v4.decodeHttpActionResponse(bytes);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -193,6 +260,10 @@ export const HTTP_ACTION_RESPONSE_VERSIONED =
 					return v3.encodeHttpActionResponse(
 						data as v3.HttpActionResponse,
 					);
+				case 4:
+					return v4.encodeHttpActionResponse(
+						data as v4.HttpActionResponse,
+					);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -202,11 +273,13 @@ export const HTTP_ACTION_RESPONSE_VERSIONED =
 	});
 
 export const HTTP_QUEUE_SEND_REQUEST_VERSIONED =
-	createVersionedDataHandler<v3.HttpQueueSendRequest>({
+	createVersionedDataHandler<v4.HttpQueueSendRequest>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 3:
 					return v3.decodeHttpQueueSendRequest(bytes);
+				case 4:
+					return v4.decodeHttpQueueSendRequest(bytes);
 				default:
 					throw new Error(
 						`HttpQueueSendRequest only exists in version 3+, got version ${version}`,
@@ -219,6 +292,10 @@ export const HTTP_QUEUE_SEND_REQUEST_VERSIONED =
 					return v3.encodeHttpQueueSendRequest(
 						data as v3.HttpQueueSendRequest,
 					);
+				case 4:
+					return v4.encodeHttpQueueSendRequest(
+						data as v4.HttpQueueSendRequest,
+					);
 				default:
 					throw new Error(
 						`HttpQueueSendRequest only exists in version 3+, got version ${version}`,
@@ -230,11 +307,13 @@ export const HTTP_QUEUE_SEND_REQUEST_VERSIONED =
 	});
 
 export const HTTP_QUEUE_SEND_RESPONSE_VERSIONED =
-	createVersionedDataHandler<v3.HttpQueueSendResponse>({
+	createVersionedDataHandler<v4.HttpQueueSendResponse>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 3:
 					return v3.decodeHttpQueueSendResponse(bytes);
+				case 4:
+					return v4.decodeHttpQueueSendResponse(bytes);
 				default:
 					throw new Error(
 						`HttpQueueSendResponse only exists in version 3+, got version ${version}`,
@@ -247,6 +326,10 @@ export const HTTP_QUEUE_SEND_RESPONSE_VERSIONED =
 					return v3.encodeHttpQueueSendResponse(
 						data as v3.HttpQueueSendResponse,
 					);
+				case 4:
+					return v4.encodeHttpQueueSendResponse(
+						data as v4.HttpQueueSendResponse,
+					);
 				default:
 					throw new Error(
 						`HttpQueueSendResponse only exists in version 3+, got version ${version}`,
@@ -258,7 +341,7 @@ export const HTTP_QUEUE_SEND_RESPONSE_VERSIONED =
 	});
 
 export const HTTP_RESPONSE_ERROR_VERSIONED =
-	createVersionedDataHandler<v3.HttpResponseError>({
+	createVersionedDataHandler<v4.HttpResponseError>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 1:
@@ -267,6 +350,8 @@ export const HTTP_RESPONSE_ERROR_VERSIONED =
 					return v2.decodeHttpResponseError(bytes);
 				case 3:
 					return v3.decodeHttpResponseError(bytes);
+				case 4:
+					return v4.decodeHttpResponseError(bytes);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -285,16 +370,32 @@ export const HTTP_RESPONSE_ERROR_VERSIONED =
 					return v3.encodeHttpResponseError(
 						data as v3.HttpResponseError,
 					);
+				case 4:
+					return v4.encodeHttpResponseError(
+						data as v4.HttpResponseError,
+					);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
 		},
-		deserializeConverters: () => [],
-		serializeConverters: () => [],
+		deserializeConverters: () => [
+			(data: v1.HttpResponseError) =>
+				data as unknown as v2.HttpResponseError,
+			(data: v2.HttpResponseError) =>
+				data as unknown as v3.HttpResponseError,
+			v3HttpResponseErrorToV4,
+		],
+		serializeConverters: () => [
+			v4HttpResponseErrorToV3,
+			(data: v3.HttpResponseError) =>
+				data as unknown as v2.HttpResponseError,
+			(data: v2.HttpResponseError) =>
+				data as unknown as v1.HttpResponseError,
+		],
 	});
 
 export const HTTP_RESOLVE_RESPONSE_VERSIONED =
-	createVersionedDataHandler<v3.HttpResolveResponse>({
+	createVersionedDataHandler<v4.HttpResolveResponse>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 1:
@@ -303,6 +404,8 @@ export const HTTP_RESOLVE_RESPONSE_VERSIONED =
 					return v2.decodeHttpResolveResponse(bytes);
 				case 3:
 					return v3.decodeHttpResolveResponse(bytes);
+				case 4:
+					return v4.decodeHttpResolveResponse(bytes);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -321,6 +424,10 @@ export const HTTP_RESOLVE_RESPONSE_VERSIONED =
 					return v3.encodeHttpResolveResponse(
 						data as v3.HttpResolveResponse,
 					);
+				case 4:
+					return v4.encodeHttpResolveResponse(
+						data as v4.HttpResolveResponse,
+					);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}

package/src/common/client-protocol-zod.ts

@@ -3,6 +3,11 @@ import { z } from "zod/v4";
 // Helper schemas
 const UintSchema = z.bigint();
 const OptionalUintSchema = UintSchema.nullable();
+const ActorSpecifierSchema = z.object({
+	actorId: z.string(),
+	generation: z.union([z.number(), z.bigint()]),
+	key: z.string().optional(),
+});
 
 // MARK: Message To Client
 export const InitSchema = z.object({
@@ -17,6 +22,7 @@ export const ErrorSchema = z.object({
 	message: z.string(),
 	metadata: z.unknown().optional(),
 	actionId: OptionalUintSchema,
+	actor: ActorSpecifierSchema.optional(),
 });
 export type Error = z.infer<typeof ErrorSchema>;
 
@@ -105,6 +111,7 @@ export const HttpResponseErrorSchema = z.object({
 	code: z.string(),
 	message: z.string(),
 	metadata: z.unknown().optional(),
+	actor: ActorSpecifierSchema.optional(),
 });
 export type HttpResponseError = z.infer<typeof HttpResponseErrorSchema>;
 

package/src/common/client-protocol.ts

@@ -1 +1 @@
-export * from "./bare/generated/client-protocol/v3";
+export * from "./bare/generated/client-protocol/v4";

package/src/common/database/native-database.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "vitest";
+import { BRIDGE_RIVET_ERROR_PREFIX } from "@/actor/errors";
 import {
 	type JsNativeDatabaseLike,
 	wrapJsNativeDatabase,
@@ -64,6 +65,14 @@ class FakeNativeDatabase implements JsNativeDatabaseLike {
 		});
 	}
 
+	rejectNext(error: unknown) {
+		const pending = this.#pending.shift();
+		if (!pending) {
+			throw new Error("no pending native execute call");
+		}
+		pending.reject(error);
+	}
+
 	async #startExecute(
 		sql: string,
 		params: NativeParams,
@@ -173,4 +182,30 @@ describe("wrapJsNativeDatabase", () => {
 			"Database is closed",
 		);
 	});
+
+	test("decodes sanitized native bridge errors without logging", async () => {
+		const native = new FakeNativeDatabase();
+		const db = wrapJsNativeDatabase(native);
+		const query = db.execute("SELECT broken", [1, "two"]);
+		const bridgeReason = `${BRIDGE_RIVET_ERROR_PREFIX}${JSON.stringify({
+			group: "rivetkit",
+			code: "internal_error",
+			message: "An internal error occurred",
+			statusCode: 500,
+		})}`;
+
+		native.rejectNext(new Error(bridgeReason));
+
+		await expect(query).rejects.toMatchObject({
+			name: "RivetError",
+			group: "rivetkit",
+			code: "internal_error",
+			message: "An internal error occurred",
+		});
+
+		await query.catch((error) => {
+			expect(error.stack).toContain("decodeBridgeRivetError");
+			expect(error.stack).toContain("enrichNativeDatabaseError");
+		});
+	});
 });

package/src/common/database/native-database.ts

@@ -92,12 +92,16 @@ function enrichNativeDatabaseError(
 	database: JsNativeDatabaseLike,
 	error: unknown,
 ): never {
-	const bridged =
+	const bridgeReason =
 		typeof error === "string"
-			? decodeBridgeRivetError(error)
+			? error
 			: error instanceof Error
-				? decodeBridgeRivetError(error.message)
-				: undefined;
+				? error.message
+			: undefined;
+	const bridged =
+		bridgeReason === undefined
+			? undefined
+			: decodeBridgeRivetError(bridgeReason);
 	if (bridged) {
 		throw bridged;
 	}