rivetkit 2.3.29 → 3.0.0-preview.1

package/src/actor/config.test.ts

@@ -1,78 +0,0 @@
-import { describe, expect, test } from "vitest";
-import {
-	ActorOptionsSchema,
-	type DefineRunHandlerOptions,
-	defineRunHandler,
-	getRunFunction,
-	getRunInspectorKind,
-	getRunMetadata,
-} from "./config";
-
-describe("ActorOptionsSchema", () => {
-	test("keeps the Actor Runtime Socket opt-in", () => {
-		expect(ActorOptionsSchema.parse({}).enableActorRuntimeSocket).toBe(
-			false,
-		);
-		expect(
-			ActorOptionsSchema.parse({ enableActorRuntimeSocket: true })
-				.enableActorRuntimeSocket,
-		).toBe(true);
-	});
-});
-
-describe("defineRunHandler", () => {
-	test("preserves the callable and exposes static metadata without creating an inspector", () => {
-		let inspectorCreates = 0;
-		const run = async (value: number): Promise<string> => String(value);
-		const defined = defineRunHandler(run, {
-			name: "Durable import",
-			icon: "diagram-project",
-			inspectorKind: "workflow",
-			createInspector: () => {
-				inspectorCreates += 1;
-				return {
-					inspector: {
-						workflow: {
-							getHistory: () => null,
-							getState: async () => null,
-							onHistoryUpdated: () => () => {},
-							replayFromStep: async () => null,
-						},
-					},
-				};
-			},
-		});
-
-		const exactType: (value: number) => Promise<string> = defined;
-		expect(exactType).toBe(run);
-		expect(getRunFunction(defined)).toBe(run);
-		expect(getRunMetadata(defined)).toEqual({
-			name: "Durable import",
-			icon: "diagram-project",
-		});
-		expect(getRunInspectorKind(defined)).toBe("workflow");
-		expect(inspectorCreates).toBe(0);
-	});
-
-	test("requires static inspector metadata and its factory together", () => {
-		expect(() =>
-			defineRunHandler(async () => {}, {
-				inspectorKind: "workflow",
-			} as unknown as DefineRunHandlerOptions),
-		).toThrow("requires inspectorKind and createInspector together");
-		expect(() =>
-			defineRunHandler(async () => {}, {
-				createInspector: () => ({
-					inspector: {
-						workflow: {
-							getHistory: () => null,
-							getState: async () => null,
-							onHistoryUpdated: () => () => {},
-							replayFromStep: async () => null,
-						},
-					},
-				}),
-			} as unknown as DefineRunHandlerOptions),
-		).toThrow("requires inspectorKind and createInspector together");
-	});
-});

package/src/actor/keys.test.ts

