silgi 0.0.13 → 0.1.0-beta.1

package/dist/adapters/message-port.mjs

@@ -0,0 +1,129 @@
+import { SilgiError, toSilgiError } from "../core/error.mjs";
+import { ValidationError } from "../core/schema.mjs";
+import { compileRouter } from "../compile.mjs";
+//#region src/adapters/message-port.ts
+/**
+* Message Port adapter — use Silgi over MessagePort/MessageChannel.
+*
+* Works with Electron (main↔renderer), browser extensions (background↔popup),
+* Web Workers, and Node.js Worker Threads.
+*
+* @example
+* ```ts
+* // Worker / Electron main
+* import { silgiMessagePort } from "silgi/message-port"
+*
+* const dispose = silgiMessagePort(appRouter, port, {
+*   context: () => ({ db: getDB() }),
+* })
+*
+* // Client side
+* import { MessagePortLink } from "silgi/message-port"
+* import { createClient } from "silgi/client"
+*
+* const client = createClient<AppRouter>(new MessagePortLink(port))
+* const users = await client.users.list({ limit: 10 })
+* ```
+*/
+/**
+* Attach Silgi to a MessagePort (server side).
+* Listens for RPC messages and responds with results.
+* Returns a dispose function to stop listening.
+*/
+function silgiMessagePort(router, port, options = {}) {
+	const flatRouter = compileRouter(router);
+	const handler = async (event) => {
+		const msg = event.data;
+		if (!msg || typeof msg !== "object" || !msg.__silgi || msg.__type !== "request") return;
+		const match = flatRouter("POST", "/" + msg.path);
+		if (!match) {
+			port.postMessage({
+				__silgi: true,
+				__type: "response",
+				id: msg.id,
+				error: {
+					code: "NOT_FOUND",
+					status: 404,
+					message: "Procedure not found"
+				}
+			});
+			return;
+		}
+		const route = match.data;
+		try {
+			const ctx = Object.create(null);
+			if (match.params) ctx.params = match.params;
+			if (options.context) {
+				const baseCtx = await options.context();
+				const keys = Object.keys(baseCtx);
+				for (let i = 0; i < keys.length; i++) ctx[keys[i]] = baseCtx[keys[i]];
+			}
+			const signal = new AbortController().signal;
+			const result = await route.handler(ctx, msg.input, signal);
+			port.postMessage({
+				__silgi: true,
+				__type: "response",
+				id: msg.id,
+				result
+			});
+		} catch (error) {
+			const e = error instanceof ValidationError ? {
+				code: "BAD_REQUEST",
+				status: 400,
+				message: error.message,
+				data: { issues: error.issues }
+			} : error instanceof SilgiError ? error.toJSON() : toSilgiError(error).toJSON();
+			port.postMessage({
+				__silgi: true,
+				__type: "response",
+				id: msg.id,
+				error: e
+			});
+		}
+	};
+	port.addEventListener("message", handler);
+	return () => port.removeEventListener("message", handler);
+}
+/**
+* Client-side MessagePort link.
+* Sends RPC messages and resolves promises when responses arrive.
+*/
+var MessagePortLink = class {
+	#port;
+	#pending = /* @__PURE__ */ new Map();
+	#nextId = 1;
+	constructor(port) {
+		this.#port = port;
+		port.addEventListener("message", (event) => {
+			const msg = event.data;
+			if (!msg || typeof msg !== "object" || !msg.__silgi || msg.__type !== "response") return;
+			const pending = this.#pending.get(msg.id);
+			if (!pending) return;
+			this.#pending.delete(msg.id);
+			if (msg.error) pending.reject(new SilgiError(msg.error.code, {
+				status: msg.error.status,
+				message: msg.error.message,
+				data: msg.error.data
+			}));
+			else pending.resolve(msg.result);
+		});
+	}
+	call(path, input, _options) {
+		return new Promise((resolve, reject) => {
+			const id = String(this.#nextId++);
+			this.#pending.set(id, {
+				resolve,
+				reject
+			});
+			this.#port.postMessage({
+				__silgi: true,
+				__type: "request",
+				id,
+				path: path.join("/"),
+				input
+			});
+		});
+	}
+};
+//#endregion
+export { MessagePortLink, silgiMessagePort };

package/dist/adapters/nestjs.d.mts

