silgi 0.0.14 → 0.1.0-beta.2

package/README.md

@@ -1,2 +1,103 @@
+<p align="center">
+  <br>
+  <img src=".github/assets/cover.png" alt="Silgi — Type-safe RPC framework for TypeScript" width="100%">
+  <br><br>
+  <a href="https://npmjs.com/package/silgi"><img src="https://img.shields.io/npm/v/silgi?style=flat&colorA=0a0908&colorB=edc462" alt="npm version"></a>
+  <a href="https://npmjs.com/package/silgi"><img src="https://img.shields.io/npm/dm/silgi?style=flat&colorA=0a0908&colorB=edc462" alt="npm downloads"></a>
+  <a href="https://github.com/productdevbook/silgi/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/productdevbook/silgi/ci.yml?style=flat&colorA=0a0908&colorB=edc462" alt="CI"></a>
+  <a href="https://github.com/productdevbook/silgi/blob/main/LICENSE"><img src="https://img.shields.io/github/license/productdevbook/silgi?style=flat&colorA=0a0908&colorB=edc462" alt="license"></a>
+</p>
+
+## Quick Start
+
+```bash
+npm install silgi
+```
+
 ```ts
-``
+import { silgi } from 'silgi'
+import { z } from 'zod'
+
+const s = silgi({ context: (req) => ({ db: getDB() }) })
+
+const appRouter = s.router({
+  users: {
+    list: k
+      .$input(z.object({ limit: z.number().optional() }))
+      .$resolve(({ input, ctx }) => ctx.db.users.find({ take: input.limit })),
+  },
+})
+
+s.serve(appRouter, { port: 3000, scalar: true })
+```
+
+## Features
+
+- **Single package** — server, client, 15 plugins, 14 adapters. One install.
+- **Compiled pipeline** — guards unrolled, handlers pre-linked at startup.
+- **Guard / Wrap** — guards enrich context (flat, sync fast-path). Wraps run before + after (onion).
+- **Content negotiation** — JSON, MessagePack, devalue. Automatic from `Accept` header.
+- **Contract-first** — define API shape, share types, implement separately.
+- **Standard Schema** — Zod, Valibot, ArkType.
+
+## Adapters
+
+| | Import |
+|---|---|
+| Standalone | `s.serve()` / `s.handler()` |
+| Nitro v3 | `serverEntry` + `s.handler()` |
+| Express | `silgi/express` |
+| Fastify | `silgi/fastify` |
+| Elysia | `silgi/elysia` |
+| Next.js | `silgi/nextjs` |
+| Nuxt | via Nitro `serverEntry` |
+| SvelteKit | `silgi/sveltekit` |
+| Remix | `silgi/remix` |
+| Astro | `silgi/astro` |
+| SolidStart | `silgi/solidstart` |
+| NestJS | `silgi/nestjs` |
+| AWS Lambda | `silgi/aws-lambda` |
+| MessagePort | `silgi/message-port` |
+
+## Ecosystem
+
+Built-in re-exports — no extra dependencies needed:
+
+| Import | Package | Use case |
+|---|---|---|
+| `silgi/unstorage` | unstorage | Key-value storage (Redis, KV, S3) |
+| `silgi/ocache` | ocache | Cached functions with TTL + SWR |
+| `silgi/ofetch` | ofetch | Universal fetch with auto-retry |
+| `silgi/srvx` | srvx | Universal server (Node, Deno, Bun) |
+
+## Integrations
+
+- **TanStack Query** — `queryOptions`, `mutationOptions`, `infiniteOptions`, `skipToken`
+- **React Server Actions** — `createAction`, `useServerAction`, `useOptimisticServerAction`
+- **AI SDK** — `routerToTools()` turns procedures into LLM tools
+- **tRPC Interop** — `fromTRPC()` for incremental migration
+
+## Examples
+
+```bash
+npx giget@latest gh:productdevbook/silgi/examples/standalone my-app
+npx giget@latest gh:productdevbook/silgi/examples/nextjs my-nextjs-app
+npx giget@latest gh:productdevbook/silgi/examples/nuxt my-nuxt-app
+```
+
+10 examples: standalone, bun, express, elysia, nitro, nitro-h3, nextjs, nuxt, sveltekit, client-react.
+
+## Documentation
+
+[silgi.dev](https://silgi.dev)
+
+## Credits
+
+- [oRPC](https://github.com/unnoq/orpc) — Pipeline architecture, client proxy, error handling, contract-first workflow
+- [tRPC](https://github.com/trpc/trpc) — Router/procedure model, end-to-end type inference
+- [Elysia](https://github.com/elysiajs/elysia) — Sucrose-style static handler analysis
+
+
+## License
+
+MIT

package/dist/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,5 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+export { __require };

package/dist/adapters/astro.d.mts

@@ -0,0 +1,17 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/astro.d.ts
+interface AstroAdapterOptions<TCtx extends Record<string, unknown>> {
+  context?: (request: Request) => TCtx | Promise<TCtx>;
+  prefix?: string;
+}
+/**
+ * Create an Astro API route handler.
+ * Astro passes { request: Request, params } — uses Silgi's handler().
+ */
+declare function silgiAstro<TCtx extends Record<string, unknown>>(router: RouterDef, options?: AstroAdapterOptions<TCtx>): (ctx: {
+  request: Request;
+  params: Record<string, string>;
+}) => Promise<Response>;
+//#endregion
+export { AstroAdapterOptions, silgiAstro };

package/dist/adapters/astro.mjs

@@ -0,0 +1,24 @@
+//#region src/adapters/astro.ts
+/**
+* Create an Astro API route handler.
+* Astro passes { request: Request, params } — uses Silgi's handler().
+*/
+function silgiAstro(router, options = {}) {
+	const prefix = options.prefix ?? "/api/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 { silgiAstro };

package/dist/adapters/aws-lambda.d.mts

@@ -0,0 +1,31 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/aws-lambda.d.ts
+interface LambdaAdapterOptions<TCtx extends Record<string, unknown>> {
+  /** Context factory — receives the Lambda event */
+  context?: (event: LambdaEvent) => TCtx | Promise<TCtx>;
+  /** Route prefix to strip. Default: none */
+  prefix?: string;
+}
+interface LambdaEvent {
+  httpMethod: string;
+  path: string;
+  body: string | null;
+  headers: Record<string, string>;
+  queryStringParameters: Record<string, string> | null;
+  requestContext?: Record<string, unknown>;
+  isBase64Encoded?: boolean;
+}
+interface LambdaResponse {
+  statusCode: number;
+  headers: Record<string, string>;
+  body: string;
+}
+/**
+ * Create an AWS Lambda handler from a Silgi router.
+ *
+ * Supports API Gateway v1 (REST) and v2 (HTTP) event formats.
+ */
+declare function silgiLambda<TCtx extends Record<string, unknown>>(router: RouterDef, options?: LambdaAdapterOptions<TCtx>): (event: LambdaEvent) => Promise<LambdaResponse>;
+//#endregion
+export { LambdaAdapterOptions, silgiLambda };

package/dist/adapters/aws-lambda.mjs

@@ -0,0 +1,85 @@
+import { SilgiError, toSilgiError } from "../core/error.mjs";
+import { ValidationError } from "../core/schema.mjs";
+import { compileRouter } from "../compile.mjs";
+//#region src/adapters/aws-lambda.ts
+/**
+* AWS Lambda adapter — deploy Silgi as a Lambda function.
+*
+* @example
+* ```ts
+* import { silgiLambda } from "silgi/aws-lambda"
+*
+* export const handler = silgiLambda(appRouter, {
+*   context: (event) => ({ db: getDB(), userId: event.requestContext?.authorizer?.userId }),
+* })
+* ```
+*/
+/**
+* Create an AWS Lambda handler from a Silgi router.
+*
+* Supports API Gateway v1 (REST) and v2 (HTTP) event formats.
+*/
+function silgiLambda(router, options = {}) {
+	const flatRouter = compileRouter(router);
+	const prefix = options.prefix ?? "";
+	return async (event) => {
+		let pathname = event.path;
+		if (prefix && pathname.startsWith(prefix)) pathname = pathname.slice(prefix.length);
+		if (pathname.startsWith("/")) pathname = pathname.slice(1);
+		const match = flatRouter(event.httpMethod, "/" + pathname);
+		if (!match) return {
+			statusCode: 404,
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				code: "NOT_FOUND",
+				status: 404,
+				message: "Procedure not found"
+			})
+		};
+		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(event);
+				const keys = Object.keys(baseCtx);
+				for (let i = 0; i < keys.length; i++) ctx[keys[i]] = baseCtx[keys[i]];
+			}
+			let input;
+			if (event.body) {
+				const body = event.isBase64Encoded ? Buffer.from(event.body, "base64").toString("utf-8") : event.body;
+				try {
+					input = JSON.parse(body);
+				} catch {}
+			} else if (event.queryStringParameters?.data) try {
+				input = JSON.parse(event.queryStringParameters.data);
+			} catch {}
+			const signal = AbortSignal.timeout(3e4);
+			const output = await route.handler(ctx, input, signal);
+			return {
+				statusCode: 200,
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify(output)
+			};
+		} catch (error) {
+			if (error instanceof ValidationError) return {
+				statusCode: 400,
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({
+					code: "BAD_REQUEST",
+					status: 400,
+					message: error.message,
+					data: { issues: error.issues }
+				})
+			};
+			const e = error instanceof SilgiError ? error : toSilgiError(error);
+			return {
+				statusCode: e.status,
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify(e.toJSON())
+			};
+		}
+	};
+}
+//#endregion
+export { silgiLambda };

package/dist/adapters/elysia.d.mts

@@ -0,0 +1,17 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/elysia.d.ts
+interface ElysiaAdapterOptions<TCtx extends Record<string, unknown>> {
+  /** Context factory — receives the Elysia context */
+  context?: (ctx: any) => TCtx | Promise<TCtx>;
+  /** Route prefix. Default: "/rpc" */
+  prefix?: string;
+}
+/**
+ * Create an Elysia plugin that routes to Silgi procedures.
+ *
+ * Returns a function that can be passed to `app.use()`.
+ */
+declare function silgiElysia<TCtx extends Record<string, unknown>>(router: RouterDef, options?: ElysiaAdapterOptions<TCtx>): (app: any) => any;
+//#endregion
+export { ElysiaAdapterOptions, silgiElysia };

package/dist/adapters/elysia.mjs

@@ -0,0 +1,76 @@
+import { SilgiError, toSilgiError } from "../core/error.mjs";
+import { ValidationError } from "../core/schema.mjs";
+import { compileRouter } from "../compile.mjs";
+//#region src/adapters/elysia.ts
+/**
+* Elysia adapter — use Silgi with Elysia on Bun.
+*
+* @example
+* ```ts
+* import { Elysia } from "elysia"
+* import { silgiElysia } from "silgi/elysia"
+*
+* const app = new Elysia()
+*   .use(silgiElysia(appRouter, { prefix: "/rpc" }))
+*   .listen(3000)
+* ```
+*/
+/**
+* Create an Elysia plugin that routes to Silgi procedures.
+*
+* Returns a function that can be passed to `app.use()`.
+*/
+function silgiElysia(router, options = {}) {
+	const flatRouter = compileRouter(router);
+	const prefix = options.prefix ?? "/rpc";
+	return (app) => {
+		app.all(`${prefix}/*`, async (elysiaCtx) => {
+			let pathname = new URL(elysiaCtx.request.url).pathname;
+			if (pathname.startsWith(prefix)) pathname = pathname.slice(prefix.length);
+			if (pathname.startsWith("/")) pathname = pathname.slice(1);
+			const match = flatRouter(elysiaCtx.request.method, "/" + pathname);
+			if (!match) {
+				elysiaCtx.set.status = 404;
+				return {
+					code: "NOT_FOUND",
+					status: 404,
+					message: "Procedure not found"
+				};
+			}
+			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(elysiaCtx);
+					const keys = Object.keys(baseCtx);
+					for (let i = 0; i < keys.length; i++) ctx[keys[i]] = baseCtx[keys[i]];
+				}
+				let input;
+				if (elysiaCtx.request.method === "POST" || elysiaCtx.request.method === "PUT") input = elysiaCtx.body;
+				else {
+					const data = elysiaCtx.query?.data;
+					if (data) input = typeof data === "string" ? JSON.parse(data) : data;
+				}
+				const signal = elysiaCtx.request.signal ?? new AbortController().signal;
+				return await route.handler(ctx, input, signal);
+			} catch (error) {
+				if (error instanceof ValidationError) {
+					elysiaCtx.set.status = 400;
+					return {
+						code: "BAD_REQUEST",
+						status: 400,
+						message: error.message,
+						data: { issues: error.issues }
+					};
+				}
+				const e = error instanceof SilgiError ? error : toSilgiError(error);
+				elysiaCtx.set.status = e.status;
+				return e.toJSON();
+			}
+		});
+		return app;
+	};
+}
+//#endregion
+export { silgiElysia };

