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

package/dist/_virtual/{_@oxc-project_runtime@0.152.0 → _@oxc-project_runtime@0.153.0}/helpers/esm/decorate.js

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.152.0/helpers/esm/decorate.js
+//#region \0@oxc-project+runtime@0.153.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);

package/dist/_virtual/{_@oxc-project_runtime@0.152.0 → _@oxc-project_runtime@0.153.0}/helpers/esm/decorateMetadata.js

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.152.0/helpers/esm/decorateMetadata.js
+//#region \0@oxc-project+runtime@0.153.0/helpers/esm/decorateMetadata.js
 function __decorateMetadata(k, v) {
 	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }

package/dist/_virtual/{_@oxc-project_runtime@0.152.0 → _@oxc-project_runtime@0.153.0}/helpers/esm/decorateParam.js

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.152.0/helpers/esm/decorateParam.js
+//#region \0@oxc-project+runtime@0.153.0/helpers/esm/decorateParam.js
 function __decorateParam(paramIndex, decorator) {
 	return function(target, key) {
 		decorator(target, key, paramIndex);

package/dist/index.js

@@ -1,3 +1,4 @@
+import { normalizePrefix, parseProxyOrigin, proxyMountProblems } from "./nodefony/src/proxy/rules.js";
 import config, { httpConfigSchema, httpOverlaySchema } from "./nodefony/config/config.js";
 import { defineHttpConfig, httpConfigJsonSchema } from "./nodefony/config/defineModuleConfig.js";
 import { createHttpAdminApi } from "./nodefony/service/HttpAdminApi.js";
@@ -16,19 +17,21 @@ import HttpRequest from "./nodefony/src/context/http/Request.js";
 import HttpResponse from "./nodefony/src/context/http/Response.js";
 import Http2Request from "./nodefony/src/context/http2/Request.js";
 import Http2Response from "./nodefony/src/context/http2/Response.js";
+import { SSE_HEARTBEAT_MS, SseStream, acceptsEventStream, openSseStream } from "./nodefony/src/context/http/SseStream.js";
 import HttpContext from "./nodefony/src/context/http/HttpContext.js";
 import DefaultErrorRenderer, { schemaMismatchOf } from "./nodefony/service/error-renderer.js";
 import DefaultRequestLogger from "./nodefony/service/request-logger.js";
 import JsonAuditLogger from "./nodefony/service/audit-logger.js";
 import PrettyRequestLogger from "./nodefony/service/pretty-request-logger.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 __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 http_kernel_default from "./nodefony/service/http-kernel.js";
 import server_http_default from "./nodefony/service/servers/server-http.js";
 import server_https_default from "./nodefony/service/servers/server-https.js";
 import server_websocket_default from "./nodefony/service/servers/server-websocket.js";
 import server_websocket_secure_default from "./nodefony/service/servers/server-websocket-secure.js";
 import Statics from "./nodefony/service/servers/server-static.js";
+import ReverseProxy from "./nodefony/service/reverse-proxy.js";
 import Network from "./nodefony/command/networkCommand.js";
 import Certificates from "./nodefony/command/certificatesCommand.js";
 import ProxyGenerate from "./nodefony/command/proxyGenerateCommand.js";
@@ -36,7 +39,7 @@ import AssetsPublish from "./nodefony/command/assetsPublishCommand.js";
 import Session from "./nodefony/src/session/session.js";
 import { SESSION_COLUMN_ALIASES, SESSION_DEFAULT_ORDER, SESSION_DEFAULT_ORDER_SQL, SESSION_SORTABLE_FIELDS } from "./nodefony/src/session/storage/sessionSort.js";
 import sessions_service_default from "./nodefony/service/sessions/sessions-service.js";
-import Certificate from "./nodefony/service/certificates.js";
+import Certificate, { trustOutboundAuthorities } from "./nodefony/service/certificates.js";
 import upload_service_default from "./nodefony/service/upload/upload-service.js";
 import { PrebuiltUi, resolveUiDelivery } from "./nodefony/src/assets/prebuiltUi.js";
 import { Kernel, Module, services } from "nodefony";
@@ -70,7 +73,9 @@ let Http = class Http extends Module {
 	*/
 	async onKernelRegister() {
 		const input = this.options;
-		this.options = defineHttpConfig(input ?? {}, this.kernel);
+		const options = defineHttpConfig(input ?? {}, this.kernel);
+		this.options = options;
+		await trustOutboundAuthorities(options.certificates.extraCaFiles, this.kernel?.path ?? process.cwd(), (message, severity) => this.log(message, severity));
 		return this;
 	}
 	/**
@@ -99,6 +104,7 @@ Http = __decorate([services([
 	Certificate,
 	sessions_service_default,
 	Statics,
+	ReverseProxy,
 	server_http_default,
 	server_https_default,
 	server_websocket_default,
@@ -107,4 +113,4 @@ Http = __decorate([services([
 ]), __decorateMetadata("design:paramtypes", [typeof Kernel === "undefined" ? Object : Kernel])], Http);
 var http_default = Http;
 //#endregion
-export { Context, Cookie, DefaultErrorRenderer, DefaultRequestLogger, FrameProfile, Http2Request, Http2Response, HttpContext, HttpError, http_kernel_default as HttpKernel, HttpRequest, HttpResponse, HttpResponse as Response, JsonAuditLogger, MemoryRateLimitStore, PrebuiltUi, PrettyRequestLogger, Profiler, SESSION_COLUMN_ALIASES, SESSION_DEFAULT_ORDER, SESSION_DEFAULT_ORDER_SQL, SESSION_SORTABLE_FIELDS, Session, sessions_service_default as SessionsService, WebsocketContext, WebsocketResponse, WebsocketResponse as wsResponse, compileDomainPattern, compileDomainPatterns, compileTrustedHosts, decideSend, http_default as default, defineHttpConfig, httpConfigJsonSchema, httpConfigSchema, isDomainAllowed, readBackpressureOptions, resolveUiDelivery, schemaMismatchOf };
+export { Context, Cookie, DefaultErrorRenderer, DefaultRequestLogger, FrameProfile, Http2Request, Http2Response, HttpContext, HttpError, http_kernel_default as HttpKernel, HttpRequest, HttpResponse, HttpResponse as Response, JsonAuditLogger, MemoryRateLimitStore, PrebuiltUi, PrettyRequestLogger, Profiler, ReverseProxy, SESSION_COLUMN_ALIASES, SESSION_DEFAULT_ORDER, SESSION_DEFAULT_ORDER_SQL, SESSION_SORTABLE_FIELDS, SSE_HEARTBEAT_MS, Session, sessions_service_default as SessionsService, SseStream, WebsocketContext, WebsocketResponse, WebsocketResponse as wsResponse, acceptsEventStream, compileDomainPattern, compileDomainPatterns, compileTrustedHosts, decideSend, http_default as default, defineHttpConfig, httpConfigJsonSchema, httpConfigSchema, isDomainAllowed, normalizePrefix, openSseStream, parseProxyOrigin, proxyMountProblems, readBackpressureOptions, resolveUiDelivery, schemaMismatchOf };

package/dist/nodefony/config/config.js

@@ -1,3 +1,4 @@
+import { normalizePrefix, proxyMountProblems } from "../src/proxy/rules.js";
 import { overlayField } from "nodefony";
 import { z } from "zod";
 //#region nodefony/config/config.ts
@@ -182,7 +183,7 @@ const sanSchema = z.strictObject({
 		description: "Noms DNS du Subject Alternative Name (RFC 5280 §4.2.1.6). Vide = dérivé du kernel (localhost + domain)."
 	}),
 	ip: z.array(z.string()).default([]).describe("Adresses IP du SAN. Vide = dérivé (127.0.0.1, ::1).")
-}).describe("Subject Alternative Name explicite. Vide = dérivé (localhost + domaine kernel). Chrome ignore le commonName depuis RFC 2818 → le SAN fait foi.");
+}).describe("Subject Alternative Name explicite. Vide = dérivé (localhost + domaine kernel). Chrome ignore le commonName ; le SAN seul fait foi (RFC 9525).");
 const certDevSchema = z.strictObject({ useMkcert: z.boolean().default(true).describe("Préférer mkcert (CA locale trustée) en dev → HTTPS sans erreur navigateur (HMR/WSS). false = forcer le fallback auto-signé. Ignoré hors dev.") }).describe("Options de génération du certificat en développement.");
 const certificatesSchema = z.strictObject({
 	strategy: z.enum([
@@ -195,6 +196,7 @@ const certificatesSchema = z.strictObject({
 	key: z.string().default("").describe("Chemin de la clé privée TLS. Vide = générée."),
 	cert: z.string().default("").describe("Chemin du certificat TLS. Vide = généré."),
 	privateKeyMode: z.number().int().default(384).meta({ description: "Permissions POSIX de la clé privée écrite sur disque (0600 = lecture/écriture owner uniquement). Une clé TLS ne doit JAMAIS être world-readable." }),
+	extraCaFiles: z.array(z.string().min(1)).default([]).describe("Autorités de certification supplémentaires pour les requêtes SORTANTES du processus (découverte OpenID, jeton, jeu de clés, API tierces) : fichiers PEM, absolus ou relatifs à la racine de l'application, un fichier pouvant porter une chaîne entière. L'équivalent porté par l'application de NODE_EXTRA_CA_CERTS — sans syntaxe de shell, donc identique sous Windows. Fichier illisible ou sans certificat = refus au démarrage. La CA de développement générée par Nodefony n'a pas besoin d'y figurer."),
 	san: sanSchema.default(() => sanSchema.parse({})),
 	dev: certDevSchema.default(() => certDevSchema.parse({})),
 	selfSigned: selfSignedSchema.default(() => selfSignedSchema.parse({}))
@@ -221,9 +223,9 @@ const websocketSchema = z.looseObject({
 	autoPong: z.boolean().default(true).describe("Répond automatiquement par un pong à chaque ping entrant (RFC 6455 §5.5.2-5.5.3). Laisser true — requis par le protocole et par le heartbeat des pairs."),
 	allowSynchronousEvents: z.boolean().default(true).describe("Émet les events ('message', 'ping'…) de plusieurs frames lues dans un même chunk réseau de façon synchrone (ws@8.18+). true = meilleur débit ; false = un event par tick d'event loop (latence plus régulière, plus équitable entre connexions)."),
 	maxBackpressure: z.number().int().nonnegative().default(4194304).describe("Seuil (octets) du buffer d'envoi par connexion (`ws.bufferedAmount`) au-delà duquel `backpressurePolicy` s'applique. Borne la RAM d'envoi face à un client LENT À RECEVOIR (anti-OOM) ; broadcast() amplifie (un seul lent peut plomber la diffusion). 0 = désactivé. Défaut 4 MiB."),
-	backpressureCloseAfterDrops: z.number().int().nonnegative().default(1e3).describe("Nombre de frames refusées D'AFFILÉE au-delà duquel la connexion est FERMÉE (1013), en politique 'drop'. Une frame qui repart remet le compteur à zéro. POURQUOI une série et pas un second seuil d'octets : une fois qu'on jette, plus rien n'alimente la file — elle plafonne au seuil de drop et n'atteint jamais un seuil supérieur, qui serait donc inatteignable (mesuré). Une série de refus, elle, distingue le pic passager du client mort. 0 = ne jamais fermer. Défaut 1000."),
+	backpressureCloseAfterDrops: z.number().int().nonnegative().default(1e3).describe("SOLDE de frames refusées au-delà duquel la connexion est FERMÉE (1013), en politique 'drop' : +1 par frame refusée, −1 par frame envoyée. POURQUOI un solde et pas un second seuil d'octets : une fois qu'on jette, plus rien n'alimente la file — elle plafonne au seuil de drop et n'atteint jamais un seuil supérieur, qui serait donc inatteignable (mesuré). Et pas une série remise à zéro au premier envoi : la file d'un client bloqué oscille autour du seuil, chaque envoi effacerait la série et il ne serait jamais fermé. Le solde, lui, distingue le pic passager du client mort. 0 = ne jamais fermer. Défaut 1000."),
 	backpressurePolicy: z.enum(["drop", "close"]).default("drop").describe("Action quand `ws.bufferedAmount` dépasse `maxBackpressure`. 'drop' = sauter la frame pour ce client (il reste connecté, dégradable — idéal télémétrie/broadcast, défaut). 'close' = fermer le client (RFC 6455 close 1013 « Try Again Later »). La fusion (coalesce) relève de la couche canal realtime, pas du transport.")
-}).describe("Serveur WebSocket (`ws@8`). Les options ci-dessus (+ loose : `verifyClient`, `handleProtocols`, `path`, `WebSocket`…) sont transmises à `ws`. GÉRÉ par Nodefony et donc NON exposé : `server`/`host`/`port` (attaché au serveur HTTP), `noServer` (forcé off), `clientTracking` (forcé true — requis par broadcast() + heartbeat), `backlog` (celui du serveur HTTP). `keepalive*`/`closeTimeout` sont des knobs Nodefony, pas des options `ws`.");
+}).describe("Serveur WebSocket (`ws@8`). Les options ci-dessus (+ loose : `verifyClient`, `handleProtocols`, `path`, `WebSocket`…) sont transmises à `ws`. GÉRÉ par Nodefony et donc NON exposé : `server`/`host`/`port`/`noServer` (forcé à `noServer` : l'upgrade du serveur HTTP passe d'abord par le proxy inverse, puis par `ws`), `clientTracking` (forcé true — requis par broadcast() + heartbeat), `backlog` (celui du serveur HTTP). `keepalive*`/`closeTimeout` sont des knobs Nodefony, pas des options `ws`.");
 const staticOptionsSchema = z.looseObject({
 	cacheControl: z.boolean().optional().describe("Active le header Cache-Control."),
 	maxAge: z.number().int().nonnegative().optional().describe("Durée de cache (selon l'entrée : secondes pour defaultOptions, ms côté serve-static).")
@@ -287,6 +289,43 @@ const healthSchema = z.looseObject({
 	readinessPath: z.string().default("/readyz").describe("Chemin de la probe readiness (k8s `readinessProbe.httpGet.path`). 200 quand le boot est complet (`onPostReady`) ; 503 avant, et dès le début du shutdown (le LB retire le pod AVANT le drain)."),
 	shutdownDelay: z.number().int().nonnegative().default(0).describe("Délai (ms) entre la bascule readiness→503 et le début du drain — laisse aux endpoints k8s/LB le temps de retirer le pod (fenêtre réelle de propagation ~1-2 s). 0 (défaut) = drain immédiat ; alternative opérationnelle : `lifecycle.preStop: sleep N` dans le pod spec. À additionner au budget < grace period (30 s k8s).")
 }).describe("Probes de santé cloud-native `/livez` + `/readyz` (liveness/readiness k8s, HEALTHCHECK Docker) — servies par les serveurs HTTP et HTTPS.");
+const proxyMountSchema = z.strictObject({
+	target: z.string().describe("Origine de l'amont : `scheme://hôte[:port]`, http ou https, SANS chemin (ex. `http://127.0.0.1:8080`). Le chemin relayé est celui de la requête (cf `stripPrefix`)."),
+	methods: z.array(z.string()).optional().describe("Méthodes relayées (casse indifférente). Une autre méthode n'est PAS relayée : la requête suit le routage de l'application (404 si rien ne la prend). Absent = toutes."),
+	websocket: z.boolean().default(false).describe("Relaie aussi l'upgrade WebSocket du préfixe (même origine, même certificat que la page). Défaut false : un upgrade sur le préfixe reste au serveur WebSocket de Nodefony."),
+	stripPrefix: z.boolean().default(false).describe("Retire le préfixe avant de transmettre (`/billing/factures` → `/factures`). Défaut false : l'amont reçoit le chemin complet. ⚠️ Un amont qui ignore son préfixe rendra des liens absolus (`/x`) et des redirections qui sortent du montage."),
+	preserveHost: z.boolean().default(false).describe("Transmet le `Host` du client au lieu de celui de la cible. Défaut false : l'amont reçoit son propre nom (ce qu'attend un serveur qui filtre les noms d'hôte), le nom d'origine part en `X-Forwarded-Host`."),
+	stripHeaders: z.array(z.string()).default([]).describe("En-têtes de requête à ne PAS transmettre (ex. `[\"cookie\", \"authorization\"]` vers un amont qui n'a pas à voir la session). Les en-têtes de connexion (RFC 9110 §7.6.1) ne le sont jamais."),
+	timeoutMs: z.number().optional().describe("Délai d'inactivité avec l'amont (ms) — dépassé avant la réponse (ou avant le `101` d'un upgrade WebSocket) : 504. Absent = `proxy.timeoutMs`. Ne s'applique pas à un WebSocket établi."),
+	secure: z.boolean().default(true).describe("Vérifie le certificat d'une cible https. `false` n'est accepté que vers la boucle locale (`127.0.0.0/8`, `localhost`, `::1`) ; ailleurs, fournir l'autorité de l'amont (`certificates.extraCaFiles`, ou `NODE_EXTRA_CA_CERTS`).")
+}).describe("Un montage du proxy inverse : un préfixe d'URL relayé vers un amont.");
+const proxySchema = z.strictObject({
+	timeoutMs: z.number().int().positive().default(3e4).describe("Délai d'inactivité par défaut de tous les montages (ms) : un amont muet au-delà rend 504 Gateway Timeout. Défaut 30 s."),
+	connectTimeoutMs: z.number().int().positive().default(5e3).describe("Délai d'ÉTABLISSEMENT de la connexion vers un amont (ms), distinct du délai d'inactivité : un amont qui n'accepte pas la connexion rend 504 sans tenir le client pendant `timeoutMs`. Défaut 5 s."),
+	maxSockets: z.number().int().positive().default(256).describe("Connexions simultanées maximales vers UN amont (pool keep-alive dédié par montage) ; au-delà, les requêtes attendent un socket libre. Borne aussi les tunnels WebSocket relayés, hors pool : au-delà, l'upgrade rend 503. Défaut 256. Le pool ignore `HTTP_PROXY`/`NODE_USE_ENV_PROXY` : un amont se joint en direct."),
+	mounts: z.record(z.string(), proxyMountSchema).default({}).describe("Préfixe d'URL → amont. Consulté AVANT le routage : une route de l'application sous ce préfixe ne sera jamais atteinte. ⚠️ Servi AVANT le pare-feu, la CSRF et les en-têtes applicatifs (CSP, Referrer-Policy, COOP) — l'amont porte sa propre politique d'accès ; les en-têtes de transport (nosniff, X-Frame-Options, HSTS) sont posés si l'amont ne les fixe pas, et les quotas (rate-limit, connexions WebSocket par IP) s'appliquent. Correspondance au préfixe le PLUS LONG. Refusés au démarrage : `/`, ce qui est sous `/nodefony/` (administration) ou `/_vite/` (monté par @nodefony/frontend), deux clés qui désignent le même préfixe.")
+}).superRefine((proxy, ctx) => {
+	const seen = /* @__PURE__ */ new Map();
+	for (const [prefix, mount] of Object.entries(proxy.mounts)) {
+		const normalized = normalizePrefix(prefix);
+		const twin = seen.get(normalized);
+		if (twin !== void 0) ctx.addIssue({
+			code: "custom",
+			path: ["mounts", prefix],
+			message: `« ${prefix} » et « ${twin} » désignent le même préfixe (${normalized}) — n'en garder qu'un`
+		});
+		seen.set(normalized, prefix);
+		for (const problem of proxyMountProblems(prefix, mount, "config")) ctx.addIssue({
+			code: "custom",
+			path: problem.field === "prefix" ? ["mounts", prefix] : [
+				"mounts",
+				prefix,
+				problem.field
+			],
+			message: problem.message
+		});
+	}
+}).describe("Proxy inverse : relaie un préfixe d'URL (requêtes et, sur demande, WebSocket) vers un autre serveur, sur la MÊME origine que la page — un seul certificat, l'amont peut rester sur la boucle locale. En-têtes de connexion jamais transmis, `X-Forwarded-*` et `Via` posés, `trustedHosts` appliqué, 502/504 sur amont injoignable/muet, boucle détectée (508).");
 const httpConfigSchema = z.strictObject({
 	headerServer: z.string().nullable().default("nodefony").meta({
 		runtimeMutable: true,
@@ -323,9 +362,10 @@ const httpConfigSchema = z.strictObject({
 	session: sessionSchema.default(() => sessionSchema.parse({})),
 	rateLimit: rateLimitSchema.default(() => rateLimitSchema.parse({})),
 	health: healthSchema.default(() => healthSchema.parse({})),
+	proxy: proxySchema.default(() => proxySchema.parse({})),
 	wsMaxConnectionsPerIp: z.number().int().positive().nullable().default(null).meta({
 		runtimeMutable: true,
-		description: "Backstop OPT-IN : plafond de connexions WebSocket CONCURRENTES par IP cliente. `null` (DÉFAUT) = désactivé. Distinct de `rateLimit` (qui borne le DÉBIT d'ouverture par fenêtre) : ici on borne le NOMBRE de sockets simultanément ouvertes par IP. Au-delà, l'upgrade est fermé (RFC 6455 close 1013). ⚠️ PORTÉE PAR PROCESS (1 pod) : un vrai plafond GLOBAL/IP se fait à l'INGRESS/LB — nginx `limit_conn`, HAProxy `sc_conn_cur`, annotation k8s `nginx.ingress.kubernetes.io/limit-connections` — qui voit TOUT le trafic, rejette AVANT que l'app paie le fd + le handshake TLS, et couvre tous les pods. En cloud-native, laisser `null` et déléguer à l'edge. N'activer (ex. 20) que sur bare-metal/VPS SANS ingress, comme défense en profondeur. IP résolue forwarded-aware (RFC 7239 + trustProxy)."
+		description: "Backstop OPT-IN : plafond de connexions LONGUES CONCURRENTES par IP cliente — sockets WebSocket ET flux SSE, un seul budget pour les deux. `null` (DÉFAUT) = désactivé. Distinct de `rateLimit` (qui borne le DÉBIT d'ouverture par fenêtre) : ici on borne le NOMBRE de connexions simultanément ouvertes par IP. Au-delà, l'upgrade WebSocket est fermé (RFC 6455 close 1013) et un flux SSE répond 429. ⚠️ PORTÉE PAR PROCESS (1 pod) : un vrai plafond GLOBAL/IP se fait à l'INGRESS/LB — nginx `limit_conn`, HAProxy `sc_conn_cur`, annotation k8s `nginx.ingress.kubernetes.io/limit-connections` — qui voit TOUT le trafic, rejette AVANT que l'app paie le fd + le handshake TLS, et couvre tous les pods. En cloud-native, laisser `null` et déléguer à l'edge. N'activer (ex. 20) que sur bare-metal/VPS SANS ingress, comme défense en profondeur. IP résolue forwarded-aware (RFC 7239 + trustProxy)."
 	})
 }).describe("Configuration de @nodefony/http.");
 /**

package/dist/nodefony/config/defineModuleConfig.js

@@ -11,7 +11,7 @@ import { z } from "zod";
 *   Sans ce remplissage, le certificat auto-signé n'aurait pas de commonName.
 * - `certificates.san` vide → Subject Alternative Name dérivé du kernel
 *   (`localhost` + `kernel.domain` en DNS ; `127.0.0.1`/`::1` en IP). Le SAN fait
-*   foi pour la vérification d'hôte (RFC 6125) — Chrome ignore le commonName.
+*   foi pour la vérification d'hôte (RFC 9525) — Chrome ignore le commonName.
 *   `0.0.0.0` (bind toutes interfaces) n'est PAS un nom DNS valide → exclu.
 *
 * Muté EN PLACE (pas de copie) : la config est ré-assignée à `module.options`

package/dist/nodefony/interfaces/IReverseProxy.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/service/HttpAdminApi.js

@@ -25,7 +25,6 @@ function pageParams(query) {
 function adminActor(user) {
 	if (user && typeof user === "object") {
 		const u = user;
-		if (typeof u.username === "string" && u.username) return u.username;
 		if (typeof u.identifier === "string" && u.identifier) return u.identifier;
 	}
 	return "admin";

package/dist/nodefony/service/audit-logger.js

@@ -1,4 +1,3 @@
-import { RequestContext } from "nodefony";
 import { performance } from "node:perf_hooks";
 //#region nodefony/service/audit-logger.ts
 /**
@@ -84,7 +83,7 @@ var JsonAuditLogger = class {
 		const entry = {
 			ts: (/* @__PURE__ */ new Date()).toISOString(),
 			requestId: ctx.requestId,
-			userId: RequestContext.getUserId() ?? null,
+			userIdentifier: ctx.userIdentifier ?? null,
 			type: "http",
 			scheme: ctx.scheme,
 			method: ctx.method,
@@ -115,7 +114,7 @@ var JsonAuditLogger = class {
 		const entry = {
 			ts: (/* @__PURE__ */ new Date()).toISOString(),
 			requestId: ctx.requestId,
-			userId: RequestContext.getUserId() ?? null,
+			userIdentifier: ctx.userIdentifier ?? null,
 			type: "ws",
 			scheme: ctx.scheme,
 			method: ctx.method,

package/dist/nodefony/service/certificates.js

@@ -1,17 +1,125 @@
 import { asServersConfig } from "../src/servers/kernelServers.js";
 import { SHA1_WITH_RSA_OID, createSelfSignedCertificate, distinguishedNameField, parseSubjectAltName, signatureAlgorithmName, signatureAlgorithmOid } from "./x509.js";
-import { Service, extend } from "nodefony";
+import { BootConfigurationError, Service, extend } from "nodefony";
 import { X509Certificate, generateKeyPair, randomBytes } from "node:crypto";
 import fsp from "node:fs/promises";
 import path, { resolve } from "node:path";
+import tls from "node:tls";
 import { promisify } from "node:util";
 import { execFile } from "node:child_process";
 //#region nodefony/service/certificates.ts
 const execFileAsync = promisify(execFile);
 const generateKeyPairAsync = promisify(generateKeyPair);
+/** Compare deux PEM sans dépendre des fins de ligne ni des espaces. */
+function normalizePem(pem) {
+	return pem.replace(/\s+/g, "");
+}
+/**
+* Ajoute une autorité aux ancres TLS par défaut du processus (requêtes sortantes
+* `fetch`, `https`, `tls.connect`), sans en retirer aucune.
+*
+* C'est l'équivalent en cours d'exécution de `NODE_EXTRA_CA_CERTS`, qui n'est lu
+* qu'au lancement du processus — trop tôt pour une CA que le boot vient de
+* générer, et que seul un script de banc posait. La capacité se CONSTATE
+* (`tls.setDefaultCACertificates` n'existe qu'à partir de Node 24.5), elle ne se
+* déduit pas d'un numéro de version. Idempotent : une autorité déjà présente
+* n'est pas ajoutée deux fois.
+*
+* @param pem - autorité au format PEM.
+* @param store - accès aux ancres ; `node:tls` par défaut.
+* @returns `added`, `present` (déjà de confiance), ou `unsupported`.
+*/
+function addDefaultCaCertificate(pem, store = tls) {
+	const { getCACertificates, setDefaultCACertificates } = store;
+	if (typeof getCACertificates !== "function" || typeof setDefaultCACertificates !== "function") return "unsupported";
+	const current = getCACertificates("default");
+	const wanted = normalizePem(pem);
+	if (current.some((c) => normalizePem(c) === wanted)) return "present";
+	setDefaultCACertificates([...current, pem]);
+	return "added";
+}
+const PEM_CERTIFICATE = /-----BEGIN CERTIFICATE-----[\s\S]+?-----END CERTIFICATE-----/g;
+/**
+* Découpe un fichier PEM en ses certificats — une chaîne d'entreprise est
+* souvent livrée en un seul fichier (racine + intermédiaires).
+*
+* Chaque certificat est ajouté SÉPARÉMENT : c'est ce qui rend l'ajout
+* idempotent certificat par certificat, la liste par défaut du processus
+* n'étant faite que de certificats isolés.
+*
+* @param pem - contenu d'un fichier PEM (un ou plusieurs certificats)
+* @returns les certificats, dans l'ordre du fichier ; vide s'il n'y en a aucun
+*/
+function splitPemCertificates(pem) {
+	return pem.match(PEM_CERTIFICATE) ?? [];
+}
+/**
+* Ajoute les autorités d'un fichier PEM aux ancres TLS du processus
+* (`certificates.extraCaFiles`) — l'équivalent, porté par l'APPLICATION, de
+* `NODE_EXTRA_CA_CERTS`.
+*
+* `NODE_EXTRA_CA_CERTS` n'est lu qu'au lancement de Node, et se pose dans la
+* syntaxe du shell — `VAR=… npm run dev` n'existe pas sous Windows. Une autorité
+* d'entreprise (Keycloak interne, proxy sortant qui ré-signe) se déclare donc
+* dans la configuration, et sert à TOUTES les requêtes sortantes du processus :
+* découverte OpenID, point de jeton, jeu de clés, appels d'administration.
+*
+* @param file - chemin du fichier, absolu ou relatif à `root`
+* @param root - racine de l'application
+* @param store - accès aux ancres ; `node:tls` par défaut
+* @returns le bilan de l'ajout
+* @throws BootConfigurationError - fichier illisible, sans certificat, ou Node
+*         incapable d'élargir ses ancres en cours d'exécution
+*/
+async function trustCaFile(file, root, store = tls) {
+	const absolute = path.resolve(root, file);
+	let content;
+	try {
+		content = await fsp.readFile(absolute, "utf8");
+	} catch (error) {
+		const code = error instanceof Error && "code" in error ? error.code : void 0;
+		const reason = typeof code === "string" ? code : error instanceof Error ? error.message : String(error);
+		throw new BootConfigurationError(`http.certificates.extraCaFiles : « ${absolute} » est illisible (${reason}).`);
+	}
+	const certificates = splitPemCertificates(content);
+	if (certificates.length === 0) throw new BootConfigurationError(`http.certificates.extraCaFiles : « ${absolute} » ne contient aucun certificat PEM (-----BEGIN CERTIFICATE-----).`);
+	let added = 0;
+	let present = 0;
+	for (const pem of certificates) {
+		const verdict = addDefaultCaCertificate(pem, store);
+		if (verdict === "unsupported") throw new BootConfigurationError(`http.certificates.extraCaFiles : ce Node ne sait pas élargir ses ancres TLS en cours d'exécution (tls.setDefaultCACertificates, Node ≥ 24.5). Mettre Node à jour, ou lancer avec NODE_EXTRA_CA_CERTS=${absolute}.`);
+		if (verdict === "added") added += 1;
+		else present += 1;
+	}
+	return {
+		file: absolute,
+		added,
+		present
+	};
+}
+/**
+* Ajoute aux ancres TLS du processus les autorités déclarées
+* (`certificates.extraCaFiles`), au plus tôt : appelé à l'enregistrement du
+* module, avant tout service — toute requête sortante, commande console
+* comprise, les trouve en place.
+*
+* La CA de DÉVELOPPEMENT n'y figure pas : le service de certificats la pose
+* lui-même ({@link Certificate.generateServerCertificates}).
+*
+* @param files - `certificates.extraCaFiles`
+* @param root - racine de l'application
+* @param log - journal du module
+* @throws BootConfigurationError - cf {@link trustCaFile}
+*/
+async function trustOutboundAuthorities(files, root, log) {
+	for (const file of files) {
+		const trust = await trustCaFile(file, root);
+		log(`autorité sortante ${trust.file} : ${trust.added} ajoutée(s), ${trust.present} déjà présente(s)`, "INFO");
+	}
+}
 /**
 * Vrai si `host` est une IP littérale (IPv4 `n.n.n.n` ou IPv6 — contient `:`).
-* Une IP doit aller en SAN `iPAddress`, jamais en `dNSName` (RFC 6125).
+* Une IP doit aller en SAN `iPAddress`, jamais en `dNSName` (RFC 9525).
 */
 function isIpLiteral(host) {
 	return /^\d{1,3}(\.\d{1,3}){3}$/.test(host) || host.includes(":");
@@ -44,7 +152,7 @@ const defaultOptions = {
 *
 * Conformité (génération auto-signée) : signature SHA-256 (jamais SHA-1,
 * RFC 5280 / CA-B Forum), numéro de série aléatoire 128 bits unique
-* (RFC 5280 §4.1.2.2), SAN qui fait foi (RFC 6125), `notBefore` reculé,
+* (RFC 5280 §4.1.2.2), SAN qui fait foi (RFC 9525), `notBefore` reculé,
 * clé privée écrite en `0600`.
 */
 var Certificate = class Certificate extends Service {
@@ -56,8 +164,6 @@ var Certificate = class Certificate extends Service {
 	cert = "";
 	fullchainPem = "";
 	publicKeyPem = "";
-	rootCertPem = "";
-	intermediateCertPem = "";
 	/** CAROOT résolu de mkcert (null tant que non détecté / indisponible). */
 	mkcertCaRoot = null;
 	path = resolve(".", "nodefony", "config", "certificates");
@@ -181,7 +287,11 @@ var Certificate = class Certificate extends Service {
 		await this.ensureDirectoriesExist();
 		const strategy = await this.resolveStrategy();
 		if (strategy === "explicit") return this.loadExplicitCert();
-		if (await this.checkCertificates() && !force && await this.isCertAdequate(strategy)) return this.readCerticates();
+		if (await this.checkCertificates() && !force && await this.isCertAdequate(strategy)) {
+			await this.readCerticates();
+			this.trustDevelopmentAuthority();
+			return this;
+		}
 		if (strategy === "mkcert") await this.generateWithMkcert();
 		else {
 			this.keysPair = await this.generateKeys();
@@ -195,7 +305,26 @@ var Certificate = class Certificate extends Service {
 			await this.writeCertificates(true);
 			await fsp.writeFile(this.caPath, certPem.toString(), "utf8");
 		}
-		return this.readCerticates();
+		await this.readCerticates();
+		this.trustDevelopmentAuthority();
+		return this;
+	}
+	/**
+	* En développement, fait confiance à la CA que Nodefony vient de générer ou de
+	* relire, pour les requêtes SORTANTES du processus.
+	*
+	* Sans elle, un service du décor qui sert le certificat de l'application
+	* (Keycloak, l'auto-vérification d'un jeton MCP) est injoignable depuis
+	* `nodefony development` — `fetch failed` / `SELF_SIGNED_CERT_IN_CHAIN` — alors
+	* que `curl -k` répond : la confiance n'existait que sous le script de banc.
+	* Réservé au DÉVELOPPEMENT et aux certificats que Nodefony fabrique : un
+	* certificat `explicit` (production) n'élargit jamais la confiance du processus.
+	*/
+	trustDevelopmentAuthority() {
+		if (!this.isDev() || !this.ca || this.ca.length === 0) return;
+		const verdict = addDefaultCaCertificate(this.ca.toString());
+		if (verdict === "added") this.log(`CA de développement ajoutée aux ancres TLS du processus (${this.caPath})`, "DEBUG");
+		else if (verdict === "unsupported") this.log(`Ce Node ne sait pas élargir ses ancres TLS en cours d'exécution (tls.setDefaultCACertificates, Node ≥ 24.5) : les requêtes sortantes vers un service qui sert le certificat de développement échoueront. Relancer avec NODE_EXTRA_CA_CERTS=${this.caPath}`, "WARNING");
 	}
 	/**
 	* Résout la stratégie effective à partir de `certificates.strategy` :
@@ -249,7 +378,7 @@ var Certificate = class Certificate extends Service {
 	/**
 	* SAN effectif : config explicite si fournie, sinon dérivé du kernel
 	* (localhost + domain en DNS ; loopback en IP). Une IP littérale (ex. domain
-	* `127.0.0.1` en dev) est classée en `ip`, pas en `dns` (RFC 6125).
+	* `127.0.0.1` en dev) est classée en `ip`, pas en `dns` (RFC 9525).
 	*/
 	derivedSan() {
 		const san = this.certOptions.san;
@@ -329,7 +458,7 @@ var Certificate = class Certificate extends Service {
 			return false;
 		}
 	}
-	/** Le SAN présent couvre-t-il tous les noms DNS requis (RFC 6125) ? */
+	/** Le SAN présent couvre-t-il tous les noms DNS requis (RFC 9525) ? */
 	sanCovers(presentDns) {
 		return this.sanDnsNames().every((name) => presentDns.includes(name));
 	}
@@ -351,11 +480,7 @@ var Certificate = class Certificate extends Service {
 		return Buffer.from(await fsp.readFile(value, "utf8"));
 	}
 	createFullChain() {
-		return [
-			this.cert,
-			this.intermediateCertPem,
-			this.rootCertPem
-		].map((part) => part?.toString().trim()).filter(Boolean).join("\n");
+		return this.cert?.toString().trim() ?? "";
 	}
 	async readCerticates() {
 		for (const file of this.files) try {
@@ -510,4 +635,4 @@ var Certificate = class Certificate extends Service {
 	}
 };
 //#endregion
-export { Certificate as default };
+export { addDefaultCaCertificate, Certificate as default, splitPemCertificates, trustCaFile, trustOutboundAuthorities };

package/dist/nodefony/service/error-renderer.js

@@ -348,7 +348,7 @@ const SCHEMA_MISMATCH_HINT = {
 *   reason: error.message
 *
 * Stateless singleton — zero per-request allocation. Override via
-* `httpKernel.setErrorRenderer(custom)` for prod hardening or RFC 7807.
+* `httpKernel.setErrorRenderer(custom)` for prod hardening or RFC 9457.
 */
 var DefaultErrorRenderer = class {
 	renderHttp(error, context) {