@@ -0,0 +1,25 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/nestjs.d.ts
+interface NestAdapterOptions<TCtx extends Record<string, unknown>> {
+  /** Context factory — receives the NestJS/Express request */
+  context?: (req: any) => TCtx | Promise<TCtx>;
+}
+/**
+ * Create a NestJS-compatible handler function.
+ *
+ * Use inside a `@Controller` with `@All("*")`.
+ * Handles routing internally — NestJS only needs to mount the prefix.
+ */
+declare function silgiNestHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: NestAdapterOptions<TCtx>): (req: any, res: any) => Promise<void>;
+/**
+ * Create a NestJS module configuration for Silgi.
+ *
+ * Returns an object that can be used with NestJS's dynamic module pattern.
+ */
+declare function createSilgiModule(router: RouterDef, options?: NestAdapterOptions<any>): {
+  handler: (req: any, res: any) => Promise<void>;
+  router: RouterDef;
+};
+//#endregion
+export { NestAdapterOptions, createSilgiModule, silgiNestHandler };

package/dist/adapters/nestjs.mjs

@@ -0,0 +1,91 @@
+import { SilgiError, toSilgiError } from "../core/error.mjs";
+import { ValidationError } from "../core/schema.mjs";
+import { compileRouter } from "../compile.mjs";
+//#region src/adapters/nestjs.ts
+/**
+* NestJS adapter — register Silgi as a NestJS controller.
+*
+* @example
+* ```ts
+* // rpc.controller.ts
+* import { Controller, All, Req, Res } from "@nestjs/common"
+* import { silgiNestHandler } from "silgi/nestjs"
+* import { appRouter } from "./rpc"
+*
+* const rpcHandler = silgiNestHandler(appRouter, {
+*   context: (req) => ({ db: getDB(), user: req.user }),
+* })
+*
+* @Controller("rpc")
+* export class RpcController {
+*   @All("*")
+*   async handle(@Req() req: Request, @Res() res: Response) {
+*     return rpcHandler(req, res)
+*   }
+* }
+* ```
+*/
+/**
+* Create a NestJS-compatible handler function.
+*
+* Use inside a `@Controller` with `@All("*")`.
+* Handles routing internally — NestJS only needs to mount the prefix.
+*/
+function silgiNestHandler(router, options = {}) {
+	const flatRouter = compileRouter(router);
+	return async (req, res) => {
+		let pathname = req.params?.[0] ?? req.path ?? req.url ?? "";
+		if (pathname.startsWith("/")) pathname = pathname.slice(1);
+		const match = flatRouter(req.method, "/" + pathname);
+		if (!match) {
+			res.status(404).json({
+				code: "NOT_FOUND",
+				status: 404,
+				message: "Procedure not found"
+			});
+			return;
+		}
+		const route = match.data;
+		try {
+			const ctx = Object.create(null);
+			if (match.params) ctx.params = match.params;
+			if (options.context) {
+				const baseCtx = await options.context(req);
+				const keys = Object.keys(baseCtx);
+				for (let i = 0; i < keys.length; i++) ctx[keys[i]] = baseCtx[keys[i]];
+			}
+			let input;
+			if (req.method === "POST" || req.method === "PUT" || req.method === "PATCH") input = req.body;
+			else if (req.query?.data) input = typeof req.query.data === "string" ? JSON.parse(req.query.data) : req.query.data;
+			const ac = new AbortController();
+			req.on?.("close", () => ac.abort());
+			const output = await route.handler(ctx, input, ac.signal);
+			res.json(output);
+		} catch (error) {
+			if (error instanceof ValidationError) {
+				res.status(400).json({
+					code: "BAD_REQUEST",
+					status: 400,
+					message: error.message,
+					data: { issues: error.issues }
+				});
+				return;
+			}
+			const e = error instanceof SilgiError ? error : toSilgiError(error);
+			res.status(e.status).json(e.toJSON());
+		}
+	};
+}
+/**
+* Create a NestJS module configuration for Silgi.
+*
+* Returns an object that can be used with NestJS's dynamic module pattern.
+*/
+function createSilgiModule(router, options = {}) {
+	return {
+		handler: silgiNestHandler(router, options),
+		router
+	};
+}
+//#endregion
+export { createSilgiModule, silgiNestHandler };

package/dist/adapters/nextjs.d.mts

@@ -0,0 +1,21 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/nextjs.d.ts
+interface NextjsAdapterOptions<TCtx extends Record<string, unknown>> {
+  /** Context factory — receives the Next.js Request */
+  context?: (req: Request) => TCtx | Promise<TCtx>;
+  /** Route prefix to strip. Default: "/api/rpc" */
+  prefix?: string;
+}
+/**
+ * Create a Next.js App Router route handler.
+ *
+ * Uses Silgi's handler() internally — full Fetch API support
+ * including content negotiation (JSON, MessagePack, devalue).
+ *
+ * The handler strips the prefix from the URL path before dispatching
+ * to the Silgi router.
+ */
+declare function silgiNextjs<TCtx extends Record<string, unknown>>(router: RouterDef, options?: NextjsAdapterOptions<TCtx>): (req: Request) => Promise<Response>;
+//#endregion
+export { NextjsAdapterOptions, silgiNextjs };

