silgi 0.43.28 → 0.50.0

package/dist/integrations/zod/converter.mjs

@@ -0,0 +1,345 @@
+//#region src/integrations/zod/converter.ts
+/**
+* Composite converter — tries each converter in order.
+*/
+var CompositeSchemaConverter = class {
+	#converters;
+	constructor(converters) {
+		this.#converters = converters;
+	}
+	convert(schema, options) {
+		if (!schema) return [false, {}];
+		for (const converter of this.#converters) if (converter.condition(schema)) return converter.convert(schema, options);
+		return [false, {}];
+	}
+};
+/**
+* Zod v4 → JSON Schema converter.
+*/
+var ZodSchemaConverter = class {
+	#maxDepth;
+	constructor(options) {
+		this.#maxDepth = options?.maxDepth ?? 10;
+	}
+	condition(schema) {
+		return schema["~standard"]?.vendor === "zod";
+	}
+	convert(schema, options) {
+		return this.#convert(schema, options, 0);
+	}
+	#convert(schema, options, depth) {
+		if (depth > this.#maxDepth) return [true, {}];
+		const zod = schema._zod;
+		const def = zod?.def ?? schema._def;
+		const bag = zod?.bag;
+		if (!def) return [true, {}];
+		switch (def.type ?? def.typeName) {
+			case "string":
+			case "ZodString": return [true, this.#convertString(def, bag)];
+			case "number":
+			case "ZodNumber": {
+				const result = this.#convertNumber(def, bag);
+				if (bag?.format === "safeint" || this.#hasIntCheck(def)) result.type = "integer";
+				return [true, result];
+			}
+			case "int": return [true, {
+				...this.#convertNumber(def, bag),
+				type: "integer"
+			}];
+			case "boolean":
+			case "ZodBoolean": return [true, { type: "boolean" }];
+			case "bigint":
+			case "ZodBigInt": return [true, {
+				type: "string",
+				pattern: "^-?[0-9]+$",
+				"x-native-type": "bigint"
+			}];
+			case "date":
+			case "ZodDate": return [true, {
+				type: "string",
+				format: "date-time",
+				"x-native-type": "date"
+			}];
+			case "symbol":
+			case "ZodSymbol": return [true, {}];
+			case "undefined":
+			case "ZodUndefined": return [false, { not: {} }];
+			case "null":
+			case "ZodNull": return [true, { type: "null" }];
+			case "void":
+			case "ZodVoid": return [false, { type: "null" }];
+			case "any":
+			case "ZodAny": return [true, {}];
+			case "unknown":
+			case "ZodUnknown": return [true, {}];
+			case "never":
+			case "ZodNever": return [true, { not: {} }];
+			case "nan":
+			case "ZodNaN": return options.strategy === "input" ? [true, { not: {} }] : [true, { type: "null" }];
+			case "literal":
+			case "ZodLiteral": {
+				const values = def.values ?? [def.value];
+				return [true, values.length === 1 ? { const: values[0] } : { enum: values }];
+			}
+			case "enum":
+			case "ZodEnum": {
+				const entries = def.entries;
+				return [true, { enum: Array.isArray(def.values) ? def.values : entries ? Object.values(entries) : [] }];
+			}
+			case "nativeEnum":
+			case "ZodNativeEnum": return [true, { enum: Object.values(def.values ?? def.entries) }];
+			case "array":
+			case "ZodArray": {
+				const inner = def.element ?? def.type;
+				if (!inner) return [true, { type: "array" }];
+				const [, itemSchema] = this.#convert(inner, options, depth + 1);
+				const result = {
+					type: "array",
+					items: itemSchema
+				};
+				if (bag?.minimum != null) result.minItems = bag.minimum;
+				if (bag?.maximum != null) result.maxItems = bag.maximum;
+				if (def.minLength != null) result.minItems ??= def.minLength.value ?? def.minLength;
+				if (def.maxLength != null) result.maxItems ??= def.maxLength.value ?? def.maxLength;
+				return [true, result];
+			}
+			case "object":
+			case "ZodObject": {
+				const shape = def.shape ?? (typeof schema.shape === "function" ? schema.shape() : schema.shape);
+				if (!shape) return [true, { type: "object" }];
+				const properties = {};
+				const required = [];
+				for (const [key, value] of Object.entries(shape)) {
+					const [isRequired, propSchema] = this.#convert(value, options, depth + 1);
+					properties[key] = propSchema;
+					if (isRequired) required.push(key);
+				}
+				const result = {
+					type: "object",
+					properties
+				};
+				if (required.length > 0) result.required = required;
+				if (def.catchall) {
+					const [, catchSchema] = this.#convert(def.catchall, options, depth + 1);
+					result.additionalProperties = catchSchema;
+				} else if (def.unknownKeys === "strict") result.additionalProperties = false;
+				return [true, result];
+			}
+			case "union":
+			case "ZodUnion":
+			case "ZodDiscriminatedUnion": {
+				const unionOptions = def.options ?? def.members;
+				if (!Array.isArray(unionOptions)) return [true, {}];
+				return [true, { anyOf: unionOptions.map((o) => this.#convert(o, options, depth + 1)).map(([, s]) => s) }];
+			}
+			case "intersection":
+			case "ZodIntersection": {
+				const [, left] = this.#convert(def.left, options, depth + 1);
+				const [, right] = this.#convert(def.right, options, depth + 1);
+				return [true, { allOf: [left, right] }];
+			}
+			case "tuple":
+			case "ZodTuple": {
+				const result = {
+					type: "array",
+					prefixItems: (def.items ?? def.types ?? []).map((t) => this.#convert(t, options, depth + 1)[1])
+				};
+				if (def.rest) result.items = this.#convert(def.rest, options, depth + 1)[1];
+				return [true, result];
+			}
+			case "record":
+			case "ZodRecord": {
+				const [, valSchema] = this.#convert(def.valueType ?? def.element, options, depth + 1);
+				return [true, {
+					type: "object",
+					additionalProperties: valSchema
+				}];
+			}
+			case "map":
+			case "ZodMap": {
+				const [, keySchema] = this.#convert(def.keyType, options, depth + 1);
+				const [, valSchema] = this.#convert(def.valueType, options, depth + 1);
+				return [true, {
+					type: "array",
+					items: {
+						type: "array",
+						prefixItems: [keySchema, valSchema]
+					},
+					"x-native-type": "map"
+				}];
+			}
+			case "set":
+			case "ZodSet": {
+				const [, itemSchema] = this.#convert(def.valueType ?? def.element, options, depth + 1);
+				return [true, {
+					type: "array",
+					items: itemSchema,
+					uniqueItems: true,
+					"x-native-type": "set"
+				}];
+			}
+			case "optional":
+			case "ZodOptional": {
+				const inner = def.innerType ?? def.wrapped;
+				const [, innerSchema] = this.#convert(inner, options, depth + 1);
+				return [false, innerSchema];
+			}
+			case "nullable":
+			case "ZodNullable": {
+				const inner = def.innerType ?? def.wrapped;
+				const [req, innerSchema] = this.#convert(inner, options, depth + 1);
+				return [req, { anyOf: [innerSchema, { type: "null" }] }];
+			}
+			case "default":
+			case "ZodDefault": {
+				const inner = def.innerType ?? def.wrapped;
+				const [, innerSchema] = this.#convert(inner, options, depth + 1);
+				const defaultValue = typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
+				return [false, {
+					...innerSchema,
+					default: defaultValue
+				}];
+			}
+			case "readonly":
+			case "ZodReadonly": {
+				const inner = def.innerType ?? def.wrapped;
+				const [req, innerSchema] = this.#convert(inner, options, depth + 1);
+				return [req, {
+					...innerSchema,
+					readOnly: true
+				}];
+			}
+			case "catch":
+			case "ZodCatch": {
+				const inner = def.innerType ?? def.wrapped;
+				return this.#convert(inner, options, depth + 1);
+			}
+			case "brand":
+			case "ZodBranded": {
+				const inner = def.type ?? def.wrapped;
+				return this.#convert(inner, options, depth + 1);
+			}
+			case "lazy":
+			case "ZodLazy": {
+				const getter = def.getter ?? def.get;
+				if (typeof getter === "function") return this.#convert(getter(), options, depth + 1);
+				return [true, {}];
+			}
+			case "promise":
+			case "ZodPromise": {
+				const inner = def.type ?? def.wrapped;
+				return this.#convert(inner, options, depth + 1);
+			}
+			case "transform":
+			case "ZodEffects": {
+				const inner = def.schema ?? def.in ?? def.wrapped;
+				if (!inner) return [true, {}];
+				if (options.strategy === "input") return this.#convert(inner, options, depth + 1);
+				return [true, {}];
+			}
+			case "pipe":
+			case "ZodPipeline":
+				if (options.strategy === "input") return this.#convert(def.in ?? def.from, options, depth + 1);
+				return this.#convert(def.out ?? def.to, options, depth + 1);
+			default: return [true, {}];
+		}
+	}
+	#convertString(def, bag) {
+		const result = { type: "string" };
+		const checks = def.checks ?? [];
+		bag = bag ?? {};
+		if (bag.minimum != null) result.minLength = bag.minimum;
+		if (bag.maximum != null) result.maxLength = bag.maximum;
+		if (bag.patterns) {
+			const patterns = Object.values(bag.patterns);
+			if (patterns.length > 0) result.pattern = patterns[0]?.source ?? String(patterns[0]);
+		}
+		if (bag.format) result.format = this.#normalizeFormat(bag.format);
+		for (const check of checks) switch (check.kind ?? check.type) {
+			case "min":
+				result.minLength = check.value;
+				break;
+			case "max":
+				result.maxLength = check.value;
+				break;
+			case "length":
+				result.minLength = check.value;
+				result.maxLength = check.value;
+				break;
+			case "email":
+				result.format = "email";
+				break;
+			case "url":
+				result.format = "uri";
+				break;
+			case "uuid":
+				result.format = "uuid";
+				break;
+			case "regex":
+				result.pattern = check.regex?.source ?? check.value;
+				break;
+			case "datetime":
+				result.format = "date-time";
+				break;
+			case "date":
+				result.format = "date";
+				break;
+			case "time":
+				result.format = "time";
+				break;
+			case "ip":
+				result.format = check.version === "v6" ? "ipv6" : "ipv4";
+				break;
+		}
+		if (def.description) result.description = def.description;
+		return result;
+	}
+	#hasIntCheck(def) {
+		return (def.checks ?? []).some((c) => (c.kind ?? c.type ?? c._zod?.def?.check) === "int" || c.isInt === true || c._zod?.def?.format === "safeint");
+	}
+	#convertNumber(def, bag) {
+		const result = { type: "number" };
+		const checks = def.checks ?? [];
+		bag = bag ?? {};
+		if (bag.minimum != null) result.minimum = bag.minimum;
+		if (bag.maximum != null) result.maximum = bag.maximum;
+		if (bag.multipleOf != null) result.multipleOf = bag.multipleOf;
+		for (const check of checks) switch (check.kind ?? check.type) {
+			case "min":
+				result.minimum = check.value;
+				break;
+			case "max":
+				result.maximum = check.value;
+				break;
+			case "int":
+				result.type = "integer";
+				break;
+			case "multipleOf":
+				result.multipleOf = check.value;
+				break;
+			case "finite": break;
+			case "nonnegative":
+				result.minimum = 0;
+				break;
+			case "nonpositive":
+				result.maximum = 0;
+				break;
+			case "positive":
+				result.exclusiveMinimum = 0;
+				break;
+			case "negative":
+				result.exclusiveMaximum = 0;
+				break;
+		}
+		if (def.description) result.description = def.description;
+		return result;
+	}
+	#normalizeFormat(format) {
+		return {
+			guid: "uuid",
+			url: "uri"
+		}[format] ?? format;
+	}
+};
+//#endregion
+export { CompositeSchemaConverter, ZodSchemaConverter };

package/dist/integrations/zod/index.d.mts

@@ -0,0 +1,2 @@
+import { CompositeSchemaConverter, ConvertOptions, JSONSchema, SchemaConverter, ZodSchemaConverter } from "./converter.mjs";
+export { CompositeSchemaConverter, type ConvertOptions, type JSONSchema, type SchemaConverter, ZodSchemaConverter };

package/dist/integrations/zod/index.mjs

@@ -0,0 +1,2 @@
+import { CompositeSchemaConverter, ZodSchemaConverter } from "./converter.mjs";
+export { CompositeSchemaConverter, ZodSchemaConverter };

package/dist/lazy.d.mts

@@ -0,0 +1,22 @@
+import { ProcedureDef, RouterDef } from "./types.mjs";
+
+//#region src/lazy.d.ts
+interface LazyRouter {
+  readonly __lazy: true;
+  readonly load: () => Promise<{
+    default: RouterDef | ProcedureDef;
+  }>;
+}
+/**
+ * Wrap a dynamic import for lazy loading.
+ * The module must export its router/procedure as `default`.
+ */
+declare function lazy(loader: () => Promise<{
+  default: RouterDef | ProcedureDef;
+}>): LazyRouter;
+/** Check if a value is a lazy router */
+declare function isLazy(value: unknown): value is LazyRouter;
+/** Resolve a lazy router (cached after first load, race-safe) */
+declare function resolveLazy(value: LazyRouter): Promise<RouterDef | ProcedureDef>;
+//#endregion
+export { LazyRouter, isLazy, lazy, resolveLazy };

package/dist/lazy.mjs

@@ -0,0 +1,34 @@
+//#region src/lazy.ts
+const resolved = /* @__PURE__ */ new WeakMap();
+const loading = /* @__PURE__ */ new WeakMap();
+/**
+* Wrap a dynamic import for lazy loading.
+* The module must export its router/procedure as `default`.
+*/
+function lazy(loader) {
+	return {
+		__lazy: true,
+		load: loader
+	};
+}
+/** Check if a value is a lazy router */
+function isLazy(value) {
+	return typeof value === "object" && value !== null && value.__lazy === true;
+}
+/** Resolve a lazy router (cached after first load, race-safe) */
+async function resolveLazy(value) {
+	const cached = resolved.get(value);
+	if (cached) return cached;
+	let pending = loading.get(value);
+	if (!pending) {
+		pending = value.load().then((mod) => {
+			resolved.set(value, mod.default);
+			loading.delete(value);
+			return mod.default;
+		});
+		loading.set(value, pending);
+	}
+	return pending;
+}
+//#endregion
+export { isLazy, lazy, resolveLazy };

package/dist/lifecycle.d.mts

@@ -0,0 +1,36 @@
+import { WrapDef } from "./types.mjs";
+
+//#region src/lifecycle.d.ts
+interface LifecycleHooks<TCtx = Record<string, unknown>> {
+  /** Called before the procedure runs */
+  onStart?: (event: {
+    ctx: TCtx;
+  }) => void | Promise<void>;
+  /** Called after a successful result */
+  onSuccess?: (event: {
+    ctx: TCtx;
+    output: unknown;
+    durationMs: number;
+  }) => void | Promise<void>;
+  /** Called when the procedure throws */
+  onError?: (event: {
+    ctx: TCtx;
+    error: unknown;
+    durationMs: number;
+  }) => void | Promise<void>;
+  /** Called after the procedure completes (success or failure) */
+  onFinish?: (event: {
+    ctx: TCtx;
+    durationMs: number;
+    error?: unknown;
+  }) => void | Promise<void>;
+}
+/**
+ * Create a wrap middleware with declarative lifecycle hooks.
+ *
+ * All hooks are optional. The procedure result is never modified —
+ * hooks are purely for side effects (logging, metrics, error reporting).
+ */
+declare function lifecycleWrap<TCtx = Record<string, unknown>>(hooks: LifecycleHooks<TCtx>): WrapDef<TCtx>;
+//#endregion
+export { LifecycleHooks, lifecycleWrap };

package/dist/lifecycle.mjs

@@ -0,0 +1,46 @@
+//#region src/lifecycle.ts
+/**
+* Create a wrap middleware with declarative lifecycle hooks.
+*
+* All hooks are optional. The procedure result is never modified —
+* hooks are purely for side effects (logging, metrics, error reporting).
+*/
+function lifecycleWrap(hooks) {
+	return {
+		kind: "wrap",
+		fn: async (ctx, next) => {
+			const typedCtx = ctx;
+			if (hooks.onStart) await hooks.onStart({ ctx: typedCtx });
+			const t0 = performance.now();
+			let error;
+			try {
+				const output = await next();
+				const durationMs = performance.now() - t0;
+				if (hooks.onSuccess) await hooks.onSuccess({
+					ctx: typedCtx,
+					output,
+					durationMs
+				});
+				return output;
+			} catch (err) {
+				error = err;
+				const durationMs = performance.now() - t0;
+				if (hooks.onError) await hooks.onError({
+					ctx: typedCtx,
+					error: err,
+					durationMs
+				});
+				throw err;
+			} finally {
+				const durationMs = performance.now() - t0;
+				if (hooks.onFinish) await hooks.onFinish({
+					ctx: typedCtx,
+					durationMs,
+					error
+				});
+			}
+		}
+	};
+}
+//#endregion
+export { lifecycleWrap };

package/dist/map-input.d.mts

@@ -0,0 +1,17 @@
+import { WrapDef } from "./types.mjs";
+
+//#region src/map-input.d.ts
+/**
+ * Create a wrap that transforms the procedure input before execution.
+ *
+ * The mapper function receives the raw input and returns the transformed input.
+ * The mapped input is set on the context as `__mappedInput` and picked up
+ * by the pipeline.
+ *
+ * Note: Since Silgi's pipeline receives input as a separate argument
+ * (not on ctx), mapInput works as a wrap that intercepts and transforms
+ * before calling next().
+ */
+declare function mapInput<TIn = unknown, TOut = unknown>(mapper: (input: TIn) => TOut | Promise<TOut>): WrapDef;
+//#endregion
+export { mapInput };

package/dist/map-input.mjs

@@ -0,0 +1,47 @@
+import { RAW_INPUT } from "./compile.mjs";
+//#region src/map-input.ts
+/**
+* mapInput — transform the input shape before a procedure runs.
+*
+* Useful when the client sends data in one shape but the procedure
+* expects a different shape, or when you want to pre-process input
+* in a reusable way.
+*
+* @example
+* ```ts
+* import { mapInput } from "silgi"
+*
+* // Rename fields
+* const mapUserId = mapInput((input: { userId: string }) => ({
+*   id: input.userId,
+* }))
+*
+* const getUser = k
+*   .$use(mapUserId)
+*   .$resolve(({ input }) => db.users.find(input.id))
+*   // input is { id: string } after mapping
+* ```
+*/
+/**
+* Create a wrap that transforms the procedure input before execution.
+*
+* The mapper function receives the raw input and returns the transformed input.
+* The mapped input is set on the context as `__mappedInput` and picked up
+* by the pipeline.
+*
+* Note: Since Silgi's pipeline receives input as a separate argument
+* (not on ctx), mapInput works as a wrap that intercepts and transforms
+* before calling next().
+*/
+function mapInput(mapper) {
+	return {
+		kind: "wrap",
+		fn: async (ctx, next) => {
+			const rawInput = ctx[RAW_INPUT];
+			ctx[RAW_INPUT] = await mapper(rawInput);
+			return next();
+		}
+	};
+}
+//#endregion
+export { mapInput };

package/dist/plugins/analytics/accumulator.d.mts

@@ -0,0 +1,24 @@
+import { ProcedureCall } from "./types.mjs";
+import { AnalyticsCollector } from "./collector.mjs";
+
+//#region src/plugins/analytics/accumulator.d.ts
+declare class RequestAccumulator {
+  #private;
+  readonly requestId: string;
+  readonly sessionId: string;
+  readonly traceId: string;
+  readonly parentRequestId?: string;
+  /** True if a new session cookie needs to be set. */
+  readonly isNewSession: boolean;
+  t0: number;
+  constructor(request: Request, collector: AnalyticsCollector, traceId?: string, parentRequestId?: string);
+  addProcedure(call: ProcedureCall): void;
+  /** Get Set-Cookie header value (only if new session). */
+  getSessionCookie(): string | null;
+  /** Flush with response headers extracted from the actual Response object. */
+  flushWithResponse(res: Response): void;
+  /** Whether any procedures have been recorded. */
+  get hasProcedures(): boolean;
+}
+//#endregion
+export { RequestAccumulator };

package/dist/plugins/analytics/accumulator.mjs

@@ -0,0 +1,91 @@
+import { parseUrlPath } from "../../core/url.mjs";
+import { generateRequestId } from "./request-id.mjs";
+import { redactHeaderValue, round } from "./utils.mjs";
+import { parse } from "cookie-es";
+//#region src/plugins/analytics/accumulator.ts
+/**
+* RequestAccumulator — HTTP-level request grouping.
+*
+* Collects procedure calls within a single HTTP request.
+* Created at the start of handleRequest, procedures are added as they complete,
+* then flushed to the collector at the end.
+*/
+const SESSION_COOKIE = "_sid";
+const SESSION_MAX_AGE = 365 * 24 * 60 * 60;
+var RequestAccumulator = class {
+	requestId;
+	sessionId;
+	traceId;
+	parentRequestId;
+	/** True if a new session cookie needs to be set. */
+	isNewSession;
+	t0;
+	#request;
+	#procedures = [];
+	#collector;
+	constructor(request, collector, traceId, parentRequestId) {
+		this.requestId = generateRequestId();
+		this.traceId = traceId ?? this.requestId;
+		this.parentRequestId = parentRequestId;
+		this.t0 = performance.now();
+		this.#request = request;
+		this.#collector = collector;
+		const cookieHeader = request.headers.get("cookie");
+		const existing = cookieHeader ? parse(cookieHeader)[SESSION_COOKIE] : void 0;
+		if (existing && existing.length >= 10) {
+			this.sessionId = existing;
+			this.isNewSession = false;
+		} else {
+			this.sessionId = generateRequestId();
+			this.isNewSession = true;
+		}
+	}
+	addProcedure(call) {
+		this.#procedures.push(call);
+	}
+	/** Get Set-Cookie header value (only if new session). */
+	getSessionCookie() {
+		if (!this.isNewSession) return null;
+		return `${SESSION_COOKIE}=${this.sessionId}; Path=/; Max-Age=${SESSION_MAX_AGE}; SameSite=Lax; HttpOnly`;
+	}
+	/** Flush with response headers extracted from the actual Response object. */
+	flushWithResponse(res) {
+		if (this.#procedures.length === 0) return;
+		const durationMs = round(performance.now() - this.t0);
+		const headers = {};
+		this.#request.headers.forEach((v, k) => {
+			headers[k] = redactHeaderValue(k, v);
+		});
+		const responseHeaders = {};
+		res.headers.forEach((v, k) => {
+			responseHeaders[k] = redactHeaderValue(k, v);
+		});
+		let worstStatus = 200;
+		for (const p of this.#procedures) if (p.status > worstStatus) worstStatus = p.status;
+		const path = parseUrlPath(this.#request.url);
+		this.#collector.recordDetailedRequest({
+			requestId: this.requestId,
+			sessionId: this.sessionId,
+			timestamp: Date.now(),
+			durationMs,
+			method: this.#request.method,
+			url: this.#request.url,
+			path,
+			ip: headers["x-forwarded-for"] || headers["x-real-ip"] || "",
+			headers,
+			responseHeaders,
+			userAgent: this.#request.headers.get("user-agent") ?? "",
+			status: worstStatus,
+			procedures: this.#procedures,
+			isBatch: this.#procedures.length > 1,
+			traceId: this.traceId,
+			parentRequestId: this.parentRequestId
+		});
+	}
+	/** Whether any procedures have been recorded. */
+	get hasProcedures() {
+		return this.#procedures.length > 0;
+	}
+};
+//#endregion
+export { RequestAccumulator };