@nodefony/http 10.0.0-beta.2 → 10.0.0-beta.3

package/dist/nodefony/service/http-kernel.js

@@ -4,6 +4,8 @@ import { resolveForwarded } from "../src/context/forwarded.js";
 import { MemoryRateLimitStore } from "../src/rateLimit/MemoryRateLimitStore.js";
 import { WsConnectionCounter } from "../src/rateLimit/WsConnectionCounter.js";
 import { compileDomainPatterns, compileTrustedHosts, isDomainAllowed } from "../src/context/domainMatcher.js";
+import { responseEnded } from "../src/context/responseEnded.js";
+import { parseWebsocketUrl } from "../src/context/websocket/websocketUrl.js";
 import WebsocketContext from "../src/context/websocket/WebsocketContext.js";
 import HttpContext from "../src/context/http/HttpContext.js";
 import DefaultErrorRenderer from "./error-renderer.js";
@@ -12,9 +14,9 @@ import JsonAuditLogger from "./audit-logger.js";
 import PrettyRequestLogger from "./pretty-request-logger.js";
 import { resolveTraceparent } from "./trace.js";
 import { asServersConfig, configuredServerPort } from "../src/servers/kernelServers.js";
-import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorate.js";
-import { GcScheduler, Module, RequestContext, Service, finallyMaybe, injectable, isPromise, logColor, nodefonyError, servedUrl, thenMaybe, writeRuntimeState } from "nodefony";
+import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.js";
+import { GcScheduler, IDENTITY_CHANGED_EVENT, Module, RequestContext, RevocationWatch, Service, finallyMaybe, injectable, isPromise, logColor, nodefonyError, servedUrl, thenMaybe, writeRuntimeState } from "nodefony";
 import cluster from "node:cluster";
 import http from "node:http";
 import Ws from "ws";