package/dist/adapters/express.d.mts

@@ -0,0 +1,16 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/express.d.ts
+interface ExpressAdapterOptions<TCtx extends Record<string, unknown>> {
+  /** Context factory — receives the Express request */
+  context?: (req: any) => TCtx | Promise<TCtx>;
+}
+/**
+ * Create Express middleware that routes to Silgi procedures.
+ *
+ * Mount at a prefix — the remainder of the path is the procedure name.
+ * Requires `express.json()` middleware for POST body parsing.
+ */
+declare function silgiExpress<TCtx extends Record<string, unknown>>(router: RouterDef, options?: ExpressAdapterOptions<TCtx>): (req: any, res: any, next: any) => void;
+//#endregion
+export { ExpressAdapterOptions, silgiExpress };

package/dist/adapters/express.mjs

@@ -0,0 +1,78 @@
+import { SilgiError, toSilgiError } from "../core/error.mjs";
+import { ValidationError } from "../core/schema.mjs";
+import { compileRouter } from "../compile.mjs";
+//#region src/adapters/express.ts
+/**
+* Express adapter — use Silgi as Express middleware.
+*
+* @example
+* ```ts
+* import express from "express"
+* import { silgiExpress } from "silgi/express"
+*
+* const app = express()
+* app.use("/rpc", silgiExpress(appRouter, {
+*   context: (req) => ({ db: getDB(), user: req.user }),
+* }))
+* app.listen(3000)
+* ```
+*/
+/**
+* Create Express middleware that routes to Silgi procedures.
+*
+* Mount at a prefix — the remainder of the path is the procedure name.
+* Requires `express.json()` middleware for POST body parsing.
+*/
+function silgiExpress(router, options = {}) {
+	const flatRouter = compileRouter(router);
+	return (req, res, next) => {
+		let pathname = req.path ?? req.url ?? "";
+		if (pathname.startsWith("/")) pathname = pathname.slice(1);
+		const match = flatRouter(req.method, "/" + pathname);
+		if (!match) return next();
+		const route = match.data;
+		const handle = async () => {
+			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) if (typeof req.query.data === "string") try {
+					input = JSON.parse(req.query.data);
+				} catch {
+					res.status(400).json({
+						code: "BAD_REQUEST",
+						status: 400,
+						message: "Invalid JSON in data parameter"
+					});
+					return;
+				}
+				else input = 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());
+			}
+		};
+		handle();
+	};
+}
+//#endregion
+export { silgiExpress };

