kkrpc 0.0.2

package/scripts/test.ts

@@ -0,0 +1,11 @@
+import { $ } from "bun"
+
+await $`deno test -R __deno_tests__`
+const buildOutput = await Bun.build({
+	entrypoints: ["__tests__/scripts/node-api.js"],
+	outdir: "__tests__/scripts",
+	target: "node",
+	format: "esm"
+})
+
+await $`bun test __tests__ --coverage`

package/src/adapters/deno.ts

@@ -0,0 +1,38 @@
+import { Buffer } from "node:buffer"
+import type { IoInterface } from "../interface.ts"
+
+/**
+ * Stdio implementation for Deno
+ * Deno doesn't have `process` object, and have a completely different stdio API,
+ * This implementation wrap Deno's `Deno.stdin` and `Deno.stdout` to follow StdioInterface
+ */
+export class DenoIo implements IoInterface {
+	private reader: ReadableStreamDefaultReader<Uint8Array>
+	name = "deno-io"
+
+	constructor(
+		private readStream: ReadableStream<Uint8Array>,
+		private writeStream: WritableStream<Uint8Array>
+	) {
+		this.reader = this.readStream.getReader()
+		// const writer = this.writeStream.getWriter()
+		// const encoder = new TextEncoder()
+
+		// writer.write(encoder.encode("hello"))
+	}
+
+	async read(): Promise<Buffer | null> {
+		const { value, done } = await this.reader.read()
+		if (done) {
+			return null // End of input
+		}
+		return Buffer.from(value)
+	}
+
+	write(data: string): Promise<void> {
+		const encoder = new TextEncoder()
+		const encodedData = encoder.encode(data + "\n")
+		Deno.stdout.writeSync(encodedData)
+		return Promise.resolve()
+	}
+}

package/src/adapters/http.ts

@@ -0,0 +1,115 @@
+import type { DestroyableIoInterface, IoInterface } from "../interface.ts"
+
+interface HTTPClientOptions {
+	url: string
+	headers?: Record<string, string>
+}
+
+/**
+ * HTTP Client implementation of IoInterface
+ */
+export class HTTPClientIO implements IoInterface {
+	name = "http-client-io"
+	private messageQueue: string[] = []
+	private resolveRead: ((value: string | null) => void) | null = null
+
+	constructor(private options: HTTPClientOptions) {}
+
+	async read(): Promise<string | null> {
+		if (this.messageQueue.length > 0) {
+			return this.messageQueue.shift() ?? null
+		}
+
+		return new Promise((resolve) => {
+			this.resolveRead = resolve
+		})
+	}
+
+	async write(data: string): Promise<void> {
+		try {
+			const response = await fetch(this.options.url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					...this.options.headers
+				},
+				body: data
+			})
+
+			if (!response.ok) {
+				throw new Error(`HTTP error! status: ${response.status}`)
+			}
+
+			const responseText = await response.text()
+
+			if (this.resolveRead) {
+				this.resolveRead(responseText)
+				this.resolveRead = null
+			} else {
+				this.messageQueue.push(responseText)
+			}
+		} catch (error) {
+			console.error("HTTP request failed:", error)
+			if (this.resolveRead) {
+				this.resolveRead(null)
+				this.resolveRead = null
+			}
+		}
+	}
+}
+
+/**
+ * HTTP Server implementation of IoInterface
+ */
+export class HTTPServerIO implements IoInterface {
+	name = "http-server-io"
+	private messageQueue: string[] = []
+	private resolveRead: ((value: string | null) => void) | null = null
+	private pendingResponses = new Map<string, (response: string) => void>()
+
+	constructor() {}
+
+	async read(): Promise<string | null> {
+		if (this.messageQueue.length > 0) {
+			return this.messageQueue.shift() ?? null
+		}
+
+		return new Promise((resolve) => {
+			this.resolveRead = resolve
+		})
+	}
+
+	async write(data: string): Promise<void> {
+		// Parse the response to get the request ID
+		const response = JSON.parse(data)
+		const requestId = response.id
+
+		const resolveResponse = this.pendingResponses.get(requestId)
+		if (resolveResponse) {
+			resolveResponse(data)
+			this.pendingResponses.delete(requestId)
+		}
+	}
+
+	async handleRequest(reqData: string): Promise<string> {
+		try {
+			// Parse the request to get its ID
+			const requestData = JSON.parse(reqData)
+			const requestId = requestData.id
+
+			if (this.resolveRead) {
+				this.resolveRead(reqData)
+				this.resolveRead = null
+			} else {
+				this.messageQueue.push(reqData)
+			}
+
+			return new Promise((resolve) => {
+				this.pendingResponses.set(requestId, resolve)
+			})
+		} catch (error) {
+			console.error("RPC processing error:", error)
+			throw new Error("Internal server error")
+		}
+	}
+}

