silgi 0.0.14 → 0.1.0-beta.2

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

@@ -0,0 +1,75 @@
+import { AnySchema } from "../../core/schema.mjs";
+
+//#region src/integrations/zod/converter.d.ts
+type JSONSchema = {
+  type?: string | string[];
+  format?: string;
+  properties?: Record<string, JSONSchema>;
+  required?: string[];
+  items?: JSONSchema;
+  prefixItems?: JSONSchema[];
+  anyOf?: JSONSchema[];
+  oneOf?: JSONSchema[];
+  allOf?: JSONSchema[];
+  not?: JSONSchema;
+  enum?: unknown[];
+  const?: unknown;
+  $ref?: string;
+  description?: string;
+  title?: string;
+  default?: unknown;
+  examples?: unknown[];
+  deprecated?: boolean;
+  readOnly?: boolean;
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: number;
+  exclusiveMaximum?: number;
+  multipleOf?: number;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+  minProperties?: number;
+  maxProperties?: number;
+  additionalProperties?: boolean | JSONSchema;
+  'x-native-type'?: string;
+  [key: string]: unknown;
+};
+interface ConvertOptions {
+  /** 'input' uses pre-transform types, 'output' uses post-transform */
+  strategy: 'input' | 'output';
+  /** Max recursion depth before falling back to {} */
+  maxDepth?: number;
+}
+/**
+ * Convert a Standard Schema to JSON Schema.
+ * Returns [required, jsonSchema] tuple.
+ */
+interface SchemaConverter {
+  condition(schema: AnySchema): boolean;
+  convert(schema: AnySchema, options: ConvertOptions): [required: boolean, schema: JSONSchema];
+}
+/**
+ * Composite converter — tries each converter in order.
+ */
+declare class CompositeSchemaConverter {
+  #private;
+  constructor(converters: SchemaConverter[]);
+  convert(schema: AnySchema | undefined, options: ConvertOptions): [boolean, JSONSchema];
+}
+/**
+ * Zod v4 → JSON Schema converter.
+ */
+declare class ZodSchemaConverter implements SchemaConverter {
+  #private;
+  constructor(options?: {
+    maxDepth?: number;
+  });
+  condition(schema: AnySchema): boolean;
+  convert(schema: AnySchema, options: ConvertOptions): [boolean, JSONSchema];
+}
+//#endregion
+export { CompositeSchemaConverter, ConvertOptions, JSONSchema, SchemaConverter, ZodSchemaConverter };

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,24 @@
+import { ProcedureDef, RouterDef } from "./types.mjs";
+
+//#region src/lazy.d.ts
+interface LazyRouter {
+  readonly __lazy: true;
+  readonly load: () => Promise<{
+    default: RouterDef | ProcedureDef;
+  }>;
+  _resolved?: RouterDef | ProcedureDef;
+  _loading?: Promise<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,27 @@
+//#region src/lazy.ts
+/**
+* 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) {
+	if (value._resolved) return value._resolved;
+	if (value._loading) return value._loading;
+	value._loading = value.load().then((mod) => {
+		value._resolved = mod.default;
+		return mod.default;
+	});
+	return value._loading;
+}
+//#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,24 @@
+//#region src/map-input.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().
+*/
+function mapInput(mapper) {
+	return {
+		kind: "wrap",
+		fn: async (ctx, next) => {
+			const rawInput = ctx.__rawInput;
+			ctx.__rawInput = await mapper(rawInput);
+			return next();
+		}
+	};
+}
+//#endregion
+export { mapInput };