@nodefony/http 10.0.0-alpha.9 → 10.0.0-beta.1

package/dist/nodefony/src/context/Context.js

@@ -141,7 +141,7 @@ var Context = class extends Service {
 	scheme;
 	webSocketState = null;
 	constructor(container, type) {
-		super(`${type}`, container);
+		super(type, container);
 		if (PERF_PROBE_SUB) {
 			const p = globalThis.__nfPerfProbe;
 			if (p && p.t0 !== 0n) p.svcNs += Number(process.hrtime.bigint() - p.t0);
@@ -227,7 +227,7 @@ var Context = class extends Service {
 	}
 	phaseStart(name) {
 		if (!this._timingEnabled) return;
-		if (this._phaseIndex === null) this._phaseIndex = /* @__PURE__ */ new Map();
+		this._phaseIndex ??= /* @__PURE__ */ new Map();
 		const idx = this.phases.length;
 		this.phases.push({
 			name,
@@ -239,8 +239,8 @@ var Context = class extends Service {
 		if (!this._timingEnabled || this._phaseIndex === null) return;
 		const idx = this._phaseIndex.get(name);
 		if (idx === void 0) return;
-		const p = this.phases[idx];
-		if (p.endMs !== void 0) return;
+		const p = this.phases.at(idx);
+		if (p === void 0 || p.endMs !== void 0) return;
 		p.endMs = performance.now();
 		p.durationMs = p.endMs - p.startMs;
 	}
@@ -250,15 +250,28 @@ var Context = class extends Service {
 			Promise.resolve().then(() => boundFn(this)).catch((e) => this.log(e, "ERROR", "onAfterResponse(late)"));
 			return;
 		}
-		if (this._afterResponseFns === null) this._afterResponseFns = [];
+		this._afterResponseFns ??= [];
 		this._afterResponseFns.push(boundFn);
 	}
-	async _runAfterResponse() {
-		if (this._afterResponseFired) return;
+	/**
+	* Exécute les hooks `onAfterResponse`, une seule fois, dans l'ordre
+	* d'enregistrement ; un hook qui lève est journalisé sans arrêter les suivants.
+	*
+	* @returns `undefined` quand aucun hook n'est enregistré (le cas nominal) ou
+	*   qu'ils ont déjà tourné : rien à attendre, le démontage continue sans
+	*   suspension. Une `Promise` sinon, réglée quand le dernier hook a fini — elle
+	*   ne rejette jamais.
+	*/
+	_runAfterResponse() {
+		if (this._afterResponseFired) return void 0;
 		this._afterResponseFired = true;
 		const fns = this._afterResponseFns;
-		if (fns === null || fns.length === 0) return;
+		if (fns === null || fns.length === 0) return void 0;
 		this._afterResponseFns = null;
+		return this.runAfterResponseHooks(fns);
+	}
+	/** Boucle des hooks `onAfterResponse` — séquentielle, erreurs journalisées. */
+	async runAfterResponseHooks(fns) {
 		for (const fn of fns) try {
 			await fn(this);
 		} catch (e) {
@@ -298,7 +311,7 @@ var Context = class extends Service {
 	* notable → INFO (EVENT_SEVERITY), event technique → DEBUG.
 	*/
 	logEvent(event) {
-		if (lifecycleEventLogging === null) lifecycleEventLogging = this.kernel?.environment !== "production";
+		lifecycleEventLogging ??= this.kernel?.environment !== "production";
 		if (!lifecycleEventLogging) return;
 		this.log(`${colorLogEvent()} ${event}`, EVENT_SEVERITY[event] || "DEBUG");
 	}
@@ -327,7 +340,9 @@ var Context = class extends Service {
 			if (logger.shouldSample && !logger.shouldSample(this, err)) return;
 			const entry = logger.renderHttp(this, err);
 			return this.log(entry.text, entry.severity, entry.msgid);
-		} catch {}
+		} catch {
+			return;
+		}
 	}
 	/**
 	* P3.7 — Émet au teardown un log DEBUG détaillant la durée de chaque phase du
@@ -339,18 +354,18 @@ var Context = class extends Service {
 	logPhasesVerbose() {
 		if (!this._timingVerbose) return;
 		const phases = this.phases;
-		const n = phases.length;
-		if (n === 0) return;
+		if (phases.length === 0) return;
 		let line = "";
 		let total = 0;
-		for (let i = 0; i < n; i++) {
-			const p = phases[i];
+		let i = 0;
+		for (const p of phases) {
 			const d = p.durationMs ?? (p.endMs !== void 0 ? p.endMs - p.startMs : void 0);
 			if (i > 0) line += " · ";
 			if (d !== void 0) {
 				line += `${p.name}=${d.toFixed(2)}ms`;
 				total += d;
 			} else line += `${p.name}=…`;
+			i++;
 		}
 		this.log(`TRACE phases [Σ ${total.toFixed(2)}ms] ${line}`, "DEBUG", `${this.type} TIMING`);
 	}
@@ -363,11 +378,12 @@ var Context = class extends Service {
 		}
 	}
 	getRequestCookies(name) {
-		if (name) return this.cookies[name] || null;
+		if (name) return Object.hasOwn(this.cookies, name) ? this.cookies[name] ?? null : null;
 		return this.cookies;
 	}
 	setCookie(cookie) {
-		if (cookie) return this.response?.addCookie(cookie);
+		const received = cookie;
+		if (received) return this.response?.addCookie(received);
 	}
 	getRequest() {
 		return this.request;
@@ -387,8 +403,7 @@ var Context = class extends Service {
 		return Boolean(this.cookieSession);
 	}
 	getCookieSession(name) {
-		if (this.cookies[name]) return this.cookies[name];
-		return null;
+		return Object.hasOwn(this.cookies, name) ? this.cookies[name] ?? null : null;
 	}
 	/**
 	* Nom effectif du cookie de session pour CE transport. Sur TLS (https/wss) on
@@ -401,7 +416,7 @@ var Context = class extends Service {
 	*/
 	getSessionCookieName() {
 		const base = this.sessionService?.defaultSessionName ?? "nodefony";
-		const mode = (this.sessionService?.options?.cookie)?.hostPrefix ?? "auto";
+		const mode = (this.sessionService?.options.cookie)?.hostPrefix ?? "auto";
 		const tls = this.scheme === "https" || this.scheme === "wss";
 		return mode === true || mode === "auto" && tls ? `__Host-${base}` : base;
 	}

package/dist/nodefony/src/context/forwarded.js

@@ -8,7 +8,7 @@ import { isIPv4 } from "node:net";
 * un point de coupe. Les `\"` échappés à l'intérieur des guillemets sont préservés.
 */
 function splitTopLevel(input, sep) {
-	if (input.indexOf("\"") === -1) return input.split(sep);
+	if (!input.includes("\"")) return input.split(sep);
 	const out = [];
 	let buf = "";
 	let inQuote = false;
@@ -43,7 +43,7 @@ function splitTopLevel(input, sep) {
 /** Retire les guillemets d'une `quoted-string` et déséchappe `\x` (RFC 7230 §3.2.6). */
 function unquote(value) {
 	const v = value.trim();
-	if (v.length >= 2 && v[0] === "\"" && v[v.length - 1] === "\"") return v.slice(1, -1).replace(/\\(.)/gu, "$1");
+	if (v.length >= 2 && v.startsWith("\"") && v.endsWith("\"")) return v.slice(1, -1).replace(/\\(.)/gu, "$1");
 	return v;
 }
 /**
@@ -104,11 +104,11 @@ function forwardedNodeIp(node) {
 	if (!node) return null;
 	const n = node.trim();
 	if (!n) return null;
-	if (n[0] === "[") {
+	if (n.startsWith("[")) {
 		const end = n.indexOf("]");
 		return end > 1 ? n.slice(1, end) : null;
 	}
-	if (n === "unknown" || n[0] === "_") return null;
+	if (n === "unknown" || n.startsWith("_")) return null;
 	const colon = n.indexOf(":");
 	const host = colon === -1 ? n : n.slice(0, colon);
 	return isIPv4(host) ? host : host || null;

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

@@ -7,7 +7,7 @@ import HttpResponse from "./Response.js";
 import Http2Request from "../http2/Request.js";
 import Http2Response from "../http2/Response.js";
 import { describeSessionStoreFailure } from "../../session/sessionStoreFailure.js";
-import { extend, typeOf } from "nodefony";
+import { extend, finallyMaybe, isPromise, thenMaybe, typeOf } from "nodefony";
 import url, { URL } from "node:url";
 //#region nodefony/src/context/http/HttpContext.ts
 const socketActiveContext = /* @__PURE__ */ new WeakMap();
@@ -20,7 +20,6 @@ var HttpContext = class extends Context {
 	request;
 	response;
 	uploadService;
-	csrf;
 	constructor(container, request, response, type) {
 		super(container, type);
 		this.uploadService = this.get("upload");
@@ -97,18 +96,28 @@ var HttpContext = class extends Context {
 		if (req.hasParsedUrl) return req.url.protocol.replace(":", "");
 		return req.scheme;
 	}
-	async handle() {
+	/**
+	* Sert la requête : délai de réponse, hooks `onRequest`, puis l'action
+	* résolue et son rendu (`resolver.callController()`).
+	*
+	* Pas `async` : synchrone quand l'action et son rendu le sont, rien n'y est
+	* alors attendu (#505).
+	*
+	* @returns ce que rend `callController()` — le résultat du rendu, pas le
+	*   contexte (comportement historique, conservé) —, ou sa promesse. Sur une
+	*   redirection déjà posée : le contexte, une fois l'envoi fait.
+	* @throws HttpError 404, de façon SYNCHRONE, quand aucune route ne résout.
+	*/
+	handle() {
 		this.setTimeout();
-		if (this.isRedirect) {
-			await this.send();
-			return this;
-		}
+		if (this.isRedirect) return thenMaybe(this.send(), () => this);
 		this.fire("onRequest", this);
-		this.kernel?.fire("onRequest", this);
+		const kernel = this.kernel;
+		if (kernel && (kernel.debug || kernel.listenerCount("onRequest") > 0)) kernel.fire("onRequest", this);
 		if (!this.resolver && this.router) this.resolver = this.router.resolve(this);
-		if (this.resolver && this.resolver.resolve) {
+		if (this.resolver?.resolve) {
 			this.setMetaData();
-			return await this.resolver.callController();
+			return this.resolver.callController();
 		}
 		throw new HttpError("", 404, this);
 	}
@@ -117,7 +126,7 @@ var HttpContext = class extends Context {
 		if (!res) return;
 		if (this.response.stream) {
 			res.setTimeout(this.response.timeout, () => {
-				if (!this.response?.response?.writableEnded) this._onTimeout();
+				if (!this.response.response?.writableEnded) this._onTimeout();
 			});
 			return;
 		}
@@ -130,27 +139,28 @@ var HttpContext = class extends Context {
 			socketTimeoutArmed.add(socket);
 			socket.on("timeout", () => {
 				const ctx = socketActiveContext.get(socket);
-				if (ctx && !ctx.response?.response?.writableEnded) ctx._onTimeout();
+				if (ctx && !ctx.response.response?.writableEnded) ctx._onTimeout();
 			});
 		}
 	}
-	async render(chunk, encoding, status, headers) {
+	/**
+	* Sérialise la donnée selon son type (JSON, HTML, texte), pose statut et
+	* en-têtes, puis l'envoie ({@link send}). Synchrone quand l'envoi l'est (#505).
+	*
+	* @returns la réponse, ou sa promesse.
+	* @throws de façon SYNCHRONE ce que lèvent la sérialisation ou l'envoi.
+	*/
+	render(chunk, encoding, status, headers) {
 		let data = chunk;
-		switch (true) {
-			case this.isJson:
+		if (this.isJson) data = JSON.stringify(chunk);
+		else {
+			const type = typeOf(chunk);
+			if (type === "object") {
+				this.setContextJson();
 				data = JSON.stringify(chunk);
-				break;
-			case this.isHtml:
-			default: switch (typeOf(chunk)) {
-				case "object":
-					this.setContextJson();
-					data = JSON.stringify(chunk);
-					break;
-				case "string":
-					if (this.response.contentType === "application/octet-stream") this.setContextHtml();
-					break;
-				default: if (this.response.contentType === "application/octet-stream") this.response.setContentType("text");
-			}
+			} else if (type === "string") {
+				if (this.response.contentType === "application/octet-stream") this.setContextHtml();
+			} else if (this.response.contentType === "application/octet-stream") this.response.setContentType("text");
 		}
 		if (headers) this.response.setHeaders(headers);
 		if (status) this.response.setStatusCode(status);
@@ -161,83 +171,118 @@ var HttpContext = class extends Context {
 			this.log(describeSessionStoreFailure(e).message, "CRITIC", "SESSION-STORE");
 			return null;
 		}).then(async (_session) => {
-			return this.close().catch((e) => {
-				throw e;
-			});
+			return this.close();
 		});
 	}
-	async send(chunk, encoding) {
+	/**
+	* Envoie la réponse : session sauvée, hook `onSend`, en-têtes, corps, puis
+	* fin de la réponse.
+	*
+	* Synchrone dans le cas nominal — aucune session ouverte, aucun écouteur
+	* `onSend`, réponse unique : rien n'y est à attendre (#505). Une promesse
+	* seulement quand une étape attend réellement (écriture du store de session,
+	* hook asynchrone, streaming chunké, flux HTTP/2).
+	*
+	* @param chunk - le corps ; absent, le corps déjà posé sur la réponse.
+	* @param encoding - l'encodage d'un corps texte.
+	* @returns la réponse, ou sa promesse.
+	* @throws de façon SYNCHRONE `Response Already sended` quand la réponse est
+	*   déjà partie, et ce que lève une étape synchrone de l'envoi.
+	*/
+	send(chunk, encoding) {
 		if (this.finished && !this.sended) {
 			this.log("send() on finished context — client disconnected", "DEBUG");
 			return this.response;
 		}
-		if (this.sended || this.finished || this.response.isHeaderSent()) return new Promise((_resolve, reject) => {
-			return reject(/* @__PURE__ */ new Error("Response Already sended"));
-		});
-		if (!this.timingEnabled) return this.#doSend(chunk, encoding);
+		if (this.sended || this.finished || this.response.isHeaderSent()) throw new Error("Response Already sended");
+		if (!this.timingEnabled) return this.doSend(chunk, encoding);
 		this.phaseStart("send");
-		try {
-			return await this.#doSend(chunk, encoding);
-		} finally {
-			this.phaseEnd("send");
-		}
+		return finallyMaybe(() => this.doSend(chunk, encoding), () => this.phaseEnd("send"));
 	}
-	async #doSend(chunk, encoding) {
+	/**
+	* Le travail de {@link send}, journalisé en ERROR quand il échoue — de façon
+	* synchrone ou par rejet, selon l'étape qui échoue.
+	*/
+	doSend(chunk, encoding) {
+		let sent;
 		try {
-			let body = chunk;
-			if (this.session != null) try {
-				await this.saveSession();
-			} catch (e) {
-				const failure = describeSessionStoreFailure(e);
-				this.log(failure.message, "CRITIC", "SESSION-STORE");
-				this.response.statusCode = failure.statusCode;
-				body = failure.body;
-			}
-			if (body) this.response?.setBody(body);
-			if (this.listenerCount("onSend") > 0) await this.fireAsync("onSend", this.response, this);
-			try {
-				this.writeHead();
-			} catch (e) {
-				this.log(e, "WARNING");
-			}
-			if (this.isRedirect) return await this.close();
-			return await this.write(body, encoding);
+			sent = this.sendSteps(chunk, encoding);
 		} catch (error) {
 			this.log(error, "ERROR");
 			throw error;
 		}
+		if (!isPromise(sent)) return sent;
+		return sent.catch((error) => {
+			this.log(error, "ERROR");
+			throw error;
+		});
+	}
+	/** Session, puis hook `onSend`, puis en-têtes et corps — chacun attendu seulement s'il attend. */
+	sendSteps(chunk, encoding) {
+		if (this.session != null) return this.saveSession().then(() => this.emitAndWrite(chunk, encoding), (e) => {
+			const failure = describeSessionStoreFailure(e);
+			this.log(failure.message, "CRITIC", "SESSION-STORE");
+			this.response.statusCode = failure.statusCode;
+			return this.emitAndWrite(failure.body, encoding);
+		});
+		return this.emitAndWrite(chunk, encoding);
+	}
+	/** Hook `onSend` (attendu seulement s'il a un écouteur), puis en-têtes et corps. */
+	emitAndWrite(body, encoding) {
+		if (body) this.response.setBody(body);
+		if (this.listenerCount("onSend") > 0) return this.fireAsync("onSend", this.response, this).then(() => this.writeHeadAndBody(body, encoding));
+		return this.writeHeadAndBody(body, encoding);
+	}
+	/** En-têtes, puis corps — ou la seule fin de réponse pour une redirection. */
+	writeHeadAndBody(body, encoding) {
+		try {
+			this.writeHead();
+		} catch (e) {
+			this.log(e, "WARNING");
+		}
+		if (this.isRedirect) return this.close();
+		return this.write(body, encoding);
 	}
 	writeHead(statusCode, headers) {
-		if (this.response) {
-			if (this.csrfToken) this.setCookie(new Cookie("csrf-token", this.csrfToken, {
-				httpOnly: false,
-				sameSite: "Strict",
-				secure: this.scheme === "https",
-				path: "/"
-			}));
-			this.response.setCookies();
-			this.response.writeHead(statusCode, headers);
-		}
+		if (this.csrfToken) this.setCookie(new Cookie("csrf-token", this.csrfToken, {
+			httpOnly: false,
+			sameSite: "Strict",
+			secure: this.scheme === "https",
+			path: "/"
+		}));
+		this.response.setCookies();
+		this.response.writeHead(statusCode, headers);
 	}
-	async write(chunk, encoding, _flush = false) {
-		await this.response.send(chunk, encoding || this.response.encoding).then(() => {
+	/**
+	* Écrit le corps, puis termine la requête ({@link close}). Synchrone pour une
+	* réponse unique (#505).
+	*
+	* @returns la réponse, ou sa promesse quand l'écriture attend.
+	*/
+	write(chunk, encoding, _flush = false) {
+		return thenMaybe(this.response.send(chunk, encoding || this.response.encoding), () => {
 			this.sended = true;
-		}).catch((e) => {
-			throw e;
-		});
-		return this.close().catch((e) => {
-			throw e;
+			return this.close();
 		});
 	}
 	flush(chunk, encoding) {
 		return this.response.flush(chunk, encoding);
 	}
-	async close() {
-		if (this.listenerCount("onClose") > 0) await this.fireAsync("onClose", this);
-		if (this.response?.response?.writableEnded) return this.response;
-		return this.response.end().then(() => this.response).catch((e) => {
-			throw e;
-		});
+	/**
+	* Termine la requête : hook `onClose`, puis fin de la réponse si l'envoi ne
+	* l'a pas déjà faite. Synchrone sans écouteur `onClose` (#505).
+	*
+	* @returns la réponse, ou sa promesse quand le hook attend.
+	*/
+	close() {
+		if (this.finished) return this.response;
+		if (this.listenerCount("onClose") > 0) return this.fireAsync("onClose", this).then(() => this.endResponse());
+		return this.endResponse();
+	}
+	/** Fin de la réponse, sauf si l'envoi l'a déjà terminée. */
+	endResponse() {
+		if (this.response.response?.writableEnded) return this.response;
+		return thenMaybe(this.response.end(), () => this.response);
 	}
 	redirect(Url, status, headers) {
 		if (typeof Url === "object") return this.response.redirect(url.format(Url), status, headers);
@@ -280,25 +325,25 @@ var HttpContext = class extends Context {
 		return this.redirect(newUrl, status, headers);
 	}
 	getHostName() {
-		return this.request?.getHostName();
+		return this.request.getHostName();
 	}
 	getRemoteAddress() {
-		return this.request?.getRemoteAddress();
+		return this.request.getRemoteAddress();
 	}
 	getHost() {
-		return this.request?.getHost();
+		return this.request.getHost();
 	}
 	getUserAgent() {
-		return this.request?.getUserAgent();
+		return this.request.getUserAgent();
 	}
 	getMethod() {
-		return this.request?.getMethod();
+		return this.request.getMethod();
 	}
 	setContentType(type, encoding) {
 		return this.response.setContentType(type, encoding);
 	}
 	resolveIsHtml() {
-		return this.request?.acceptHtml ?? false;
+		return this.request.acceptHtml;
 	}
 	setDefaultContentType() {
 		if (this.isHtml) this.response.setContentType("html", "utf-8");