package/src/adapters/iframe.ts

@@ -0,0 +1,178 @@
+/**
+ * This file contains the implementation of the IframeParentIO and IframeChildIO classes.
+ * They are used to create a bidirectional communication channel between a parent window and a child iframe.
+ */
+import type { DestroyableIoInterface } from "../interface.ts"
+
+const DESTROY_SIGNAL = "__DESTROY__"
+const PORT_INIT_SIGNAL = "__PORT_INIT__"
+
+/**
+ * This design relies on built-in `MessageChannel`, and requires a pairing process to establish the port.
+ * The `PORT_INIT_SIGNAL` is designed to be initiated by the child frame, parent window will wait for the signal and establish the port.
+ *
+ * If `PORT_INIT_SIGNAL` is started by the parent window, there has to be a delay (with `setTimeout`) to wait for the child frame to listen to the signal.
+ * Parent window can easily listen to iframe onload event, but there is no way to know when child JS is ready to listen to the message without
+ * letting child `postMessage` a signal first.
+ *
+ * It's much easier to make sure parent window is ready (listening) before iframe is loaded, so `MessageChannel` is designed to be created from iframe's side.
+ *
+ * It's a good practice to call `destroy()` on either side of the channel to close `MessageChannel` and release resources.
+ */
+export class IframeParentIO implements DestroyableIoInterface {
+	name = "iframe-parent-io"
+	private messageQueue: string[] = []
+	private resolveRead: ((value: string | null) => void) | null = null
+	private port: MessagePort | null = null
+
+	/**
+	 * @example
+	 * ```ts
+	 * const io = new IframeParentIO(iframeRef.contentWindow)
+	 * const rpc = new RPCChannel(io, {
+	 *	 add: (a: number, b: number) => Promise.resolve(a + b)
+	 * })
+	 * ```
+	 */
+	constructor(private targetWindow: Window) {
+		this.port = null as unknown as MessagePort
+		window.addEventListener("message", (event: MessageEvent) => {
+			if (event.source !== this.targetWindow) return
+			if (event.data === PORT_INIT_SIGNAL && event.ports.length > 0) {
+				this.port = event.ports[0]
+				this.port.onmessage = this.handleMessage
+
+				while (this.messageQueue.length > 0) {
+					const message = this.messageQueue.shift()
+					if (message) this.port.postMessage(message)
+				}
+			}
+		})
+	}
+
+	private handleMessage = (event: MessageEvent) => {
+		const message = event.data
+
+		// Handle destroy signal
+		if (message === DESTROY_SIGNAL) {
+			this.destroy()
+			return
+		}
+
+		if (this.resolveRead) {
+			// If there's a pending read, resolve it immediately
+			this.resolveRead(message)
+			this.resolveRead = null
+		} else {
+			// Otherwise, queue the message
+			this.messageQueue.push(message)
+		}
+	}
+
+	async read(): Promise<string | null> {
+		// If there are queued messages, return the first one
+		if (this.messageQueue.length > 0) {
+			return this.messageQueue.shift() ?? null
+		}
+
+		// Otherwise, wait for the next message
+		return new Promise((resolve) => {
+			this.resolveRead = resolve
+		})
+	}
+
+	async write(data: string): Promise<void> {
+		if (!this.port) {
+			this.messageQueue.push(data)
+			return
+		}
+		this.port.postMessage(data)
+	}
+
+	destroy(): void {
+		if (this.port) {
+			this.port.postMessage(DESTROY_SIGNAL)
+			this.port.close()
+		}
+	}
+
+	signalDestroy(): void {
+		if (this.port) {
+			this.port.postMessage(DESTROY_SIGNAL)
+		}
+	}
+}
+
+// Child frame version
+export class IframeChildIO implements DestroyableIoInterface {
+	name = "iframe-child-io"
+	private messageQueue: string[] = []
+	private resolveRead: ((value: string | null) => void) | null = null
+	private port: MessagePort | null = null
+	private pendingMessages: string[] = []
+	private initialized: Promise<void>
+	private channel: MessageChannel
+
+	constructor() {
+		this.channel = new MessageChannel()
+		this.port = this.channel.port1
+		this.port.onmessage = this.handleMessage
+
+		window.parent.postMessage(PORT_INIT_SIGNAL, "*", [this.channel.port2])
+		this.initialized = Promise.resolve()
+	}
+
+	private handleMessage = (event: MessageEvent) => {
+		const message = event.data
+
+		// Handle destroy signal
+		if (message === DESTROY_SIGNAL) {
+			this.destroy()
+			return
+		}
+
+		if (this.resolveRead) {
+			this.resolveRead(message)
+			this.resolveRead = null
+		} else {
+			this.messageQueue.push(message)
+		}
+	}
+
+	async read(): Promise<string | null> {
+		await this.initialized
+
+		if (this.messageQueue.length > 0) {
+			return this.messageQueue.shift() ?? null
+		}
+
+		return new Promise((resolve) => {
+			this.resolveRead = resolve
+		})
+	}
+
+	async write(data: string): Promise<void> {
+		await this.initialized
+
+		if (this.port) {
+			this.port.postMessage(data)
+		} else {
+			this.pendingMessages.push(data)
+		}
+	}
+
+	destroy(): void {
+		if (this.port) {
+			this.port.postMessage(DESTROY_SIGNAL)
+			this.port.close()
+		}
+	}
+
+	signalDestroy(): void {
+		if (this.port) {
+			this.port.postMessage(DESTROY_SIGNAL)
+		} else {
+			this.pendingMessages.push(DESTROY_SIGNAL)
+		}
+	}
+}

