silgi 0.43.28 → 0.50.0

package/dist/codegen/parse.d.mts

@@ -0,0 +1,124 @@
+//#region src/codegen/parse.d.ts
+/**
+ * OpenAPI 3.x spec parser.
+ *
+ * Walks an OpenAPI document and extracts operations with their
+ * parameters, request body, responses, and error definitions.
+ */
+interface OpenAPISpec {
+  openapi: string;
+  info: {
+    title: string;
+    version: string;
+    description?: string;
+  };
+  paths?: Record<string, PathItem>;
+  components?: {
+    schemas?: Record<string, JsonSchema>;
+    securitySchemes?: Record<string, unknown>;
+  };
+  tags?: {
+    name: string;
+    description?: string;
+  }[];
+  servers?: {
+    url: string;
+    description?: string;
+  }[];
+}
+interface PathItem {
+  get?: OperationObject;
+  post?: OperationObject;
+  put?: OperationObject;
+  patch?: OperationObject;
+  delete?: OperationObject;
+  head?: OperationObject;
+  options?: OperationObject;
+  trace?: OperationObject;
+  parameters?: ParameterObject[];
+}
+interface OperationObject {
+  operationId?: string;
+  summary?: string;
+  description?: string;
+  tags?: string[];
+  deprecated?: boolean;
+  parameters?: ParameterObject[];
+  requestBody?: RequestBodyObject;
+  responses?: Record<string, ResponseObject>;
+  security?: Record<string, string[]>[];
+}
+interface ParameterObject {
+  name: string;
+  in: 'path' | 'query' | 'header' | 'cookie';
+  required?: boolean;
+  schema?: JsonSchema;
+  description?: string;
+  deprecated?: boolean;
+  $ref?: string;
+}
+interface RequestBodyObject {
+  required?: boolean;
+  content?: Record<string, {
+    schema?: JsonSchema;
+  }>;
+  description?: string;
+  $ref?: string;
+}
+interface ResponseObject {
+  description?: string;
+  content?: Record<string, {
+    schema?: JsonSchema;
+  }>;
+  $ref?: string;
+}
+interface JsonSchema {
+  [key: string]: unknown;
+}
+interface ParsedOperation {
+  /** e.g. "getUser" */
+  operationId: string;
+  /** HTTP method uppercase */
+  method: string;
+  /** OpenAPI path, e.g. "/users/{id}" */
+  path: string;
+  /** Silgi path, e.g. "/users/:id" */
+  silgiPath: string;
+  summary?: string;
+  description?: string;
+  tags: string[];
+  deprecated: boolean;
+  /** Path parameters */
+  pathParams: ParsedParam[];
+  /** Query parameters */
+  queryParams: ParsedParam[];
+  /** Request body JSON Schema (if any) */
+  body: JsonSchema | null;
+  bodyRequired: boolean;
+  /** Success response schema */
+  successSchema: JsonSchema | null;
+  successStatus: number;
+  /** Error responses: status code → schema */
+  errors: Map<number, {
+    description: string;
+    schema: JsonSchema | null;
+  }>;
+  /** Security requirement (false = public) */
+  security: string[] | false | null;
+}
+interface ParsedParam {
+  name: string;
+  required: boolean;
+  schema: JsonSchema;
+  description?: string;
+}
+declare function parseOpenAPI(spec: OpenAPISpec): {
+  operations: ParsedOperation[];
+  components: Record<string, JsonSchema>;
+  tags: {
+    name: string;
+    description?: string;
+  }[];
+};
+//#endregion
+export { OpenAPISpec, ParsedOperation, parseOpenAPI };

package/dist/codegen/parse.mjs

