silgi 0.0.14 → 0.1.0-beta.10

package/dist/core/error.mjs

@@ -0,0 +1,139 @@
+//#region src/core/error.ts
+/**
+* SilgiError — unified RPC error with cross-realm instanceof.
+*/
+const COMMON_ERRORS = /* @__PURE__ */ Object.freeze({
+	BAD_REQUEST: {
+		status: 400,
+		message: "Bad Request"
+	},
+	UNAUTHORIZED: {
+		status: 401,
+		message: "Unauthorized"
+	},
+	FORBIDDEN: {
+		status: 403,
+		message: "Forbidden"
+	},
+	NOT_FOUND: {
+		status: 404,
+		message: "Not Found"
+	},
+	METHOD_NOT_ALLOWED: {
+		status: 405,
+		message: "Method Not Allowed"
+	},
+	NOT_ACCEPTABLE: {
+		status: 406,
+		message: "Not Acceptable"
+	},
+	CONFLICT: {
+		status: 409,
+		message: "Conflict"
+	},
+	GONE: {
+		status: 410,
+		message: "Gone"
+	},
+	UNPROCESSABLE_CONTENT: {
+		status: 422,
+		message: "Unprocessable Content"
+	},
+	PRECONDITION_REQUIRED: {
+		status: 428,
+		message: "Precondition Required"
+	},
+	TOO_MANY_REQUESTS: {
+		status: 429,
+		message: "Too Many Requests"
+	},
+	CLIENT_CLOSED_REQUEST: {
+		status: 499,
+		message: "Client Closed Request"
+	},
+	INTERNAL_SERVER_ERROR: {
+		status: 500,
+		message: "Internal Server Error"
+	},
+	NOT_IMPLEMENTED: {
+		status: 501,
+		message: "Not Implemented"
+	},
+	BAD_GATEWAY: {
+		status: 502,
+		message: "Bad Gateway"
+	},
+	SERVICE_UNAVAILABLE: {
+		status: 503,
+		message: "Service Unavailable"
+	},
+	GATEWAY_TIMEOUT: {
+		status: 504,
+		message: "Gateway Timeout"
+	}
+});
+const REGISTRY_KEY = Symbol.for("silgi.error.registry");
+const registry = globalThis[REGISTRY_KEY] ??= /* @__PURE__ */ new WeakSet();
+var SilgiError = class extends Error {
+	code;
+	status;
+	data;
+	defined;
+	constructor(code, options = {}) {
+		const defaults = COMMON_ERRORS[code];
+		const message = options.message ?? defaults?.message ?? code;
+		super(message, options.cause ? { cause: options.cause } : void 0);
+		this.code = code;
+		this.status = options.status ?? defaults?.status ?? 500;
+		this.data = options.data;
+		this.defined = options.defined ?? false;
+		this.name = "SilgiError";
+	}
+	toJSON() {
+		return {
+			defined: this.defined,
+			code: this.code,
+			status: this.status,
+			message: this.message,
+			data: this.data
+		};
+	}
+	static {
+		registry.add(this);
+	}
+	static [Symbol.hasInstance](instance) {
+		if (typeof instance !== "object" || instance === null) return false;
+		let proto = Object.getPrototypeOf(instance);
+		while (proto) {
+			if (proto.constructor && registry.has(proto.constructor)) return true;
+			proto = Object.getPrototypeOf(proto);
+		}
+		return false;
+	}
+};
+function isDefinedError(error) {
+	return error instanceof SilgiError && error.defined === true;
+}
+function toSilgiError(error) {
+	if (error instanceof SilgiError) return error;
+	return new SilgiError("INTERNAL_SERVER_ERROR", {
+		message: "Internal server error",
+		cause: error
+	});
+}
+function isErrorStatus(status) {
+	return status >= 400;
+}
+function isSilgiErrorJSON(json) {
+	return typeof json === "object" && json !== null && "code" in json && "status" in json && typeof json.code === "string";
+}
+function fromSilgiErrorJSON(json) {
+	return new SilgiError(json.code, {
+		status: json.status,
+		message: json.message,
+		data: json.data,
+		defined: json.defined
+	});
+}
+//#endregion
+export { SilgiError, fromSilgiErrorJSON, isDefinedError, isErrorStatus, isSilgiErrorJSON, toSilgiError };

