rivetkit 2.0.37 → 2.0.39

package/src/serverless/router.test.ts

@@ -26,6 +26,12 @@ describe("normalizeEndpointUrl", () => {
 		);
 	});
 
+	test("normalizes IPv6 loopback [::1] to localhost", () => {
+		expect(normalizeEndpointUrl("http://[::1]:6420")).toBe(
+			"http://localhost:6420/",
+		);
+	});
+
 	test("preserves path without trailing slash", () => {
 		expect(normalizeEndpointUrl("http://example.com/api/v1")).toBe(
 			"http://example.com/api/v1",
@@ -69,6 +75,50 @@ describe("normalizeEndpointUrl", () => {
 	test("returns null for empty string", () => {
 		expect(normalizeEndpointUrl("")).toBeNull();
 	});
+
+	describe("regional endpoint normalization", () => {
+		test("normalizes api-us-west-1.rivet.dev to api.rivet.dev", () => {
+			expect(normalizeEndpointUrl("https://api-us-west-1.rivet.dev")).toBe(
+				"https://api.rivet.dev/",
+			);
+		});
+
+		test("normalizes api-lax.staging.rivet.dev to api.staging.rivet.dev", () => {
+			expect(
+				normalizeEndpointUrl("https://api-lax.staging.rivet.dev"),
+			).toBe("https://api.staging.rivet.dev/");
+		});
+
+		test("preserves api.rivet.dev unchanged", () => {
+			expect(normalizeEndpointUrl("https://api.rivet.dev")).toBe(
+				"https://api.rivet.dev/",
+			);
+		});
+
+		test("does not normalize non-api prefixed hostnames", () => {
+			expect(normalizeEndpointUrl("https://foo-bar.rivet.dev")).toBe(
+				"https://foo-bar.rivet.dev/",
+			);
+		});
+
+		test("does not normalize non-rivet.dev domains", () => {
+			expect(normalizeEndpointUrl("https://api-us-west-1.example.com")).toBe(
+				"https://api-us-west-1.example.com/",
+			);
+		});
+
+		test("preserves path when normalizing regional endpoint", () => {
+			expect(
+				normalizeEndpointUrl("https://api-us-west-1.rivet.dev/v1/actors"),
+			).toBe("https://api.rivet.dev/v1/actors");
+		});
+
+		test("preserves port when normalizing regional endpoint", () => {
+			expect(
+				normalizeEndpointUrl("https://api-us-west-1.rivet.dev:8080"),
+			).toBe("https://api.rivet.dev:8080/");
+		});
+	});
 });
 
 describe("endpointsMatch", () => {
@@ -102,6 +152,12 @@ describe("endpointsMatch", () => {
 		).toBe(true);
 	});
 
+	test("matches localhost and IPv6 loopback [::1]", () => {
+		expect(
+			endpointsMatch("http://localhost:6420", "http://[::1]:6420"),
+		).toBe(true);
+	});
+
 	test("does not match different hosts", () => {
 		expect(
 			endpointsMatch("http://localhost:6420", "http://example.com:6420"),
@@ -130,4 +186,114 @@ describe("endpointsMatch", () => {
 		expect(endpointsMatch("not-a-url", "not-a-url")).toBe(true);
 		expect(endpointsMatch("not-a-url", "different")).toBe(false);
 	});
+
+	describe("regional endpoint matching", () => {
+		test("matches api.rivet.dev with api-us-west-1.rivet.dev", () => {
+			expect(
+				endpointsMatch(
+					"https://api.rivet.dev",
+					"https://api-us-west-1.rivet.dev",
+				),
+			).toBe(true);
+		});
+
+		test("matches api-us-west-1.rivet.dev with api.rivet.dev (reverse order)", () => {
+			expect(
+				endpointsMatch(
+					"https://api-us-west-1.rivet.dev",
+					"https://api.rivet.dev",
+				),
+			).toBe(true);
+		});
+
+		test("matches api.staging.rivet.dev with api-lax.staging.rivet.dev", () => {
+			expect(
+				endpointsMatch(
+					"https://api.staging.rivet.dev",
+					"https://api-lax.staging.rivet.dev",
+				),
+			).toBe(true);
+		});
+
+		test("matches api-lax.staging.rivet.dev with api.staging.rivet.dev (reverse order)", () => {
+			expect(
+				endpointsMatch(
+					"https://api-lax.staging.rivet.dev",
+					"https://api.staging.rivet.dev",
+				),
+			).toBe(true);
+		});
+
+		test("matches with paths", () => {
+			expect(
+				endpointsMatch(
+					"https://api.rivet.dev/v1/actors",
+					"https://api-us-west-1.rivet.dev/v1/actors",
+				),
+			).toBe(true);
+		});
+
+		test("does not match different domains", () => {
+			expect(
+				endpointsMatch(
+					"https://api.rivet.dev",
+					"https://api-us-west-1.example.com",
+				),
+			).toBe(false);
+		});
+
+		test("does not match different protocols", () => {
+			expect(
+				endpointsMatch(
+					"http://api.rivet.dev",
+					"https://api-us-west-1.rivet.dev",
+				),
+			).toBe(false);
+		});
+
+		test("does not match different paths", () => {
+			expect(
+				endpointsMatch(
+					"https://api.rivet.dev/v1",
+					"https://api-us-west-1.rivet.dev/v2",
+				),
+			).toBe(false);
+		});
+
+		test("does not match different ports", () => {
+			expect(
+				endpointsMatch(
+					"https://api.rivet.dev:8080",
+					"https://api-us-west-1.rivet.dev:9090",
+				),
+			).toBe(false);
+		});
+
+		test("matches with same port", () => {
+			expect(
+				endpointsMatch(
+					"https://api.rivet.dev:8080",
+					"https://api-us-west-1.rivet.dev:8080",
+				),
+			).toBe(true);
+		});
+
+		test("does not match non-api prefixed hosts", () => {
+			expect(
+				endpointsMatch(
+					"https://foo.rivet.dev",
+					"https://foo-us-west-1.rivet.dev",
+				),
+			).toBe(false);
+		});
+
+		test("does not match api.staging.rivet.dev with api-us-west-1.rivet.dev (different base domains)", () => {
+			expect(
+				endpointsMatch(
+					"https://api.staging.rivet.dev",
+					"https://api-us-west-1.rivet.dev",
+				),
+			).toBe(false);
+		});
+	});
 });

package/src/serverless/router.ts

@@ -124,7 +124,8 @@ export function buildServerlessRouter(
 
 /**
  * Normalizes a URL for comparison by extracting protocol, host, port, and pathname.
- * Normalizes 127.0.0.1 and 0.0.0.0 to localhost for consistent comparison.
+ * Normalizes loopback addresses (127.0.0.1, 0.0.0.0, ::1) to localhost for consistent comparison.
+ * Normalizes regional endpoints (api-*.domain) to base endpoints (api.domain).
  * Returns null if the URL is invalid.
  */
 export function normalizeEndpointUrl(url: string): string | null {
@@ -133,13 +134,20 @@ export function normalizeEndpointUrl(url: string): string | null {
 		// Normalize pathname by removing trailing slash (except for root)
 		const pathname =
 			parsed.pathname === "/" ? "/" : parsed.pathname.replace(/\/+$/, "");
+
 		// Normalize loopback addresses to localhost
-		const hostname =
-			parsed.hostname === "127.0.0.1" || parsed.hostname === "0.0.0.0"
-				? "localhost"
-				: parsed.hostname;
+		let hostname = isLoopbackAddress(parsed.hostname)
+			? "localhost"
+			: parsed.hostname;
+
+		// Normalize regional endpoints (api-region.domain) to base endpoints (api.domain)
+		// HACK: This is specific to Rivet Cloud and will not work for self-hosted
+		// engines with different regional endpoint naming conventions.
+		hostname = normalizeRegionalHostname(hostname);
+
 		// Reconstruct host with normalized hostname and port
 		const host = parsed.port ? `${hostname}:${parsed.port}` : hostname;
+
 		// Reconstruct normalized URL with protocol, host, and pathname
 		return `${parsed.protocol}//${host}${pathname}`;
 	} catch {
@@ -147,6 +155,39 @@ export function normalizeEndpointUrl(url: string): string | null {
 	}
 }
 
+/**
+ * Normalizes regional hostnames (api-region.domain) to base hostnames (api.domain).
+ * Only applies to rivet.dev domains.
+ *
+ * Examples:
+ * - api-us-west-1.rivet.dev -> api.rivet.dev
+ * - api-lax.staging.rivet.dev -> api.staging.rivet.dev
+ * - api.rivet.dev -> api.rivet.dev (unchanged)
+ * - api-us-west-1.example.com -> api-us-west-1.example.com (unchanged, not rivet.dev)
+ * - foo-bar.rivet.dev -> foo-bar.rivet.dev (unchanged, not api- prefix)
+ */
+function normalizeRegionalHostname(hostname: string): string {
+	// Only apply to rivet.dev domains
+	if (!hostname.endsWith(".rivet.dev")) {
+		return hostname;
+	}
+
+	if (!hostname.startsWith("api-")) {
+		return hostname;
+	}
+
+	// Find the first dot after "api-"
+	const withoutPrefix = hostname.slice(4); // Remove "api-"
+	const firstDotIndex = withoutPrefix.indexOf(".");
+	if (firstDotIndex === -1) {
+		return hostname;
+	}
+
+	// Extract the domain part and prepend "api."
+	const domain = withoutPrefix.slice(firstDotIndex + 1);
+	return `api.${domain}`;
+}
+
 /**
  * Compares two endpoint URLs after normalization.
  * Returns true if they match (same protocol, host, port, and path).
@@ -160,3 +201,15 @@ export function endpointsMatch(a: string, b: string): boolean {
 	}
 	return normalizedA === normalizedB;
 }
+
+/**
+ * Checks if a hostname is a loopback address that should be normalized to localhost.
+ */
+function isLoopbackAddress(hostname: string): boolean {
+	return (
+		hostname === "127.0.0.1" ||
+		hostname === "0.0.0.0" ||
+		hostname === "::1" ||
+		hostname === "[::1]"
+	);
+}

package/src/utils/env-vars.ts

@@ -1,4 +1,7 @@
-// TODO: briefly document this file is used for consolidating all env vars that affect rivet's behavior
+// This file consolidates all environment variables that affect RivetKit's behavior.
+//
+// IMPORTANT: When adding or modifying environment variables here, also update the
+// documentation at: docs/general/registry-configuration.mdx
 
 import { getEnvUniversal } from "@/utils";