@@ -0,0 +1,135 @@
+//#region src/codegen/parse.ts
+const HTTP_METHODS = [
+	"get",
+	"post",
+	"put",
+	"patch",
+	"delete",
+	"head",
+	"options",
+	"trace"
+];
+function parseOpenAPI(spec) {
+	const operations = [];
+	const components = spec.components?.schemas ?? {};
+	const tags = spec.tags ?? [];
+	if (!spec.paths) return {
+		operations,
+		components,
+		tags
+	};
+	for (const [path, pathItem] of Object.entries(spec.paths)) {
+		const sharedParams = resolveParams(pathItem.parameters ?? [], spec);
+		for (const method of HTTP_METHODS) {
+			const op = pathItem[method];
+			if (!op) continue;
+			const allParams = mergeParams(sharedParams, resolveParams(op.parameters ?? [], spec));
+			const pathParams = allParams.filter((p) => p.in === "path");
+			const queryParams = allParams.filter((p) => p.in === "query");
+			const bodyObj = op.requestBody ? resolveRef(op.requestBody, spec) : null;
+			const bodySchema = bodyObj ? extractBodySchema(bodyObj) : null;
+			const { successSchema, successStatus, errors } = parseResponses(op.responses ?? {}, spec);
+			let security = null;
+			if (op.security) if (op.security.length === 0) security = false;
+			else security = op.security.flatMap((s) => Object.keys(s));
+			operations.push({
+				operationId: op.operationId ?? generateOperationId(method, path),
+				method: method.toUpperCase(),
+				path,
+				silgiPath: toSilgiPath(path),
+				summary: op.summary,
+				description: op.description,
+				tags: op.tags ?? [],
+				deprecated: op.deprecated ?? false,
+				pathParams: pathParams.map((p) => ({
+					name: p.name,
+					required: p.required ?? true,
+					schema: p.schema ?? { type: "string" },
+					description: p.description
+				})),
+				queryParams: queryParams.map((p) => ({
+					name: p.name,
+					required: p.required ?? false,
+					schema: p.schema ?? { type: "string" },
+					description: p.description
+				})),
+				body: bodySchema,
+				bodyRequired: bodyObj?.required ?? false,
+				successSchema,
+				successStatus,
+				errors,
+				security
+			});
+		}
+	}
+	return {
+		operations,
+		components,
+		tags
+	};
+}
+/**
+* Convert OpenAPI path to Silgi path.
+* `/users/{id}/posts/{postId}` → `/users/:id/posts/:postId`
+*/
+function toSilgiPath(path) {
+	return path.replace(/\{([^}]+)\}/g, ":$1");
+}
+/**
+* Generate a fallback operationId from method + path.
+* `GET /users/{id}` → `getUsers_id`
+*/
+function generateOperationId(method, path) {
+	const camel = path.replace(/\{([^}]+)\}/g, "$1").split("/").filter(Boolean).map((s, i) => i === 0 ? s : s[0].toUpperCase() + s.slice(1)).join("");
+	return method + camel[0].toUpperCase() + camel.slice(1);
+}
+function resolveRef(obj, spec) {
+	if (!obj || typeof obj !== "object" || !("$ref" in obj) || !obj.$ref) return obj;
+	const parts = obj.$ref.replace("#/", "").split("/");
+	let current = spec;
+	for (const part of parts) current = current?.[part];
+	return current ?? obj;
+}
+function resolveParams(params, spec) {
+	return params.map((p) => resolveRef(p, spec));
+}
+function mergeParams(shared, op) {
+	const map = /* @__PURE__ */ new Map();
+	for (const p of shared) map.set(`${p.in}:${p.name}`, p);
+	for (const p of op) map.set(`${p.in}:${p.name}`, p);
+	return [...map.values()];
+}
+function extractBodySchema(body) {
+	if (!body.content) return null;
+	return (body.content["application/json"] ?? body.content["*/*"])?.schema ?? null;
+}
+function parseResponses(responses, spec) {
+	let successSchema = null;
+	let successStatus = 200;
+	const errors = /* @__PURE__ */ new Map();
+	for (const [statusCode, rawResp] of Object.entries(responses)) {
+		const resp = resolveRef(rawResp, spec);
+		const status = statusCode === "default" ? 500 : Number.parseInt(statusCode, 10);
+		const schema = extractResponseSchema(resp);
+		if (status >= 200 && status < 300) {
+			if (!successSchema) {
+				successSchema = schema;
+				successStatus = status;
+			}
+		} else if (status >= 400) errors.set(status, {
+			description: resp.description ?? "",
+			schema
+		});
+	}
+	return {
+		successSchema,
+		successStatus,
+		errors
+	};
+}
+function extractResponseSchema(resp) {
+	if (!resp.content) return null;
+	return (resp.content["application/json"] ?? resp.content["*/*"])?.schema ?? null;
+}
+//#endregion
+export { parseOpenAPI };