package/dist/core/handler.d.mts

@@ -0,0 +1,6 @@
+import { Hookable } from "hookable";
+
+//#region src/core/handler.d.ts
+type FetchHandler = (request: Request) => Response | Promise<Response>;
+//#endregion
+export { FetchHandler };

package/dist/core/handler.mjs

@@ -0,0 +1,148 @@
+import { routerCache } from "./router-utils.mjs";
+import { compileRouter, createContext, releaseContext } from "../compile.mjs";
+import { applyContext } from "./dispatch.mjs";
+import { analyticsTraceMap } from "../plugins/analytics.mjs";
+import { detectResponseFormat, encodeResponse, makeErrorResponse } from "./codec.mjs";
+import { parseInput } from "./input.mjs";
+import { iteratorToEventStream } from "./sse.mjs";
+//#region src/core/handler.ts
+/**
+* Fetch API handler — single unified request handler.
+*
+* Orchestrates: routing → context → input parsing → pipeline → response encoding.
+* Each concern lives in its own module (codec.ts, input.ts, sse.ts).
+*
+* Analytics / Scalar are NOT here — they wrap the handler externally
+* (see wrapWithAnalytics / wrapWithScalar in their respective modules).
+*/
+/** Wrap a stream to release pooled context on completion or cancellation. */
+function wrapStreamWithRelease(source, ctx) {
+	let released = false;
+	const release = () => {
+		if (!released) {
+			released = true;
+			releaseContext(ctx);
+		}
+	};
+	const reader = source.getReader();
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await reader.read();
+				if (done) {
+					release();
+					controller.close();
+				} else controller.enqueue(value);
+			} catch (err) {
+				release();
+				controller.error(err);
+			}
+		},
+		cancel() {
+			release();
+			reader.cancel();
+		}
+	});
+}
+function makeResponse(output, route, format, ctx) {
+	if (output instanceof Response) {
+		releaseContext(ctx);
+		return output;
+	}
+	if (output instanceof ReadableStream) return new Response(wrapStreamWithRelease(output, ctx), { headers: { "content-type": "application/octet-stream" } });
+	if (output && typeof output === "object" && Symbol.asyncIterator in output) {
+		const stream = iteratorToEventStream(output);
+		return new Response(wrapStreamWithRelease(stream, ctx), { headers: {
+			"content-type": "text/event-stream",
+			"cache-control": "no-cache"
+		} });
+	}
+	releaseContext(ctx);
+	const cacheHeaders = route.cacheControl ? { "cache-control": route.cacheControl } : void 0;
+	if (format !== "json") return encodeResponse(output, 200, format, cacheHeaders);
+	return new Response(JSON.stringify(output), { headers: cacheHeaders ? {
+		"content-type": "application/json",
+		...cacheHeaders
+	} : { "content-type": "application/json" } });
+}
+function createFetchHandler(routerDef, contextFactory, hooks) {
+	let compiledRouter = routerCache.get(routerDef);
+	if (!compiledRouter) {
+		compiledRouter = compileRouter(routerDef);
+		routerCache.set(routerDef, compiledRouter);
+	}
+	const jsonHeaders = { "content-type": "application/json" };
+	const notFoundBody = JSON.stringify({
+		code: "NOT_FOUND",
+		status: 404,
+		message: "Procedure not found"
+	});
+	function callHook(name, event) {
+		if (!hooks) return;
+		try {
+			const result = hooks.callHook(name, event);
+			if (result instanceof Promise) result.catch(() => {});
+		} catch {}
+	}
+	return async function handleRequest(request) {
+		const url = request.url;
+		const pathStart = url.indexOf("/", url.indexOf("//") + 2);
+		const qMark = url.indexOf("?", pathStart);
+		const fullPath = qMark === -1 ? url.slice(pathStart) : url.slice(pathStart, qMark);
+		const pathname = fullPath.length > 1 ? fullPath.slice(1) : "";
+		const match = compiledRouter(request.method, fullPath);
+		if (!match) return new Response(notFoundBody, {
+			status: 404,
+			headers: jsonHeaders
+		});
+		const route = match.data;
+		const reqMethod = request.method;
+		if (route.method !== "*" && reqMethod !== route.method && reqMethod !== "OPTIONS") {
+			if (!(reqMethod === "GET" && route.method === "POST")) return new Response(JSON.stringify({
+				code: "METHOD_NOT_ALLOWED",
+				status: 405,
+				message: `Method ${reqMethod} not allowed`
+			}), {
+				status: 405,
+				headers: {
+					...jsonHeaders,
+					allow: route.method
+				}
+			});
+		}
+		const format = detectResponseFormat(request);
+		const ctx = createContext();
+		let rawInput;
+		try {
+			const baseCtxResult = contextFactory(request);
+			applyContext(ctx, baseCtxResult instanceof Promise ? await baseCtxResult : baseCtxResult);
+			if (match.params) ctx.params = match.params;
+			const reqTrace = analyticsTraceMap.get(request);
+			if (reqTrace) ctx.__analyticsTrace = reqTrace;
+			if (!route.passthrough) rawInput = await parseInput(request, url, qMark);
+			callHook("request", {
+				path: pathname,
+				input: rawInput
+			});
+			const pipelineResult = route.handler(ctx, rawInput, request.signal);
+			const output = pipelineResult instanceof Promise ? await pipelineResult : pipelineResult;
+			callHook("response", {
+				path: pathname,
+				output,
+				durationMs: 0
+			});
+			const response = makeResponse(output, route, format, ctx);
+			return response instanceof Promise ? await response : response;
+		} catch (error) {
+			releaseContext(ctx);
+			callHook("error", {
+				path: pathname,
+				error
+			});
+			const errorResponse = makeErrorResponse(error, format);
+			return errorResponse instanceof Promise ? await errorResponse : errorResponse;
+		}
+	};
+}
+//#endregion
+export { createFetchHandler };

