rivetkit 2.3.30 → 3.0.0-preview.1

package/src/unstable/migrations.test.ts

@@ -1,170 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-import { afterEach, describe, expect, test } from "vitest";
-import {
-	DEFAULT_MIGRATION_TABLE_NAME,
-	migrations,
-	type MigrationDatabase,
-} from "./migrations";
-
-const databases: DatabaseSync[] = [];
-
-afterEach(() => {
-	for (const database of databases.splice(0)) database.close();
-});
-
-function createDatabase(): { raw: DatabaseSync; db: MigrationDatabase } {
-	const raw = new DatabaseSync(":memory:");
-	databases.push(raw);
-	return {
-		raw,
-		db: {
-			execute: async <TRow extends Record<string, unknown>>(
-				sql: string,
-				...args: unknown[]
-			): Promise<TRow[]> => {
-				if (args.length > 0 || /^\s*SELECT\b/i.test(sql)) {
-					return raw.prepare(sql).all(...(args as never[])) as TRow[];
-				}
-				raw.exec(sql);
-				return [];
-			},
-		},
-	};
-}
-
-describe("migrations", () => {
-	test("applies SQL and function migrations once in order", async () => {
-		const { raw, db } = createDatabase();
-		const applied: number[] = [];
-		const migrate = migrations({
-			tableName: "app_schema_version",
-			migrations: [
-				{
-					version: 1,
-					sql: "CREATE TABLE items (id INTEGER PRIMARY KEY, name TEXT NOT NULL)",
-				},
-				{
-					version: 2,
-					up: async (database) => {
-						applied.push(2);
-						await database.execute(
-							"ALTER TABLE items ADD COLUMN active INTEGER NOT NULL DEFAULT 1",
-						);
-					},
-				},
-			],
-		});
-
-		await migrate(db);
-		await migrate(db);
-
-		expect(applied).toEqual([2]);
-		expect(
-			raw
-				.prepare(
-					"SELECT schema_version FROM app_schema_version WHERE singleton = 1",
-				)
-				.get(),
-		).toEqual({ schema_version: 2 });
-		expect(
-			raw
-				.prepare("PRAGMA table_info(items)")
-				.all()
-				.map((row) => row.name),
-		).toEqual(["id", "name", "active"]);
-	});
-
-	test("uses the default migration table", async () => {
-		const { raw, db } = createDatabase();
-		await migrations({
-			migrations: [{ version: 1, sql: "CREATE TABLE item (id INTEGER)" }],
-		})(db);
-
-		expect(
-			raw
-				.prepare(
-					`SELECT schema_version FROM ${DEFAULT_MIGRATION_TABLE_NAME} WHERE singleton = 1`,
-				)
-				.get(),
-		).toEqual({ schema_version: 1 });
-	});
-
-	test("adopts an unversioned schema before applying later migrations", async () => {
-		const { raw, db } = createDatabase();
-		raw.exec(
-			"CREATE TABLE items (id INTEGER PRIMARY KEY, name TEXT NOT NULL)",
-		);
-		const applied: number[] = [];
-
-		await migrations({
-			tableName: "app_schema_version",
-			adopt: async (database) => {
-				const tables = await database.execute<{ name: string }>(
-					"SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'items'",
-				);
-				return tables.length === 0 ? 0 : 1;
-			},
-			migrations: [
-				{
-					version: 1,
-					up: () => {
-						throw new Error("already applied migration ran");
-					},
-				},
-				{
-					version: 2,
-					up: async (database) => {
-						applied.push(2);
-						await database.execute(
-							"ALTER TABLE items ADD COLUMN active INTEGER NOT NULL DEFAULT 1",
-						);
-					},
-				},
-			],
-		})(db);
-
-		expect(applied).toEqual([2]);
-		expect(
-			raw
-				.prepare(
-					"SELECT schema_version FROM app_schema_version WHERE singleton = 1",
-				)
-				.get(),
-		).toEqual({ schema_version: 2 });
-	});
-
-	test("rejects invalid ladders and table names before executing", () => {
-		expect(() => migrations({ migrations: [] })).toThrow(
-			"must not be empty",
-		);
-		expect(() =>
-			migrations({
-				migrations: [{ version: 2, sql: "SELECT 1" }],
-			}),
-		).toThrow("expected version 1");
-		expect(() =>
-			migrations({
-				tableName: "schema; DROP TABLE items",
-				migrations: [{ version: 1, sql: "SELECT 1" }],
-			}),
-		).toThrow("invalid migration table name");
-	});
-
-	test("rejects a database newer than the migration ladder", async () => {
-		const { raw, db } = createDatabase();
-		raw.exec(`
-			CREATE TABLE app_schema_version (
-				singleton INTEGER PRIMARY KEY,
-				schema_version INTEGER NOT NULL
-			) STRICT;
-			INSERT INTO app_schema_version VALUES (1, 2);
-		`);
-
-		await expect(
-			migrations({
-				tableName: "app_schema_version",
-				migrations: [{ version: 1, sql: "SELECT 1" }],
-			})(db),
-		).rejects.toThrow("newer than supported version 1");
-	});
-});