package/dist/codegen/preserve.d.mts

@@ -0,0 +1,21 @@
+//#region src/codegen/preserve.d.ts
+/**
+ * Smart route preservation — uses oxc-parser to extract the $resolve() body
+ * from an existing route file so it survives regeneration.
+ *
+ * The strategy: parse the existing file's AST, find the .$resolve(fn) call,
+ * extract the fn source code by span, then splice it into the newly generated file.
+ */
+/**
+ * Extract the $resolve() argument source code from a route file.
+ * Returns the raw source string of the resolve function, or null if not found
+ * or if the resolve body is a stub (contains "Not implemented").
+ */
+declare function extractResolveBody(source: string): string | null;
+/**
+ * Splice a preserved resolve body into a newly generated route file.
+ * Replaces the generated stub $resolve(...) argument with the preserved one.
+ */
+declare function spliceResolveBody(generatedSource: string, preservedBody: string): string;
+//#endregion
+export { extractResolveBody, spliceResolveBody };

package/dist/codegen/preserve.mjs

@@ -0,0 +1,62 @@
+import { parseSync } from "oxc-parser";
+//#region src/codegen/preserve.ts
+/**
+* Smart route preservation — uses oxc-parser to extract the $resolve() body
+* from an existing route file so it survives regeneration.
+*
+* The strategy: parse the existing file's AST, find the .$resolve(fn) call,
+* extract the fn source code by span, then splice it into the newly generated file.
+*/
+/**
+* Extract the $resolve() argument source code from a route file.
+* Returns the raw source string of the resolve function, or null if not found
+* or if the resolve body is a stub (contains "Not implemented").
+*/
+function extractResolveBody(source) {
+	try {
+		const { program } = parseSync("route.ts", source);
+		const exportDecl = program.body.find((n) => n.type === "ExportNamedDeclaration" && n.declaration?.type === "VariableDeclaration");
+		if (!exportDecl) return null;
+		const init = exportDecl.declaration.declarations[0]?.init;
+		if (!init) return null;
+		const resolveCall = findResolveCall(init);
+		if (!resolveCall || !resolveCall.arguments[0]) return null;
+		const arg = resolveCall.arguments[0];
+		const body = source.slice(arg.start, arg.end);
+		if (body.includes("Not implemented")) return null;
+		return body;
+	} catch {
+		return null;
+	}
+}
+/**
+* Splice a preserved resolve body into a newly generated route file.
+* Replaces the generated stub $resolve(...) argument with the preserved one.
+*/
+function spliceResolveBody(generatedSource, preservedBody) {
+	try {
+		const { program } = parseSync("route.ts", generatedSource);
+		const exportDecl = program.body.find((n) => n.type === "ExportNamedDeclaration" && n.declaration?.type === "VariableDeclaration");
+		if (!exportDecl) return generatedSource;
+		const init = exportDecl.declaration.declarations[0]?.init;
+		if (!init) return generatedSource;
+		const resolveCall = findResolveCall(init);
+		if (!resolveCall || !resolveCall.arguments[0]) return generatedSource;
+		const arg = resolveCall.arguments[0];
+		return generatedSource.slice(0, arg.start) + preservedBody + generatedSource.slice(arg.end);
+	} catch {
+		return generatedSource;
+	}
+}
+/** Walk a chained CallExpression to find .$resolve(...) */
+function findResolveCall(node) {
+	if (!node) return null;
+	if (node.type === "CallExpression") {
+		if (node.callee?.type === "MemberExpression" && node.callee.property?.name === "$resolve") return node;
+		return findResolveCall(node.callee?.object);
+	}
+	if (node.type === "MemberExpression") return findResolveCall(node.object);
+	return null;
+}
+//#endregion
+export { extractResolveBody, spliceResolveBody };