package/dist/adapters/fastify.d.mts

@@ -0,0 +1,15 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/fastify.d.ts
+interface SilgiFastifyOptions {
+  /** Context factory — receives Fastify request */
+  context?: (req: any) => Record<string, unknown> | Promise<Record<string, unknown>>;
+}
+/**
+ * Create a Fastify plugin from a silgi router.
+ *
+ * Uses a single wildcard route with the compiled radix router for dispatch.
+ */
+declare function silgiFastify(routerDef: RouterDef, options?: SilgiFastifyOptions): (fastify: any) => Promise<void>;
+//#endregion
+export { SilgiFastifyOptions, silgiFastify };

package/dist/adapters/fastify.mjs

@@ -0,0 +1,78 @@
+import { SilgiError, toSilgiError } from "../core/error.mjs";
+import { ValidationError } from "../core/schema.mjs";
+import { compileRouter } from "../compile.mjs";
+//#region src/adapters/fastify.ts
+/**
+* Fastify adapter — register silgi router as a Fastify plugin.
+*
+* @example
+* ```ts
+* import Fastify from "fastify"
+* import { silgiFastify } from "silgi/fastify"
+*
+* const app = Fastify()
+* app.register(silgiFastify(appRouter), { prefix: "/rpc" })
+* app.listen({ port: 3000 })
+* ```
+*/
+let _msgpack;
+let _devalue;
+/**
+* Create a Fastify plugin from a silgi router.
+*
+* Uses a single wildcard route with the compiled radix router for dispatch.
+*/
+function silgiFastify(routerDef, options = {}) {
+	const compiledRouter = compileRouter(routerDef);
+	const contextFactory = options.context ?? (() => ({}));
+	return async function plugin(fastify) {
+		fastify.all("/*", async (req, reply) => {
+			const pathname = "/" + (req.params?.["*"] ?? "");
+			const match = compiledRouter(req.method ?? "POST", pathname);
+			if (!match) return reply.status(404).send({
+				code: "NOT_FOUND",
+				status: 404,
+				message: "Not found"
+			});
+			const route = match.data;
+			const ctx = Object.create(null);
+			if (match.params) ctx.params = match.params;
+			try {
+				const baseCtx = await contextFactory(req);
+				Object.assign(ctx, baseCtx);
+			} catch (err) {
+				const e = err instanceof SilgiError ? err : toSilgiError(err);
+				return reply.status(e.status).send(e.toJSON());
+			}
+			const rawInput = req.body && typeof req.body === "object" ? req.body : {};
+			try {
+				const ac = new AbortController();
+				req.raw?.on?.("close", () => ac.abort());
+				const result = route.handler(ctx, rawInput, ac.signal);
+				const output = result instanceof Promise ? await result : result;
+				if (route.cacheControl) reply.header("cache-control", route.cacheControl);
+				const accept = req.headers.accept;
+				if (accept?.includes("msgpack")) {
+					_msgpack ??= await import("../codec/msgpack.mjs");
+					return reply.header("content-type", _msgpack.MSGPACK_CONTENT_TYPE).send(Buffer.from(_msgpack.encode(output)));
+				}
+				if (accept?.includes("x-devalue")) {
+					_devalue ??= await import("../codec/devalue.mjs");
+					return reply.header("content-type", _devalue.DEVALUE_CONTENT_TYPE).send(_devalue.encode(output));
+				}
+				return reply.header("content-type", "application/json").send(route.stringify(output));
+			} catch (error) {
+				if (error instanceof ValidationError) return reply.status(400).send({
+					code: "BAD_REQUEST",
+					status: 400,
+					message: error.message,
+					data: { issues: error.issues }
+				});
+				const e = error instanceof SilgiError ? error : toSilgiError(error);
+				return reply.status(e.status).send(e.toJSON());
+			}
+		});
+	};
+}
+//#endregion
+export { silgiFastify };

