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

package/dist/error.mjs

@@ -28,20 +28,60 @@ function isCacheableExpected(value, visited = /* @__PURE__ */ new Set()) {
 var ElysiaError = class extends Error {
 	constructor(message, cause) {
 		super(message);
-		this.problemType = "about:blank";
 		this.name = this.constructor.name;
 		if (cause) this.cause = cause;
 	}
 	toResponse(headers) {
-		return problemResponse({
-			type: this.problemType,
-			title: this.problemTitle,
-			status: this.status ?? 500,
-			detail: this.response !== void 0 && this.response !== this.problemTitle ? this.response : void 0
-		}, headers);
+		return problemResponse(elysiaErrorProblem(this), headers);
 	}
 };
 /**
+* `type` an error slug resolves to: the slug verbatim, or `<typeBase>/<slug>`
+* once {@link HTTPError.typeBase} is set. Shared by `ElysiaError` and every
+* class {@link HTTPError.id} makes, so both lanes derive `type` identically
+*/
+function problemTypeOf(code) {
+	if (code === void 0) return;
+	const base = HTTPError.typeBase;
+	if (!base) return code;
+	return (base.endsWith("/") ? base : base + "/") + code;
+}
+/**
+* Problem members an `ElysiaError` serves. `title` is left to `problemBody`,
+* which derives it from the status — so `response` is only worth serving as
+* `detail` when it says something the title doesn't
+*/
+function elysiaErrorProblem(error) {
+	const status = error.status ?? 500;
+	return {
+		type: error.type ?? "about:blank",
+		code: error.code,
+		status,
+		detail: error.response !== void 0 && error.response !== StatusMapBack[status] ? error.response : void 0
+	};
+}
+function defineData(target, key, value, enumerable = true) {
+	Object.defineProperty(target, key, {
+		value,
+		writable: true,
+		enumerable,
+		configurable: true
+	});
+}
+function defineProblemType(prototype) {
+	Object.defineProperty(prototype, "type", {
+		get() {
+			return problemTypeOf(this.code);
+		},
+		set(value) {
+			defineData(this, "type", value);
+		},
+		enumerable: true,
+		configurable: true
+	});
+}
+defineProblemType(ElysiaError.prototype);
+/**
 * Wrap a string into a TypeBox `error` callback that overrides the default
 * validation message. Use as `t.Number({ error: validationDetail('x must be a number') })`.
 */
@@ -54,8 +94,7 @@ var InternalServerError = class extends ElysiaError {
 		super(response, cause);
 		this.response = response;
 		this.status = 500;
-		this.problemType = "internal-server-error";
-		this.problemTitle = "Internal Server Error";
+		this.code = "internal-server-error";
 	}
 };
 var NotFound = class extends ElysiaError {
@@ -63,8 +102,7 @@ var NotFound = class extends ElysiaError {
 		super(response);
 		this.response = response;
 		this.status = 404;
-		this.problemType = "not-found";
-		this.problemTitle = "Not Found";
+		this.code = "not-found";
 	}
 };
 var ParseError = class extends ElysiaError {
@@ -72,15 +110,12 @@ var ParseError = class extends ElysiaError {
 		super("Bad Request", cause);
 		this.status = 400;
 		this.response = "Bad Request";
-		this.problemType = "parse";
-		this.problemTitle = "Bad Request";
+		this.code = "parse";
 	}
 	toResponse(headers) {
 		const cause = this.cause;
 		return problemResponse({
-			type: this.problemType,
-			title: this.problemTitle,
-			status: 400,
+			...elysiaErrorProblem(this),
 			detail: !isProduction() && cause?.message != null ? String(cause.message) : void 0
 		}, headers);
 	}
@@ -112,6 +147,7 @@ function walkComposition(schema, parts, seen = /* @__PURE__ */ new WeakSet()) {
 const walkSubSchema = (schema, instancePath) => !schema || !instancePath ? schema : walkComposition(schema, instancePath.split("/").filter(Boolean));
 const FOUND_ECHO_LIMIT = 8192;
 const FOUND_ECHO_OMITTED = `[value exceeds ${FOUND_ECHO_LIMIT} byte echo limit]`;
+const MAX_ERRORS = 64;
 function jsonStringLengthWithin(value, budget) {
 	budget -= 2;
 	for (let i = 0; i < value.length && budget >= 0; i++) {
@@ -173,11 +209,54 @@ function subValueAt(value, path) {
 	}
 	return current;
 }
-function scopeFound(value, first) {
-	if (jsonLengthWithin(value, FOUND_ECHO_LIMIT) >= 0) return value;
-	const sub = subValueAt(value, first?.instancePath ?? first?.path);
-	if (sub !== void 0 && jsonLengthWithin(sub, FOUND_ECHO_LIMIT) >= 0) return sub;
-	return FOUND_ECHO_OMITTED;
+const issueLocator = new Set([
+	"keyword",
+	"schemaPath",
+	"instancePath",
+	"path"
+]);
+function scopeIssues(errors) {
+	let budget = FOUND_ECHO_LIMIT;
+	let out;
+	for (let i = 0; i < errors.length; i++) {
+		const issue = errors[i];
+		if (!issue || typeof issue !== "object") {
+			out?.push(issue);
+			continue;
+		}
+		let scoped;
+		for (const key in issue) {
+			if (issueLocator.has(key)) continue;
+			const member = issue[key];
+			const remaining = jsonLengthWithin(member, budget);
+			if (remaining >= 0) {
+				budget = remaining;
+				continue;
+			}
+			scoped ??= { ...issue };
+			if (member === null || typeof member !== "object" || Array.isArray(member)) {
+				scoped[key] = FOUND_ECHO_OMITTED;
+				continue;
+			}
+			const narrowed = {};
+			for (const name in member) {
+				const value = member[name];
+				const rest = jsonLengthWithin(value, budget);
+				if (rest >= 0) {
+					narrowed[name] = value;
+					budget = rest;
+				} else narrowed[name] = FOUND_ECHO_OMITTED;
+			}
+			scoped[key] = narrowed;
+		}
+		if (!scoped) {
+			out?.push(issue);
+			continue;
+		}
+		out ??= errors.slice(0, i);
+		out.push(scoped);
+	}
+	return out ?? errors;
 }
 var ValidationError = class extends ElysiaError {
 	#thunk;
@@ -188,19 +267,16 @@ var ValidationError = class extends ElysiaError {
 		this.type = type;
 		this.value = value;
 		this.status = 422;
+		this.code = "validation";
 		this.allowUnsafeValidationDetails = false;
+		if (type === "response") this.status = 500;
 		this.schema = schema;
 		this.#thunk = typeof errors === "function" ? errors : () => errors;
 		this.#findCustomError = findCustomError;
 		Object.defineProperty(this, "errors", {
 			get: () => this["~resolve"]().errors,
 			set(v) {
-				Object.defineProperty(this, "errors", {
-					value: v,
-					writable: true,
-					enumerable: true,
-					configurable: true
-				});
+				defineData(this, "errors", v);
 			},
 			enumerable: true,
 			configurable: true
@@ -215,7 +291,6 @@ var ValidationError = class extends ElysiaError {
 		const findCustomError = this.#findCustomError;
 		let resolved;
 		let custom;
-		let message;
 		if (production && !allowUnsafe && findCustomError) {
 			const hit = findCustomError(value);
 			resolved = hit ? [{ instancePath: hit.instancePath }] : [];
@@ -224,26 +299,23 @@ var ValidationError = class extends ElysiaError {
 				on: type,
 				found: void 0
 			}) : hit.error;
-			message = custom !== void 0 ? typeof custom === "string" ? custom : JSON.stringify(custom) : `Validation error on ${type ?? "unknown"}`;
-			return this.#state = {
-				errors: resolved,
-				custom,
-				message
-			};
+		} else {
+			resolved = this.#thunk() ?? [];
+			if (resolved.length > 64) resolved = resolved.slice(0, 64);
+			resolved = scopeIssues(resolved);
+			const sub = walkSubSchema(this.schema, resolved[0]?.instancePath);
+			if (sub?.error !== void 0) custom = typeof sub.error === "function" ? sub.error(production && !allowUnsafe ? {
+				type: "validation",
+				on: type,
+				found: void 0
+			} : {
+				type: "validation",
+				on: type,
+				value,
+				errors: resolved
+			}) : sub.error;
 		}
-		resolved = this.#thunk() ?? [];
-		const sub = walkSubSchema(this.schema, resolved[0]?.instancePath);
-		if (sub?.error !== void 0) custom = typeof sub.error === "function" ? sub.error(production && !allowUnsafe ? {
-			type: "validation",
-			on: type,
-			found: void 0
-		} : {
-			type: "validation",
-			on: type,
-			value,
-			errors: resolved
-		}) : sub.error;
-		message = custom !== void 0 ? typeof custom === "string" ? custom : JSON.stringify(custom) : resolved[0]?.message ? resolved[0].message : `Validation error on ${type ?? "unknown"}`;
+		const message = custom !== void 0 ? typeof custom === "string" ? custom : JSON.stringify(custom) : resolved[0]?.message ? resolved[0].message : `Validation error on ${type ?? "unknown"}`;
 		return this.#state = {
 			errors: resolved,
 			custom,
@@ -254,16 +326,21 @@ var ValidationError = class extends ElysiaError {
 		return this["~resolve"]().custom;
 	}
 	set customError(v) {
-		Object.defineProperty(this, "customError", {
-			value: v,
-			writable: true,
-			enumerable: true,
-			configurable: true
-		});
+		defineData(this, "customError", v);
 	}
 	get all() {
 		if (!this.errors) return [];
-		return this.#collapseCoercionErrors(this.errors.filter(Boolean)).map((e) => this.#normalizeIssue(e));
+		return this.#collapseCoercionErrors(this.errors.filter(Boolean)).map((e) => {
+			if (!e) return e;
+			const issue = {
+				path: Array.isArray(e.path) ? e.path.length ? e.path.map(segmentString).join(".") : "root" : typeof e.path === "string" ? e.path.replace(/^\//, "").replace(/\//g, ".") || "root" : "root",
+				message: e.message ?? "",
+				schemaPath: e.schemaPath,
+				params: e.params
+			};
+			defineData(issue, "value", this.value, false);
+			return issue;
+		});
 	}
 	#collapseCoercionErrors(errors) {
 		if (!this.schema || !errors.length) return errors;
@@ -303,52 +380,30 @@ var ValidationError = class extends ElysiaError {
 		}
 		return out ?? errors;
 	}
-	#normalizeIssue(e) {
-		if (!e) return e;
-		return {
-			path: Array.isArray(e.path) ? e.path.length ? e.path.map(segmentString).join(".") : "root" : typeof e.path === "string" ? e.path.replace(/^\//, "").replace(/\//g, ".") || "root" : "root",
-			message: e.message ?? "",
-			schemaPath: e.schemaPath,
-			params: e.params,
-			value: this.value
-		};
-	}
 	get #productionDetail() {
 		return isProduction() && !this.allowUnsafeValidationDetails;
 	}
-	get #maskResponseValue() {
-		return this.type === "response" && this.#productionDetail;
-	}
 	detail(message) {
-		if (this.#productionDetail) {
-			if (this.type === "response") return {
-				type: "internal-server-error",
-				on: this.type,
-				message
-			};
-			return {
-				type: "validation",
-				on: this.type,
-				message
-			};
-		}
-		return {
+		if (!this.#productionDetail) return {
 			type: "validation",
 			on: this.type,
 			message,
 			errors: this.all
 		};
+		return {
+			type: this.type === "response" ? "internal-server-error" : "validation",
+			on: this.type,
+			message
+		};
 	}
 	get payload() {
+		const server = this.type === "response";
 		if (this.#productionDetail) {
-			if (this.type === "response") return {
-				type: "internal-server-error",
-				title: "Internal Server Error",
-				status: 500
-			};
+			if (server) return internalServerErrorProblem();
 			const first = (this.errors ?? []).find(Boolean);
 			return {
 				type: "validation",
+				code: "validation",
 				title: "Validation Error",
 				status: 422,
 				on: this.type,
@@ -373,24 +428,35 @@ var ValidationError = class extends ElysiaError {
 			}
 			else expected = created;
 		} catch {}
+		const value = this.value;
+		let found;
+		if (jsonLengthWithin(value, FOUND_ECHO_LIMIT) >= 0) found = value;
+		else {
+			const sub = subValueAt(value, first?.instancePath ?? first?.path);
+			if (sub !== void 0 && jsonLengthWithin(sub, FOUND_ECHO_LIMIT) >= 0) found = sub;
+			else found = FOUND_ECHO_OMITTED;
+		}
 		return {
-			type: "validation",
-			title: "Validation Error",
-			status: 422,
+			...server ? internalServerErrorProblem() : {
+				type: "validation",
+				code: "validation",
+				title: "Validation Error",
+				status: 422
+			},
 			detail,
 			on: this.type,
 			property,
-			found: scopeFound(this.value, first),
+			found,
 			expected,
 			errors
 		};
 	}
 	toResponse(headers) {
-		if (this.#maskResponseValue) return problemResponse(this.payload, headers);
+		if (this.type === "response" && this.#productionDetail) return problemResponse(this.payload, headers);
 		if (this.customError !== void 0) {
 			const isString = typeof this.customError === "string";
 			const response = new Response(isString ? this.customError : JSON.stringify(this.customError), {
-				status: this.status ?? 422,
+				status: this.type === "response" ? 500 : this.status ?? 422,
 				headers: {
 					...headers,
 					"content-type": isString ? "text/plain" : "application/json"
@@ -407,12 +473,7 @@ Object.defineProperty(ValidationError.prototype, "message", {
 		return this["~resolve"]().message;
 	},
 	set(v) {
-		Object.defineProperty(this, "message", {
-			value: v,
-			writable: true,
-			enumerable: false,
-			configurable: true
-		});
+		defineData(this, "message", v, false);
 	},
 	enumerable: false,
 	configurable: true
@@ -428,13 +489,10 @@ const emptyHttpStatus = new Set([
 var ElysiaStatus = class {
 	constructor(code, res, headers) {
 		const response = res ?? (code in StatusMapBack ? StatusMapBack[code] : code);
-		this.code = StatusMap[code] ?? code;
-		if (!emptyHttpStatus.has(this.code)) this.response = response;
+		this.status = StatusMap[code] ?? code;
+		if (!emptyHttpStatus.has(this.status)) this.response = response;
 		this.headers = headers;
 	}
-	get status() {
-		return this.code;
-	}
 };
 Object.defineProperty(ElysiaStatus, "name", { value: "ElysiaStatus" });
 const status = (code, response) => new ElysiaStatus(code, response);
@@ -461,12 +519,14 @@ function problemResponse(p, headers) {
 	skipClone.add(response);
 	return response;
 }
+const internalServerErrorProblem = () => ({
+	type: problemTypeOf("internal-server-error"),
+	code: "internal-server-error",
+	title: "Internal Server Error",
+	status: 500
+});
 function internalServerErrorBody(error) {
-	const body = {
-		type: "internal-server-error",
-		title: "Internal Server Error",
-		status: 500
-	};
+	const body = internalServerErrorProblem();
 	if (!isProduction()) {
 		if (error?.message != null) body.detail = error.message;
 		if (error?.name) body.name = error.name;
@@ -483,11 +543,7 @@ function internalServerErrorBodyString(error) {
 			delete safe.cause;
 			return JSON.stringify(safe);
 		} catch {
-			return JSON.stringify({
-				type: "internal-server-error",
-				title: "Internal Server Error",
-				status: 500
-			});
+			return JSON.stringify(internalServerErrorProblem());
 		}
 	}
 }
@@ -565,12 +621,17 @@ function problem(statusOrDetail, detail) {
 * @since 2.0.0
 */
 var HTTPError = class HTTPError extends Error {
-	static id(type, status) {
-		const Tagged = class extends HTTPError {};
-		Tagged.prototype.type = type;
-		Tagged.prototype.name = type;
+	static id(code, status) {
+		const Tagged = class extends HTTPError {
+			constructor(..._args) {
+				super(..._args);
+				this.code = code;
+			}
+		};
+		defineProblemType(Tagged.prototype);
+		Tagged.prototype.name = code;
 		Object.defineProperty(Tagged, "name", {
-			value: type,
+			value: code,
 			configurable: true
 		});
 		const resolved = typeof status === "string" ? StatusMap[status] : status;
@@ -580,4 +641,4 @@ var HTTPError = class HTTPError extends Error {
 };
 
 //#endregion
-export { ElysiaError, ElysiaStatus, HTTPError, InternalServerError, NotFound, PROBLEM_JSON, ParseError, ValidationError, internalServerErrorBody, internalServerErrorBodyString, internalServerErrorResponse, isProduction, problem, problemBody, problemResponse, status, subValueAt, validationDetail };
+export { ElysiaError, ElysiaStatus, HTTPError, InternalServerError, MAX_ERRORS, NotFound, PROBLEM_JSON, ParseError, ValidationError, elysiaErrorProblem, internalServerErrorBody, internalServerErrorBodyString, internalServerErrorResponse, isProduction, problem, problemBody, problemResponse, problemTypeOf, status, subValueAt, validationDetail };

package/dist/generation.d.ts

@@ -1,5 +1,5 @@
-import { TraceCapability } from "./trace.js";
 import { ChainNode } from "./utils.js";
+import { TraceCapability } from "./trace.js";
 import { ProgramId } from "./compile/aot.js";
 import { WSCapability, WSOptions } from "./ws/types.js";
 import { RouteTable } from "./route-table.js";
@@ -27,4 +27,4 @@ declare const resolvedWsOf: (root: AnyElysia) => {
 } | undefined;
 declare const wsCapabilityRequired = "[Elysia] .ws() requires the WebSocket capability: import { websocket } from 'elysia/websocket' and .use(websocket())";
 //#endregion
-export { FrozenRootView, Generation, frozenRootOf, resolvedTraceOf, resolvedWsOf, traceCapabilityRequired, wsCapabilityRequired };
+export { Generation, frozenRootOf, resolvedTraceOf, resolvedWsOf, traceCapabilityRequired, wsCapabilityRequired };

package/dist/handler/error.d.ts

@@ -1,18 +1,8 @@
-import { AppHook } from "../types.js";
 import { Context } from "../context.js";
+import { AppHook } from "../types.js";
 
 //#region src/handler/error.d.ts
-/**
- * Adopt the intercepted error's `type` into a problem the hook produced
- * without one.
- *
- * `'about:blank'` is RFC 9457's "unspecified" default, so it's the only value
- * worth replacing — an explicit type the handler set always wins.
- *
- * The result is copied rather than mutated: `.error(Class, value)` wraps a
- * non-function into `() => value`, so the very same `ElysiaStatus` is replayed
- * on every request and an in-place write would leak across requests
- */
+declare const claimsProblemType: (error: any) => boolean;
 declare function adoptErrorType(result: any, error: any): any;
 /**
  * Response served once every error hook has declined the error.
@@ -20,7 +10,28 @@ declare function adoptErrorType(result: any, error: any): any;
  * Exported for the JIT: a route with error hooks emits its own catch block,
  * which must land on *this* function rather than re-implementing it
  */
-declare function fallbackResponse(context: Context, error: any, mapResponse: (response: unknown, set: Context['set'], context?: Context) => unknown, defaultError?: Response): unknown;
-declare function createErrorHandler(onErrors: AppHook['error'] | undefined, mapResponse: (response: unknown, set: Context['set'], ...any: unknown[]) => unknown, defaultError?: Response, allowUnsafe?: boolean): (context: Context, error: Error) => unknown;
+declare function fallbackResponse(context: Context, error: any, mapResponse: (response: unknown, set: Context['set'], context?: Context) => unknown): unknown;
+/**
+ * Numeric form of an annotated status, which may be written as a name.
+ * A numeric string keeps coercing so the production mask below can't be
+ * slipped past with `'502'`
+ */
+declare const resolveStatus: (status: unknown) => unknown;
+/**
+ * Body served by an error that carries a status but no usable body:
+ * its declared `response`, otherwise its message
+ */
+declare function statusFallbackBody(error: any, status: unknown): any;
+/**
+ * Read one annotation knob.
+ *
+ * Both knobs are canonically methods, so they're evaluated per serve and may
+ * be `async`. Running a stranger's function is side-effect surface (it may
+ * consume a stream or do IO), so it takes the same problem claim the shaping
+ * does — an unclaimed duck error never invokes one. A *value* annotation stays
+ * inert data and keeps duck-participating as it always has
+ */
+declare const readAnnotation: (self: any, key: "value" | "detail", claimsProblem: boolean) => any;
+declare function createErrorHandler(onErrors: AppHook['error'] | undefined, mapResponse: (response: unknown, set: Context['set'], ...any: unknown[]) => unknown, allowUnsafe?: boolean): (context: Context, error: Error, sign?: ((set: Context["set"]) => unknown) | undefined) => unknown;
 //#endregion
-export { adoptErrorType, createErrorHandler, fallbackResponse };
+export { adoptErrorType, claimsProblemType, createErrorHandler, fallbackResponse, readAnnotation, resolveStatus, statusFallbackBody };