silgi 0.0.14 → 0.1.0-beta.10

package/dist/ws.mjs

@@ -0,0 +1,205 @@
+import { SilgiError, toSilgiError } from "./core/error.mjs";
+import { compileRouter, createContext, releaseContext } from "./compile.mjs";
+import { stringifyJSON } from "./core/utils.mjs";
+import { decode, encode } from "./codec/msgpack.mjs";
+//#region src/ws.ts
+/**
+* WebSocket RPC adapter — powered by crossws.
+*
+* Bidirectional type-safe RPC over WebSocket.
+* Supports subscriptions (server → client streaming) natively.
+*
+* Protocol:
+*   Client → Server: { id: string, path: string, input?: unknown }
+*   Server → Client: { id: string, result?: unknown, error?: unknown }
+*   Server → Client (stream): { id: string, data: unknown, done?: boolean }
+*/
+const peerAbortControllers = /* @__PURE__ */ new WeakMap();
+const peerKeepaliveTimers = /* @__PURE__ */ new WeakMap();
+/**
+* Create crossws-compatible hooks for Silgi RPC over WebSocket.
+*
+* Works with any crossws integration — Nitro, Deno, Bun, Cloudflare, etc.
+*
+* @example
+* ```ts
+* // Nitro / Nuxt
+* import { createWSHooks } from "silgi/ws";
+* export default defineWebSocketHandler(createWSHooks(appRouter));
+*
+* // With context
+* export default defineWebSocketHandler(createWSHooks(appRouter, {
+*   context: (peer) => ({ userId: peer.request?.headers.get('x-user-id') }),
+* }));
+* ```
+*/
+function createWSHooks(routerDef, options = {}) {
+	const flat = compileRouter(routerDef);
+	const useMsgpack = options.protocol === "messagepack" || options.protocol == null && (options.binary ?? false);
+	const contextFactory = options.context;
+	const keepaliveMs = options.keepalive === false ? 0 : options.keepalive ?? 3e4;
+	function send(peer, data) {
+		const compress = !!options.compress;
+		if (useMsgpack) peer.send(encode(data), { compress });
+		else peer.send(stringifyJSON(data), { compress });
+	}
+	function parseMessage(message) {
+		if (useMsgpack) return decode(message.uint8Array());
+		return message.json();
+	}
+	return {
+		open(peer) {
+			peerAbortControllers.set(peer, /* @__PURE__ */ new Set());
+			if (keepaliveMs > 0) {
+				const ws = peer._internal?.ws;
+				if (ws && typeof ws.ping === "function") {
+					let alive = true;
+					ws.on("pong", () => {
+						alive = true;
+					});
+					const timer = setInterval(() => {
+						if (!alive) {
+							clearInterval(timer);
+							ws.terminate();
+							return;
+						}
+						alive = false;
+						ws.ping();
+					}, keepaliveMs);
+					peerKeepaliveTimers.set(peer, timer);
+				}
+			}
+		},
+		async message(peer, message) {
+			let req;
+			try {
+				req = parseMessage(message);
+			} catch {
+				send(peer, {
+					id: "0",
+					error: {
+						code: "BAD_REQUEST",
+						status: 400,
+						message: "Invalid message format"
+					}
+				});
+				return;
+			}
+			const { id, path, input } = req;
+			const route = flat("POST", "/" + path)?.data;
+			if (!route || !route.ws) {
+				send(peer, {
+					id,
+					error: {
+						code: "NOT_FOUND",
+						status: 404,
+						message: `Procedure "${path}" not found`
+					}
+				});
+				return;
+			}
+			const ctx = createContext();
+			if (contextFactory) try {
+				const baseResult = contextFactory(peer);
+				const base = baseResult instanceof Promise ? await baseResult : baseResult;
+				const keys = Object.keys(base);
+				for (let i = 0; i < keys.length; i++) ctx[keys[i]] = base[keys[i]];
+			} catch (err) {
+				releaseContext(ctx);
+				send(peer, {
+					id,
+					error: (err instanceof SilgiError ? err : toSilgiError(err)).toJSON()
+				});
+				return;
+			}
+			const ac = new AbortController();
+			const controllers = peerAbortControllers.get(peer);
+			controllers?.add(ac);
+			try {
+				const result = route.handler(ctx, input ?? {}, ac.signal);
+				const output = result instanceof Promise ? await result : result;
+				if (output && typeof output === "object" && Symbol.asyncIterator in output) {
+					const iter = output;
+					try {
+						for await (const data of iter) {
+							if (ac.signal.aborted) break;
+							send(peer, {
+								id,
+								data
+							});
+						}
+						if (!ac.signal.aborted) send(peer, {
+							id,
+							data: null,
+							done: true
+						});
+					} catch (err) {
+						if (!ac.signal.aborted) send(peer, {
+							id,
+							error: (err instanceof SilgiError ? err : toSilgiError(err)).toJSON()
+						});
+					} finally {
+						await iter.return?.();
+					}
+					return;
+				}
+				send(peer, {
+					id,
+					result: output
+				});
+			} catch (err) {
+				send(peer, {
+					id,
+					error: (err instanceof SilgiError ? err : toSilgiError(err)).toJSON()
+				});
+			} finally {
+				controllers?.delete(ac);
+				releaseContext(ctx);
+			}
+		},
+		close(peer, _details) {
+			const timer = peerKeepaliveTimers.get(peer);
+			if (timer) {
+				clearInterval(timer);
+				peerKeepaliveTimers.delete(peer);
+			}
+			const controllers = peerAbortControllers.get(peer);
+			if (controllers) {
+				for (const ac of controllers) ac.abort();
+				controllers.clear();
+				peerAbortControllers.delete(peer);
+			}
+		},
+		error(_peer, error) {
+			console.error("[silgi:ws] error:", error);
+		}
+	};
+}
+/**
+* Attach WebSocket RPC handler to an existing Node.js HTTP server.
+*
+* @example
+* ```ts
+* import { createServer } from "node:http";
+* import { attachWebSocket } from "silgi/ws";
+*
+* const server = createServer(httpHandler);
+* attachWebSocket(server, appRouter);
+* server.listen(3000);
+* ```
+*/
+async function attachWebSocket(server, routerDef, options = {}) {
+	const nodeAdapter = (await import("crossws/adapters/node")).default;
+	const serverOptions = {};
+	if (options.compress) serverOptions.perMessageDeflate = typeof options.compress === "object" ? options.compress : true;
+	if (options.maxPayload !== void 0) serverOptions.maxPayload = options.maxPayload;
+	const ws = nodeAdapter({
+		hooks: createWSHooks(routerDef, options),
+		...Object.keys(serverOptions).length > 0 && { serverOptions }
+	});
+	server.on("upgrade", (req, socket, head) => {
+		ws.handleUpgrade(req, socket, head);
+	});
+}
+//#endregion
+export { attachWebSocket, createWSHooks };