@@ -1,275 +0,0 @@
-import { describe, expect, test } from "vitest";
-import {
-	deserializeActorKey,
-	EMPTY_KEY,
-	KEY_SEPARATOR,
-	serializeActorKey,
-} from "./keys";
-
-describe("Key serialization and deserialization", () => {
-	// Test serialization
-	describe("serializeActorKey", () => {
-		test("serializes empty key array", () => {
-			expect(serializeActorKey([])).toBe(EMPTY_KEY);
-		});
-
-		test("serializes single key", () => {
-			expect(serializeActorKey(["test"])).toBe("test");
-		});
-
-		test("serializes multiple keys", () => {
-			expect(serializeActorKey(["a", "b", "c"])).toBe(
-				`a${KEY_SEPARATOR}b${KEY_SEPARATOR}c`,
-			);
-		});
-
-		test("escapes forward slashes in keys", () => {
-			expect(serializeActorKey(["a/b"])).toBe("a\\/b");
-			expect(serializeActorKey(["a/b", "c"])).toBe(
-				`a\\/b${KEY_SEPARATOR}c`,
-			);
-		});
-
-		test("escapes empty key marker in keys", () => {
-			expect(serializeActorKey([EMPTY_KEY])).toBe(`\\${EMPTY_KEY}`);
-		});
-
-		test("handles complex keys", () => {
-			expect(serializeActorKey(["a/b", EMPTY_KEY, "c/d"])).toBe(
-				`a\\/b${KEY_SEPARATOR}\\${EMPTY_KEY}${KEY_SEPARATOR}c\\/d`,
-			);
-		});
-	});
-
-	// Test deserialization
-	describe("deserializeActorKey", () => {
-		test("deserializes empty string", () => {
-			expect(deserializeActorKey("")).toEqual([]);
-		});
-
-		test("deserializes undefined/null", () => {
-			expect(deserializeActorKey(undefined as unknown as string)).toEqual(
-				[],
-			);
-			expect(deserializeActorKey(null as unknown as string)).toEqual([]);
-		});
-
-		test("deserializes empty key marker", () => {
-			expect(deserializeActorKey(EMPTY_KEY)).toEqual([]);
-		});
-
-		test("deserializes single key", () => {
-			expect(deserializeActorKey("test")).toEqual(["test"]);
-		});
-
-		test("deserializes multiple keys", () => {
-			expect(
-				deserializeActorKey(`a${KEY_SEPARATOR}b${KEY_SEPARATOR}c`),
-			).toEqual(["a", "b", "c"]);
-		});
-
-		test("deserializes keys with escaped forward slashes", () => {
-			expect(deserializeActorKey("a\\/b")).toEqual(["a/b"]);
-			expect(deserializeActorKey(`a\\/b${KEY_SEPARATOR}c`)).toEqual([
-				"a/b",
-				"c",
-			]);
-		});
-
-		test("deserializes keys with escaped empty key marker", () => {
-			expect(deserializeActorKey(`\\${EMPTY_KEY}`)).toEqual([EMPTY_KEY]);
-		});
-
-		test("deserializes complex keys", () => {
-			expect(
-				deserializeActorKey(
-					`a\\/b${KEY_SEPARATOR}\\${EMPTY_KEY}${KEY_SEPARATOR}c\\/d`,
-				),
-			).toEqual(["a/b", EMPTY_KEY, "c/d"]);
-		});
-	});
-
-	// Test edge cases
-	describe("edge cases", () => {
-		test("handles empty string parts", () => {
-			const testCases: Array<[string[], string]> = [
-				[[""], "\\0"],
-				[["a", "", "b"], "a/\\0/b"],
-				[["", "a"], "\\0/a"],
-				[["a", ""], "a/\\0"],
-				[["", "", ""], "\\0/\\0/\\0"],
-				[["", "a", "", "b", ""], "\\0/a/\\0/b/\\0"],
-				[[], "/"],
-				[["test"], "test"],
-				[["a", "b", "c"], "a/b/c"],
-				[["a/b", "c"], "a\\/b/c"],
-				[[EMPTY_KEY], "\\/"],
-				[["a/b", EMPTY_KEY, "c/d"], "a\\/b/\\//c\\/d"],
-				[
-					["special\\chars", "more:complex,keys", "final key"],
-					"special\\\\chars/more:complex,keys/final key",
-				],
-			];
-
-			for (const [key, expectedSerialized] of testCases) {
-				const serialized = serializeActorKey(key);
-				expect(serialized).toBe(expectedSerialized);
-				const deserialized = deserializeActorKey(serialized);
-				expect(deserialized).toEqual(key);
-			}
-		});
-
-		test("differentiates empty array from array with empty string", () => {
-			const emptyArray: string[] = [];
-			const arrayWithEmptyString = [""];
-
-			const serialized1 = serializeActorKey(emptyArray);
-			const serialized2 = serializeActorKey(arrayWithEmptyString);
-
-			expect(serialized1).toBe(EMPTY_KEY); // Should be "/"
-			expect(serialized2).not.toBe(EMPTY_KEY); // Should NOT be "/"
-			expect(serialized2).toBe("\\0"); // Empty string becomes \0 marker
-
-			expect(deserializeActorKey(serialized1)).toEqual(emptyArray);
-			expect(deserializeActorKey(serialized2)).toEqual(
-				arrayWithEmptyString,
-			);
-		});
-
-		test("handles mix of empty strings and forward slash (EMPTY_KEY)", () => {
-			const testCases: Array<[string[], string]> = [
-				[["", EMPTY_KEY, ""], "\\0/\\//\\0"],
-				[[EMPTY_KEY, ""], "\\//\\0"],
-				[["", EMPTY_KEY], "\\0/\\/"],
-				[["a", "", EMPTY_KEY, "", "b"], "a/\\0/\\//\\0/b"],
-			];
-
-			for (const [key, expectedSerialized] of testCases) {
-				const serialized = serializeActorKey(key);
-				expect(serialized).toBe(expectedSerialized);
-				const deserialized = deserializeActorKey(serialized);
-				expect(deserialized).toEqual(key);
-			}
-		});
-
-		test("handles literal backslash-zero string", () => {
-			const testCases: Array<[string[], string]> = [
-				[["\\0"], "\\\\0"], // Literal \0 string
-				[["a\\0b"], "a\\\\0b"], // Literal \0 in middle
-				[["\\0", ""], "\\\\0/\\0"], // Literal \0 with empty string
-				[["", "\\0"], "\\0/\\\\0"], // Empty string with literal \0
-			];
-
-			for (const [key, expectedSerialized] of testCases) {
-				const serialized = serializeActorKey(key);
-				expect(serialized).toBe(expectedSerialized);
-				const deserialized = deserializeActorKey(serialized);
-				expect(deserialized).toEqual(key);
-			}
-		});
-
-		test("handles backslash at the end", () => {
-			const key = ["abc\\"];
-			const serialized = serializeActorKey(key);
-			expect(serialized).toBe("abc\\\\");
-			const deserialized = deserializeActorKey(serialized);
-			expect(deserialized).toEqual(key);
-		});
-
-		test("handles backslashes in middle of string", () => {
-			const testCases: Array<[string[], string]> = [
-				[["abc\\def"], "abc\\\\def"],
-				[["abc\\\\def"], "abc\\\\\\\\def"],
-				[["path\\to\\file"], "path\\\\to\\\\file"],
-			];
-
-			for (const [key, expectedSerialized] of testCases) {
-				const serialized = serializeActorKey(key);
-				expect(serialized).toBe(expectedSerialized);
-				const deserialized = deserializeActorKey(serialized);
-				expect(deserialized).toEqual(key);
-			}
-		});
-
-		test("handles forward slashes at the end of strings", () => {
-			const serialized = serializeActorKey(["abc\\/"]);
-			expect(deserializeActorKey(serialized)).toEqual(["abc\\/"]);
-		});
-
-		test("handles mixed backslashes and forward slashes", () => {
-			const testCases: Array<[string[], string]> = [
-				[["path\\to\\file/dir"], "path\\\\to\\\\file\\/dir"],
-				[["file\\with/slash"], "file\\\\with\\/slash"],
-				[
-					["path\\to\\file", "with/slash"],
-					"path\\\\to\\\\file/with\\/slash",
-				],
-			];
-
-			for (const [key, expectedSerialized] of testCases) {
-				const serialized = serializeActorKey(key);
-				expect(serialized).toBe(expectedSerialized);
-				const deserialized = deserializeActorKey(serialized);
-				expect(deserialized).toEqual(key);
-			}
-		});
-
-		test("handles multiple consecutive forward slashes", () => {
-			const key = ["a//b"];
-			const serialized = serializeActorKey(key);
-			expect(serialized).toBe("a\\/\\/b");
-			const deserialized = deserializeActorKey(serialized);
-			expect(deserialized).toEqual(key);
-		});
-
-		test("handles special characters", () => {
-			const key = ["a💻b", "c🔑d"];
-			const serialized = serializeActorKey(key);
-			expect(serialized).toBe("a💻b/c🔑d");
-			const deserialized = deserializeActorKey(serialized);
-			expect(deserialized).toEqual(key);
-		});
-
-		test("handles escaped forward slashes immediately after separator", () => {
-			const key = ["abc", "/def"];
-			const serialized = serializeActorKey(key);
-			expect(serialized).toBe(`abc${KEY_SEPARATOR}\\/def`);
-			expect(deserializeActorKey(serialized)).toEqual(key);
-		});
-	});
-
-	// Test exact key matching
-	describe("exact key matching", () => {
-		test("differentiates [a,b] from [a,b,c]", () => {
-			const key1 = ["a", "b"];
-			const key2 = ["a", "b", "c"];
-
-			const serialized1 = serializeActorKey(key1);
-			const serialized2 = serializeActorKey(key2);
-
-			expect(serialized1).not.toBe(serialized2);
-		});
-
-		test("differentiates [a,b] from [a]", () => {
-			const key1 = ["a", "b"];
-			const key2 = ["a"];
-
-			const serialized1 = serializeActorKey(key1);
-			const serialized2 = serializeActorKey(key2);
-
-			expect(serialized1).not.toBe(serialized2);
-		});
-
-		test("differentiates [a/b] from [a,b]", () => {
-			const key1 = ["a/b"];
-			const key2 = ["a", "b"];
-
-			const serialized1 = serializeActorKey(key1);
-			const serialized2 = serializeActorKey(key2);
-
-			expect(serialized1).not.toBe(serialized2);
-			expect(deserializeActorKey(serialized1)).toEqual(key1);
-			expect(deserializeActorKey(serialized2)).toEqual(key2);
-		});
-	});
-});