package/dist/core/input.mjs

@@ -0,0 +1,49 @@
+import { SilgiError } from "./error.mjs";
+//#region src/core/input.ts
+/**
+* Request input parsing — JSON, MessagePack, devalue, query string.
+*/
+let _msgpack;
+let _devalue;
+const isBun = typeof globalThis.Bun !== "undefined";
+/** Max allowed size for GET ?data= parameter (bytes). Prevents JSON bomb via URL. */
+const MAX_QUERY_DATA_LENGTH = 8192;
+/** Parse request input from body or query string */
+async function parseInput(request, url, qMark) {
+	if (request.method === "GET" || !request.body) {
+		if (qMark !== -1) {
+			const searchStr = url.slice(qMark + 1);
+			const dataIdx = searchStr.indexOf("data=");
+			if (dataIdx !== -1) {
+				const valueStart = dataIdx + 5;
+				const valueEnd = searchStr.indexOf("&", valueStart);
+				const encoded = valueEnd === -1 ? searchStr.slice(valueStart) : searchStr.slice(valueStart, valueEnd);
+				if (encoded.length > MAX_QUERY_DATA_LENGTH) throw new SilgiError("BAD_REQUEST", { message: "Query data parameter too large" });
+				return JSON.parse(decodeURIComponent(encoded));
+			}
+		}
+		return;
+	}
+	const ct = request.headers.get("content-type");
+	if (ct) {
+		if (ct.includes("msgpack")) {
+			_msgpack ??= await import("../codec/msgpack.mjs");
+			const buf = new Uint8Array(await request.arrayBuffer());
+			return buf.length > 0 ? _msgpack.decode(buf) : void 0;
+		}
+		if (ct.includes("x-devalue")) {
+			_devalue ??= await import("../codec/devalue.mjs");
+			const text = await request.text();
+			return text ? _devalue.decode(text) : void 0;
+		}
+	}
+	if (isBun) try {
+		return await request.json();
+	} catch {
+		return;
+	}
+	const text = await request.text();
+	return text ? JSON.parse(text) : void 0;
+}
+//#endregion
+export { parseInput };

package/dist/core/iterator.d.mts