package/dist/adapters/nextjs.mjs

@@ -0,0 +1,30 @@
+//#region src/adapters/nextjs.ts
+/**
+* Create a Next.js App Router route handler.
+*
+* Uses Silgi's handler() internally — full Fetch API support
+* including content negotiation (JSON, MessagePack, devalue).
+*
+* The handler strips the prefix from the URL path before dispatching
+* to the Silgi router.
+*/
+function silgiNextjs(router, options = {}) {
+	const prefix = options.prefix ?? "/api/rpc";
+	let _handler = null;
+	return async (req) => {
+		if (!_handler) {
+			const { silgi } = await import("../silgi.mjs");
+			_handler = silgi({ context: options.context ?? (() => ({})) }).handler(router);
+		}
+		const url = new URL(req.url);
+		let pathname = url.pathname;
+		if (pathname.startsWith(prefix)) {
+			pathname = pathname.slice(prefix.length);
+			if (!pathname.startsWith("/")) pathname = "/" + pathname;
+		}
+		const rewritten = new Request(new URL(pathname + url.search, url.origin), req);
+		return _handler(rewritten);
+	};
+}
+//#endregion
+export { silgiNextjs };

package/dist/adapters/peer.d.mts

@@ -0,0 +1,27 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/peer.d.ts
+interface PeerOptions<TCtx extends Record<string, unknown>> {
+  context?: () => TCtx | Promise<TCtx>;
+}
+interface Peer {
+  /** Client proxy to call the remote peer's procedures */
+  client: any;
+  /** Stop listening for incoming calls */
+  dispose: () => void;
+}
+/**
+ * Create a bidirectional peer — serves your router AND creates a client
+ * for the remote peer's router.
+ */
+declare function createPeer(localRouter: RouterDef, port: {
+  postMessage(msg: unknown): void;
+  addEventListener(type: 'message', handler: (event: {
+    data: unknown;
+  }) => void): void;
+  removeEventListener(type: 'message', handler: (event: {
+    data: unknown;
+  }) => void): void;
+}, options?: PeerOptions<Record<string, unknown>>): Peer;
+//#endregion
+export { Peer, PeerOptions, createPeer };

package/dist/adapters/peer.mjs

@@ -0,0 +1,36 @@
+import { createClient } from "../client/client.mjs";
+import { MessagePortLink, silgiMessagePort } from "./message-port.mjs";
+//#region src/adapters/peer.ts
+/**
+* Peer-to-peer adapter — bidirectional RPC between two Silgi instances.
+*
+* Both sides can be client AND server simultaneously. Uses MessagePort
+* or any bidirectional channel (WebSocket, WebRTC DataChannel, etc.).
+*
+* @example
+* ```ts
+* import { createPeer } from "silgi/peer"
+*
+* const peerA = createPeer(routerA, channel.port1)
+* const peerB = createPeer(routerB, channel.port2)
+*
+* // A calls B's procedures
+* const result = await peerA.client.hello()
+*
+* // B calls A's procedures
+* const result = await peerB.client.ping()
+* ```
+*/
+/**
+* Create a bidirectional peer — serves your router AND creates a client
+* for the remote peer's router.
+*/
+function createPeer(localRouter, port, options = {}) {
+	const dispose = silgiMessagePort(localRouter, port, options);
+	return {
+		client: createClient(new MessagePortLink(port)),
+		dispose
+	};
+}
+//#endregion
+export { createPeer };

package/dist/adapters/remix.d.mts

@@ -0,0 +1,17 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/remix.d.ts
+interface RemixAdapterOptions<TCtx extends Record<string, unknown>> {
+  context?: (request: Request) => TCtx | Promise<TCtx>;
+  prefix?: string;
+}
+/**
+ * Create a Remix action/loader handler.
+ * Uses Silgi's handler() — full Fetch API + content negotiation.
+ */
+declare function silgiRemix<TCtx extends Record<string, unknown>>(router: RouterDef, options?: RemixAdapterOptions<TCtx>): (args: {
+  request: Request;
+  params: Record<string, string>;
+}) => Promise<Response>;
+//#endregion
+export { RemixAdapterOptions, silgiRemix };

