rivetkit 2.0.2 → 2.0.4

package/src/client/raw-utils.ts

@@ -0,0 +1,149 @@
+import invariant from "invariant";
+import { PATH_RAW_WEBSOCKET_PREFIX } from "@/actor/router";
+import { deconstructError } from "@/common/utils";
+import { HEADER_CONN_PARAMS, type ManagerDriver } from "@/driver-helpers/mod";
+import type { ActorQuery } from "@/manager/protocol/query";
+import { queryActor } from "./actor-query";
+import { ActorError } from "./errors";
+import { logger } from "./log";
+
+/**
+ * Shared implementation for raw HTTP fetch requests
+ */
+export async function rawHttpFetch(
+	driver: ManagerDriver,
+	actorQuery: ActorQuery,
+	params: unknown,
+	input: string | URL | Request,
+	init?: RequestInit,
+): Promise<Response> {
+	// Extract path and merge init options
+	let path: string;
+	let mergedInit: RequestInit = init || {};
+
+	if (typeof input === "string") {
+		path = input;
+	} else if (input instanceof URL) {
+		path = input.pathname + input.search;
+	} else if (input instanceof Request) {
+		// Extract path from Request URL
+		const url = new URL(input.url);
+		path = url.pathname + url.search;
+		// Merge Request properties with init
+		const requestHeaders = new Headers(input.headers);
+		const initHeaders = new Headers(init?.headers || {});
+
+		// Merge headers - init headers override request headers
+		const mergedHeaders = new Headers(requestHeaders);
+		for (const [key, value] of initHeaders) {
+			mergedHeaders.set(key, value);
+		}
+
+		mergedInit = {
+			method: input.method,
+			body: input.body,
+			mode: input.mode,
+			credentials: input.credentials,
+			redirect: input.redirect,
+			referrer: input.referrer,
+			referrerPolicy: input.referrerPolicy,
+			integrity: input.integrity,
+			keepalive: input.keepalive,
+			signal: input.signal,
+			...mergedInit, // init overrides Request properties
+			headers: mergedHeaders, // headers must be set after spread to ensure proper merge
+		};
+		// Add duplex if body is present
+		if (mergedInit.body) {
+			(mergedInit as any).duplex = "half";
+		}
+	} else {
+		throw new TypeError("Invalid input type for fetch");
+	}
+
+	try {
+		// Get the actor ID
+		const { actorId } = await queryActor(undefined, actorQuery, driver);
+		logger().debug({ msg: "found actor for raw http", actorId });
+		invariant(actorId, "Missing actor ID");
+
+		// Build the URL with normalized path
+		const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+		const url = new URL(`http://actor/raw/http/${normalizedPath}`);
+
+		// Forward conn params if provided
+		const proxyRequestHeaders = new Headers(mergedInit.headers);
+		if (params) {
+			proxyRequestHeaders.set(HEADER_CONN_PARAMS, JSON.stringify(params));
+		}
+
+		// Forward the request to the actor
+		const proxyRequest = new Request(url, {
+			...init,
+			headers: proxyRequestHeaders,
+		});
+
+		return driver.sendRequest(actorId, proxyRequest);
+	} catch (err) {
+		// Standardize to ClientActorError instead of the native backend error
+		const { group, code, message, metadata } = deconstructError(
+			err,
+			logger(),
+			{},
+			true,
+		);
+		throw new ActorError(group, code, message, metadata);
+	}
+}
+
+/**
+ * Shared implementation for raw WebSocket connections
+ */
+export async function rawWebSocket(
+	driver: ManagerDriver,
+	actorQuery: ActorQuery,
+	params: unknown,
+	path?: string,
+	// TODO: Supportp rotocols
+	protocols?: string | string[],
+): Promise<any> {
+	// TODO: Do we need encoding in rawWebSocket?
+	const encoding = "bare";
+
+	// Get the actor ID
+	const { actorId } = await queryActor(undefined, actorQuery, driver);
+	logger().debug({ msg: "found actor for action", actorId });
+	invariant(actorId, "Missing actor ID");
+
+	// Parse path and query parameters
+	let pathPortion = "";
+	let queryPortion = "";
+	if (path) {
+		const queryIndex = path.indexOf("?");
+		if (queryIndex !== -1) {
+			pathPortion = path.substring(0, queryIndex);
+			queryPortion = path.substring(queryIndex); // includes the '?'
+		} else {
+			pathPortion = path;
+		}
+		// Remove leading slash if present
+		if (pathPortion.startsWith("/")) {
+			pathPortion = pathPortion.slice(1);
+		}
+	}
+
+	const fullPath = `${PATH_RAW_WEBSOCKET_PREFIX}${pathPortion}${queryPortion}`;
+
+	logger().debug({
+		msg: "opening websocket",
+		actorId,
+		encoding,
+		path: fullPath,
+	});
+
+	// Open WebSocket
+	const ws = await driver.openWebSocket(fullPath, actorId, encoding, params);
+
+	// Node & browser WebSocket types are incompatible
+	return ws as any;
+}

