@nodefony/http 10.0.0-alpha.1

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

@@ -0,0 +1,543 @@
+import HttpError from "../../errors/httpError.js";
+import { hasForwardingHeaders, resolveForwarded } from "../forwarded.js";
+import { Parser, ParserJson, ParserQs, ParserXml, acceptParser } from "./parser.js";
+import { isCanonicalAuthority, splitTarget } from "./urlFastPath.js";
+import { extend } from "nodefony";
+import { createHash, randomUUID } from "node:crypto";
+import { URL } from "node:url";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import QS from "qs";
+import { Busboy } from "@fastify/busboy";
+//#region nodefony/src/context/http/Request.ts
+const reg = /(.*)[[][\]]$/u;
+/**
+* Supprime un fichier temporaire d'upload sans jamais faire échouer le nettoyage :
+* le fichier peut déjà avoir disparu, et l'erreur d'origine qu'on est en train de
+* remonter doit rester celle que l'appelant voit. Définie au niveau du module —
+* une seule allocation pour tout le processus, jamais une par requête.
+*/
+const unlinkQuiet = (p) => fsp.unlink(p).catch(() => void 0);
+var BodyHandled = class {};
+const BODY_DONE = new BodyHandled();
+const CHARSET_ALIASES = {
+	"utf-8": "utf8",
+	utf8: "utf8",
+	"iso-8859-1": "latin1",
+	latin1: "latin1",
+	"us-ascii": "ascii",
+	ascii: "ascii",
+	"ucs-2": "ucs2",
+	"utf-16le": "utf16le"
+};
+const QUOTE_TRIM = /^["']|["']$/gu;
+const parse = {
+	POST: true,
+	PUT: true,
+	PATCH: true,
+	DELETE: true
+};
+const PERF_PROBE_SUB = process.env.NF_PERF_PROBE === "1";
+function perfMark(field) {
+	const p = globalThis.__nfPerfProbe;
+	if (p && p.t0 !== 0n) p[field] += Number(process.hrtime.bigint() - p.t0);
+}
+var HttpRequest = class {
+	context;
+	request;
+	#url = null;
+	headers = {};
+	host = "";
+	method;
+	contentType;
+	rawContentType = {};
+	domain;
+	remoteAddress = "";
+	hostname;
+	sUrl;
+	/**
+	* Scheme effectif côté client (`http` | `https`, ou le proto `Forwarded`
+	* brut derrière un proxy de confiance) — posé par {@link getFullUrl}, seule
+	* source de cette décision. `HttpContext.setScheme` le lit sans toucher à
+	* l'URL.
+	*/
+	scheme = "http";
+	/**
+	* Pathname de la requête, TOUJOURS sous forme normalisée WHATWG : découpe
+	* du target quand elle est prouvablement identique au parse (fast-path),
+	* `URL.pathname` sinon. C'est la valeur que consomment le router et le
+	* matching de zones du firewall — sans jamais construire l'URL.
+	*/
+	pathname = "";
+	/** Query string au format `URL.search` (`?…`, ou `""`) — même provenance. */
+	search = "";
+	/** L'objet {@link url} a-t-il déjà été construit ? (diagnostic/sonde). */
+	get hasParsedUrl() {
+		return this.#url !== null;
+	}
+	/**
+	* Sérialisation de l'URL de la requête — `URL.href` si l'objet existe,
+	* sinon `sUrl` (identique par construction sur le fast-path). Les lecteurs
+	* descriptifs (logs, profiler, `context.url`) passent par ici : 0 parse.
+	*/
+	get href() {
+		return this.#url === null ? this.sUrl : this.#url.href;
+	}
+	/**
+	* URL WHATWG complète de la requête, construite au premier accès (fast-path)
+	* ou dès le ctor (bail-out). Porte `query` (le GET parsé) comme toujours.
+	*/
+	get url() {
+		let u = this.#url;
+		if (u === null) {
+			u = this.getUrl(this.sUrl);
+			u.query = this.queryGet;
+			this.#url = u;
+		}
+		return u;
+	}
+	set url(u) {
+		this.#url = u;
+	}
+	parser = null;
+	queryPost = {};
+	queryGet = {};
+	queryFile = [];
+	query = {};
+	/**
+	* Le CORPS de la requête, parsé — nom universel de l'écosystème (Express,
+	* Fastify, NestJS), alias de {@link queryPost}.
+	*
+	* Ne pas confondre avec {@link query}, qui FUSIONNE la query string et le
+	* corps : `body` ne rend jamais un paramètre d'URL. Le data plane admin
+	* expose déjà cette sémantique (`IAdminRequest.body`) ; ce getter la rend
+	* disponible partout.
+	*
+	* Getter (aucune allocation) : `queryPost` reste la source unique.
+	*/
+	get body() {
+		return this.queryPost;
+	}
+	queryStringOptions;
+	charset = "utf8";
+	uploadOption = {};
+	maxBodySize = 0;
+	data = Buffer.alloc(0);
+	#accept = null;
+	#acceptHtml = null;
+	/** Media-ranges de l'en-tête `Accept`, parsés au premier accès (mémoïsé). */
+	get accept() {
+		if (this.#accept === null) this.#accept = acceptParser(this.headers?.accept);
+		return this.#accept;
+	}
+	/** `true` si le client accepte `text/html` — résolu au premier accès (mémoïsé). */
+	get acceptHtml() {
+		if (this.#acceptHtml === null) this.#acceptHtml = this.accepts("html");
+		return this.#acceptHtml;
+	}
+	origin;
+	trustedProxy = false;
+	forwarded = null;
+	constructor(request, context) {
+		if (PERF_PROBE_SUB) perfMark("reqStartNs");
+		this.request = request;
+		this.context = context;
+		this.request.body = null;
+		this.headers = request.headers;
+		this.origin = this.headers.origin;
+		const checker = this.context?.httpKernel?.getTrustProxyChecker();
+		const socketAddress = this.request.socket?.remoteAddress;
+		this.trustedProxy = !!checker?.isTrusted(socketAddress);
+		if (this.trustedProxy && checker && hasForwardingHeaders(this.headers)) this.forwarded = resolveForwarded(this.headers, socketAddress, checker);
+		if (PERF_PROBE_SUB) perfMark("reqProxyNs");
+		this.method = this.getMethod();
+		this.host = this.getHost();
+		this.hostname = this.getHostName(this.host);
+		this.sUrl = this.getFullUrl(request);
+		const fast = (this.scheme === "http" || this.scheme === "https") && isCanonicalAuthority(this.host, this.scheme) ? splitTarget(this.getRawTarget()) : null;
+		if (fast !== null) {
+			this.pathname = fast.pathname;
+			this.search = fast.search;
+		} else {
+			const u = this.getUrl(this.sUrl);
+			this.#url = u;
+			this.pathname = u.pathname;
+			this.search = u.search;
+		}
+		if (PERF_PROBE_SUB) perfMark("reqUrlNs");
+		this.queryStringOptions = this.context?.httpKernel?.module.options.queryString || {};
+		this.uploadOption = this.context?.httpKernel?.module.options.upload || {};
+		this.maxBodySize = this.context?.httpKernel?.module.options.maxBodySize ?? 0;
+		let query;
+		if (this.search) query = QS.parse(this.search.slice(1), this.queryStringOptions || {});
+		else query = {};
+		if (this.#url !== null) this.#url.query = query;
+		this.queryGet = query;
+		this.query = query;
+		if (PERF_PROBE_SUB) perfMark("reqQueryNs");
+		this.contentType = this.getContentType(this.request);
+		this.charset = this.getCharset();
+		this.domain = this.getDomain();
+		this.remoteAddress = this.getRemoteAddress();
+		if (PERF_PROBE_SUB) perfMark("reqMetaNs");
+		if (PERF_PROBE_SUB) perfMark("reqAcceptNs");
+	}
+	/**
+	* Fin de corps — émission unique d'`onRequestEnd`. L'alias `body` est posé
+	* ICI sur la requête Node brute (au moment du fire, le corps est parsé) —
+	* remplace le `once("onRequestEnd")` du ctor qui allouait 1 onceWrapper +
+	* 1 closure à CHAQUE requête.
+	*
+	* Il porte le CORPS (`queryPost`), pas la fusion `query` : un seul sens de
+	* `body` dans tout le framework, celui de l'écosystème et d'`IAdminRequest`.
+	*/
+	fireRequestEnd() {
+		this.request.body = this.queryPost;
+		if (this.context.listenerCount("onRequestEnd") === 0) return false;
+		return this.context.fireAsync("onRequestEnd", this);
+	}
+	async initialize() {
+		return this.parseRequest().then(async (parser) => {
+			switch (true) {
+				case parser instanceof ParserXml:
+				case parser instanceof ParserQs:
+				case parser instanceof Parser: try {
+					if (this.context.finished) return;
+					await parser.parse();
+					return this.fireRequestEnd();
+				} catch (error) {
+					return this.context?.httpKernel?.onError(error, this.context);
+				}
+				default: if (!parser) try {
+					if (this.context.finished) return;
+					this.context.requestEnded = true;
+					return this.fireRequestEnd();
+				} catch (error) {
+					return this.context.httpKernel?.onError(error, this.context);
+				}
+			}
+			return parser;
+		}).catch((e) => {
+			throw e;
+		});
+	}
+	/**
+	* 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
+	* tête (client honnête) ; le compteur streaming de {@link Parser.write} couvre
+	* le cas sans `Content-Length` (chunked) ou menteur. No-op si limite à 0.
+	*
+	* @throws {HttpError} 413 si `Content-Length` dépasse `maxBodySize`.
+	*/
+	enforceBodyLimit() {
+		const max = this.maxBodySize;
+		if (max <= 0) return;
+		const cl = this.headers["content-length"];
+		if (cl === void 0) return;
+		const declared = parseInt(Array.isArray(cl) ? cl[0] : cl, 10);
+		if (Number.isFinite(declared) && declared > max) throw new HttpError(`Request body too large: ${declared} bytes > maxBodySize ${max}`, 413, this.context);
+	}
+	async parseRequest() {
+		if (!(this.method in parse)) return this.parser;
+		if (this.contentType !== "multipart/form-data") this.enforceBodyLimit();
+		switch (this.contentType) {
+			case "application/xml":
+			case "text/xml":
+				this.parser = new ParserXml(this);
+				return this.parser;
+			case "application/x-www-form-urlencoded":
+				this.parser = new ParserQs(this);
+				return this.parser;
+			case "multipart/form-data": return this.parseMultipart();
+			default:
+				if (this.contentType === "application/json" || this.contentType?.endsWith("+json")) {
+					const jsonParser = new ParserJson(this);
+					this.parser = jsonParser;
+					await jsonParser.parse();
+					await this.fireRequestEnd();
+					return BODY_DONE;
+				}
+				this.parser = new Parser(this);
+				return this.parser;
+		}
+	}
+	/**
+	* Parse un corps `multipart/form-data` via **busboy** (streaming pur).
+	*
+	* Contrairement à l'ancien chemin formidable, le corps brut n'est **jamais**
+	* bufferisé en RAM : busboy lit le flux, les fichiers sont écrits au fil de
+	* l'eau dans le répertoire temp (`UploadService.path`), seuls les champs
+	* texte (petits) restent en mémoire → fin de la double-bufferisation
+	* (`Parser.chunks` + parser de fichiers) qui doublait la RAM par upload.
+	*
+	* Robustesse / sécurité :
+	* - `new Busboy()` lève **synchroniquement** si le Content-Type n'est pas un
+	*   multipart exploitable (boundary manquant, en-tête absent) → le flux n'a
+	*   pas encore été consommé → bascule sur le `Parser` de secours.
+	* - `limits.fileSize` borne CHAQUE fichier ; `maxTotalFileSize` borne le
+	*   CUMUL par requête (compteur Nodefony) ; `files`/`fields`/`parts` bornent
+	*   la quantité → 413. Toute erreur nettoie les temporaires déjà posés
+	*   (anti-orphelins / saturation disque sur endpoint d'upload public).
+	* - nom temp = `randomUUID()` + extension d'origine → jamais le nom client
+	*   dans le chemin (anti path-traversal).
+	*
+	* @returns la sentinelle `BODY_DONE` (corps déjà traité), ou le `Parser`
+	*   de secours quand le corps n'est pas un multipart.
+	* @throws {HttpError} 413 si une limite de taille/quantité est dépassée.
+	*/
+	async parseMultipart() {
+		let bb;
+		try {
+			bb = new Busboy({
+				headers: this.request.headers,
+				defCharset: this.uploadOption.encoding || "utf8",
+				limits: {
+					fileSize: this.uploadOption.maxFileSize,
+					files: this.uploadOption.maxFiles,
+					fields: this.uploadOption.maxFields,
+					fieldSize: this.uploadOption.maxFieldsSize
+				}
+			});
+		} catch (e) {
+			this.log(`${e.message} : fallback simple parser`, "WARNING");
+			this.parser = new Parser(this);
+			return this.parser;
+		}
+		const { fields, files } = await this.streamMultipart(bb);
+		this.queryPost = fields;
+		this.query = extend({}, this.query, this.queryPost);
+		for (const pf of files) await this.createFileUpload(pf.field, pf.file);
+		this.context.requestEnded = true;
+		await this.fireRequestEnd();
+		return BODY_DONE;
+	}
+	/**
+	* Pilote busboy : pipe le flux requête, écrit chaque fichier dans un temp au
+	* fil de l'eau, accumule les champs texte. Résout `{ fields, files }` à
+	* `finish` (après flush de tous les writes), rejette — avec cleanup des temp
+	* déjà posés — à la moindre erreur ou dépassement de limite.
+	*/
+	streamMultipart(bb) {
+		const dir = this.context.uploadService?.path || this.uploadOption.uploadDir || os.tmpdir();
+		const maxTotal = this.uploadOption.maxTotalFileSize;
+		const algo = this.uploadOption.hashAlgorithm || false;
+		return new Promise((resolve, reject) => {
+			const fields = {};
+			const files = [];
+			const pending = [];
+			const tempPaths = [];
+			const openStreams = /* @__PURE__ */ new Set();
+			let totalBytes = 0;
+			let aborted = 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));
+			};
+			bb.on("field", (name, value) => {
+				if (aborted) return;
+				this.assignField(fields, name, value);
+			});
+			bb.on("file", (fieldname, stream, filename, _enc, mimeType) => {
+				if (aborted) {
+					stream.resume();
+					return;
+				}
+				const match = reg.exec(fieldname);
+				const field = match ? match[1] : fieldname;
+				const ext = filename ? path.extname(filename) : "";
+				const newFilename = `${randomUUID()}${ext}`;
+				const filepath = path.join(dir, newFilename);
+				tempPaths.push(filepath);
+				const hasher = algo ? createHash(algo) : null;
+				const ws = fs.createWriteStream(filepath);
+				openStreams.add(ws);
+				let size = 0;
+				stream.on("data", (chunk) => {
+					size += chunk.length;
+					totalBytes += chunk.length;
+					hasher?.update(chunk);
+					if (maxTotal && totalBytes > maxTotal) abort(new HttpError(`maxTotalFileSize exceeded (${maxTotal} bytes)`, 413, this.context));
+				});
+				stream.on("limit", () => {
+					abort(new HttpError(`maxFileSize exceeded for ${filename || field}`, 413, this.context));
+				});
+				const done = new Promise((res, rej) => {
+					stream.on("error", rej);
+					ws.on("error", rej);
+					ws.on("close", () => {
+						openStreams.delete(ws);
+						if (aborted) return res();
+						files.push({
+							field,
+							file: {
+								filepath,
+								newFilename,
+								originalFilename: filename || null,
+								mimetype: mimeType || null,
+								size,
+								mtime: /* @__PURE__ */ new Date(),
+								hashAlgorithm: algo,
+								hash: hasher ? hasher.digest("hex") : null
+							}
+						});
+						res();
+					});
+				});
+				pending.push(done.catch((e) => abort(e instanceof Error ? e : new Error(String(e)))));
+				stream.pipe(ws);
+			});
+			bb.on("filesLimit", () => abort(new HttpError("too many files", 413, this.context)));
+			bb.on("fieldsLimit", () => abort(new HttpError("too many fields", 413, this.context)));
+			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", () => {
+				if (aborted) return;
+				Promise.all(pending).then(() => {
+					if (!aborted) resolve({
+						fields,
+						files
+					});
+				}).catch(abort);
+			});
+			this.request.pipe(bb);
+		});
+	}
+	/**
+	* Accumule un champ texte multipart. `foo[]` (ou répétition de `foo`) →
+	* tableau ; sinon valeur scalaire. (Anciennement délégué à formidable.)
+	*/
+	assignField(fields, name, value) {
+		const match = reg.exec(name);
+		const key = match ? match[1] : name;
+		if (key in fields) {
+			const cur = fields[key];
+			if (Array.isArray(cur)) cur.push(value);
+			else fields[key] = [cur, value];
+		} else fields[key] = match ? [value] : value;
+	}
+	accepts(Type) {
+		let parts = [];
+		let subtype = "*";
+		let type = "*";
+		if (Type) parts = Type.split("/");
+		if (parts) switch (parts.length) {
+			case 1:
+				subtype = parts.shift();
+				break;
+			case 2:
+				type = parts.shift();
+				subtype = parts.shift();
+				break;
+			default: throw new Error("request accepts method bad type format");
+		}
+		for (let i = 0; i < this.accept.length; i++) {
+			const line = this.accept[i];
+			if ((type === "*" || line.type.test(type)) && (subtype === "*" || line.subtype.test(subtype))) return true;
+		}
+		return false;
+	}
+	async createFileUpload(name, file) {
+		const fileUpload = await this.context.uploadService?.createUploadFile(file, name);
+		if (fileUpload) this.queryFile.push(fileUpload);
+		return fileUpload;
+	}
+	getMethod() {
+		return this.request.method;
+	}
+	getContentType(request) {
+		if (request.headers["content-type"]) {
+			const tab = request.headers["content-type"].split(";");
+			if (tab.length > 1) for (let i = 1; i < tab.length; i++) if (typeof tab[i] === "string") {
+				const ele = tab[i].split("=");
+				const key = ele[0].replace(/\s+/g, "").toLowerCase();
+				this.rawContentType[key] = ele[1];
+			} else continue;
+			return tab[0];
+		}
+		return null;
+	}
+	/**
+	* Charset du corps déduit du `Content-Type` (`charset=…`), normalisé en un
+	* `BufferEncoding` Node valide. Les alias IANA courants sont mappés
+	* (`iso-8859-1` → `latin1`, `us-ascii` → `ascii`…) ; tout charset inconnu ou
+	* non supporté par Node retombe sur `utf8` — JAMAIS de throw `.toString()`
+	* sur un encoding invalide (erreur propre, pas de 500 sur charset exotique).
+	*/
+	getCharset() {
+		const raw = this.rawContentType.charset;
+		if (!raw) return "utf8";
+		const normalized = raw.trim().toLowerCase().replace(QUOTE_TRIM, "");
+		const enc = CHARSET_ALIASES[normalized] ?? normalized;
+		return Buffer.isEncoding(enc) ? enc : "utf8";
+	}
+	getDomain() {
+		return this.getHostName();
+	}
+	getUserAgent() {
+		return this.request.headers["user-agent"];
+	}
+	getHostName(host) {
+		if (this.#url?.hostname) return this.#url.hostname;
+		if (host) return host.split(":")[0];
+		if (host = this.getHost()) return host.split(":")[0];
+		return "";
+	}
+	getHost() {
+		return this.request.headers.host;
+	}
+	getRemoteAddress() {
+		if (this.forwarded) return this.forwarded.clientIp;
+		return this.request.socket?.remoteAddress ?? null;
+	}
+	/**
+	* 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).
+	*/
+	getRawTarget() {
+		return this.request.url;
+	}
+	/**
+	* Scheme effectif côté client : `Forwarded`/`X-Forwarded-*` résolu de façon
+	* canonique (this.forwarded, gated proxy de confiance) ; sinon le transport
+	* réel. HTTP/2 remplace la lecture du socket par le pseudo-header `:scheme`.
+	*/
+	resolveScheme(request) {
+		if (this.forwarded?.proto) return this.forwarded.proto;
+		if ("encrypted" in request.socket && request.socket.encrypted) return "https";
+		return "http";
+	}
+	getFullUrl(request = this.request) {
+		this.scheme = this.resolveScheme(request);
+		return `${this.scheme}://${this.host}${this.getRawTarget()}`;
+	}
+	getHeader(name) {
+		if (name in this.headers) return this.headers[name];
+		return null;
+	}
+	setUrl(Url) {
+		const u = this.getUrl(Url);
+		this.#url = u;
+		this.sUrl = u.href;
+		this.pathname = u.pathname;
+		this.search = u.search;
+		this.scheme = u.protocol.replace(":", "");
+		return u;
+	}
+	getUrl(sUrl, baseUrl) {
+		return new URL(sUrl, baseUrl);
+	}
+	log(pci, severity, msgid, msg) {
+		if (!msgid) msgid = `${this.context.type} REQUEST `;
+		return this.context.log(pci, severity, msgid, msg);
+	}
+};
+//#endregion
+export { HttpRequest as default };