rivetkit 2.0.6 → 2.0.7

package/src/common/fake-event-source.ts

@@ -1,267 +0,0 @@
-import type { EventListener } from "eventsource";
-import type { SSEStreamingApi } from "hono/streaming";
-import { getLogger } from "@/common//log";
-import type {
-	UniversalEvent,
-	UniversalEventSource,
-	UniversalMessageEvent,
-} from "@/common/eventsource-interface";
-
-export function logger() {
-	return getLogger("fake-event-source");
-}
-
-/**
- * FakeEventSource provides a minimal implementation of an SSE stream
- * that handles events for the inline client driver
- */
-export class FakeEventSource implements UniversalEventSource {
-	// EventSource readyState values
-	readonly CONNECTING = 0 as const;
-	readonly OPEN = 1 as const;
-	readonly CLOSED = 2 as const;
-
-	url = "http://internal-sse-endpoint";
-	readyState: 0 | 1 | 2 = 1; // OPEN
-	withCredentials = false;
-
-	// Event handlers
-	onopen: ((event: UniversalEvent) => void) | null = null;
-	onmessage: ((event: UniversalMessageEvent) => void) | null = null;
-	onerror: ((event: UniversalEvent) => void) | null = null;
-
-	// Private event listeners
-	#listeners: Record<string, Set<EventListener>> = {
-		open: new Set(),
-		message: new Set(),
-		error: new Set(),
-		close: new Set(),
-	};
-
-	// Stream that will be passed to the handler
-	#stream: SSEStreamingApi;
-	#onCloseCallback: () => Promise<void>;
-
-	/**
-	 * Creates a new FakeEventSource
-	 */
-	constructor(onCloseCallback: () => Promise<void>) {
-		this.#onCloseCallback = onCloseCallback;
-
-		this.#stream = this.#createStreamApi();
-
-		// Trigger open event on next tick
-		setTimeout(() => {
-			if (this.readyState === 1) {
-				this.#dispatchEvent("open");
-			}
-		}, 0);
-
-		logger().debug("FakeEventSource created");
-	}
-
-	// Creates the SSE streaming API implementation
-	#createStreamApi(): SSEStreamingApi {
-		// Create self-reference for closures
-		const self = this;
-
-		const streamApi: SSEStreamingApi = {
-			write: async (input) => {
-				const data =
-					typeof input === "string" ? input : new TextDecoder().decode(input);
-				self.#dispatchEvent("message", { data });
-				return streamApi;
-			},
-
-			writeln: async (input: string) => {
-				await streamApi.write(input + "\n");
-				return streamApi;
-			},
-
-			writeSSE: async (message: {
-				data: string | Promise<string>;
-				event?: string;
-				id?: string;
-				retry?: number;
-			}): Promise<void> => {
-				const data = await message.data;
-
-				if (message.event) {
-					self.#dispatchEvent(message.event, { data });
-				} else {
-					self.#dispatchEvent("message", { data });
-				}
-			},
-
-			sleep: async (ms: number) => {
-				await new Promise((resolve) => setTimeout(resolve, ms));
-				return streamApi;
-			},
-
-			close: async () => {
-				self.close();
-			},
-
-			pipe: async (_body: ReadableStream) => {
-				// No-op implementation
-			},
-
-			onAbort: async (cb: () => void) => {
-				self.addEventListener("error", () => {
-					cb();
-				});
-				return streamApi;
-			},
-
-			abort: async () => {
-				self.#dispatchEvent("error");
-				return streamApi;
-			},
-
-			// Additional required properties
-			get responseReadable() {
-				return null as unknown as ReadableStream;
-			},
-
-			get aborted() {
-				return self.readyState === 2; // CLOSED
-			},
-
-			get closed() {
-				return self.readyState === 2; // CLOSED
-			},
-		};
-
-		return streamApi;
-	}
-
-	/**
-	 * Closes the connection
-	 */
-	close(): void {
-		if (this.readyState === 2) {
-			// CLOSED
-			return;
-		}
-
-		logger().debug({ msg: "closing FakeEventSource" });
-		this.readyState = 2; // CLOSED
-
-		// Call the close callback
-		this.#onCloseCallback().catch((err) => {
-			logger().error({ msg: "error in onClose callback", error: err });
-		});
-
-		// Dispatch close event
-		this.#dispatchEvent("close");
-	}
-
-	/**
-	 * Get the stream API to pass to the handler
-	 */
-	getStream(): SSEStreamingApi {
-		return this.#stream;
-	}
-
-	// Implementation of EventTarget-like interface
-	addEventListener(type: string, listener: EventListener): void {
-		if (!this.#listeners[type]) {
-			this.#listeners[type] = new Set();
-		}
-		this.#listeners[type].add(listener);
-	}
-
-	removeEventListener(type: string, listener: EventListener): void {
-		if (this.#listeners[type]) {
-			this.#listeners[type].delete(listener);
-		}
-	}
-
-	dispatchEvent(event: UniversalEvent): boolean {
-		this.#dispatchEvent(event.type, event);
-		return true;
-	}
-
-	// Internal method to dispatch events
-	#dispatchEvent(type: string, detail?: Record<string, any>): void {
-		// Create appropriate event object
-		let event: any;
-		if (type === "message") {
-			event = {
-				type: "message",
-				target: this,
-				data: detail?.data || "",
-				origin: "",
-				lastEventId: "",
-			};
-		} else if (type === "close") {
-			event = {
-				type: "close",
-				target: this,
-				code: detail?.code || 1000,
-				reason: detail?.reason || "",
-				wasClean: detail?.wasClean ?? true,
-			};
-		} else if (type === "error") {
-			event = {
-				type: "error",
-				target: this,
-				error: detail?.error,
-			};
-		} else {
-			event = {
-				type: type,
-				target: this,
-			};
-		}
-
-		// Call all listeners first
-		if (this.#listeners[type]) {
-			for (const listener of this.#listeners[type]) {
-				try {
-					listener.call(this, event);
-				} catch (err) {
-					logger().error({
-						msg: `error in ${type} event listener`,
-						error: err,
-					});
-				}
-			}
-		}
-
-		// Then call specific handler
-		switch (type) {
-			case "open":
-				if (this.onopen) {
-					try {
-						this.onopen.call(this as any, event);
-					} catch (err) {
-						logger().error({ msg: "error in onopen handler", error: err });
-					}
-				}
-				break;
-			case "message":
-				if (this.onmessage) {
-					try {
-						this.onmessage.call(this as any, event);
-					} catch (err) {
-						logger().error({ msg: "error in onmessage handler", error: err });
-					}
-				}
-				break;
-			case "error":
-				if (this.onerror) {
-					try {
-						this.onerror.call(this as any, event);
-					} catch (err) {
-						logger().error({ msg: "error in onerror handler", error: err });
-					}
-				}
-				break;
-			case "close":
-				// Note: EventSource doesn't have onclose in the standard API
-				// but we handle it here for consistency
-				break;
-		}
-	}
-}