package/src/actor/utils.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { isConnStatePath, isStatePath } from "./utils";
-
-describe("isStatePath", () => {
-	test("matches exact state", () => {
-		expect(isStatePath("state")).toBe(true);
-	});
-
-	test("matches nested state paths", () => {
-		expect(isStatePath("state.foo")).toBe(true);
-		expect(isStatePath("state.foo.bar")).toBe(true);
-	});
-
-	test("does not match other paths", () => {
-		expect(isStatePath("connections")).toBe(false);
-		expect(isStatePath("stateX")).toBe(false);
-		expect(isStatePath("mystate")).toBe(false);
-	});
-});
-
-describe("isConnStatePath", () => {
-	test("matches connection state paths", () => {
-		expect(isConnStatePath("connections.0.state")).toBe(true);
-		expect(isConnStatePath("connections.123.state")).toBe(true);
-	});
-
-	test("matches nested connection state paths", () => {
-		expect(isConnStatePath("connections.0.state.foo")).toBe(true);
-		expect(isConnStatePath("connections.5.state.bar.baz")).toBe(true);
-	});
-
-	test("does not match non-state connection paths", () => {
-		expect(isConnStatePath("connections.0.params")).toBe(false);
-		expect(isConnStatePath("connections.0.token")).toBe(false);
-		expect(isConnStatePath("connections.0")).toBe(false);
-	});
-
-	test("does not match other paths", () => {
-		expect(isConnStatePath("state")).toBe(false);
-		expect(isConnStatePath("connections")).toBe(false);
-		expect(isConnStatePath("other.0.state")).toBe(false);
-	});
-
-	test("does not match malformed paths", () => {
-		expect(isConnStatePath("connections.state")).toBe(false);
-		expect(isConnStatePath("connections.0.stateX")).toBe(false);
-	});
-});