package/src/adapters/node.ts

@@ -0,0 +1,69 @@
+/**
+ * Node.js implementation of IoInterface
+ * Should also work with Bun
+ */
+import { type Buffer } from "node:buffer"
+import { Readable, Writable } from "node:stream"
+import { type IoInterface } from "../interface.ts"
+
+/**
+ * Stdio implementation for Node.js
+ * Simply wrap Node.js's `process.stdin` and `process.stdout` to follow StdioInterface
+ */
+export class NodeIo implements IoInterface {
+	name = "node-io"
+	private readStream: Readable
+	private writeStream: Writable
+	private dataHandler: ((chunk: Buffer) => void) | null = null
+	private errorHandler: ((error: Error) => void) | null = null
+
+	constructor(readStream: Readable, writeStream: Writable) {
+		this.readStream = readStream
+		this.writeStream = writeStream
+
+		// Set up persistent listeners
+		this.readStream.on("error", (error) => {
+			if (this.errorHandler) this.errorHandler(error)
+		})
+	}
+
+	async read(): Promise<Buffer | null> {
+		return new Promise((resolve, reject) => {
+			const onData = (chunk: Buffer) => {
+				cleanup()
+				resolve(chunk)
+			}
+
+			const onEnd = () => {
+				cleanup()
+				resolve(null)
+			}
+
+			const onError = (error: Error) => {
+				cleanup()
+				reject(error)
+			}
+
+			const cleanup = () => {
+				this.readStream.removeListener("data", onData)
+				this.readStream.removeListener("end", onEnd)
+				this.readStream.removeListener("error", onError)
+			}
+
+			this.readStream.once("data", onData)
+			this.readStream.once("end", onEnd)
+			this.readStream.once("error", onError)
+		})
+	}
+
+	async write(data: string): Promise<void> {
+		return new Promise((resolve, reject) => {
+			this.writeStream.write(data, (err) => {
+				if (err) reject(err)
+				else {
+					resolve()
+				}
+			})
+		})
+	}
+}

package/src/adapters/websocket.ts

@@ -0,0 +1,127 @@
+import type { DestroyableIoInterface } from "../interface.ts"
+
+const DESTROY_SIGNAL = "__DESTROY__"
+
+interface WebSocketClientOptions {
+	url: string
+	protocols?: string | string[]
+}
+
+/**
+ * WebSocket Client implementation of IoInterface
+ */
+export class WebSocketClientIO implements DestroyableIoInterface {
+	name = "websocket-client-io"
+	private messageQueue: string[] = []
+	private resolveRead: ((value: string | null) => void) | null = null
+	private ws: WebSocket
+	private connected: Promise<void>
+	private connectResolve: (() => void) | null = null
+
+	constructor(private options: WebSocketClientOptions) {
+		this.ws = new WebSocket(options.url, options.protocols)
+		this.connected = new Promise((resolve) => {
+			this.connectResolve = resolve
+		})
+
+		this.ws.onopen = () => {
+			this.connectResolve?.()
+		}
+
+		this.ws.onmessage = (event) => {
+			const message = event.data
+			if (message === DESTROY_SIGNAL) {
+				this.destroy()
+				return
+			}
+
+			if (this.resolveRead) {
+				this.resolveRead(message)
+				this.resolveRead = null
+			} else {
+				this.messageQueue.push(message)
+			}
+		}
+
+		this.ws.onerror = (error) => {
+			console.error("WebSocket error:", error)
+		}
+	}
+
+	async read(): Promise<string | null> {
+		await this.connected
+
+		if (this.messageQueue.length > 0) {
+			return this.messageQueue.shift() ?? null
+		}
+
+		return new Promise((resolve) => {
+			this.resolveRead = resolve
+		})
+	}
+
+	async write(data: string): Promise<void> {
+		await this.connected
+		this.ws.send(data)
+	}
+
+	destroy(): void {
+		this.ws.close()
+	}
+
+	signalDestroy(): void {
+		this.write(DESTROY_SIGNAL)
+	}
+}
+
+/**
+ * WebSocket Server implementation of IoInterface
+ */
+export class WebSocketServerIO implements DestroyableIoInterface {
+	name = "websocket-server-io"
+	private messageQueue: string[] = []
+	private resolveRead: ((value: string | null) => void) | null = null
+
+	constructor(private ws: WebSocket) {
+		this.ws.onmessage = (event) => {
+			const message = event.data
+			if (message === DESTROY_SIGNAL) {
+				this.destroy()
+				return
+			}
+
+			if (this.resolveRead) {
+				this.resolveRead(message)
+				this.resolveRead = null
+			} else {
+				this.messageQueue.push(message)
+			}
+		}
+
+		this.ws.onerror = (error) => {
+			console.error("WebSocket error:", error)
+		}
+	}
+
+	async read(): Promise<string | null> {
+		if (this.messageQueue.length > 0) {
+			return this.messageQueue.shift() ?? null
+		}
+
+		return new Promise((resolve) => {
+			this.resolveRead = resolve
+		})
+	}
+
+	async write(data: string): Promise<void> {
+		this.ws.send(data)
+	}
+
+	destroy(): void {
+		this.ws.close()
+	}
+
+	signalDestroy(): void {
+		this.write(DESTROY_SIGNAL)
+	}
+}