package/src/client/test.ts

@@ -0,0 +1,44 @@
+//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/utils.ts

@@ -0,0 +1,152 @@
+import * as cbor from "cbor-x";
+import invariant from "invariant";
+import { assertUnreachable } from "@/common/utils";
+import type { VersionedDataHandler } from "@/common/versioned-data";
+import type { Encoding } from "@/mod";
+import type { HttpResponseError } from "@/schemas/client-protocol/mod";
+import { HTTP_RESPONSE_ERROR_VERSIONED } from "@/schemas/client-protocol/versioned";
+import {
+	contentTypeForEncoding,
+	deserializeWithEncoding,
+	serializeWithEncoding,
+} from "@/serde";
+import { httpUserAgent } from "@/utils";
+import { ActorError, HttpRequestError } from "./errors";
+import { logger } from "./log";
+
+export type WebSocketMessage = string | Blob | ArrayBuffer | Uint8Array;
+
+export function messageLength(message: WebSocketMessage): number {
+	if (message instanceof Blob) {
+		return message.size;
+	}
+	if (message instanceof ArrayBuffer) {
+		return message.byteLength;
+	}
+	if (message instanceof Uint8Array) {
+		return message.byteLength;
+	}
+	if (typeof message === "string") {
+		return message.length;
+	}
+	assertUnreachable(message);
+}
+
+export interface HttpRequestOpts<RequestBody, ResponseBody> {
+	method: string;
+	url: string;
+	headers: Record<string, string>;
+	body?: RequestBody;
+	encoding: Encoding;
+	skipParseResponse?: boolean;
+	signal?: AbortSignal;
+	customFetch?: (req: Request) => Promise<Response>;
+	requestVersionedDataHandler: VersionedDataHandler<RequestBody> | undefined;
+	responseVersionedDataHandler: VersionedDataHandler<ResponseBody> | undefined;
+}
+
+export async function sendHttpRequest<
+	RequestBody = unknown,
+	ResponseBody = unknown,
+>(opts: HttpRequestOpts<RequestBody, ResponseBody>): Promise<ResponseBody> {
+	logger().debug({
+		msg: "sending http request",
+		url: opts.url,
+		encoding: opts.encoding,
+	});
+
+	// Serialize body
+	let contentType: string | undefined;
+	let bodyData: string | Uint8Array | undefined;
+	if (opts.method === "POST" || opts.method === "PUT") {
+		invariant(opts.body !== undefined, "missing body");
+		contentType = contentTypeForEncoding(opts.encoding);
+		bodyData = serializeWithEncoding<RequestBody>(
+			opts.encoding,
+			opts.body,
+			opts.requestVersionedDataHandler,
+		);
+	}
+
+	// Send request
+	let response: Response;
+	try {
+		// Make the HTTP request
+		response = await (opts.customFetch ?? fetch)(
+			new Request(opts.url, {
+				method: opts.method,
+				headers: {
+					...opts.headers,
+					...(contentType
+						? {
+								"Content-Type": contentType,
+							}
+						: {}),
+					"User-Agent": httpUserAgent(),
+				},
+				body: bodyData,
+				credentials: "include",
+				signal: opts.signal,
+			}),
+		);
+	} catch (error) {
+		throw new HttpRequestError(`Request failed: ${error}`, {
+			cause: error,
+		});
+	}
+
+	// Parse response error
+	if (!response.ok) {
+		// Attempt to parse structured data
+		const bufferResponse = await response.arrayBuffer();
+		let responseData: HttpResponseError;
+		try {
+			responseData = deserializeWithEncoding(
+				opts.encoding,
+				new Uint8Array(bufferResponse),
+				HTTP_RESPONSE_ERROR_VERSIONED,
+			);
+		} catch (error) {
+			//logger().warn("failed to cleanly parse error, this is likely because a non-structured response is being served", {
+			//	error: stringifyError(error),
+			//});
+
+			// Error is not structured
+			const textResponse = new TextDecoder("utf-8", { fatal: false }).decode(
+				bufferResponse,
+			);
+			throw new HttpRequestError(
+				`${response.statusText} (${response.status}):\n${textResponse}`,
+			);
+		}
+
+		// Throw structured error
+		throw new ActorError(
+			responseData.group,
+			responseData.code,
+			responseData.message,
+			responseData.metadata
+				? cbor.decode(new Uint8Array(responseData.metadata))
+				: undefined,
+		);
+	}
+
+	// Some requests don't need the success response to be parsed, so this can speed things up
+	if (opts.skipParseResponse) {
+		return undefined as ResponseBody;
+	}
+
+	// Parse the response based on encoding
+	try {
+		const buffer = new Uint8Array(await response.arrayBuffer());
+		return deserializeWithEncoding(
+			opts.encoding,
+			buffer,
+			opts.responseVersionedDataHandler,
+		);
+	} catch (error) {
+		throw new HttpRequestError(`Failed to parse response: ${error}`, {
+			cause: error,
+		});
+	}
+}