package/src/client/test.ts

@@ -1,44 +0,0 @@
-//import { exec as execCallback } from "node:child_process";
-//import { setupLogging } from "@/common//log";
-//import type { ClientOptions } from "./client";
-//import { InternalError } from "./errors";
-//import { Client } from "./mod.ts";
-//
-///**
-// * Uses the Rivet CLI to read the manager endpoint to connect to. This allows
-// * for writing tests that run locally without hardcoding the manager endpoint.
-// */
-//export async function readEndpointFromCli(): Promise<string> {
-//	// Read endpoint
-//	const cliPath = process.env.RIVET_CLI_PATH ?? "rivet";
-//
-//	try {
-//		const { stdout, stderr } = await new Promise<{
-//			stdout: string;
-//			stderr: string;
-//		}>((resolve, reject) => {
-//			execCallback(`${cliPath} manager endpoint`, (error, stdout, stderr) => {
-//				if (error) reject(error);
-//				else resolve({ stdout, stderr });
-//			});
-//		});
-//
-//		if (stderr) {
-//			throw new Error(stderr);
-//		}
-//
-//		// Decode output
-//		return stdout.trim();
-//	} catch (error) {
-//		throw new InternalError(`Read endpoint failed: ${error}`);
-//	}
-//}
-//
-//export class TestClient extends Client {
-//	public constructor(opts?: ClientOptions) {
-//		// Setup logging automatically
-//		setupLogging();
-//
-//		super(readEndpointFromCli(), opts);
-//	}
-//}