@@ -0,0 +1,17 @@
+//#region src/core/iterator.d.ts
+/**
+ * Async iterator utilities for streaming support.
+ */
+type CleanupReason = 'return' | 'throw' | 'next' | 'dispose';
+declare class AsyncIteratorClass<TYield, TReturn = void> implements AsyncGenerator<TYield, TReturn> {
+  #private;
+  constructor(nextFn: () => Promise<IteratorResult<TYield, TReturn>>, cleanup?: (reason: CleanupReason) => Promise<void>);
+  next(): Promise<IteratorResult<TYield, TReturn>>;
+  return(value?: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<TYield, TReturn>>;
+  throw(error?: unknown): Promise<IteratorResult<TYield, TReturn>>;
+  [Symbol.asyncIterator](): this;
+  [Symbol.asyncDispose](): Promise<void>;
+}
+declare function mapAsyncIterator<TIn, TOut, TReturn = void>(source: AsyncIterableIterator<TIn>, transform: (value: TIn) => Promise<TOut> | TOut, transformError?: (error: unknown) => unknown): AsyncIteratorClass<TOut, TReturn>;
+//#endregion
+export { AsyncIteratorClass, mapAsyncIterator };

package/dist/core/iterator.mjs

@@ -0,0 +1,79 @@
+import { sequential } from "./utils.mjs";
+//#region src/core/iterator.ts
+/**
+* Async iterator utilities for streaming support.
+*/
+var AsyncIteratorClass = class {
+	#nextFn;
+	#cleanup;
+	#isDone = false;
+	#cleanupCalled = false;
+	constructor(nextFn, cleanup) {
+		this.#nextFn = sequential(nextFn);
+		this.#cleanup = cleanup;
+	}
+	async #doCleanup(reason) {
+		if (this.#cleanupCalled) return;
+		this.#cleanupCalled = true;
+		await this.#cleanup?.(reason);
+	}
+	async next() {
+		if (this.#isDone) return {
+			done: true,
+			value: void 0
+		};
+		try {
+			const result = await this.#nextFn();
+			if (result.done) {
+				this.#isDone = true;
+				await this.#doCleanup("next");
+			}
+			return result;
+		} catch (error) {
+			this.#isDone = true;
+			await this.#doCleanup("throw");
+			throw error;
+		}
+	}
+	async return(value) {
+		this.#isDone = true;
+		await this.#doCleanup("return");
+		return {
+			done: true,
+			value
+		};
+	}
+	async throw(error) {
+		this.#isDone = true;
+		await this.#doCleanup("throw");
+		throw error;
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+	async [Symbol.asyncDispose]() {
+		this.#isDone = true;
+		await this.#doCleanup("dispose");
+	}
+};
+function mapAsyncIterator(source, transform, transformError) {
+	return new AsyncIteratorClass(async () => {
+		try {
+			const result = await source.next();
+			if (result.done) return {
+				done: true,
+				value: await transform(result.value)
+			};
+			return {
+				done: false,
+				value: await transform(result.value)
+			};
+		} catch (error) {
+			throw transformError ? transformError(error) : error;
+		}
+	}, async () => {
+		await source.return?.();
+	});
+}
+//#endregion
+export { AsyncIteratorClass, mapAsyncIterator };

package/dist/core/router-utils.d.mts

@@ -0,0 +1,25 @@
+import { compileRouter } from "../compile.mjs";
+
+//#region src/core/router-utils.d.ts
+/** Extracted route metadata — safe for client bundles (no server code) */
+interface ExtractedRoute {
+  path: string;
+  method: string;
+}
+/** Nested route map — mirrors the router tree structure with only route metadata */
+type ExtractedRoutes = {
+  [key: string]: ExtractedRoute | ExtractedRoutes;
+};
+/**
+ * Extract route metadata from a router definition.
+ * Returns a lightweight nested object safe for client bundles — no resolve functions,
+ * no guards, no schemas, no server code.
+ *
+ * ```ts
+ * // server/routes.ts — import this on the client
+ * export const routes = extractRoutes(appRouter)
+ * ```
+ */
+declare function extractRoutes(def: unknown, prefix?: string[]): ExtractedRoutes;
+//#endregion
+export { ExtractedRoute, ExtractedRoutes, extractRoutes };

package/dist/core/router-utils.mjs

@@ -0,0 +1,98 @@
+import "../compile.mjs";
+//#region src/core/router-utils.ts
+const routerCache = /* @__PURE__ */ new WeakMap();
+function isProcedureDef(value) {
+	return typeof value === "object" && value !== null && "type" in value && "resolve" in value && typeof value.resolve === "function";
+}
+function assignPaths(def, prefix = []) {
+	const result = {};
+	for (const [key, value] of Object.entries(def)) {
+		const currentPath = [...prefix, key];
+		if (isProcedureDef(value)) if (!value.route) result[key] = {
+			...value,
+			route: { path: "/" + currentPath.join("/") }
+		};
+		else result[key] = value;
+		else if (typeof value === "object" && value !== null) result[key] = assignPaths(value, currentPath);
+		else result[key] = value;
+	}
+	return result;
+}
+/**
+* Extract route metadata from a router definition.
+* Returns a lightweight nested object safe for client bundles — no resolve functions,
+* no guards, no schemas, no server code.
+*
+* ```ts
+* // server/routes.ts — import this on the client
+* export const routes = extractRoutes(appRouter)
+* ```
+*/
+function extractRoutes(def, prefix = []) {
+	const result = {};
+	if (def == null || typeof def !== "object") return result;
+	for (const [key, value] of Object.entries(def)) if (isProcedureDef(value)) {
+		const route = value.route;
+		if (route?.path) result[key] = {
+			path: route.path,
+			method: (route.method ?? "POST").toUpperCase()
+		};
+	} else if (typeof value === "object" && value !== null) {
+		const nested = extractRoutes(value, [...prefix, key]);
+		if (Object.keys(nested).length > 0) result[key] = nested;
+	}
+	return result;
+}
+/** Check if a value is an extracted route leaf (has path + method, not a nested object) */
+function isExtractedRoute(value) {
+	return typeof value === "object" && value !== null && "path" in value && "method" in value && !("resolve" in value);
+}
+/** Walk a route tree by path segments and return the route metadata. Works with both full routers and extracted routes. */
+function resolveRoute(routes, path) {
+	let current = routes;
+	for (const segment of path) {
+		if (current == null || typeof current !== "object") return void 0;
+		current = current[segment];
+	}
+	if (isExtractedRoute(current)) return current;
+	if (isProcedureDef(current)) {
+		const route = current.route;
+		if (!route?.path) return void 0;
+		return {
+			path: route.path,
+			method: (route.method ?? "POST").toUpperCase()
+		};
+	}
+}
+/**
+* Substitute :param placeholders in a route path with values from input.
+* Returns the resolved URL path and the input with used params removed.
+*/
+function substituteParams(routePath, input) {
+	if (input == null || typeof input !== "object" || Array.isArray(input)) return {
+		url: routePath,
+		remainingInput: input
+	};
+	const obj = input;
+	const used = /* @__PURE__ */ new Set();
+	const url = routePath.replace(/:([a-zA-Z_]\w*)/g, (_match, name) => {
+		const val = obj[name];
+		if (val !== void 0) {
+			used.add(name);
+			return encodeURIComponent(String(val));
+		}
+		return `:${name}`;
+	});
+	if (used.size === 0) return {
+		url,
+		remainingInput: input
+	};
+	const remaining = {};
+	for (const key of Object.keys(obj)) if (!used.has(key)) remaining[key] = obj[key];
+	return {
+		url,
+		remainingInput: Object.keys(remaining).length > 0 ? remaining : void 0
+	};
+}
+//#endregion
+export { assignPaths, extractRoutes, isProcedureDef, resolveRoute, routerCache, substituteParams };

package/dist/core/schema.d.mts

@@ -0,0 +1,20 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/core/schema.d.ts
+type Schema<TInput = unknown, TOutput = unknown> = StandardSchemaV1<TInput, TOutput>;
+type AnySchema = Schema<any, any>;
+type InferSchemaInput<T extends AnySchema> = T extends Schema<infer I, unknown> ? I : never;
+type InferSchemaOutput<T extends AnySchema> = T extends Schema<unknown, infer O> ? O : never;
+type SchemaIssue = StandardSchemaV1.Issue;
+declare class ValidationError extends Error {
+  readonly issues: readonly SchemaIssue[];
+  constructor(options: {
+    message?: string;
+    issues: readonly SchemaIssue[];
+  });
+}
+/** Sync fast-path: Zod 4 validate() returns sync result — avoid Promise allocation */
+declare function validateSchema(schema: AnySchema, value: unknown): unknown;
+declare function type<TInput, TOutput = TInput>(...args: TInput extends TOutput ? TOutput extends TInput ? [map?: (input: TInput) => TOutput] : [map: (input: TInput) => TOutput] : [map: (input: TInput) => TOutput]): Schema<TInput, TOutput>;
+//#endregion
+export { AnySchema, InferSchemaInput, InferSchemaOutput, Schema, ValidationError, type, validateSchema };

package/dist/core/schema.mjs

@@ -0,0 +1,33 @@
+//#region src/core/schema.ts
+var ValidationError = class extends Error {
+	issues;
+	constructor(options) {
+		super(options.message ?? "Validation failed");
+		this.name = "ValidationError";
+		this.issues = options.issues;
+	}
+};
+/** Sync fast-path: Zod 4 validate() returns sync result — avoid Promise allocation */
+function validateSchema(schema, value) {
+	const result = schema["~standard"].validate(value);
+	if (typeof result?.then !== "function") {
+		if ("issues" in result && result.issues) throw new ValidationError({ issues: result.issues });
+		return result.value;
+	}
+	return result.then((r) => {
+		if ("issues" in r && r.issues) throw new ValidationError({ issues: r.issues });
+		return r.value;
+	});
+}
+function type(...args) {
+	const mapFn = args[0];
+	return { "~standard": {
+		version: 1,
+		vendor: "silgi",
+		validate(value) {
+			return { value: mapFn ? mapFn(value) : value };
+		}
+	} };
+}
+//#endregion
+export { ValidationError, type, validateSchema };

package/dist/core/serve.d.mts

@@ -0,0 +1,51 @@
+import { AnalyticsOptions } from "../plugins/analytics.mjs";
+import { ScalarOptions } from "../scalar.mjs";
+import { WSAdapterOptions } from "../ws.mjs";
+import { Hookable } from "hookable";
+
+//#region src/core/serve.d.ts
+interface SilgiServer {
+  /** Server URL (e.g. "http://127.0.0.1:3000") */
+  readonly url: string;
+  /** Configured port */
+  readonly port: number;
+  /** Configured hostname */
+  readonly hostname: string;
+  /**
+   * Gracefully shut down the server.
+   *
+   * By default waits for in-flight requests to complete.
+   * Pass `true` to forcefully terminate all active connections immediately.
+   */
+  close(forceCloseConnections?: boolean): Promise<void>;
+}
+interface ServeOptions {
+  port?: number;
+  hostname?: string;
+  /** Enable Scalar API Reference UI at /reference and /openapi.json */
+  scalar?: boolean | ScalarOptions;
+  /** Enable analytics dashboard at /analytics */
+  analytics?: boolean | AnalyticsOptions;
+  /** Enable WebSocket RPC (requires crossws) */
+  ws?: boolean | WSAdapterOptions;
+  /** Enable HTTP/2 (requires cert + key for TLS) */
+  http2?: {
+    cert: string;
+    key: string;
+  };
+  /**
+   * Graceful shutdown on SIGINT/SIGTERM signals.
+   *
+   * - `true` (default): enables graceful shutdown with srvx defaults
+   * - `false`: disables automatic signal handling
+   * - `object`: fine-tune timeouts
+   *
+   * @default true
+   */
+  gracefulShutdown?: boolean | {
+    /** Max time (ms) to wait for in-flight requests before force-closing */timeout?: number; /** Max time (ms) after graceful period before process.exit */
+    forceTimeout?: number;
+  };
+}
+//#endregion
+export { ServeOptions, SilgiServer };