package/src/utils/endpoint-parser.test.ts

@@ -1,206 +0,0 @@
-import { describe, expect, test } from "vitest";
-import type { z } from "zod/v4";
-import { tryParseEndpoint } from "./endpoint-parser";
-
-// Helper to create a mock Zod refinement context for testing
-function createMockCtx(): { ctx: z.RefinementCtx; issues: z.ZodIssue[] } {
-	const issues: z.ZodIssue[] = [];
-	const ctx = {
-		addIssue: (issue: z.IssueData) => {
-			issues.push(issue as z.ZodIssue);
-		},
-		path: [],
-		value: undefined,
-		issues: [],
-	} as unknown as z.RefinementCtx;
-	return { ctx, issues };
-}
-
-describe("tryParseEndpoint", () => {
-	describe("basic parsing", () => {
-		test("parses endpoint with full auth", () => {
-			const { ctx, issues } = createMockCtx();
-			const result = tryParseEndpoint(ctx, {
-				endpoint: "https://foo:bar@api.rivet.dev",
-			});
-			expect(issues).toHaveLength(0);
-			expect(result).toEqual({
-				endpoint: "https://api.rivet.dev/",
-				namespace: "foo",
-				token: "bar",
-			});
-		});
-
-		test("parses endpoint with namespace only", () => {
-			const { ctx, issues } = createMockCtx();
-			const result = tryParseEndpoint(ctx, {
-				endpoint: "https://foo@api.rivet.dev",
-			});
-			expect(issues).toHaveLength(0);
-			expect(result).toEqual({
-				endpoint: "https://api.rivet.dev/",
-				namespace: "foo",
-				token: undefined,
-			});
-		});
-
-		test("parses endpoint without auth", () => {
-			const { ctx, issues } = createMockCtx();
-			const result = tryParseEndpoint(ctx, {
-				endpoint: "https://api.rivet.dev",
-			});
-			expect(issues).toHaveLength(0);
-			expect(result).toEqual({
-				endpoint: "https://api.rivet.dev/",
-				namespace: undefined,
-				token: undefined,
-			});
-		});
-
-		test("preserves path", () => {
-			const { ctx, issues } = createMockCtx();
-			const result = tryParseEndpoint(ctx, {
-				endpoint: "https://foo:bar@api.rivet.dev/v1/actors",
-			});
-			expect(issues).toHaveLength(0);
-			expect(result).toEqual({
-				endpoint: "https://api.rivet.dev/v1/actors",
-				namespace: "foo",
-				token: "bar",
-			});
-		});
-	});
-
-	describe("validation errors", () => {
-		test("adds issue for invalid URL", () => {
-			const { ctx, issues } = createMockCtx();
-			const result = tryParseEndpoint(ctx, { endpoint: "not-a-url" });
-			expect(result).toBeUndefined();
-			expect(issues).toHaveLength(1);
-			expect(issues[0]?.message).toContain("invalid URL");
-		});
-
-		test("adds issue for query string", () => {
-			const { ctx, issues } = createMockCtx();
-			const result = tryParseEndpoint(ctx, {
-				endpoint: "https://foo:bar@api.rivet.dev?region=us",
-			});
-			expect(result).toBeUndefined();
-			expect(issues).toHaveLength(1);
-			expect(issues[0]?.message).toBe(
-				"endpoint cannot contain a query string",
-			);
-		});
-
-		test("adds issue for fragment", () => {
-			const { ctx, issues } = createMockCtx();
-			const result = tryParseEndpoint(ctx, {
-				endpoint: "https://foo:bar@api.rivet.dev#section",
-			});
-			expect(result).toBeUndefined();
-			expect(issues).toHaveLength(1);
-			expect(issues[0]?.message).toBe(
-				"endpoint cannot contain a fragment",
-			);
-		});
-
-		test("adds issue for token without namespace", () => {
-			const { ctx, issues } = createMockCtx();
-			const result = tryParseEndpoint(ctx, {
-				endpoint: "https://:token@api.rivet.dev",
-			});
-			expect(result).toBeUndefined();
-			expect(issues).toHaveLength(1);
-			expect(issues[0]?.message).toBe(
-				"endpoint cannot have a token without a namespace",
-			);
-		});
-	});
-
-	describe("duplicate credential checking", () => {
-		test("adds issue when namespace in URL and config", () => {
-			const { ctx, issues } = createMockCtx();
-			const result = tryParseEndpoint(ctx, {
-				endpoint: "https://url-ns@api.rivet.dev",
-				path: ["endpoint"],
-				namespace: "config-ns",
-			});
-			// Still returns result, but adds issue
-			expect(result).toEqual({
-				endpoint: "https://api.rivet.dev/",
-				namespace: "url-ns",
-				token: undefined,
-			});
-			expect(issues).toHaveLength(1);
-			expect(issues[0]?.message).toContain(
-				"cannot specify namespace both in endpoint URL and as a separate config option",
-			);
-			expect(issues[0]?.path).toEqual(["namespace"]);
-		});
-
-		test("adds issue when token in URL and config", () => {
-			const { ctx, issues } = createMockCtx();
-			const result = tryParseEndpoint(ctx, {
-				endpoint: "https://ns:url-token@api.rivet.dev",
-				path: ["endpoint"],
-				token: "config-token",
-			});
-			// Still returns result, but adds issue
-			expect(result).toEqual({
-				endpoint: "https://api.rivet.dev/",
-				namespace: "ns",
-				token: "url-token",
-			});
-			expect(issues).toHaveLength(1);
-			expect(issues[0]?.message).toContain(
-				"cannot specify token both in endpoint URL and as a separate config option",
-			);
-			expect(issues[0]?.path).toEqual(["token"]);
-		});
-
-		test("adds issues for both namespace and token duplicates", () => {
-			const { ctx, issues } = createMockCtx();
-			const result = tryParseEndpoint(ctx, {
-				endpoint: "https://url-ns:url-token@api.rivet.dev",
-				path: ["endpoint"],
-				namespace: "config-ns",
-				token: "config-token",
-			});
-			expect(result).toBeDefined();
-			expect(issues).toHaveLength(2);
-		});
-
-		test("no issue when namespace only in URL", () => {
-			const { ctx, issues } = createMockCtx();
-			const result = tryParseEndpoint(ctx, {
-				endpoint: "https://url-ns@api.rivet.dev",
-				path: ["endpoint"],
-				token: "config-token",
-			});
-			expect(result).toBeDefined();
-			expect(issues).toHaveLength(0);
-		});
-
-		test("no issue when namespace only in config", () => {
-			const { ctx, issues } = createMockCtx();
-			const result = tryParseEndpoint(ctx, {
-				endpoint: "https://api.rivet.dev",
-				path: ["endpoint"],
-				namespace: "config-ns",
-			});
-			expect(result).toBeDefined();
-			expect(issues).toHaveLength(0);
-		});
-	});
-
-	describe("custom path", () => {
-		test("uses custom path in error issues", () => {
-			const { ctx, issues } = createMockCtx();
-			tryParseEndpoint(ctx, {
-				endpoint: "not-a-url",
-				path: ["serverless", "publicEndpoint"],
-			});
-			expect(issues[0]?.path).toEqual(["serverless", "publicEndpoint"]);
-		});
-	});
-});

