rivetkit 2.0.1 → 2.0.3

package/src/common/inline-websocket-adapter2.ts

@@ -0,0 +1,445 @@
+import { WSContext } from "hono/ws";
+import type {
+	RivetCloseEvent,
+	RivetEvent,
+	RivetMessageEvent,
+	UniversalWebSocket,
+} from "@/common/websocket-interface";
+import { getLogger } from "./log";
+
+export const LOGGER_NAME = "fake-event-source2";
+
+export function logger() {
+	return getLogger(LOGGER_NAME);
+}
+
+// TODO: Merge with ConnectWebSocketOutput interface
+export interface UpgradeWebSocketArgs {
+	onOpen: (event: any, ws: WSContext) => void;
+	onMessage: (event: any, ws: WSContext) => void;
+	onClose: (event: any, ws: WSContext) => void;
+	onError: (error: any, ws: WSContext) => void;
+}
+
+// TODO: Remove `2` suffix
+/**
+ * InlineWebSocketAdapter implements a WebSocket-like interface
+ * that connects to a UpgradeWebSocketArgs handler
+ */
+export class InlineWebSocketAdapter2 implements UniversalWebSocket {
+	// WebSocket readyState values
+	readonly CONNECTING = 0 as const;
+	readonly OPEN = 1 as const;
+	readonly CLOSING = 2 as const;
+	readonly CLOSED = 3 as const;
+
+	// Private properties
+	#handler: UpgradeWebSocketArgs;
+	#wsContext: WSContext;
+	#readyState: 0 | 1 | 2 | 3 = 0; // Start in CONNECTING state
+	#queuedMessages: Array<string | ArrayBuffer | Uint8Array> = [];
+	// Event buffering is needed since events can be fired
+	// before JavaScript has a chance to add event listeners (e.g. within the same tick)
+	#bufferedEvents: Array<{
+		type: string;
+		event: any;
+	}> = [];
+
+	// Event listeners with buffering
+	#eventListeners: Map<string, ((ev: any) => void)[]> = new Map();
+
+	constructor(handler: UpgradeWebSocketArgs) {
+		this.#handler = handler;
+
+		// Create a fake WSContext to pass to the handler
+		this.#wsContext = new WSContext({
+			raw: this,
+			send: (data: string | ArrayBuffer | Uint8Array) => {
+				logger().debug("WSContext.send called");
+				this.#handleMessage(data);
+			},
+			close: (code?: number, reason?: string) => {
+				logger().debug("WSContext.close called", { code, reason });
+				this.#handleClose(code || 1000, reason || "");
+			},
+			// Set readyState to 1 (OPEN) since handlers expect an open connection
+			readyState: 1,
+		});
+
+		// Initialize the connection
+		this.#initialize();
+	}
+
+	get readyState(): 0 | 1 | 2 | 3 {
+		return this.#readyState;
+	}
+
+	get binaryType(): "arraybuffer" | "blob" {
+		return "arraybuffer";
+	}
+
+	set binaryType(value: "arraybuffer" | "blob") {
+		// Ignored for now - always use arraybuffer
+	}
+
+	get bufferedAmount(): number {
+		return 0; // Not tracked in InlineWebSocketAdapter
+	}
+
+	get extensions(): string {
+		return ""; // Not available in InlineWebSocketAdapter
+	}
+
+	get protocol(): string {
+		return ""; // Not available in InlineWebSocketAdapter
+	}
+
+	get url(): string {
+		return ""; // Not available in InlineWebSocketAdapter
+	}
+
+	send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void {
+		logger().debug("send called", { readyState: this.readyState });
+
+		if (this.readyState !== this.OPEN) {
+			const error = new Error("WebSocket is not open");
+			logger().warn("cannot send message, websocket not open", {
+				readyState: this.readyState,
+				dataType: typeof data,
+				dataLength: typeof data === "string" ? data.length : "binary",
+				error,
+			});
+			this.#fireError(error);
+			return;
+		}
+
+		this.#handler.onMessage({ data }, this.#wsContext);
+	}
+
+	/**
+	 * Closes the connection
+	 */
+	close(code = 1000, reason = ""): void {
+		if (this.readyState === this.CLOSED || this.readyState === this.CLOSING) {
+			return;
+		}
+
+		logger().debug("closing fake websocket", { code, reason });
+
+		this.#readyState = this.CLOSING;
+
+		// Call the handler's onClose method
+		try {
+			this.#handler.onClose({ code, reason, wasClean: true }, this.#wsContext);
+		} catch (err) {
+			logger().error("error closing websocket", { error: err });
+		} finally {
+			this.#readyState = this.CLOSED;
+
+			// Fire the close event
+			// Create a close event object since CloseEvent is not available in Node.js
+			const closeEvent = {
+				type: "close",
+				wasClean: code === 1000,
+				code,
+				reason,
+				target: this,
+				currentTarget: this,
+			} as unknown as RivetCloseEvent;
+
+			this.#fireClose(closeEvent);
+		}
+	}
+
+	/**
+	 * Initialize the connection with the handler
+	 */
+	async #initialize(): Promise<void> {
+		try {
+			logger().debug("fake websocket initializing");
+
+			// Call the handler's onOpen method
+			logger().debug("calling handler.onOpen with WSContext");
+			this.#handler.onOpen(undefined, this.#wsContext);
+
+			// Update the ready state and fire events
+			this.#readyState = this.OPEN;
+			logger().debug("fake websocket initialized and now OPEN");
+
+			// Fire the open event
+			this.#fireOpen();
+
+			// Delay processing queued messages slightly to allow event handlers to be set up
+			if (this.#queuedMessages.length > 0) {
+				if (this.readyState !== this.OPEN) {
+					logger().warn("socket no longer open, dropping queued messages");
+					return;
+				}
+
+				logger().debug(
+					`now processing ${this.#queuedMessages.length} queued messages`,
+				);
+
+				// Create a copy to avoid issues if new messages arrive during processing
+				const messagesToProcess = [...this.#queuedMessages];
+				this.#queuedMessages = [];
+
+				// Process each queued message
+				for (const message of messagesToProcess) {
+					logger().debug("processing queued message");
+					this.#handleMessage(message);
+				}
+			}
+		} catch (err) {
+			logger().error("error opening fake websocket", {
+				error: err,
+				errorMessage: err instanceof Error ? err.message : String(err),
+				stack: err instanceof Error ? err.stack : undefined,
+			});
+			this.#fireError(err);
+			this.close(1011, "Internal error during initialization");
+		}
+	}
+
+	/**
+	 * Handle messages received from the server via the WSContext
+	 */
+	#handleMessage(data: string | ArrayBuffer | Uint8Array): void {
+		// Store messages that arrive before the socket is fully initialized
+		if (this.readyState !== this.OPEN) {
+			logger().debug("message received before socket is OPEN, queuing", {
+				readyState: this.readyState,
+				dataType: typeof data,
+				dataLength:
+					typeof data === "string"
+						? data.length
+						: data instanceof ArrayBuffer
+							? data.byteLength
+							: data instanceof Uint8Array
+								? data.byteLength
+								: "unknown",
+			});
+
+			// Queue the message to be processed once the socket is open
+			this.#queuedMessages.push(data);
+			return;
+		}
+
+		// Log message received from server
+		logger().debug("fake websocket received message from server", {
+			dataType: typeof data,
+			dataLength:
+				typeof data === "string"
+					? data.length
+					: data instanceof ArrayBuffer
+						? data.byteLength
+						: data instanceof Uint8Array
+							? data.byteLength
+							: "unknown",
+		});
+
+		// Create a MessageEvent-like object
+		const event = {
+			type: "message",
+			data,
+			target: this,
+			currentTarget: this,
+		} as unknown as RivetMessageEvent;
+
+		// Dispatch the event
+		this.#dispatchEvent("message", event);
+	}
+
+	#handleClose(code: number, reason: string): void {
+		if (this.readyState === this.CLOSED) return;
+
+		this.#readyState = this.CLOSED;
+
+		// Create a CloseEvent-like object
+		const event = {
+			type: "close",
+			code,
+			reason,
+			wasClean: code === 1000,
+			target: this,
+			currentTarget: this,
+		} as unknown as RivetCloseEvent;
+
+		// Dispatch the event
+		this.#dispatchEvent("close", event);
+	}
+
+	addEventListener(type: string, listener: (ev: any) => void): void {
+		if (!this.#eventListeners.has(type)) {
+			this.#eventListeners.set(type, []);
+		}
+		this.#eventListeners.get(type)!.push(listener);
+
+		// Flush any buffered events for this type
+		this.#flushBufferedEvents(type);
+	}
+
+	removeEventListener(type: string, listener: (ev: any) => void): void {
+		const listeners = this.#eventListeners.get(type);
+		if (listeners) {
+			const index = listeners.indexOf(listener);
+			if (index !== -1) {
+				listeners.splice(index, 1);
+			}
+		}
+	}
+
+	#dispatchEvent(type: string, event: any): void {
+		const listeners = this.#eventListeners.get(type);
+		if (listeners && listeners.length > 0) {
+			logger().debug(
+				`dispatching ${type} event to ${listeners.length} listeners`,
+			);
+			for (const listener of listeners) {
+				try {
+					listener(event);
+				} catch (err) {
+					logger().error(`error in ${type} event listener`, { error: err });
+				}
+			}
+		} else {
+			logger().debug(`no ${type} listeners registered, buffering event`);
+			this.#bufferedEvents.push({ type, event });
+		}
+
+		// Also check for on* properties
+		switch (type) {
+			case "open":
+				if (this.#onopen) {
+					try {
+						this.#onopen(event);
+					} catch (error) {
+						logger().error("error in onopen handler", { error });
+					}
+				}
+				break;
+			case "close":
+				if (this.#onclose) {
+					try {
+						this.#onclose(event);
+					} catch (error) {
+						logger().error("error in onclose handler", { error });
+					}
+				}
+				break;
+			case "error":
+				if (this.#onerror) {
+					try {
+						this.#onerror(event);
+					} catch (error) {
+						logger().error("error in onerror handler", { error });
+					}
+				}
+				break;
+			case "message":
+				if (this.#onmessage) {
+					try {
+						this.#onmessage(event);
+					} catch (error) {
+						logger().error("error in onmessage handler", { error });
+					}
+				}
+				break;
+		}
+	}
+
+	dispatchEvent(event: RivetEvent): boolean {
+		this.#dispatchEvent(event.type, event);
+		return true;
+	}
+
+	#flushBufferedEvents(type: string): void {
+		const eventsToFlush = this.#bufferedEvents.filter(
+			(buffered) => buffered.type === type,
+		);
+		this.#bufferedEvents = this.#bufferedEvents.filter(
+			(buffered) => buffered.type !== type,
+		);
+
+		for (const { event } of eventsToFlush) {
+			this.#dispatchEvent(type, event);
+		}
+	}
+
+	#fireOpen(): void {
+		try {
+			// Create an Event-like object since Event constructor may not be available
+			const event = {
+				type: "open",
+				target: this,
+				currentTarget: this,
+			} as unknown as RivetEvent;
+
+			this.#dispatchEvent("open", event);
+		} catch (err) {
+			logger().error("error in open event", { error: err });
+		}
+	}
+
+	#fireClose(event: RivetCloseEvent): void {
+		try {
+			this.#dispatchEvent("close", event);
+		} catch (err) {
+			logger().error("error in close event", { error: err });
+		}
+	}
+
+	#fireError(error: unknown): void {
+		try {
+			// Create an Event-like object for error
+			const event = {
+				type: "error",
+				target: this,
+				currentTarget: this,
+				error,
+				message: error instanceof Error ? error.message : String(error),
+			} as unknown as RivetEvent;
+
+			this.#dispatchEvent("error", event);
+		} catch (err) {
+			logger().error("error in error event", { error: err });
+		}
+
+		// Log the error
+		logger().error("websocket error", { error });
+	}
+
+	// Event handler properties with getters/setters
+	#onopen: ((event: RivetEvent) => void) | null = null;
+	#onclose: ((event: RivetCloseEvent) => void) | null = null;
+	#onerror: ((event: RivetEvent) => void) | null = null;
+	#onmessage: ((event: RivetMessageEvent) => void) | null = null;
+
+	get onopen(): ((event: RivetEvent) => void) | null {
+		return this.#onopen;
+	}
+	set onopen(handler: ((event: RivetEvent) => void) | null) {
+		this.#onopen = handler;
+	}
+
+	get onclose(): ((event: RivetCloseEvent) => void) | null {
+		return this.#onclose;
+	}
+	set onclose(handler: ((event: RivetCloseEvent) => void) | null) {
+		this.#onclose = handler;
+	}
+
+	get onerror(): ((event: RivetEvent) => void) | null {
+		return this.#onerror;
+	}
+	set onerror(handler: ((event: RivetEvent) => void) | null) {
+		this.#onerror = handler;
+	}
+
+	get onmessage(): ((event: RivetMessageEvent) => void) | null {
+		return this.#onmessage;
+	}
+	set onmessage(handler: ((event: RivetMessageEvent) => void) | null) {
+		this.#onmessage = handler;
+	}
+}