@@ -67,13 +69,37 @@ let HttpKernel = class HttpKernel extends Service {
 	cert = "";
 	ca = "";
 	serverStatic = null;
+	/**
+	* Proxy inverse (`reverse-proxy`) — lu à chaque requête avant le routage ;
+	* `mounts === null` tant que personne n'a monté de préfixe.
+	*/
+	reverseProxy = null;
 	domain = "";
 	trustedHosts;
-	domainCheck = false;
+	/**
+	* Contrôle de domaine actif (`domainCheck` de la config d'application) —
+	* lu à la source, pour le HTTP comme pour le handshake WebSocket.
+	*/
+	get domainCheck() {
+		return this.kernel?.options.domainCheck === true;
+	}
 	regAlias = [];
 	module;
-	httpsPort;
-	httpPort;
+	/**
+	* Port du serveur HTTPS effectivement lié, `undefined` s'il est inactif —
+	* lu sur le serveur, jamais recopié (lu par `HttpContext.redirectHttps`).
+	*/
+	get httpsPort() {
+		return this.boundPort("server-https");
+	}
+	/** Port du serveur HTTP effectivement lié, `undefined` s'il est inactif. */
+	get httpPort() {
+		return this.boundPort("server-http");
+	}
+	boundPort(name) {
+		const server = this.get(name);
+		return server?.active === true && server.port > 0 ? server.port : void 0;
+	}
 	responseTimeout;
 	closeTimeOutWs;
 	secContentTypeOptions = null;
@@ -90,6 +116,7 @@ let HttpKernel = class HttpKernel extends Service {
 	rateLimiter = null;
 	rateLimitGc = null;
 	#wsConnCounter = null;
+	#streams = null;
 	#healthPaths = null;
 	#healthShutdownDelay = 0;
 	#terminating = false;
@@ -108,6 +135,9 @@ let HttpKernel = class HttpKernel extends Service {
 			wss: this.options.websocketSecure.closeTimeout
 		};
 		this.computeSecurityHeaderCaches();
+		this.kernel?.on(IDENTITY_CHANGED_EVENT, (event) => {
+			this.#streams?.refreshIdentity(event.identifier);
+		});
 	}
 	/**
 	* (Re)calcule les caches dérivés des en-têtes de sécurité depuis `this.options`
@@ -244,6 +274,7 @@ let HttpKernel = class HttpKernel extends Service {
 		this.kernel?.prependOnceListener("onReady", () => {
 			this.serviceCerticats = this.get("certificates");
 			this.serverStatic = this.get("server-static");
+			this.reverseProxy = this.get("reverse-proxy");
 			this.domain = this.kernel?.domain;
 			this.trustedHosts = this.options.trustedHosts;
 			this.regAlias = this.compileAlias();
@@ -307,6 +338,35 @@ let HttpKernel = class HttpKernel extends Service {
 		return policy;
 	}
 	/**
+	* L'`Origin` d'un handshake WebSocket est-elle acceptée ? Règle UNIQUE,
+	* interrogeable SANS contexte : le serveur WebSocket de Nodefony
+	* ({@link checkWebsocketOrigin}) et le proxy inverse, qui relaie un upgrade
+	* avant qu'aucun contexte n'existe, décident par elle.
+	*
+	* Same-origin (nom de l'`Origin` = nom servi, port ignoré), loopback toléré
+	* en development, allowlist `allowedOrigins` ; sans `Origin` (client
+	* non-navigateur) → acceptée. Doctrine complète : {@link checkWebsocketOrigin}.
+	*
+	* @param origin - valeur brute de l'en-tête `Origin`
+	* @param hostname - nom d'hôte servi, sans port (`Context.domain`)
+	* @param secure - handshake reçu en TLS (politique `websocketSecure`)
+	* @returns `true` si le handshake peut se poursuivre
+	*/
+	isWebsocketOriginAllowed(origin, hostname, secure) {
+		const policy = this.getWsOriginPolicy(secure ? "websocketSecure" : "websocket");
+		if (policy.disabled) return true;
+		if (!origin) return true;
+		let originHost = null;
+		try {
+			originHost = new URL(origin).hostname;
+		} catch {
+			return false;
+		}
+		if (originHost === hostname) return true;
+		if (this.kernel?.environment === "development" && WS_DEV_LOOPBACK.has(originHost)) return true;
+		return policy.extra.length > 0 && isDomainAllowed(policy.extra, originHost);
+	}
+	/**
 	* B4 — Validation d'`Origin` au handshake WebSocket (anti-CSWSH, OWASP
 	* WSTG-CLNT-10). Les navigateurs n'appliquent PAS CORS aux WebSockets : sans
 	* ce contrôle, une page tierce peut ouvrir un WS **authentifié par le cookie de
@@ -322,22 +382,9 @@ let HttpKernel = class HttpKernel extends Service {
 	* @throws {HttpError} code WS 1008 (Policy Violation) si l'Origin est refusée.
 	*/
 	checkWebsocketOrigin(context) {
-		const cfgKey = context.type === "websocket-secure" ? "websocketSecure" : "websocket";
-		const policy = this.getWsOriginPolicy(cfgKey);
-		if (policy.disabled) return;
+		const secure = context.type === "websocket-secure";
 		const raw = context.origin;
-		if (!raw) return;
-		let originHost = null;
-		try {
-			originHost = new URL(raw).hostname;
-		} catch {
-			originHost = null;
-		}
-		if (originHost) {
-			if (originHost === context.domain) return;
-			if (this.kernel?.environment === "development" && WS_DEV_LOOPBACK.has(originHost)) return;
-			if (policy.extra.length && isDomainAllowed(policy.extra, originHost)) return;
-		}
+		if (this.isWebsocketOriginAllowed(raw, context.domain, secure)) return;
 		const error = new HttpError(`WebSocket Origin "${raw}" not allowed (CSWSH protection)`, 1008, context);
 		error.type = "origin";
 		throw error;
@@ -483,7 +530,7 @@ let HttpKernel = class HttpKernel extends Service {
 	*/
 	/**
 	* Override the default error renderer — e.g. to hide stack traces in prod
-	* or emit RFC 7807 problem+json. Stateless singleton expected.
+	* or emit RFC 9457 problem+json. Stateless singleton expected.
 	*/
 	setErrorRenderer(renderer) {
 		this.errorRenderer = renderer;
@@ -504,6 +551,10 @@ let HttpKernel = class HttpKernel extends Service {
 	async onError(error, context, _extraHeaders) {
 		if (context) context.error = error;
 		if (context instanceof HttpContext) {
+			if (context.isRedirect && error.code === 401) {
+				if (!(context.finished || context.sended)) await context.send();
+				return context;
+			}
 			const result = this.errorRenderer.renderHttp(error, context);
 			if (error instanceof HttpError || error instanceof nodefonyError) error.code = result.status;
 			context.response.setStatusCode(result.status, http.STATUS_CODES[result.status] ?? "Unknown Error");
@@ -514,6 +565,10 @@ let HttpKernel = class HttpKernel extends Service {
 				return context;
 			}
 			if (!context.response.isHeaderSent()) {
+				if (context.isRedirect) {
+					context.isRedirect = false;
+					context.response.response?.removeHeader("Location");
+				}
 				try {
 					await context.render(result.body);
 				} catch (e) {
@@ -799,7 +854,7 @@ let HttpKernel = class HttpKernel extends Service {
 				perfProbe.t0 = 0n;
 			} else context = new HttpContext(scope, request, response, type);
 			response.on("close", () => {
-				if (!response.writableEnded) {
+				if (!responseEnded(response)) {
 					context._abortIfPending("Connection closed before response finished");
 					if (!context.sended) context.response.statusCode = 499;
 				}
@@ -842,14 +897,16 @@ let HttpKernel = class HttpKernel extends Service {
 		const profilerQueries = this.profiler ? [] : null;
 		context.profilerQueries = profilerQueries;
 		context.profiling = profilerQueries !== null;
-		return RequestContext.run({
+		const store = {
 			requestId: context.requestId,
 			scheme: context.scheme,
 			traceparent: context.traceparent,
 			queries: profilerQueries ?? void 0,
 			context,
 			scope
-		}, () => this.runHttpPipeline(context, request, response));
+		};
+		context.holdRequestStore(store);
+		return RequestContext.run(store, () => this.runHttpPipeline(context, request, response));
 	}
 	/**
 	* Chemin d'erreur de {@link handleHttp} : libère le scope d'un contexte qui
@@ -887,6 +944,10 @@ let HttpKernel = class HttpKernel extends Service {
 	* N'attend que le repli statique, et seulement quand aucune route ne matche.
 	*/
 	routeHttpRequest(httpContext, request, response) {
+		if (this.reverseProxy !== null && this.reverseProxy.mounts !== null && (httpContext.validDomain || !this.domainCheck)) {
+			const relayed = this.reverseProxy.forward(request, response, httpContext.scheme);
+			if (relayed !== void 0) return relayed.then(() => httpContext);
+		}
 		httpContext.phaseStart("resolve");
 		httpContext.resolver = this.router ? this.router.resolve(httpContext) : null;
 		httpContext.phaseEnd("resolve");
@@ -931,7 +992,7 @@ let HttpKernel = class HttpKernel extends Service {
 		if (error) throw error;
 		const schemeHeaders = context.scheme === "https" ? this.options.https.headers : context.scheme === "http" ? this.options.http.headers : null;
 		if (schemeHeaders) context.response.setHeaders(schemeHeaders);
-		if (this.kernel?.options.domainCheck) this.checkValidDomain(context);
+		if (this.domainCheck) this.checkValidDomain(context);
 		if (this.listenerCount("beforeResolve")) return this.fireAsync("beforeResolve", context).then(() => this.armAndGuard(context));
 		return this.armAndGuard(context);
 	}
@@ -942,7 +1003,7 @@ let HttpKernel = class HttpKernel extends Service {
 	armAndGuard(context) {
 		this.prepareFrontController(context);
 		this.firewall?.enforceCsrf(context);
-		return thenMaybe(this.startSession(context), () => context.secure || context.isControlledAccess ? this.runFirewall(context) : context);
+		return thenMaybe(this.startSession(context), () => context.secure ? this.runFirewall(context) : context);
 	}
 	/**
 	* Le pare-feu d'une requête en zone protégée : `handleSecurity`, puis les
@@ -997,22 +1058,10 @@ let HttpKernel = class HttpKernel extends Service {
 		}
 	}
 	async onWebsocketRequest(ws, req, type) {
-		const wsConnCounter = this.#wsConnCounter;
-		if (this.rateLimiter !== null || wsConnCounter !== null) {
-			const ip = resolveForwarded(req.headers, req.socket.remoteAddress, this.getTrustProxyChecker()).clientIp;
-			if (ip !== null) {
-				if (this.rateLimiter?.hit(ip).limited) {
-					if (ws.readyState === Ws.OPEN) ws.close(1013, "rate limit");
-					return;
-				}
-				if (wsConnCounter !== null) {
-					if (!wsConnCounter.tryAcquire(ip)) {
-						if (ws.readyState === Ws.OPEN) ws.close(1013, "too many connections");
-						return;
-					}
-					ws.once("close", () => wsConnCounter.release(ip));
-				}
-			}
+		const refusal = this.websocketQuotaRefusal(req, ws);
+		if (refusal !== null) {
+			if (ws.readyState === Ws.OPEN) ws.close(1013, refusal);
+			return;
 		}
 		await this.fireAsync("onServerRequest", req, null, type);
 		const scope = this.container?.enterScope("request");
@@ -1034,15 +1083,17 @@ let HttpKernel = class HttpKernel extends Service {
 			const wsRunId = context?.requestId ?? "ws-no-ctx";
 			const wsScheme = context?.scheme ?? "ws";
 			const wsTrace = context?.traceparent ?? null;
-			return await RequestContext.run({
+			const store = {
 				requestId: wsRunId,
 				scheme: wsScheme,
 				...wsTrace ? { traceparent: wsTrace } : {},
 				context,
 				scope
-			}, async () => {
+			};
+			context?.holdRequestStore(store);
+			return await RequestContext.run(store, async () => {
 				await this.onConnect(context, error);
-				if (this.firewall && (context?.secure || context?.isControlledAccess)) {
+				if (this.firewall && context?.secure) {
 					context.phaseStart("firewall");
 					try {
 						try {
@@ -1126,8 +1177,131 @@ let HttpKernel = class HttpKernel extends Service {
 	isTrustedHostname(hostname) {
 		return isDomainAllowed(this.regAlias, hostname);
 	}
+	/**
+	* Refus d'un upgrade WebSocket AVANT le `101`, par un statut HTTP
+	* (RFC 6455 §4.2.2) — appelé par le répartiteur d'upgrade, après le proxy
+	* inverse et avant le serveur `ws`.
+	*
+	* Pourquoi avant : accepter puis fermer fait croire au client que le serveur
+	* a répondu. Le client Vite sonde « le serveur est-il revenu ? » en ouvrant
+	* une socket ; une ouverture suivie d'une fermeture `4004` lui faisait
+	* recharger la page avant que Vite soit prêt — page blanche.
+	*
+	* Ne juge que l'existence d'une route WebSocket pour le chemin
+	* ({@link IRequestRouter.servesWebsocket}) : hôte, origine, sous-protocole,
+	* quotas et pare-feu restent jugés après l'ouverture, comme avant. Un refus
+	* compte au limiteur de débit comme une requête HTTP refusée — sans quoi un
+	* flot d'upgrades vers des chemins inexistants y échapperait.
+	*
+	* @param req - requête d'upgrade
+	* @returns le statut du refus — `404` chemin sans route WebSocket, `400` URL
+	*   inanalysable, `429` débit dépassé, `503` routeur pas encore posé (boot) —
+	*   ou `null` si l'upgrade est admis
+	*/
+	websocketUpgradeRefusal(req) {
+		const router = this.router;
+		if (router === null || router === void 0) return 503;
+		let pathname;
+		try {
+			pathname = parseWebsocketUrl("ws", req.headers.host, req.url).pathname;
+		} catch {
+			return this.#rateLimitedRefusal(req) ?? 400;
+		}
+		if (router.servesWebsocket(pathname)) return null;
+		return this.#rateLimitedRefusal(req) ?? 404;
+	}
+	/** Compte un upgrade refusé au limiteur de débit : `429` s'il le dépasse. */
+	#rateLimitedRefusal(req) {
+		if (this.rateLimiter === null) return null;
+		const ip = this.#clientIp(req);
+		return ip !== null && this.rateLimiter.hit(ip).limited ? 429 : null;
+	}
+	/**
+	* Bornes par IP d'un upgrade WebSocket : débit de handshakes (le MÊME
+	* compteur que les requêtes HTTP — un upgrade EST un GET) puis connexions
+	* simultanées (`wsMaxConnectionsPerIp`). Seule implémentation, appelée par
+	* le serveur WebSocket de Nodefony ET par le proxy inverse pour un upgrade
+	* qu'il relaie : un tunnel relayé n'échappe pas aux quotas d'une connexion
+	* servie.
+	*
+	* L'IP est résolue comme en HTTP (RFC 7239 + `trustProxy`), et seulement si
+	* un limiteur est armé — 0 coût quand tout est désactivé (défaut). Aucun log
+	* par refus : sous un flood, il serait lui-même un amplificateur.
+	*
+	* @param req - requête d'upgrade
+	* @param connection - ce dont la fermeture libère la place comptée (le `ws`
+	*   accepté, ou le socket du client pour un tunnel relayé)
+	* @returns `null` si l'upgrade est admis — sa place est alors rendue à la
+	*   fermeture de `connection` —, sinon la raison du refus
+	*/
+	websocketQuotaRefusal(req, connection) {
+		if (this.rateLimiter === null && this.#wsConnCounter === null) return null;
+		const ip = this.#clientIp(req);
+		if (ip === null) return null;
+		if (this.rateLimiter?.hit(ip).limited) return "rate limit";
+		return this.#acquireSlot(ip, connection) ? null : "too many connections";
+	}
+	/**
+	* Prend une place de connexion LONGUE pour l'IP de la requête — le plafond
+	* `wsMaxConnectionsPerIp`, partagé par les sockets WebSocket ET les flux SSE :
+	* un seul budget par IP, sinon N sockets plus N flux doubleraient le plafond.
+	* Le débit n'est pas recompté ici : la requête qui ouvre un flux l'a déjà été
+	* à l'entrée du pipeline.
+	*
+	* @param req - la requête qui ouvre le flux (en-têtes + socket du pair)
+	* @param connection - ce dont la fermeture rend la place (la réponse)
+	* @returns `true` si la place est prise — ou si aucun plafond n'est armé
+	*/
+	acquireConnectionSlot(req, connection) {
+		if (this.#wsConnCounter === null) return true;
+		const ip = this.#clientIp(req);
+		return ip === null || this.#acquireSlot(ip, connection);
+	}
+	/** IP cliente, résolue comme en HTTP (RFC 7239 + `trustProxy`). */
+	#clientIp(req) {
+		return resolveForwarded(req.headers, req.socket.remoteAddress, this.getTrustProxyChecker()).clientIp;
+	}
+	/**
+	* Compte une connexion de `ip` ; sa place est rendue à la fermeture de
+	* `connection`. Le compteur est capturé : la connexion décrémente TOUJOURS
+	* l'instance qui l'a comptée, même après reconfiguration — et `once("close")`
+	* part à toute fermeture (`terminate` du battement, rejet du pare-feu…).
+	*/
+	#acquireSlot(ip, connection) {
+		const counter = this.#wsConnCounter;
+		if (counter === null) return true;
+		if (!counter.tryAcquire(ip)) return false;
+		connection.once("close", () => counter.release(ip));
+		return true;
+	}
+	/**
+	* Inscrit un flux SSE à identité révocable : il sera fermé dans la fenêtre de
+	* re-validation qui suit la mort de son identité (déconnexion, session
+	* révoquée, jeton expiré ou annulé) — le même registre et la même règle que
+	* les sockets WebSocket.
+	*
+	* @internal — appelé par le flux lui-même.
+	*/
+	watchStream(stream) {
+		(this.#streams ??= new RevocationWatch({
+			isValid: (entry) => entry.revalidate(),
+			revoke: (entry) => void entry.close(),
+			identityOf: (entry) => entry.identifier ?? void 0
+		})).register(stream);
+	}
+	/** Retire un flux du registre de révocation (à sa fermeture). @internal */
+	unwatchStream(stream) {
+		this.#streams?.unregister(stream);
+	}
+	/**
+	* Re-valide tous les flux SSE et ferme ceux dont l'identité est morte.
+	* Publique pour qu'un banc la déclenche sans attendre le tick.
+	*/
+	revalidateStreams() {
+		return this.#streams?.revalidate() ?? Promise.resolve();
+	}
 };
 HttpKernel = __decorate([injectable(), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module])], HttpKernel);
 var http_kernel_default = HttpKernel;
 //#endregion
-export { http_kernel_default as default };
+export { http_kernel_default as default, responseEnded };