package/src/common/eventsource-interface.ts

@@ -0,0 +1,47 @@
+// Define minimal event interfaces to avoid conflicts between different EventSource implementations
+export interface UniversalEvent {
+	type: string;
+	target?: any;
+	currentTarget?: any;
+}
+
+export interface UniversalMessageEvent extends UniversalEvent {
+	data: string;
+	lastEventId: string;
+	origin: string;
+}
+
+export interface UniversalErrorEvent extends UniversalEvent {
+	message: string;
+	filename?: string;
+	lineno?: number;
+	colno?: number;
+	error?: any;
+}
+
+/**
+ * Common EventSource interface that can be implemented by different EventSource-like classes
+ * This is compatible with the standard EventSource API but allows for custom implementations
+ */
+export interface UniversalEventSource {
+	// EventSource readyState values
+	readonly CONNECTING: 0;
+	readonly OPEN: 1;
+	readonly CLOSED: 2;
+
+	// Properties
+	readonly readyState: 0 | 1 | 2;
+	readonly url: string;
+	readonly withCredentials: boolean;
+
+	// Methods
+	close(): void;
+	addEventListener(type: string, listener: (event: any) => void): void;
+	removeEventListener(type: string, listener: (event: any) => void): void;
+	dispatchEvent(event: UniversalEvent): boolean;
+
+	// Event handlers (optional)
+	onopen?: ((event: UniversalEvent) => void) | null;
+	onmessage?: ((event: UniversalMessageEvent) => void) | null;
+	onerror?: ((event: UniversalErrorEvent) => void) | null;
+}

package/src/common/eventsource.ts

@@ -0,0 +1,80 @@
+import type { EventSource } from "eventsource";
+import { logger } from "@/client/log";
+
+// Global singleton promise that will be reused for subsequent calls
+let eventSourcePromise: Promise<typeof EventSource> | null = null;
+
+/**
+ * Import `eventsource` from the custom `eventsource` library. We need a custom implemnetation since we need to attach our own custom headers to the request.
+ **/
+export async function importEventSource(): Promise<typeof EventSource> {
+	// Return existing promise if we already started loading
+	if (eventSourcePromise !== null) {
+		return eventSourcePromise;
+	}
+
+	// Create and store the promise
+	eventSourcePromise = (async () => {
+		let _EventSource: typeof EventSource;
+
+		// Node.js environment
+		try {
+			const es = await import("eventsource");
+			_EventSource = es.EventSource;
+			logger().debug("using eventsource from npm");
+		} catch (err) {
+			// EventSource not available
+			_EventSource = class MockEventSource {
+				constructor() {
+					throw new Error(
+						'EventSource support requires installing the "eventsource" peer dependency.',
+					);
+				}
+			} as unknown as typeof EventSource;
+			logger().debug("using mock eventsource");
+		}
+
+		return _EventSource;
+	})();
+
+	return eventSourcePromise;
+}
+
+//export async function importEventSource(): Promise<typeof EventSource> {
+//	// Return existing promise if we already started loading
+//	if (eventSourcePromise !== null) {
+//		return eventSourcePromise;
+//	}
+//
+//	// Create and store the promise
+//	eventSourcePromise = (async () => {
+//		let _EventSource: typeof EventSource;
+//
+//		if (typeof EventSource !== "undefined") {
+//			// Browser environment
+//			_EventSource = EventSource;
+//			logger().debug("using native eventsource");
+//		} else {
+//			// Node.js environment
+//			try {
+//				const es = await import("eventsource");
+//				_EventSource = es.EventSource;
+//				logger().debug("using eventsource from npm");
+//			} catch (err) {
+//				// EventSource not available
+//				_EventSource = class MockEventSource {
+//					constructor() {
+//						throw new Error(
+//							'EventSource support requires installing the "eventsource" peer dependency.',
+//						);
+//					}
+//				} as unknown as typeof EventSource;
+//				logger().debug("using mock eventsource");
+//			}
+//		}
+//
+//		return _EventSource;
+//	})();
+//
+//	return eventSourcePromise;
+//}