@nodefony/http 10.0.0-beta.5 → 10.0.0-beta.7

package/dist/nodefony/src/context/http/Request.js

@@ -1,8 +1,8 @@
-import HttpError from "../../errors/httpError.js";
-import { hasForwardingHeaders, resolveForwarded } from "../forwarded.js";
 import { hostnameOf } from "../domainMatcher.js";
 import { Parser, ParserJson, ParserQs, ParserRaw, ParserXml, acceptParser } from "./parser.js";
-import { isCanonicalAuthority, splitTarget } from "./urlFastPath.js";
+import { isCanonicalAuthority, splitAbsoluteForm, splitTarget } from "./urlFastPath.js";
+import HttpError from "../../errors/httpError.js";
+import { hasForwardingHeaders, resolveForwarded } from "../forwarded.js";
 import { RequestContext, useConfig } from "nodefony";
 import { createHash, randomUUID } from "node:crypto";
 import { URL } from "node:url";
@@ -23,6 +23,18 @@ const reg = /(.*)[[][\]]$/u;
 const unlinkQuiet = (p) => fsp.unlink(p).catch(() => void 0);
 var BodyHandled = class {};
 const BODY_DONE = new BodyHandled();
+/**
+* Une réception multipart EN COURS, interruptible de l'extérieur : `fail` rompt
+* la lecture comme le ferait un dépassement de limite (temporaires nettoyés).
+* Posée dans `request.parser` le temps de la lecture seulement — l'allocation
+* est réservée au multipart, déjà lourd.
+*/
+var MultipartReception = class {
+	fail;
+	constructor(fail) {
+		this.fail = fail;
+	}
+};
 const CHARSET_ALIASES = {
 	"utf-8": "utf8",
 	utf8: "utf8",
@@ -128,6 +140,9 @@ var HttpRequest = class {
 	* temporaire — lus par `@UploadedFile()` / `@UploadedFiles()`. Les champs
 	* texte du même corps sont dans {@link body}.
 	*
+	* Ces temporaires sont EFFACÉS à la fin de la requête : pour garder un
+	* fichier, l'action le déplace (`moveAsync`) avant de répondre.
+	*
 	* Lecture seule : une requête sans upload rend un vide partagé et gelé,
 	* aucune allocation.
 	*/
@@ -271,6 +286,25 @@ var HttpRequest = class {
 		}
 	}
 	/**
+	* Lit le plafond du corps et les limites d'envoi tels que les voit CETTE
+	* requête : la configuration http, surchargée par le calque que la requête a
+	* pu poser avant la lecture du corps (`overlayConfig`, #494), puis par les
+	* bornes que la route déclare pour elle-même (option de route `upload`). La
+	* route est déjà résolue à ce moment : une route sans bornes propres
+	* n'alloue rien. Hors pipeline (aucun scope ouvert), la configuration du
+	* module telle quelle.
+	*/
+	readBodyLimits() {
+		const options = RequestContext.getScope() !== void 0 ? useConfig("@nodefony/http") : this.context.httpKernel?.module.options;
+		const base = options?.upload ?? {};
+		const route = this.context.resolver?.route?.upload;
+		this.uploadOption = route ? {
+			...base,
+			...route
+		} : base;
+		this.maxBodySize = options?.maxBodySize ?? 0;
+	}
+	/**
 	* B1 — Pré-contrôle de taille du corps via l'en-tête `Content-Length` :
 	* rejette en 413 (RFC 9110 §15.5.14 « Content Too Large ») AVANT toute lecture
 	* quand le client annonce une taille supérieure à `maxBodySize`. Rideau de
@@ -279,17 +313,6 @@ var HttpRequest = class {
 	*
 	* @throws {HttpError} 413 si `Content-Length` dépasse `maxBodySize`.
 	*/
-	/**
-	* Lit le plafond du corps et les limites d'envoi tels que les voit CETTE
-	* requête : la configuration http, surchargée par le calque que la requête a
-	* pu poser avant la lecture du corps (`overlayConfig`, #494). Hors pipeline
-	* (aucun scope ouvert), la configuration du module telle quelle.
-	*/
-	readBodyLimits() {
-		const options = RequestContext.getScope() !== void 0 ? useConfig("@nodefony/http") : this.context.httpKernel?.module.options;
-		this.uploadOption = options?.upload ?? {};
-		this.maxBodySize = options?.maxBodySize ?? 0;
-	}
 	enforceBodyLimit() {
 		const max = this.maxBodySize;
 		if (max <= 0) return;
@@ -366,6 +389,7 @@ var HttpRequest = class {
 			return this.parser;
 		}
 		const { fields, files } = await this.streamMultipart(bb);
+		this.parser = null;
 		this.body = fields;
 		for (const pf of files) await this.createFileUpload(pf.field, pf.file);
 		this.context.requestEnded = true;
@@ -385,18 +409,33 @@ var HttpRequest = class {
 		return new Promise((resolve, reject) => {
 			const fields = {};
 			const files = [];
+			let order = 0;
 			const pending = [];
 			const tempPaths = [];
 			const openStreams = /* @__PURE__ */ new Set();
 			let totalBytes = 0;
 			let aborted = false;
+			let received = false;
 			const abort = (err) => {
 				if (aborted) return;
 				aborted = true;
 				this.request.unpipe(bb);
 				this.request.resume();
-				for (const ws of openStreams) ws.destroy();
-				Promise.all(tempPaths.map(unlinkQuiet)).finally(() => reject(err));
+				const purge = () => {
+					Promise.all(tempPaths.map(unlinkQuiet)).finally(() => reject(err));
+				};
+				let closing = openStreams.size;
+				if (closing === 0) {
+					purge();
+					return;
+				}
+				for (const ws of openStreams) {
+					ws.once("close", () => {
+						closing -= 1;
+						if (closing === 0) purge();
+					});
+					ws.destroy();
+				}
 			};
 			bb.on("field", (name, value) => {
 				if (aborted) return;
@@ -407,6 +446,8 @@ var HttpRequest = class {
 					stream.resume();
 					return;
 				}
+				const slot = order;
+				order += 1;
 				const field = reg.exec(fieldname)?.[1] ?? fieldname;
 				const ext = filename ? path.extname(filename) : "";
 				const newFilename = `${randomUUID()}${ext}`;
@@ -431,7 +472,7 @@ var HttpRequest = class {
 					ws.on("close", () => {
 						openStreams.delete(ws);
 						if (aborted) return res();
-						files.push({
+						files[slot] = {
 							field,
 							file: {
 								filepath,
@@ -443,7 +484,7 @@ var HttpRequest = class {
 								hashAlgorithm: algo,
 								hash: hasher ? hasher.digest("hex") : null
 							}
-						});
+						};
 						res();
 					});
 				});
@@ -455,6 +496,7 @@ var HttpRequest = class {
 			bb.on("partsLimit", () => abort(new HttpError("too many parts", 413, this.context)));
 			bb.on("error", (e) => abort(e instanceof Error ? e : new Error(String(e))));
 			bb.on("finish", () => {
+				received = true;
 				if (aborted) return;
 				Promise.all(pending).then(() => {
 					if (!aborted) resolve({
@@ -463,10 +505,32 @@ var HttpRequest = class {
 					});
 				}).catch(abort);
 			});
+			this.parser = new MultipartReception((error) => {
+				if (aborted || received) return false;
+				abort(error);
+				return true;
+			});
 			this.request.pipe(bb);
 		});
 	}
 	/**
+	* Interrompt la réception du corps en cours : la promesse de `initialize()`
+	* rejette avec `error`, rendue par le chemin d'erreur habituel — comme un
+	* corps qui dépasse sa limite (413).
+	*
+	* Sert le délai de réception HTTP/2 (`requestTimeout`), que `node:http2` ne
+	* borne pas. Sans effet hors réception : corps déjà reçu, lu en flux par
+	* l'action (`bodyStream`), ou méthode sans corps.
+	*
+	* @param error - la cause rendue au client (408 au délai dépassé)
+	* @returns vrai si une réception en cours a été interrompue
+	*/
+	abortBody(error) {
+		const parser = this.parser;
+		if (parser instanceof Parser || parser instanceof MultipartReception) return parser.fail(error);
+		return false;
+	}
+	/**
 	* Accumule un champ texte multipart. `foo[]` (ou répétition de `foo`) →
 	* tableau ; sinon valeur scalaire. (Anciennement délégué à formidable.)
 	*/
@@ -499,9 +563,25 @@ var HttpRequest = class {
 	}
 	async createFileUpload(name, file) {
 		const fileUpload = await this.context.uploadService?.createUploadFile(file, name);
-		if (fileUpload) (this.#uploads ??= []).push(fileUpload);
+		if (fileUpload) {
+			if (this.#uploads === null) {
+				this.#uploads = [];
+				this.context.onAfterResponse(() => this.#purgeUploads());
+			}
+			this.#uploads.push(fileUpload);
+		}
 		return fileUpload;
 	}
+	/**
+	* Efface, une fois la requête terminée (réponse envoyée ou client parti),
+	* les temporaires que l'action n'a pas déplacés — la règle de PHP. Un
+	* fichier déplacé (`move`/`moveAsync`) n'est plus à son chemin temporaire :
+	* l'effacement n'y trouve rien, et l'erreur est ignorée.
+	*/
+	#purgeUploads() {
+		const uploads = this.#uploads ?? NO_FILES;
+		return Promise.all(uploads.map((upload) => unlinkQuiet(upload.parsedFile.filepath))).then(() => void 0);
+	}
 	getMethod() {
 		return this.request.method;
 	}
@@ -546,8 +626,14 @@ var HttpRequest = class {
 		host = this.getHost();
 		return host === this.#rawHostSource ? this.#rawHostname : hostnameOf(host);
 	}
+	/**
+	* L'autorité de la requête : celle de la cible en forme absolue, sinon
+	* l'en-tête `Host` (RFC 9112 §3.2.2 — le serveur DOIT alors ignorer `Host`).
+	* HTTP/2 lit `:authority` (override).
+	*/
 	getHost() {
-		return this.request.headers.host;
+		const absolute = splitAbsoluteForm(this.request.url);
+		return absolute === null ? this.request.headers.host : absolute.authority;
 	}
 	getRemoteAddress() {
 		if (this.forwarded) return this.forwarded.clientIp;
@@ -556,10 +642,13 @@ var HttpRequest = class {
 	/**
 	* Request-target brut (origin-form) tel que reçu du transport — SOURCE
 	* UNIQUE partagée par la concaténation de {@link getFullUrl} et la découpe
-	* fast-path du ctor. HTTP/2 lit le pseudo-header `:path` (override).
+	* fast-path du ctor. Une cible en forme absolue est ramenée à sa forme
+	* origine, son autorité passant par {@link getHost}. HTTP/2 lit le
+	* pseudo-header `:path` (override).
 	*/
 	getRawTarget() {
-		return this.request.url;
+		const target = this.request.url;
+		return splitAbsoluteForm(target)?.target ?? target;
 	}
 	/**
 	* Scheme effectif côté client : `Forwarded`/`X-Forwarded-*` résolu de façon