package/dist/adapters/remix.mjs

@@ -0,0 +1,24 @@
+//#region src/adapters/remix.ts
+/**
+* Create a Remix action/loader handler.
+* Uses Silgi's handler() — full Fetch API + content negotiation.
+*/
+function silgiRemix(router, options = {}) {
+	const prefix = options.prefix ?? "/rpc";
+	let _handler = null;
+	return async ({ request }) => {
+		if (!_handler) {
+			const { silgi } = await import("../silgi.mjs");
+			_handler = silgi({ context: options.context ?? (() => ({})) }).handler(router);
+		}
+		const url = new URL(request.url);
+		let pathname = url.pathname;
+		if (pathname.startsWith(prefix)) {
+			pathname = pathname.slice(prefix.length);
+			if (!pathname.startsWith("/")) pathname = "/" + pathname;
+		}
+		return _handler(new Request(new URL(pathname + url.search, url.origin), request));
+	};
+}
+//#endregion
+export { silgiRemix };

package/dist/adapters/solidstart.d.mts

@@ -0,0 +1,14 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/solidstart.d.ts
+interface SolidStartAdapterOptions<TCtx extends Record<string, unknown>> {
+  context?: (event: any) => TCtx | Promise<TCtx>;
+  prefix?: string;
+}
+/**
+ * Create a SolidStart API route handler.
+ * SolidStart uses Fetch API events — uses Silgi's handler().
+ */
+declare function silgiSolidStart<TCtx extends Record<string, unknown>>(router: RouterDef, options?: SolidStartAdapterOptions<TCtx>): (event: any) => Promise<Response>;
+//#endregion
+export { SolidStartAdapterOptions, silgiSolidStart };

package/dist/adapters/solidstart.mjs

@@ -0,0 +1,30 @@
+//#region src/adapters/solidstart.ts
+/**
+* Create a SolidStart API route handler.
+* SolidStart uses Fetch API events — uses Silgi's handler().
+*/
+function silgiSolidStart(router, options = {}) {
+	const prefix = options.prefix ?? "/api/rpc";
+	let _handler = null;
+	let _currentEvent = null;
+	return async (event) => {
+		_currentEvent = event;
+		if (!_handler) {
+			const { silgi } = await import("../silgi.mjs");
+			_handler = silgi({ context: (_req) => {
+				if (options.context) return options.context(_currentEvent);
+				return {};
+			} }).handler(router);
+		}
+		const request = event.request ?? event;
+		const url = new URL(request.url);
+		let pathname = url.pathname;
+		if (pathname.startsWith(prefix)) {
+			pathname = pathname.slice(prefix.length);
+			if (!pathname.startsWith("/")) pathname = "/" + pathname;
+		}
+		return _handler(new Request(new URL(pathname + url.search, url.origin), request));
+	};
+}
+//#endregion
+export { silgiSolidStart };

package/dist/adapters/sveltekit.d.mts

@@ -0,0 +1,18 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/sveltekit.d.ts
+interface SvelteKitAdapterOptions<TCtx extends Record<string, unknown>> {
+  /** Context factory — receives the SvelteKit RequestEvent */
+  context?: (event: any) => TCtx | Promise<TCtx>;
+  /** Route prefix to strip. Default: "/api/rpc" */
+  prefix?: string;
+}
+/**
+ * Create a SvelteKit request handler.
+ *
+ * SvelteKit passes a RequestEvent with `.request` (standard Request).
+ * The handler uses Silgi's handler() for full protocol support.
+ */
+declare function silgiSvelteKit<TCtx extends Record<string, unknown>>(router: RouterDef, options?: SvelteKitAdapterOptions<TCtx>): (event: any) => Promise<Response>;
+//#endregion
+export { SvelteKitAdapterOptions, silgiSvelteKit };

package/dist/adapters/sveltekit.mjs

@@ -0,0 +1,33 @@
+//#region src/adapters/sveltekit.ts
+/**
+* Create a SvelteKit request handler.
+*
+* SvelteKit passes a RequestEvent with `.request` (standard Request).
+* The handler uses Silgi's handler() for full protocol support.
+*/
+function silgiSvelteKit(router, options = {}) {
+	const prefix = options.prefix ?? "/api/rpc";
+	let _handler = null;
+	let _currentEvent = null;
+	return async (event) => {
+		_currentEvent = event;
+		if (!_handler) {
+			const { silgi } = await import("../silgi.mjs");
+			_handler = silgi({ context: (_req) => {
+				if (options.context) return options.context(_currentEvent);
+				return {};
+			} }).handler(router);
+		}
+		const req = event.request;
+		const url = new URL(req.url);
+		let pathname = url.pathname;
+		if (pathname.startsWith(prefix)) {
+			pathname = pathname.slice(prefix.length);
+			if (!pathname.startsWith("/")) pathname = "/" + pathname;
+		}
+		const rewritten = new Request(new URL(pathname + url.search, url.origin), req);
+		return _handler(rewritten);
+	};
+}
+//#endregion
+export { silgiSvelteKit };

