@warlock.js/core 5.30.0 → 5.32.0

package/esm/http/response.d.mts

@@ -1,16 +1,17 @@
 import { StorageFile } from "../storage/storage-file.mjs";
+import "../storage/index.mjs";
 import { PipeableReactStream } from "./stream-react-response.mjs";
 import { XMLable } from "./xmlable.mjs";
 import { Request } from "./request.mjs";
 import { ResponseEvent, ResponseSSEController, ResponseSSEOptions, ResponseStreamController, ResponseStreamOptions } from "./types.mjs";
 import { Route } from "../router/types.mjs";
+import "../router/index.mjs";
 import { ValidationResult } from "@warlock.js/seal";
 import { LogLevel } from "@warlock.js/logger";
 import { EventSubscription } from "@mongez/events";
 import { FastifyReply } from "fastify";
 import { CookieSerializeOptions } from "@fastify/cookie";
 import React from "react";
-
 //#region ../../packages/core/src/http/response.d.ts
 type CookieValue = string | number | boolean | Record<string, any> | Array<any>;
 /**
@@ -25,7 +26,7 @@ type CookieValue = string | number | boolean | Record<string, any> | Array<any>;
  * to the raw string on parse failure, so round-tripping a raw string cookie
  * Just Works.
  */
-type CookieOptions = CookieSerializeOptions & {
+export type CookieOptions = CookieSerializeOptions & {
   /**
    * Skip JSON.stringify and write the value as-is.
    *
@@ -33,7 +34,7 @@ type CookieOptions = CookieSerializeOptions & {
    */
   raw?: boolean;
 };
-declare enum ResponseStatus {
+export declare enum ResponseStatus {
   OK = 200,
   CREATED = 201,
   ACCEPTED = 202,
@@ -57,7 +58,7 @@ declare enum ResponseStatus {
 /**
  * Options for sending files
  */
-type SendFileOptions = {
+export type SendFileOptions = {
   cacheTime?: number;
   immutable?: boolean;
   inline?: boolean;
@@ -66,7 +67,7 @@ type SendFileOptions = {
 /**
  * Options for sending buffers
  */
-type SendBufferOptions = SendFileOptions & {
+export type SendBufferOptions = SendFileOptions & {
   contentType?: string;
   etag?: string;
 };
@@ -75,8 +76,8 @@ type SendBufferOptions = SendFileOptions & {
  * would end the field and inject the rest as new fields or events, and the
  * spec makes a client ignore an `id` containing NUL. All three are removed.
  */
-declare function toSingleLineSseField(value: unknown): string;
-declare class Response {
+export declare function toSingleLineSseField(value: unknown): string;
+export declare class Response {
   /**
    * Current route
    */
@@ -211,6 +212,8 @@ declare class Response {
   protected fireSentEvents(statusCode?: number): void;
   /** Send a bare 304 and fire the lifecycle. */
   protected send304(): FastifyReply<import("fastify").RouteGenericInterface, import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>;
+  /** Send a bare 412 (a failed `If-Match` / `If-Unmodified-Since`) and fire the lifecycle. */
+  protected send412(): FastifyReply<import("fastify").RouteGenericInterface, import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>;
   /** Send a raw stream/buffer body and fire the lifecycle. */
   protected sendRaw(body: any): FastifyReply<import("fastify").RouteGenericInterface, import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>;
   /**
@@ -356,6 +359,9 @@ declare class Response {
    * Get the response time
    */
   getResponseTime(): number;
+  protected isHttp11(): boolean;
+  /** Apply cache/application overrides without letting callers change framing. */
+  protected applyStreamHeaders(headers?: Record<string, string>): void;
   /**
    * Ask a long-lived response (`sse()`, `stream()`) to keep its connection
    * open, unless a graceful shutdown already marked it `Connection: close`
@@ -559,9 +565,9 @@ declare class Response {
    * Automatically detects image format and sets content type
    */
   sendImage(image: any, // Type as 'any' to avoid circular dependency with Image class
-  options?: number | (Omit<SendBufferOptions, "contentType"> & {
-    contentType?: string;
-  })): Promise<never>;
+    options?: number | (Omit<SendBufferOptions, "contentType"> & {
+      contentType?: string;
+    })): Promise<never>;
   /**
    * Send file and cache it
    * Cache time in seconds
@@ -581,10 +587,15 @@ declare class Response {
    */
   getFileContentType(filePath: string): string;
   /**
-   * Mark the response as failed
+   * Answer a failed schema validation.
+   *
+   * Uses the global `validation.response.body(result, route)` hook when it is
+   * configured and returns a body; otherwise the framework body,
+   * `{ [errors]: [{ [inputKey], [inputError] }] }`. The status is
+   * `validation.response.status` (422 by default) either way.
    */
   failedSchema(result: ValidationResult): Promise<Response>;
 }
 //#endregion
-export { CookieOptions, Response, ResponseStatus, SendBufferOptions, SendFileOptions, toSingleLineSseField };
+export {};
 //# sourceMappingURL=response.d.mts.map

package/esm/http/response.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"response.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/http/response.ts"],"mappings":"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"}
+{"version":3,"file":"response.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/http/response.ts"],"mappings":"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"}

package/esm/http/response.mjs

@@ -1,14 +1,16 @@
 import { LOCALE_COOKIE_NAME, LOCALE_PREFERENCE_COOKIE_NAME, resolveLocaleConfiguration } from "../config/locale-configuration.mjs";
+import { evaluateConditionalRequest } from "./conditional-request.mjs";
+import { validationFailureStatus } from "../validation/validation-failure-status.mjs";
 import { Application } from "../application/application.mjs";
 import { UnknownLocaleError } from "../errors/unknown-locale-error.mjs";
 import { StorageFile } from "../storage/storage-file.mjs";
 import "../storage/index.mjs";
 import { renderReact } from "../react/index.mjs";
-import { matchesIfNoneMatch } from "./uploads/matches-if-none-match.mjs";
 import { flushPendingCookies } from "./flush-pending-cookies.mjs";
 import { streamReactResponse } from "./stream-react-response.mjs";
+import { createBoundedStreamQueue, validateStreamQueueOptions } from "./bounded-stream-queue.mjs";
 import { createRetainedTail, createStreamTransport } from "./stream-transport.mjs";
-import config from "@mongez/config";
+import baseConfig from "@mongez/config";
 import { log } from "@warlock.js/logger";
 import path from "path";
 import { isIterable, isPlainObject, isScalar } from "@mongez/supportive-is";
@@ -207,7 +209,7 @@ var Response = class Response {
 	* Make a log message
 	*/
 	log(message, level = "info") {
-		if (!config.get("http.log")) return;
+		if (!baseConfig.get("http.log")) return;
 		log.log({
 			module: "response",
 			action: this.route.method + " " + this.route.path.replace("/*", "") + `:${this.request.id}`,
@@ -290,6 +292,12 @@ var Response = class Response {
 		this.fireSentEvents(304);
 		return reply;
 	}
+	/** Send a bare 412 (a failed `If-Match` / `If-Unmodified-Since`) and fire the lifecycle. */
+	send412() {
+		const reply = this.baseResponse.status(412).send();
+		this.fireSentEvents(412);
+		return reply;
+	}
 	/** Send a raw stream/buffer body and fire the lifecycle. */
 	sendRaw(body) {
 		const reply = this.baseResponse.send(body);
@@ -382,11 +390,14 @@ var Response = class Response {
 	* @returns Stream controller with send(), write(), render(), drain() and end() methods
 	*/
 	stream(contentType = "text/plain", options = {}) {
-		this.setContentType(contentType);
-		this.header("Transfer-Encoding", "chunked");
+		validateStreamQueueOptions(options);
 		this.header("Cache-Control", "no-cache");
-		this.keepLongLivedConnectionAlive();
+		this.applyStreamHeaders(options.headers);
+		this.removeHeader("Content-Length");
+		this.setContentType(contentType);
+		if (this.isHttp11()) this.header("Transfer-Encoding", "chunked");
 		this.header("X-Content-Type-Options", "nosniff");
+		this.keepLongLivedConnectionAlive();
 		Response.trigger("sending", this);
 		for (const callback of this.events.get("sending") || []) callback(this);
 		this.log("Starting stream");
@@ -396,6 +407,8 @@ var Response = class Response {
 			disconnectMessage: "The client disconnected from the stream",
 			onClientDisconnected: () => this.log("Stream client disconnected")
 		});
+		const queue = createBoundedStreamQueue(raw, transport, options);
+		let bounded = options.maxQueuedBytes !== void 0;
 		this.flushPendingCookies();
 		raw.writeHead(this.statusCode, this.getHeaders());
 		/**
@@ -405,14 +418,22 @@ var Response = class Response {
 		*/
 		const canWrite = (action) => {
 			if (transport.disconnected) return false;
-			if (transport.closed) throw new Error(`Cannot ${action}: stream has already ended`);
+			if (transport.closed || queue.ending) throw new Error(`Cannot ${action}: stream has already ended`);
 			return true;
 		};
 		const writeChunk = (chunk) => {
+			if (bounded) {
+				if (!queue.enqueue(chunk)) return false;
+			} else raw.write(chunk);
 			retained.push(chunk);
-			raw.write(chunk);
+			return true;
 		};
 		const controller = {
+			enqueue: (data) => {
+				bounded = true;
+				if (transport.closed || queue.ending) return false;
+				return writeChunk(data);
+			},
 			/**
 			* Send a chunk of data to the client. Does not wait for the client.
 			* @param data - Data to send (string or Buffer)
@@ -427,9 +448,9 @@ var Response = class Response {
 			* stream ended or the client disconnected (stop producing).
 			*/
 			write: (data) => {
-				if (transport.closed) return Promise.resolve(false);
+				if (transport.closed || queue.ending) return Promise.resolve(false);
 				writeChunk(data);
-				return transport.waitForDrain();
+				return queue.waitForDrain();
 			},
 			/**
 			* Render a React component and send it as a chunk
@@ -442,21 +463,23 @@ var Response = class Response {
 			/**
 			* Wait until buffered output has been flushed to the client.
 			*/
-			drain: () => transport.waitForDrain(),
+			drain: () => queue.waitForDrain(),
 			/**
 			* End the stream and trigger completion events
 			*/
 			end: () => {
-				if (transport.closed) return this;
-				transport.finish();
-				this.currentBody = retained.items;
-				this.parsedBody = retained.items;
-				raw.end();
-				this.log("Stream ended");
-				Response.trigger("sent", this);
-				for (const callback of this.events.get("sent") || []) callback(this);
-				if (this.isOk) Response.trigger("success", this);
-				if (this.currentStatusCode === 201) Response.trigger("successCreate", this);
+				if (transport.closed || queue.ending) return this;
+				queue.finish(() => {
+					transport.finish();
+					this.currentBody = retained.items;
+					this.parsedBody = retained.items;
+					raw.end();
+					this.log("Stream ended");
+					Response.trigger("sent", this);
+					for (const callback of this.events.get("sent") || []) callback(this);
+					if (this.isOk) Response.trigger("success", this);
+					if (this.currentStatusCode === 201) Response.trigger("successCreate", this);
+				});
 				return this;
 			},
 			/**
@@ -474,13 +497,16 @@ var Response = class Response {
 			* Whether the transport is holding more than its high-water mark.
 			*/
 			get backpressured() {
-				return transport.backpressured;
+				return queue.backpressured;
+			},
+			get dropped() {
+				return queue.dropped;
 			},
 			/**
 			* Check if the stream has ended (either via end() or client disconnect)
 			*/
 			get ended() {
-				return transport.closed;
+				return transport.closed || queue.ending;
 			}
 		};
 		return controller;
@@ -550,10 +576,14 @@ var Response = class Response {
 	* @returns SSE controller with send(), write(), drain(), comment(), and end() methods
 	*/
 	sse(options = {}) {
-		this.setContentType("text/event-stream");
+		validateStreamQueueOptions(options);
 		this.header("Cache-Control", "no-cache, no-store, must-revalidate");
-		this.keepLongLivedConnectionAlive();
+		this.applyStreamHeaders(options.headers);
+		this.removeHeader("Content-Length");
+		if (this.isHttp11()) this.header("Transfer-Encoding", "chunked");
+		this.setContentType("text/event-stream");
 		this.header("X-Accel-Buffering", "no");
+		this.keepLongLivedConnectionAlive();
 		Response.trigger("sending", this);
 		for (const callback of this.events.get("sending") || []) callback(this);
 		this.log("Starting SSE stream");
@@ -563,33 +593,45 @@ var Response = class Response {
 			disconnectMessage: "The client disconnected from the SSE stream",
 			onClientDisconnected: () => this.log("SSE client disconnected")
 		});
+		const queue = createBoundedStreamQueue(raw, transport, options);
+		let bounded = options.maxQueuedBytes !== void 0;
 		this.flushPendingCookies();
 		raw.writeHead(this.statusCode, this.getHeaders());
-		const writeMessage = (event, data, id) => {
-			const safeEvent = toSingleLineSseField(event);
+		const writeMessage = (event, data, id, messageOptions = {}) => {
+			if (messageOptions.raw && typeof data !== "string") throw new TypeError("Raw SSE data must be a string");
+			const safeEvent = event === void 0 ? void 0 : toSingleLineSseField(event);
 			const safeId = id === void 0 ? void 0 : toSingleLineSseField(id);
+			const payload = messageOptions.raw ? data : JSON.stringify(data);
 			let message = "";
 			if (safeId) message += `id: ${safeId}\n`;
-			message += `event: ${safeEvent}\n`;
-			message += `data: ${JSON.stringify(data)}\n\n`;
+			if (safeEvent !== void 0) message += `event: ${safeEvent}\n`;
+			message += String(payload).split(/\r\n|\r|\n/).map((line) => `data: ${line}\n`).join("") + "\n";
+			if (bounded) {
+				if (!queue.enqueue(message)) return false;
+			} else raw.write(message);
 			retained.push({
 				event,
 				data,
 				id
 			});
-			raw.write(message);
+			return true;
 		};
-		const waitForDrain = () => transport.waitForDrain();
+		const waitForDrain = () => queue.waitForDrain();
 		const controller = {
+			enqueue: (event, data, id, messageOptions) => {
+				bounded = true;
+				if (transport.closed || queue.ending) return false;
+				return writeMessage(event, data, id, messageOptions);
+			},
 			/**
 			* Send an SSE event
 			* @param event - Event name (e.g., "message", "chunk", "done")
 			* @param data - Event data (will be JSON stringified)
 			* @param id - Optional event ID for client-side Last-Event-ID tracking (reconnect support)
 			*/
-			send: (event, data, id) => {
-				if (transport.closed) return controller;
-				writeMessage(event, data, id);
+			send: (event, data, id, messageOptions) => {
+				if (transport.closed || queue.ending) return controller;
+				writeMessage(event, data, id, messageOptions);
 				return controller;
 			},
 			/**
@@ -597,9 +639,9 @@ var Response = class Response {
 			* @returns `true` once the transport can accept more, `false` if the
 			* stream ended or the client disconnected (stop producing).
 			*/
-			write: (event, data, id) => {
-				if (transport.closed) return Promise.resolve(false);
-				writeMessage(event, data, id);
+			write: (event, data, id, messageOptions) => {
+				if (transport.closed || queue.ending) return Promise.resolve(false);
+				writeMessage(event, data, id, messageOptions);
 				return waitForDrain();
 			},
 			/**
@@ -612,24 +654,27 @@ var Response = class Response {
 			* @param text - Comment text
 			*/
 			comment: (text) => {
-				if (transport.closed) return controller;
-				const lines = String(text).split(/\r\n|\r|\n/);
-				raw.write(`${lines.map((line) => `: ${line}`).join("\n")}\n\n`);
+				if (transport.closed || queue.ending) return controller;
+				const message = `${String(text).split(/\r\n|\r|\n/).map((line) => `: ${line}`).join("\n")}\n\n`;
+				if (bounded) queue.enqueue(message);
+				else raw.write(message);
 				return controller;
 			},
 			/**
 			* End the SSE stream and trigger completion events
 			*/
 			end: () => {
-				if (transport.closed) return controller;
-				transport.finish();
-				this.currentBody = retained.items;
-				this.parsedBody = retained.items;
-				raw.end();
-				this.log("SSE stream ended");
-				Response.trigger("sent", this);
-				for (const callback of this.events.get("sent") || []) callback(this);
-				if (this.isOk) Response.trigger("success", this);
+				if (transport.closed || queue.ending) return controller;
+				queue.finish(() => {
+					transport.finish();
+					this.currentBody = retained.items;
+					this.parsedBody = retained.items;
+					raw.end();
+					this.log("SSE stream ended");
+					Response.trigger("sent", this);
+					for (const callback of this.events.get("sent") || []) callback(this);
+					if (this.isOk) Response.trigger("success", this);
+				});
 				return controller;
 			},
 			/**
@@ -656,13 +701,16 @@ var Response = class Response {
 			* Whether the transport is holding more than its high-water mark.
 			*/
 			get backpressured() {
-				return transport.backpressured;
+				return queue.backpressured;
+			},
+			get dropped() {
+				return queue.dropped;
 			},
 			/**
 			* Check if the stream has ended (either via end() or client disconnect)
 			*/
 			get ended() {
-				return transport.closed;
+				return transport.closed || queue.ending;
 			}
 		};
 		return controller;
@@ -696,6 +744,23 @@ var Response = class Response {
 	getResponseTime() {
 		return this.baseResponse.elapsedTime;
 	}
+	isHttp11() {
+		const request = this.baseResponse.raw.req;
+		return request?.httpVersionMajor === 1 && request.httpVersionMinor >= 1;
+	}
+	/** Apply cache/application overrides without letting callers change framing. */
+	applyStreamHeaders(headers = {}) {
+		const protectedHeaders = /* @__PURE__ */ new Set([
+			"content-length",
+			"transfer-encoding",
+			"content-type",
+			"connection",
+			"keep-alive",
+			"proxy-connection",
+			"upgrade"
+		]);
+		for (const [name, value] of Object.entries(headers)) if (!protectedHeaders.has(name.toLowerCase())) this.header(name, value);
+	}
 	/**
 	* Ask a long-lived response (`sse()`, `stream()`) to keep its connection
 	* open, unless a graceful shutdown already marked it `Connection: close`
@@ -704,8 +769,21 @@ var Response = class Response {
 	* and hold the server's `close()` until the shutdown budget runs out.
 	*/
 	keepLongLivedConnectionAlive() {
+		if (!this.isHttp11()) {
+			for (const name of [
+				"connection",
+				"keep-alive",
+				"proxy-connection",
+				"upgrade",
+				"transfer-encoding"
+			]) this.removeHeader(name);
+			return;
+		}
 		const current = this.baseResponse.raw.getHeader("connection");
-		if (typeof current === "string" && current.toLowerCase() === "close") return;
+		if (typeof current === "string" && current.toLowerCase() === "close") {
+			this.header("Connection", "close");
+			return;
+		}
 		this.header("Connection", "keep-alive");
 	}
 	/**
@@ -782,7 +860,7 @@ var Response = class Response {
 	*/
 	cookie(name, value, options = {}) {
 		const { raw, ...cookieOptions } = options;
-		const defaultOptions = config.get("http.cookies.options", {});
+		const defaultOptions = baseConfig.get("http.cookies.options", {});
 		const serializedValue = raw ? String(value) : JSON.stringify(value);
 		const mergedCookieOptions = {
 			...secureCookieDefaults(),
@@ -815,7 +893,7 @@ var Response = class Response {
 	* response.setLocale("ar");
 	*/
 	setLocale(locale) {
-		const { localeCodes } = resolveLocaleConfiguration(config.get("app.localeCode"), config.get("app.localeCodes"));
+		const { localeCodes } = resolveLocaleConfiguration(baseConfig.get("app.localeCode"), baseConfig.get("app.localeCodes"));
 		if (localeCodes !== void 0 && !localeCodes.includes(locale)) throw new UnknownLocaleError(locale, localeCodes);
 		this.baseResponse.clearCookie(LOCALE_PREFERENCE_COOKIE_NAME, {
 			path: "/",
@@ -832,7 +910,7 @@ var Response = class Response {
 	* response.clearCookie('token', { path: '/' });
 	*/
 	clearCookie(name, options) {
-		const defaultOptions = config.get("http.cookies.options", {});
+		const defaultOptions = baseConfig.get("http.cookies.options", {});
 		this.baseResponse.clearCookie(name, {
 			...defaultOptions,
 			...options
@@ -973,21 +1051,34 @@ var Response = class Response {
 		if (!/[^\x20-\x7E]/.test(name)) return `${type}; filename="${ascii}"`;
 		return `${type}; filename="${ascii}"; filename*=UTF-8''${encodeURIComponent(name).replace(/['()*]/g, (char) => "%" + char.charCodeAt(0).toString(16).toUpperCase())}`;
 	}
-	applyResponseOptions(options, defaultFilename) {
+	applyResponseOptions(options, defaultFilename, lastModified) {
 		if (options.contentType) this.baseResponse.type(options.contentType);
 		if (options.cacheTime) {
 			const cacheControl = options.immutable ? `public, max-age=${options.cacheTime}, immutable` : `public, max-age=${options.cacheTime}`;
 			this.header("Cache-Control", cacheControl);
 			this.header("Expires", new Date(Date.now() + options.cacheTime * 1e3).toUTCString());
 		}
-		if (options.etag) {
-			this.header("ETag", options.etag);
-			const ifNoneMatch = this.request.header("if-none-match");
-			if (ifNoneMatch && matchesIfNoneMatch(ifNoneMatch, options.etag)) {
-				this.log("Content not modified (ETag match), sending 304");
+		if (options.etag) this.header("ETag", options.etag);
+		if (options.etag || lastModified) {
+			const outcome = evaluateConditionalRequest({
+				method: this.request.method,
+				etag: options.etag,
+				lastModified,
+				ifMatch: this.request.header("if-match"),
+				ifNoneMatch: this.request.header("if-none-match"),
+				ifModifiedSince: this.request.header("if-modified-since"),
+				ifUnmodifiedSince: this.request.header("if-unmodified-since")
+			});
+			if (outcome === "not-modified") {
+				this.log("Content not modified, sending 304");
 				this.send304();
 				return true;
 			}
+			if (outcome === "precondition-failed") {
+				this.log("Precondition failed, sending 412");
+				this.send412();
+				return true;
+			}
 		}
 		if (options.inline !== void 0 || options.filename) {
 			const disposition = options.inline ? "inline" : "attachment";
@@ -1017,20 +1108,7 @@ var Response = class Response {
 				...opts,
 				etag,
 				contentType
-			}, defaultFilename)) return this.baseResponse;
-			const ifNoneMatch = this.request.header("if-none-match");
-			const ifModifiedSince = this.request.header("if-modified-since");
-			if (ifNoneMatch && matchesIfNoneMatch(ifNoneMatch, etag)) {
-				this.log("File not modified (ETag match), sending 304");
-				return this.send304();
-			}
-			if (ifModifiedSince && !ifNoneMatch) {
-				const modifiedSinceDate = new Date(ifModifiedSince);
-				if (Math.floor(lastModified.getTime() / 1e3) <= Math.floor(modifiedSinceDate.getTime() / 1e3)) {
-					this.log("File not modified (Last-Modified check), sending 304");
-					return this.send304();
-				}
-			}
+			}, defaultFilename, lastModified)) return this.baseResponse;
 			const stream = fs.createReadStream(filePath);
 			stream.on("error", (error) => {
 				this.log(`Error reading file: ${error.message}`, "error");
@@ -1123,17 +1201,27 @@ var Response = class Response {
 		return mime.getType(filePath) || "application/octet-stream";
 	}
 	/**
-	* Mark the response as failed
-	*/
-	failedSchema(result) {
-		const { errors, inputKey, inputError, status } = {
+	* Answer a failed schema validation.
+	*
+	* Uses the global `validation.response.body(result, route)` hook when it is
+	* configured and returns a body; otherwise the framework body,
+	* `{ [errors]: [{ [inputKey], [inputError] }] }`. The status is
+	* `validation.response.status` (422 by default) either way.
+	*/
+	async failedSchema(result) {
+		const settings = baseConfig.get("validation.response", {});
+		const { errors, inputKey, inputError } = {
 			errors: "errors",
 			inputKey: "input",
 			inputError: "error",
-			status: 422,
-			...config.get("validation.response", {})
+			...settings
 		};
+		const status = validationFailureStatus();
 		log.error("request", "validation", `${this.request.id} - Validation failed`);
+		if (typeof settings.body === "function") {
+			const body = await settings.body(result, this.request.route);
+			if (body !== void 0) return this.send(body, status);
+		}
 		return this.send({ [errors]: result.errors.map((error) => ({
 			[inputKey]: error.input,
 			[inputError]: error.error