package/src/common/log-levels.ts

@@ -0,0 +1,27 @@
+export type LogLevel =
+	| "TRACE"
+	| "DEBUG"
+	| "INFO"
+	| "WARN"
+	| "ERROR"
+	| "CRITICAL";
+
+export const LogLevels: Record<LogLevel, LevelIndex> = {
+	TRACE: 0,
+	DEBUG: 1,
+	INFO: 2,
+	WARN: 3,
+	ERROR: 4,
+	CRITICAL: 5,
+} as const;
+
+export const LevelNameMap: Record<number, LogLevel> = {
+	0: "TRACE",
+	1: "DEBUG",
+	2: "INFO",
+	3: "WARN",
+	4: "ERROR",
+	5: "CRITICAL",
+};
+
+export type LevelIndex = number;

package/src/common/log.ts

@@ -0,0 +1,139 @@
+import { getEnvUniversal } from "@/utils";
+import {
+	type LevelIndex,
+	LevelNameMap,
+	type LogLevel,
+	LogLevels,
+} from "./log-levels";
+import {
+	castToLogValue,
+	formatTimestamp,
+	type LogEntry,
+	stringify,
+} from "./logfmt";
+
+interface LogRecord {
+	args: unknown[];
+	datetime: Date;
+	level: number;
+	levelName: string;
+	loggerName: string;
+	msg: string;
+}
+
+export class Logger {
+	name: string;
+	level: LogLevel;
+
+	constructor(name: string, level: LogLevel) {
+		this.name = name;
+		this.level = level;
+	}
+
+	log(level: LevelIndex, message: string, ...args: unknown[]): void {
+		const record: LogRecord = {
+			msg: message,
+			args,
+			level,
+			loggerName: this.name,
+			datetime: new Date(),
+			levelName: LevelNameMap[level],
+		};
+
+		if (this.#shouldLog(level)) {
+			this.#logRecord(record);
+		}
+	}
+
+	#shouldLog(level: LevelIndex): boolean {
+		return level >= LogLevels[this.level];
+	}
+
+	#logRecord(record: LogRecord): void {
+		console.log(formatter(record));
+	}
+
+	trace(message: string, ...args: unknown[]): void {
+		this.log(LogLevels.TRACE, message, ...args);
+	}
+
+	debug(message: string, ...args: unknown[]): void {
+		this.log(LogLevels.DEBUG, message, ...args);
+	}
+
+	info(message: string, ...args: unknown[]): void {
+		this.log(LogLevels.INFO, message, ...args);
+	}
+
+	warn(message: string, ...args: unknown[]): void {
+		this.log(LogLevels.WARN, message, ...args);
+	}
+
+	error(message: string, ...args: unknown[]): void {
+		this.log(LogLevels.ERROR, message, ...args);
+	}
+
+	critical(message: string, ...args: unknown[]): void {
+		this.log(LogLevels.CRITICAL, message, ...args);
+	}
+}
+
+const loggers: Record<string, Logger> = {};
+
+export function getLogger(name = "default"): Logger {
+	const defaultLogLevelEnv: LogLevel | undefined = getEnvUniversal(
+		"_LOG_LEVEL",
+	) as LogLevel | undefined;
+
+	const defaultLogLevel: LogLevel = defaultLogLevelEnv ?? "INFO";
+	if (!loggers[name]) {
+		loggers[name] = new Logger(name, defaultLogLevel);
+	}
+	return loggers[name];
+}
+
+function formatter(log: LogRecord): string {
+	const args: LogEntry[] = [];
+	for (let i = 0; i < log.args.length; i++) {
+		const logArg = log.args[i];
+		if (logArg && typeof logArg === "object") {
+			// Spread object
+			for (const k in logArg) {
+				// biome-ignore lint/suspicious/noExplicitAny: Unknown type
+				const v = (logArg as any)[k];
+
+				pushArg(k, v, args);
+			}
+		} else {
+			pushArg(`arg${i}`, logArg, args);
+		}
+	}
+
+	const logTs = getEnvUniversal("_LOG_TIMESTAMP") === "1";
+	const logTarget = getEnvUniversal("_LOG_TARGET") === "1";
+
+	return stringify(
+		...(logTs ? [["ts", formatTimestamp(new Date())] as LogEntry] : []),
+		["level", LevelNameMap[log.level]],
+		...(logTarget ? [["target", log.loggerName] as LogEntry] : []),
+		["msg", log.msg],
+		...args,
+	);
+}
+
+function pushArg(k: string, v: unknown, args: LogEntry[]) {
+	args.push([k, castToLogValue(v)]);
+}
+
+// function getEnv(name: string): string | undefined {
+// 	if (typeof window !== "undefined" && window.localStorage) {
+// 		return window.localStorage.getItem(name) || undefined;
+// 	}
+// 	return undefined;
+// 	// TODO(ACTR-9): Add back env config once node compat layer works
+// 	//return crossGetEnv(name);
+// }
+
+export function setupLogging() {
+	// Do nothing for now
+}