package/src/utils.test.ts

@@ -1,34 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { joinSignals } from "./utils";
-
-describe("joinSignals", () => {
-	test("returns a non-aborted signal when no inputs are provided", () => {
-		const signal = joinSignals();
-		expect(signal.aborted).toBe(false);
-	});
-
-	test("returns the same signal when only one input is provided", () => {
-		const controller = new AbortController();
-		const signal = joinSignals(controller.signal);
-		expect(signal).toBe(controller.signal);
-	});
-
-	test("aborts immediately when any input signal is already aborted", () => {
-		const controllerA = new AbortController();
-		const controllerB = new AbortController();
-		controllerA.abort("already-aborted");
-
-		const signal = joinSignals(controllerA.signal, controllerB.signal);
-		expect(signal.aborted).toBe(true);
-	});
-
-	test("aborts when one of the joined signals aborts", () => {
-		const controllerA = new AbortController();
-		const controllerB = new AbortController();
-		const signal = joinSignals(controllerA.signal, controllerB.signal);
-
-		expect(signal.aborted).toBe(false);
-		controllerB.abort("stopped");
-		expect(signal.aborted).toBe(true);
-	});
-});

package/src/workflow/driver.test.ts

@@ -1,62 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { ActorWorkflowDriver, chunkWorkflowWrites } from "./driver";
-
-function write(keyBytes: number, valueBytes: number) {
-	return {
-		key: new Uint8Array(keyBytes),
-		value: new Uint8Array(valueBytes),
-	};
-}
-
-describe("workflow sqlite batching", () => {
-	test.each([
-		[127, 1],
-		[128, 1],
-		[129, 2],
-	])("chunks %i rows into %i transaction(s)", (rowCount, chunkCount) => {
-		const chunks = chunkWorkflowWrites(
-			Array.from({ length: rowCount }, () => write(1, 1)),
-		);
-		expect(chunks).toHaveLength(chunkCount);
-		expect(chunks.flat()).toHaveLength(rowCount);
-		expect(chunks.every((chunk) => chunk.length <= 128)).toBe(true);
-	});
-
-	test("splits immediately above the 512 KiB payload budget", () => {
-		// Each persisted key also includes the two-byte workflow namespace.
-		const exact = [write(1, 256 * 1024 - 3), write(1, 256 * 1024 - 3)];
-		expect(chunkWorkflowWrites(exact)).toHaveLength(1);
-
-		const over = [write(1, 256 * 1024 - 3), write(1, 256 * 1024 - 2)];
-		expect(chunkWorkflowWrites(over)).toHaveLength(2);
-	});
-
-	test("delegates actor state and the whole workflow batch to one atomic runtime call", async () => {
-		let receivedWrites: Array<{ key: Uint8Array; value: Uint8Array }> = [];
-		const sql = {
-			query: async () => ({ columns: [], rows: [] }),
-			execute: async () => [],
-			run: async () => ({ changes: 0 }),
-			executeBatch: async () => [],
-		};
-		const actor = {
-			stateManager: {
-				saveStateAndWorkflowBatch: async (
-					writes: Array<{ key: Uint8Array; value: Uint8Array }>,
-				) => {
-					receivedWrites = writes;
-				},
-			},
-			queueManager: {},
-		};
-		const runCtx = {
-			sql,
-			internalKeepAwake: async <T>(promise: Promise<T>) => await promise,
-		};
-		const driver = new ActorWorkflowDriver(actor as never, runCtx as never);
-		const writes = [write(1, 1), write(2, 2)];
-		await driver.batch(writes);
-		expect(driver.atomicBatch).toBe(true);
-		expect(receivedWrites).toBe(writes);
-	});
-});