package/dist/codegen/schema-to-code.d.mts

@@ -0,0 +1,57 @@
+import { SchemaEmitter, SchemaTarget } from "./emitters.mjs";
+
+//#region src/codegen/schema-to-code.d.ts
+interface JsonSchema {
+  type?: string | string[];
+  properties?: Record<string, JsonSchema>;
+  required?: string[];
+  items?: JsonSchema;
+  additionalProperties?: boolean | JsonSchema;
+  allOf?: JsonSchema[];
+  anyOf?: JsonSchema[];
+  oneOf?: JsonSchema[];
+  not?: JsonSchema;
+  enum?: unknown[];
+  const?: unknown;
+  $ref?: string;
+  format?: string;
+  pattern?: string;
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: number | boolean;
+  exclusiveMaximum?: number | boolean;
+  minLength?: number;
+  maxLength?: number;
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+  default?: unknown;
+  nullable?: boolean;
+  description?: string;
+  deprecated?: boolean;
+  title?: string;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  discriminator?: {
+    propertyName: string;
+    mapping?: Record<string, string>;
+  };
+  [key: string]: unknown;
+}
+interface SchemaContext {
+  /** Collected component schema names that need to be emitted */
+  refs: Set<string>;
+  /** All component schemas from the spec */
+  components: Record<string, JsonSchema>;
+  /** Already-emitted schema names (prevents infinite recursion) */
+  emitted: Set<string>;
+  /** Active emitter for the target library */
+  emitter: SchemaEmitter;
+}
+declare function createSchemaContext(target: SchemaTarget, components?: Record<string, JsonSchema>): SchemaContext;
+/**
+ * Convert a JSON Schema to a validation library code string.
+ */
+declare function jsonSchemaToCode(schema: JsonSchema, ctx: SchemaContext): string;
+//#endregion
+export { SchemaContext, createSchemaContext, jsonSchemaToCode };

package/dist/codegen/schema-to-code.mjs