package/src/client/token-provider.test.ts

@@ -1,86 +0,0 @@
-import { describe, expect, test, vi } from "vitest";
-import {
-	isInvalidToken,
-	isInvalidTokenResponse,
-	TokenProvider,
-} from "./token-provider";
-
-describe("renewable client tokens", () => {
-	test("single-flights initial issuance and concurrent rejection refreshes", async () => {
-		const getToken = vi.fn(
-			async ({ forceRefresh }: { forceRefresh: boolean }) =>
-				forceRefresh ? "renewed" : "initial",
-		);
-		const provider = new TokenProvider(getToken);
-		expect(
-			await Promise.all([provider.current(), provider.current()]),
-		).toEqual(["initial", "initial"]);
-		expect(getToken).toHaveBeenCalledTimes(1);
-		expect(
-			await Promise.all([
-				provider.refreshIfCurrent("initial"),
-				provider.refreshIfCurrent("initial"),
-			]),
-		).toEqual(["renewed", "renewed"]);
-		expect(getToken).toHaveBeenCalledTimes(2);
-		expect(await provider.refreshIfCurrent("initial")).toBe("renewed");
-		expect(getToken).toHaveBeenCalledTimes(2);
-	});
-
-	test("retries failed issuance and refuses empty credentials", async () => {
-		const getToken = vi
-			.fn()
-			.mockRejectedValueOnce(new Error("issuer down"))
-			.mockResolvedValueOnce("ok");
-		const provider = new TokenProvider(getToken);
-		await expect(provider.current()).rejects.toThrow("issuer down");
-		expect(await provider.current()).toBe("ok");
-		await expect(
-			new TokenProvider(async () => "").current(),
-		).rejects.toThrow("nonempty");
-	});
-
-	test("refreshes before a known JWT expiry and treats opaque tokens as unexpiring hints", async () => {
-		const payload = btoa(
-			JSON.stringify({ exp: Math.floor(Date.now() / 1_000) + 1 }),
-		).replaceAll("=", "");
-		const getToken = vi.fn(async () => `header.${payload}.signature`);
-		const provider = new TokenProvider(getToken);
-		await provider.current();
-		await provider.current();
-		expect(getToken).toHaveBeenCalledTimes(2);
-		const opaque = vi.fn(async () => "opaque");
-		const opaqueProvider = new TokenProvider(opaque);
-		await opaqueProvider.current();
-		await opaqueProvider.current();
-		expect(opaque).toHaveBeenCalledTimes(1);
-	});
-
-	test("only confirmed 401 invalid/expired errors permit renewal", () => {
-		expect(isInvalidToken("auth", "invalid_token")).toBe(true);
-		expect(isInvalidToken("auth", "token_expired")).toBe(true);
-		for (const code of [
-			"insufficient_permissions",
-			"verification_unavailable",
-			"issuance_unavailable",
-		]) {
-			expect(isInvalidToken("auth", code)).toBe(false);
-		}
-		expect(
-			isInvalidTokenResponse(
-				new Response(null, {
-					status: 401,
-					headers: { "x-rivet-error": "auth.token_expired" },
-				}),
-			),
-		).toBe(true);
-		expect(
-			isInvalidTokenResponse(
-				new Response(null, {
-					status: 503,
-					headers: { "x-rivet-error": "auth.token_expired" },
-				}),
-			),
-		).toBe(false);
-	});
-});