package/src/manager-api/routes/actors-create.ts

@@ -1,16 +0,0 @@
-import { z } from "zod";
-import { ActorSchema } from "./common";
-
-export const ActorsCreateRequestSchema = z.object({
-	name: z.string(),
-	runner_name_selector: z.string(),
-	crash_policy: z.string(),
-	key: z.string().nullable().optional(),
-	input: z.string().nullable().optional(),
-});
-export type ActorsCreateRequest = z.infer<typeof ActorsCreateRequestSchema>;
-
-export const ActorsCreateResponseSchema = z.object({
-	actor: ActorSchema,
-});
-export type ActorsCreateResponse = z.infer<typeof ActorsCreateResponseSchema>;

package/src/manager-api/routes/actors-delete.ts

@@ -1,4 +0,0 @@
-import { z } from "zod";
-
-export const ActorsDeleteResponseSchema = z.object({});
-export type ActorsDeleteResponse = z.infer<typeof ActorsDeleteResponseSchema>;

package/src/manager-api/routes/actors-get-by-id.ts

@@ -1,7 +0,0 @@
-import { z } from "zod";
-import { RivetIdSchema } from "./common";
-
-export const ActorsGetByIdResponseSchema = z.object({
-	actor_id: RivetIdSchema.nullable().optional(),
-});
-export type ActorsGetByIdResponse = z.infer<typeof ActorsGetByIdResponseSchema>;

package/src/manager-api/routes/actors-get-or-create-by-id.ts

@@ -1,29 +0,0 @@
-import { z } from "zod";
-import { ActorSchema, RivetIdSchema } from "./common";
-
-export const ActorsGetOrCreateResponseSchema = z.object({
-	actor: ActorSchema,
-	created: z.boolean(),
-});
-export type ActorsGetOrCreateResponse = z.infer<
-	typeof ActorsGetOrCreateResponseSchema
->;
-
-export const ActorsGetOrCreateByIdResponseSchema = z.object({
-	actor_id: RivetIdSchema,
-	created: z.boolean(),
-});
-export type ActorsGetOrCreateByIdResponse = z.infer<
-	typeof ActorsGetOrCreateByIdResponseSchema
->;
-
-export const ActorsGetOrCreateByIdRequestSchema = z.object({
-	name: z.string(),
-	key: z.string(),
-	runner_name_selector: z.string(),
-	crash_policy: z.string(),
-	input: z.string().nullable().optional(),
-});
-export type ActorsGetOrCreateByIdRequest = z.infer<
-	typeof ActorsGetOrCreateByIdRequestSchema
->;

package/src/manager-api/routes/actors-get.ts

@@ -1,7 +0,0 @@
-import { z } from "zod";
-import { ActorSchema } from "./common";
-
-export const ActorsGetResponseSchema = z.object({
-	actor: ActorSchema,
-});
-export type ActorsGetResponse = z.infer<typeof ActorsGetResponseSchema>;

package/src/manager-api/routes/common.ts

@@ -1,18 +0,0 @@
-import { z } from "zod";
-
-export const RivetIdSchema = z.string();
-export type RivetId = z.infer<typeof RivetIdSchema>;
-
-export const ActorSchema = z.object({
-	actor_id: RivetIdSchema,
-	name: z.string(),
-	key: z.string(),
-	namespace_id: RivetIdSchema,
-	runner_name_selector: z.string(),
-	create_ts: z.number(),
-	connectable_ts: z.number().nullable().optional(),
-	destroy_ts: z.number().nullable().optional(),
-	sleep_ts: z.number().nullable().optional(),
-	start_ts: z.number().nullable().optional(),
-});
-export type Actor = z.infer<typeof ActorSchema>;