package/dist/analyze.mjs

@@ -0,0 +1,26 @@
+//#region src/analyze.ts
+/**
+* Analyze a resolve function to determine what it actually uses.
+*
+* @example
+* ```ts
+* analyzeHandler(({ ctx }) => ctx.db.users.findMany())
+* // → { usesContext: true, usesInput: false, usesFail: false, usesSignal: false, isAsync: false }
+*
+* analyzeHandler(async ({ input }) => input.name)
+* // → { usesContext: false, usesInput: true, usesFail: false, usesSignal: false, isAsync: true }
+* ```
+*/
+function analyzeHandler(fn) {
+	const src = fn.toString();
+	const isAsync = src.startsWith("async ") || src.includes("__async");
+	return {
+		usesContext: /\bctx\b/.test(src) || /\.ctx\b/.test(src) || /\bcontext\b/.test(src),
+		usesInput: /\binput\b/.test(src) || /\.input\b/.test(src),
+		usesFail: /\bfail\b/.test(src) || /\.fail\b/.test(src),
+		usesSignal: /\bsignal\b/.test(src) || /\.signal\b/.test(src),
+		isAsync
+	};
+}
+//#endregion
+export { analyzeHandler };

package/dist/broker/index.d.mts

@@ -0,0 +1,62 @@
+import { RouterDef } from "../types.mjs";
+import { ClientContext, ClientLink, ClientOptions } from "../client/types.mjs";
+
+//#region src/broker/index.d.ts
+/**
+ * Universal broker transport — implement this for any message broker.
+ *
+ * Two methods: `subscribe` (server listens) and `request` (client calls).
+ * The driver handles serialization, correlation, and reply routing internally.
+ */
+interface BrokerDriver {
+  /**
+   * Subscribe to a subject. Handler receives a serialized payload and a
+   * `reply` callback to send the response back to the caller.
+   *
+   * Returns a cleanup function (sync or async) to unsubscribe.
+   */
+  subscribe(subject: string, handler: (payload: string, reply: (data: string) => void) => void): (() => void) | Promise<() => void>;
+  /**
+   * Request-reply: publish payload to a subject and wait for the response.
+   * The driver handles correlation and reply routing internally.
+   */
+  request(subject: string, payload: string, opts?: {
+    timeout?: number;
+  }): Promise<string>;
+}
+interface BrokerOptions<TCtx extends Record<string, unknown>> {
+  /** Subject/topic to listen on. Default: `"silgi"` */
+  subject?: string;
+  /** Context factory — called per request */
+  context?: () => TCtx | Promise<TCtx>;
+}
+/**
+ * Attach Silgi to a message broker (server side).
+ *
+ * Listens for RPC messages on the given subject, dispatches to the compiled
+ * router, and replies with results or errors.
+ *
+ * Returns a cleanup function to stop listening.
+ */
+declare function silgiBroker<TCtx extends Record<string, unknown>>(router: RouterDef, driver: BrokerDriver, options?: BrokerOptions<TCtx>): Promise<() => void>;
+interface BrokerLinkOptions {
+  /** Subject/topic to send requests to. Default: `"silgi"` */
+  subject?: string;
+  /** Request timeout in ms. Default: `10_000` */
+  timeout?: number;
+}
+/**
+ * Client-side broker link — sends RPC calls via a broker driver.
+ */
+declare class BrokerLink<TCtx extends ClientContext = ClientContext> implements ClientLink<TCtx> {
+  #private;
+  constructor(driver: BrokerDriver, options?: BrokerLinkOptions);
+  call(path: readonly string[], input: unknown, _options: ClientOptions<TCtx>): Promise<unknown>;
+}
+/**
+ * In-memory broker driver — for testing and single-process development.
+ * Simulates request-reply without any external broker.
+ */
+declare function memoryBroker(): BrokerDriver;
+//#endregion
+export { BrokerDriver, BrokerLink, BrokerLinkOptions, BrokerOptions, memoryBroker, silgiBroker };