@@ -0,0 +1,167 @@
+import { getEmitter } from "./emitters.mjs";
+//#region src/codegen/schema-to-code.ts
+/**
+* JSON Schema → validation library code converter.
+*
+* Generic converter that delegates to a SchemaEmitter for library-specific output.
+* Supports Zod, Valibot, and ArkType via the emitter pattern.
+*/
+function createSchemaContext(target, components = {}) {
+	return {
+		refs: /* @__PURE__ */ new Set(),
+		components,
+		emitted: /* @__PURE__ */ new Set(),
+		emitter: getEmitter(target)
+	};
+}
+/**
+* Convert a JSON Schema to a validation library code string.
+*/
+function jsonSchemaToCode(schema, ctx) {
+	const e = ctx.emitter;
+	if (!schema || typeof schema !== "object") return e.unknown();
+	if (schema.$ref) {
+		const refName = resolveRefName(schema.$ref);
+		ctx.refs.add(refName);
+		return refName + "Schema";
+	}
+	if (schema.const !== void 0) return e.literal(schema.const);
+	if (schema.enum) {
+		if (schema.enum.length === 1) return e.literal(schema.enum[0]);
+		return e.enum(schema.enum);
+	}
+	if (schema.allOf?.length) {
+		if (schema.allOf.length === 1) return jsonSchemaToCode(schema.allOf[0], ctx);
+		const parts = schema.allOf.map((s) => jsonSchemaToCode(s, ctx));
+		return e.intersection(parts);
+	}
+	if (schema.oneOf?.length || schema.anyOf?.length) {
+		const variants = schema.oneOf ?? schema.anyOf;
+		if (variants.length === 1) return jsonSchemaToCode(variants[0], ctx);
+		const members = variants.map((v) => jsonSchemaToCode(v, ctx));
+		if (schema.discriminator?.propertyName) return e.discriminatedUnion(schema.discriminator.propertyName, members);
+		return e.union(members);
+	}
+	const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+	const isNullable = schema.nullable || types.includes("null");
+	const nonNullTypes = types.filter((t) => t !== "null");
+	if (nonNullTypes.length > 1) {
+		const members = nonNullTypes.map((t) => jsonSchemaToCode({
+			...schema,
+			type: t
+		}, ctx));
+		let result = e.union(members);
+		if (isNullable) result = e.nullable(result);
+		return result;
+	}
+	const type = nonNullTypes[0] ?? (types.length === 0 ? void 0 : nonNullTypes[0]);
+	let result;
+	switch (type) {
+		case "string":
+			result = buildString(schema, e);
+			break;
+		case "number":
+		case "integer":
+			result = buildNumber(schema, type, e);
+			break;
+		case "boolean":
+			result = e.boolean();
+			break;
+		case "null": return e.null();
+		case "object":
+			result = buildObject(schema, ctx);
+			break;
+		case "array":
+			result = buildArray(schema, ctx);
+			break;
+		default: if (schema.properties) result = buildObject(schema, ctx);
+		else result = e.unknown();
+	}
+	if (isNullable && type !== "null") result = e.nullable(result);
+	if (schema.default !== void 0) result = e.default(result, schema.default);
+	if (schema.description) result = e.describe(result, schema.description);
+	return result;
+}
+function buildString(schema, e) {
+	if (schema.format === "email") return applyStringConstraints(e.email(), schema, e);
+	if (schema.format === "uri" || schema.format === "url") return applyStringConstraints(e.url(), schema, e);
+	if (schema.format === "uuid") return applyStringConstraints(e.uuid(), schema, e);
+	if (schema.format === "date-time") return applyStringConstraints(e.datetime(), schema, e);
+	if (schema.format === "date") return applyStringConstraints(e.date(), schema, e);
+	if (schema.format === "ipv4") return applyStringConstraints(e.ipv4(), schema, e);
+	if (schema.format === "ipv6") return applyStringConstraints(e.ipv6(), schema, e);
+	return applyStringConstraints(e.string(), schema, e);
+}
+function applyStringConstraints(base, schema, e) {
+	let s = base;
+	if (schema.minLength != null) s = e.min(s, schema.minLength);
+	if (schema.maxLength != null) s = e.max(s, schema.maxLength);
+	if (schema.pattern) s = e.regex(s, schema.pattern);
+	return s;
+}
+function buildNumber(schema, type, e) {
+	let s = type === "integer" ? e.int() : e.number();
+	if (schema.minimum != null) s = e.min(s, schema.minimum);
+	if (schema.maximum != null) s = e.max(s, schema.maximum);
+	if (typeof schema.exclusiveMinimum === "number") s = e.gt(s, schema.exclusiveMinimum);
+	if (typeof schema.exclusiveMaximum === "number") s = e.lt(s, schema.exclusiveMaximum);
+	return s;
+}
+function buildObject(schema, ctx) {
+	const e = ctx.emitter;
+	if (!schema.properties && schema.additionalProperties) {
+		const valueSchema = typeof schema.additionalProperties === "object" ? jsonSchemaToCode(schema.additionalProperties, ctx) : e.unknown();
+		return e.record(e.string(), valueSchema);
+	}
+	if (!schema.properties) {
+		if (schema.additionalProperties === false) return e.object([]);
+		return e.record(e.string(), e.unknown());
+	}
+	const required = new Set(schema.required ?? []);
+	const entries = Object.entries(schema.properties).map(([key, prop]) => ({
+		key,
+		value: jsonSchemaToCode(prop, ctx),
+		required: required.has(key)
+	}));
+	return e.object(entries);
+}
+function buildArray(schema, ctx) {
+	const e = ctx.emitter;
+	const items = schema.items ? jsonSchemaToCode(schema.items, ctx) : e.unknown();
+	let s = e.array(items);
+	if (schema.minItems != null) s = e.min(s, schema.minItems);
+	if (schema.maxItems != null) s = e.max(s, schema.maxItems);
+	return s;
+}
+function resolveRefName(ref) {
+	const parts = ref.split("/");
+	return parts[parts.length - 1];
+}
+/**
+* Generate all referenced component schemas as declarations.
+* Recursively resolves nested refs.
+*/
+function emitComponentSchemas(ctx) {
+	const lines = [];
+	let toProcess = [...ctx.refs];
+	while (toProcess.length > 0) {
+		const next = [];
+		for (const name of toProcess) {
+			if (ctx.emitted.has(name)) continue;
+			ctx.emitted.add(name);
+			const schema = ctx.components[name];
+			if (!schema) {
+				lines.push(`// WARNING: Missing component schema "${name}"`);
+				lines.push(`export const ${name}Schema = ${ctx.emitter.unknown()}`);
+				continue;
+			}
+			const code = jsonSchemaToCode(schema, ctx);
+			lines.push(`export const ${name}Schema = ${code}`);
+			for (const ref of ctx.refs) if (!ctx.emitted.has(ref)) next.push(ref);
+		}
+		toProcess = next;
+	}
+	return lines.join("\n\n");
+}
+//#endregion
+export { createSchemaContext, emitComponentSchemas, jsonSchemaToCode };