package/src/adapters/worker.ts

@@ -0,0 +1,116 @@
+import type { DestroyableIoInterface } from "../interface.ts"
+
+const DESTROY_SIGNAL = "__DESTROY__"
+
+export class WorkerParentIO implements DestroyableIoInterface {
+	name = "worker-parent-io"
+	private messageQueue: string[] = []
+	private resolveRead: ((value: string | null) => void) | null = null
+	private worker: Worker
+
+	constructor(worker: Worker) {
+		this.worker = worker
+		this.worker.onmessage = this.handleMessage
+	}
+
+	private handleMessage = (event: MessageEvent) => {
+		const message = event.data
+
+		// Handle destroy signal
+		if (message === DESTROY_SIGNAL) {
+			this.destroy()
+			return
+		}
+
+		if (this.resolveRead) {
+			// If there's a pending read, resolve it immediately
+			this.resolveRead(message)
+			this.resolveRead = null
+		} else {
+			// Otherwise, queue the message
+			this.messageQueue.push(message)
+		}
+	}
+
+	read(): Promise<string | null> {
+		// If there are queued messages, return the first one
+		if (this.messageQueue.length > 0) {
+			return Promise.resolve(this.messageQueue.shift() ?? null)
+		}
+
+		// Otherwise, wait for the next message
+		return new Promise((resolve) => {
+			this.resolveRead = resolve
+		})
+	}
+
+	write(data: string): Promise<void> {
+		this.worker.postMessage(data)
+		return Promise.resolve()
+	}
+
+	destroy(): void {
+		this.worker.postMessage(DESTROY_SIGNAL)
+		this.worker.terminate()
+	}
+
+	signalDestroy(): void {
+		this.worker.postMessage(DESTROY_SIGNAL)
+	}
+}
+
+// Worker version
+export class WorkerChildIO implements DestroyableIoInterface {
+	name = "worker-child-io"
+	private messageQueue: string[] = []
+	private resolveRead: ((value: string | null) => void) | null = null
+
+	constructor() {
+		// @ts-ignore: lack of types in deno
+		self.onmessage = this.handleMessage
+	}
+
+	private handleMessage = (event: MessageEvent) => {
+		const message = event.data
+
+		// Handle destroy signal
+		if (message === DESTROY_SIGNAL) {
+			this.destroy()
+			return
+		}
+
+		if (this.resolveRead) {
+			this.resolveRead(message)
+			this.resolveRead = null
+		} else {
+			this.messageQueue.push(message)
+		}
+	}
+
+	async read(): Promise<string | null> {
+		if (this.messageQueue.length > 0) {
+			return this.messageQueue.shift() ?? null
+		}
+
+		return new Promise((resolve) => {
+			this.resolveRead = resolve
+		})
+	}
+
+	async write(data: string): Promise<void> {
+		// @ts-ignore: lack of types in deno
+		self.postMessage(data)
+	}
+
+	destroy(): void {
+		// @ts-ignore: lack of types in deno
+		self.postMessage(DESTROY_SIGNAL)
+		// In a worker context, we can use close() to terminate the worker
+		self.close()
+	}
+
+	signalDestroy(): void {
+		// @ts-ignore: lack of types in deno
+		self.postMessage(DESTROY_SIGNAL)
+	}
+}