elysia 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/compile/handler/frozen-validator.mjs

@@ -1,17 +1,13 @@
 import { nullObject } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../../type/constants.mjs";
 import { ValidationError } from "../../error.mjs";
-import { Compiled, reconstruct } from "../aot.mjs";
+import { Compiled, EMPTY_EXTERNALS, reconstruct } from "../aot.mjs";
 import { frozenRootOf } from "../../generation.mjs";
 import { isFullyClosedObject } from "../../type/validator/clean-safe.mjs";
 import { StandardValidator } from "../../validator/index.mjs";
 
 //#region src/compile/handler/frozen-validator.ts
 const isBridgeNotInitialized = (error) => error instanceof Error && error.message.startsWith("Typebox module isn't initialized");
-function codecCoercionBridgeFree(f, coerced, raw) {
-	return f.k === 1 && !!f.dm && !f.em && !f.ce && f.a !== 1 && !(f.d === 1 && f.ps !== 1) && innerCodecsAligned(f.ic?.length, coerced) && mirrorUnionsAligned(f.u, raw) && mirrorUnionsAligned(f.dm.u, coerced);
-}
-const innerCodecsAligned = (icLength, coerced) => reconstruct().collectStringCodecNodes(coerced).length === (icLength ?? 0);
 function mirrorUnionsAligned(u, schema) {
 	if (!u) return true;
 	const branches = reconstruct().collectMirrorUnions(schema);
@@ -21,25 +17,12 @@ function mirrorUnionsAligned(u, schema) {
 }
 function isBridgeFreeComplete(f, schema, raw) {
 	if (!f.cm) return false;
-	if (codecCoercionBridgeFree(f, schema, raw)) return true;
+	if (f.k === 1 && !!f.dm && !f.em && !f.ce && f.a !== 1 && !(f.d === 1 && f.ps !== 1) && (f.ic?.length ?? 0) === reconstruct().collectStringCodecNodes(schema).length && mirrorUnionsAligned(f.u, raw) && mirrorUnionsAligned(f.dm.u, schema)) return true;
 	if (f.e === 1 || f.u || f.dm || f.em || f.k === 1 || f.ce || f.ic || f.a === 1) return false;
 	if (f.d === 1 && f.ps !== 1) return false;
 	if (isFullyClosedObject(schema)) return false;
 	return true;
 }
-const EMPTY_EXTERNALS = Object.freeze([]);
-function jsTypeMatches(value, type) {
-	switch (type) {
-		case "string": return typeof value === "string";
-		case "number": return typeof value === "number";
-		case "integer": return typeof value === "number" && Number.isInteger(value);
-		case "boolean": return typeof value === "boolean";
-		case "null": return value === null;
-		case "array": return Array.isArray(value);
-		case "object": return typeof value === "object" && value !== null && !Array.isArray(value);
-		default: return true;
-	}
-}
 const typeError = (schema, instancePath, schemaPath) => ({
 	keyword: "type",
 	schemaPath,
@@ -97,63 +80,28 @@ function walkCompactError(schema, value, instancePath, schemaPath) {
 		}
 		return;
 	}
-	if (typeof type === "string" && !jsTypeMatches(value, type)) return typeError(schema, instancePath, schemaPath);
-}
-function bestEffortCodecError(schema, value) {
-	if (schema?.type === "object" && typeof value === "object" && value !== null && !Array.isArray(value) && schema.properties) for (const key in schema.properties) {
-		if (!(key in value)) continue;
-		if (isCompactDiagnosable(schema.properties[key])) continue;
-		return {
-			keyword: "type",
-			schemaPath: `#/properties/${key}`,
-			instancePath: `/${key}`,
-			params: {},
-			message: `must match ${schema.properties[key]?.["~kind"] ?? "schema"}`
-		};
-	}
-	return {
-		keyword: "type",
-		schemaPath: "#",
-		instancePath: "",
-		params: {},
-		message: `must match ${schema?.["~kind"] ?? "schema"}`
-	};
-}
-function isCompactDiagnosable(schema) {
-	if (!schema || typeof schema !== "object") return false;
-	if (schema.anyOf || schema.oneOf || schema.allOf) return false;
-	const type = schema.type;
-	if (type === "object") {
-		const properties = schema.properties;
-		if (properties) {
-			for (const key in properties) if (!isCompactDiagnosable(properties[key])) return false;
-		}
-		return true;
-	}
-	if (type === "array") return isCompactDiagnosable(schema.items);
-	return type === "string" || type === "number" || type === "integer" || type === "boolean" || type === "null";
+	if (!(type === "string" || type === "number" || type === "boolean" ? typeof value === type : type === "integer" ? Number.isInteger(value) : type !== "null" || value === null)) return typeError(schema, instancePath, schemaPath);
 }
-function isCompactWalkable(schema) {
+function isCompactWalkable(schema, lookThrough = true) {
 	if (!schema || typeof schema !== "object") return false;
 	const elyTyp = schema["~elyTyp"];
-	if (schema.anyOf && (elyTyp === ELYSIA_TYPES.ObjectString || elyTyp === ELYSIA_TYPES.ArrayString)) return isCompactWalkable(schema.anyOf[0]);
+	if (lookThrough && schema.anyOf && (elyTyp === ELYSIA_TYPES.ObjectString || elyTyp === ELYSIA_TYPES.ArrayString)) return isCompactWalkable(schema.anyOf[0]);
 	if (schema.anyOf || schema.oneOf || schema.allOf) return false;
 	const type = schema.type;
 	if (type === "object") {
 		const properties = schema.properties;
 		if (properties) {
-			for (const key in properties) if (!isCompactWalkable(properties[key])) return false;
+			for (const key in properties) if (!isCompactWalkable(properties[key], lookThrough)) return false;
 		}
 		return true;
 	}
-	if (type === "array") return isCompactWalkable(schema.items);
+	if (type === "array") return isCompactWalkable(schema.items, lookThrough);
 	return type === "string" || type === "number" || type === "integer" || type === "boolean" || type === "null";
 }
 var FrozenSlotValidator = class {
 	#check;
 	#clean;
 	#decode;
-	#hasDefault;
 	#defaultFastPath;
 	#hasOptional;
 	#noValidate;
@@ -162,13 +110,21 @@ var FrozenSlotValidator = class {
 		this.hasCodec = false;
 		this.schema = schema;
 		this.hasCodec = frozen.k === 1;
-		const built = this.buildCheckClean(frozen, schema, raw, normalize);
-		this.#check = built.check;
-		this.#clean = built.clean;
-		this.#decode = built.decode;
+		if (frozen.ic) reconstruct().reconstructInnerCodecs(frozen.ic, schema);
+		if (frozen.k === 1 && frozen.dm) {
+			const both = reconstruct().instantiateFrozenBoth(frozen, schema, raw);
+			this.#check = both.check;
+			if (normalize !== false) {
+				this.#clean = both.clean;
+				this.#decode = reconstruct().instantiateFrozenDecodeMirror(frozen.dm, schema);
+			}
+		} else {
+			const both = frozen.cm(EMPTY_EXTERNALS, void 0);
+			this.#check = both.check;
+			if (normalize !== false) this.#clean = both.clean;
+		}
 		this.#hasOptional = !!schema?.["~optional"];
 		this.#noValidate = schema?.["~elyTyp"] === ELYSIA_TYPES.NoValidate;
-		this.#hasDefault = frozen.d === 1;
 		if (frozen.ps === 1) this.#defaultFastPath = {
 			value: frozen.pd,
 			appliesToNull: frozen.pn === 1,
@@ -176,20 +132,34 @@ var FrozenSlotValidator = class {
 			merge: frozen.pm
 		};
 	}
-	buildCheckClean(frozen, schema, raw, normalize) {
-		const both = frozen.cm(EMPTY_EXTERNALS, void 0);
-		return {
-			check: both.check,
-			clean: normalize === false ? void 0 : both.clean
-		};
-	}
 	Check(value) {
 		return this.#check(value);
 	}
 	Errors(value) {
 		const hit = walkCompactError(this.schema, value, "", "#");
 		if (hit) return [hit];
-		return [bestEffortCodecError(this.schema, value)];
+		const schema = this.schema;
+		let error;
+		if (schema?.type === "object" && typeof value === "object" && value !== null && !Array.isArray(value) && schema.properties) for (const key in schema.properties) {
+			if (!(key in value)) continue;
+			if (isCompactWalkable(schema.properties[key], false)) continue;
+			error = {
+				keyword: "type",
+				schemaPath: `#/properties/${key}`,
+				instancePath: `/${key}`,
+				params: {},
+				message: `must match ${schema.properties[key]?.["~kind"] ?? "schema"}`
+			};
+			break;
+		}
+		if (!error) error = {
+			keyword: "type",
+			schemaPath: "#",
+			instancePath: "",
+			params: {},
+			message: `must match ${schema?.["~kind"] ?? "schema"}`
+		};
+		return [error];
 	}
 	#error(value, type) {
 		return new ValidationError(type, value, () => this.Errors(value), this.schema);
@@ -200,16 +170,11 @@ var FrozenSlotValidator = class {
 		if (value === null || typeof value !== "object") return value;
 		return defaults.clone ? defaults.clone() : structuredClone(value);
 	}
-	#applyDefault(value) {
-		return this.#defaultFastPath.merge(value);
-	}
 	From(value, type) {
-		if (this.#hasDefault) {
-			const defaults = this.#defaultFastPath;
-			if (defaults) {
-				if (value === void 0 || value === null && defaults.appliesToNull) value = this.#cloneSharedDefault();
-				else if (value !== null && typeof value === "object" && defaults.merge !== void 0) value = this.#applyDefault(value);
-			}
+		const defaults = this.#defaultFastPath;
+		if (defaults) {
+			if (value === void 0 || value === null && defaults.appliesToNull) value = this.#cloneSharedDefault();
+			else if (value !== null && typeof value === "object" && defaults.merge !== void 0) value = defaults.merge(value);
 		}
 		if (this.#hasOptional) {
 			const schema = this.schema;
@@ -225,25 +190,6 @@ var FrozenSlotValidator = class {
 		return this.#clean ? this.#clean(value) : value;
 	}
 };
-/**
-* The JIT/frozen slot validator: the reconstruct-free `FrozenSlotValidator`
-* base plus the codec/inner-codec branch re-added via the `buildCheckClean`
-* override
-*/
-var CodecFrozenSlotValidator = class extends FrozenSlotValidator {
-	buildCheckClean(frozen, schema, raw, normalize) {
-		if (frozen.ic) reconstruct().reconstructInnerCodecs(frozen.ic, schema);
-		if (frozen.k === 1 && frozen.dm) {
-			const both = reconstruct().instantiateFrozenBoth(frozen, schema, raw);
-			return {
-				check: both.check,
-				clean: normalize === false ? void 0 : both.clean,
-				decode: normalize === false ? void 0 : reconstruct().instantiateFrozenDecodeMirror(frozen.dm, schema)
-			};
-		}
-		return super.buildCheckClean(frozen, schema, raw, normalize);
-	}
-};
 const REQUEST_SLOTS = [
 	"body",
 	"headers",
@@ -289,11 +235,13 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 			coerced = rebuild(schema, frozen.cp);
 		}
 		if (!isBridgeFreeComplete(frozen, coerced, schema)) return void 0;
-		out[slot] = new CodecFrozenSlotValidator(frozen, coerced, schema, normalize);
+		out[slot] = new FrozenSlotValidator(frozen, coerced, schema, normalize);
 	}
 	const response = hook?.response;
 	if (response) {
-		const statuses = isResponseMap(response) ? response : { 200: response };
+		const resolved = resolveModelRef(response, root);
+		if (!resolved) return void 0;
+		const statuses = isResponseMap(resolved) ? resolved : { 200: resolved };
 		const responseOut = {};
 		for (const status in statuses) {
 			const raw = statuses[status];
@@ -306,13 +254,13 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 			}
 			const frozen = Compiled.getValidator(method, path, `response:${status}`, root["~programId"]);
 			if (!frozen || !isBridgeFreeComplete(frozen, schema, schema)) return void 0;
-			responseOut[status] = new CodecFrozenSlotValidator(frozen, schema, schema, normalize);
+			responseOut[status] = new FrozenSlotValidator(frozen, schema, schema, normalize);
 		}
 		out.response = responseOut;
 	}
 	return out;
 }
-const isResponseMap = (schema) => !("~kind" in schema || "~elyAcl" in schema || "~standard" in schema);
+const isResponseMap = (schema) => schema !== null && typeof schema === "object" && !("~kind" in schema || "~elyAcl" in schema || "~standard" in schema);
 const capturedBothMarker = (() => ({}));
 function isCapturedBridgeFree(c, schema, coerced = schema) {
 	if (typeof schema === "string") return false;
@@ -339,4 +287,4 @@ function isCapturedBridgeFree(c, schema, coerced = schema) {
 }
 
 //#endregion
-export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactDiagnosable, isCompactWalkable, isStandardSchema, mergeSchemasAllStandard };
+export { REQUEST_SLOTS, buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree, isCompactWalkable, isResponseMap, isStandardSchema, mergeSchemasAllStandard, resolveModelRef };

package/dist/compile/handler/index.d.ts

@@ -1,5 +1,5 @@
 import { ChainNode } from "../../utils.js";
-import { AnyLocalHook, CompiledHandler, InternalRoute } from "../../types.js";
+import { AnyLocalHook, AppHook, CompiledHandler, InternalRoute } from "../../types.js";
 import { AnyElysia } from "../../base.js";
 import { setCaptureHeaderShorthand } from "./jit.js";
 
@@ -11,9 +11,11 @@ declare function resolveWSLocalHook(scope: AnyElysia, hook: Partial<AnyLocalHook
  * (JIT or rebuild) compile repopulates them anyway, just uncached
  */
 declare function clearHandlerAnalysisCaches(root: AnyElysia): void;
+declare function chainResolver(root: AnyElysia): ((node: ChainNode) => Partial<AppHook> | undefined) | undefined;
 declare const localMacroRoot: (instance: AnyElysia, root: AnyElysia) => AnyElysia;
-declare function buildNativeStaticResponse([,, handler, instance, localHook, appHook, inheritedChain, macroScope]: InternalRoute, root: AnyElysia): Response | undefined;
-declare function composeRouteHook(instance: AnyElysia, localHook: Partial<AnyLocalHook> | undefined, appHook: ChainNode | undefined, inheritedChain: ChainNode | undefined, root: AnyElysia, macroScope?: AnyElysia): AnyLocalHook | undefined;
-declare function compileHandler([_method, path, handler, instance, localHook, appHook, inheritedChain, macroScope]: InternalRoute, root: AnyElysia, precomputedStatic?: Response): CompiledHandler;
+declare function buildNativeStaticResponse(route: InternalRoute, root: AnyElysia): Response | undefined;
+declare function composeRouteHook(instance: AnyElysia, localHook: Partial<AnyLocalHook> | undefined, appHook: ChainNode | undefined, inheritedChain: ChainNode | undefined, root: AnyElysia, macroScope?: AnyElysia, allowCompactPrefix?: boolean): AnyLocalHook | undefined;
+declare function routeShape(hook: AnyLocalHook | undefined, handler: unknown, root: AnyElysia): number | undefined;
+declare function compileHandler(route: InternalRoute, root: AnyElysia, liveOnly?: boolean): CompiledHandler;
 //#endregion
-export { buildNativeStaticResponse, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, resolveWSLocalHook, setCaptureHeaderShorthand };
+export { buildNativeStaticResponse, chainResolver, clearHandlerAnalysisCaches, compileHandler, composeRouteHook, localMacroRoot, resolveLocalHook, resolveWSLocalHook, routeShape, setCaptureHeaderShorthand };