package/dist/compile.d.mts

@@ -0,0 +1,46 @@
+import { ProcedureDef } from "./types.mjs";
+
+//#region src/compile.d.ts
+/**
+ * Compiled pipeline — called per request.
+ * May return sync value OR Promise — caller uses instanceof check.
+ */
+type CompiledHandler = (ctx: Record<string, unknown>, rawInput: unknown, signal: AbortSignal) => unknown | Promise<unknown>;
+/**
+ * Compile a procedure into the fastest possible handler.
+ *
+ * Optimizations applied:
+ * - Guard count specialization (unrolled for 0-4)
+ * - Separate fast path for no-wrap case (zero closures per request)
+ * - Pre-computed fail function (singleton per procedure)
+ * - Sync fast path when all guards are sync
+ */
+declare function compileProcedure(procedure: ProcedureDef): CompiledHandler;
+interface CompiledRoute {
+  handler: CompiledHandler;
+  /** Pre-computed Cache-Control header value, or undefined if no caching */
+  cacheControl?: string;
+  /** Procedure is accessible over WebSocket */
+  ws?: boolean;
+  /** Skip body parsing — procedure receives raw request (e.g. catch-all proxy) */
+  passthrough?: boolean;
+  /** HTTP method this route is registered for (uppercase) */
+  method: string;
+}
+/** Match result from the router */
+interface MatchedRoute<T = unknown> {
+  data: T;
+  params?: Record<string, string>;
+}
+/** Compiled router function — returns matched route + params */
+type CompiledRouterFn = (method: string, path: string) => MatchedRoute<CompiledRoute> | undefined;
+/**
+ * Compile a router tree into a rou3 radix router.
+ *
+ * Powered by rou3 (unjs) — battle-tested, fast, minimal.
+ */
+declare function compileRouter(def: Record<string, unknown>): CompiledRouterFn;
+/** Acquire a context object from the pool (or create one). */
+declare function createContext(): Record<string, unknown>;
+//#endregion
+export { compileProcedure, compileRouter, createContext };