package/dist/adapters/message-port.d.mts

@@ -0,0 +1,37 @@
+import { RouterDef } from "../types.mjs";
+import { ClientContext, ClientLink, ClientOptions } from "../client/types.mjs";
+
+//#region src/adapters/message-port.d.ts
+interface MessagePortAdapterOptions<TCtx extends Record<string, unknown>> {
+  context?: () => TCtx | Promise<TCtx>;
+}
+/**
+ * Attach Silgi to a MessagePort (server side).
+ * Listens for RPC messages and responds with results.
+ * Returns a dispose function to stop listening.
+ */
+declare function silgiMessagePort<TCtx extends Record<string, unknown>>(router: 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?: MessagePortAdapterOptions<TCtx>): () => void;
+/**
+ * Client-side MessagePort link.
+ * Sends RPC messages and resolves promises when responses arrive.
+ */
+declare class MessagePortLink<TCtx extends ClientContext = ClientContext> implements ClientLink<TCtx> {
+  #private;
+  constructor(port: {
+    postMessage(msg: unknown): void;
+    addEventListener(type: 'message', handler: (event: {
+      data: unknown;
+    }) => void): void;
+  });
+  call(path: readonly string[], input: unknown, _options: ClientOptions<TCtx>): Promise<unknown>;
+}
+//#endregion
+export { MessagePortAdapterOptions, MessagePortLink, silgiMessagePort };