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

package/dist/nodefony/service/certificates.js

@@ -1,17 +1,209 @@
 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
+// 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
+* Chaque refus dit le problème, d'où vient le chemin quand on le sait, puis le
+* geste qui répare ({@link caFileRemedy}).
+*
+* @param store - accès aux ancres ; `node:tls` par défaut
+* @param origin - phrase qui dit d'où vient le chemin (` Valeur venue de …`), insérée dans un refus
+* @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, origin = "") {
+	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(`${unreadableProblem(absolute, reason)}${origin} ${caFileRemedy(reason)}`);
+	}
+	const certificates = splitPemCertificates(content);
+	if (certificates.length === 0) throw new BootConfigurationError(`http.certificates.extraCaFiles : « ${absolute} » ne contient aucun certificat PEM (-----BEGIN CERTIFICATE-----).${origin} ${caFileRemedy("NOPEM")}`);
+	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
+	};
+}
+/** Première phrase d'un refus de lecture : le fichier et la cause en un mot. */
+function unreadableProblem(absolute, reason) {
+	return `http.certificates.extraCaFiles : « ${absolute} » est illisible (${reason}).`;
+}
+/**
+* Le geste qui répare une autorité déclarée qu'on ne peut pas reconnaître.
+*
+* Un refus au démarrage qui ne dit que la cause envoie chercher ; celui-ci dit
+* quoi faire. Pure : éprouvée cause par cause, y compris celles qu'une machine
+* de test ne sait pas produire (un droit refusé ne l'est pas à `root`, ni
+* sous Windows).
+*
+* @param cause - code système (`ENOENT`, `EACCES`, `EPERM`, `EISDIR`),
+*   `NOPEM` pour un fichier lu sans certificat, ou tout autre motif
+* @returns la phrase du geste
+*/
+function caFileRemedy(cause) {
+	switch (cause) {
+		case "ENOENT": return "Poser le fichier à ce chemin (absolu, ou relatif à la racine de l'application), ou retirer la déclaration.";
+		case "EACCES":
+		case "EPERM": return "Le compte qui lance l'application n'a pas le droit de le lire : lui donner ce droit (sous Kubernetes, monter le ConfigMap ou le Secret lisible par l'utilisateur du pod).";
+		case "EISDIR": return "C'est un dossier : désigner le fichier PEM qu'il contient.";
+		case "NOPEM": return "Le fichier doit porter le CERTIFICAT de l'autorité (pas sa clé privée), au format PEM ; un fichier DER se convertit par `openssl x509 -inform der -in autorite.der -out autorite.pem`.";
+		default: return "Vérifier le chemin et les droits du fichier, ou retirer la déclaration.";
+	}
+}
+/**
+* Dossier où Nodefony range les certificats qu'il fabrique en développement,
+* relatif au répertoire courant.
+*
+* @returns le chemin absolu de `nodefony/config/certificates`
+*/
+function certificatesDirectory() {
+	return resolve(".", "nodefony", "config", "certificates");
+}
+/**
+* Chemin de l'autorité de DÉVELOPPEMENT : le certificat racine que Nodefony
+* fabrique lui-même pour signer le certificat du serveur local. Généré, jamais
+* versionné — une seule convention, que le service et la confiance sortante lisent.
+*
+* @param directory - dossier des certificats ; {@link certificatesDirectory} par défaut
+* @returns le chemin absolu du fichier PEM de l'autorité
+*/
+function developmentAuthorityPath(directory = certificatesDirectory()) {
+	return resolve(directory, "ca", "nodefony-root-ca.crt.pem");
+}
+/** Vrai si le fichier n'existe pas (et seulement dans ce cas). */
+async function isMissing(file) {
+	try {
+		await fsp.stat(file);
+		return false;
+	} catch (error) {
+		return error instanceof Error && "code" in error && error.code === "ENOENT";
+	}
+}
+/**
+* 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.
+*
+* L'autorité de DÉVELOPPEMENT déclarée mais pas encore engendrée est ignorée en
+* développement, et le journal le dit : elle n'a signé aucun certificat, il n'y
+* a donc rien à lui faire confiance, et le serveur de développement la pose
+* lui-même quand il la fabrique ({@link Certificate.generateServerCertificates}).
+* Rien n'est fabriqué ici : une commande console n'écrit pas de certificat.
+* Une autre autorité absente, ou n'importe laquelle hors développement, reste
+* un refus — qui nomme la variable d'origine et le geste qui répare
+* ({@link caFileRemedy}).
+*
+* @param files - `certificates.extraCaFiles`
+* @param root - racine de l'application
+* @param log - journal du module
+* @param context - décor (environnement, autorité de dev, ancres)
+* @throws BootConfigurationError - cf {@link trustCaFile}
+*/
+async function trustOutboundAuthorities(files, root, log, context = {}) {
+	const developmentAuthority = context.developmentAuthority ?? developmentAuthorityPath();
+	for (const file of files) {
+		const absolute = path.resolve(root, file);
+		const isDevelopmentAuthority = absolute === developmentAuthority;
+		if (isDevelopmentAuthority && context.development === true && await isMissing(absolute)) {
+			log(`autorité de développement ${absolute} pas encore engendrée : ignorée. Elle naît au premier \`npx nodefony development\` (ou \`npx nodefony http:certificates\`), et le serveur de développement lui fait alors confiance de lui-même.`, "INFO");
+			continue;
+		}
+		const origin = originOf(absolute, root, context.env ?? process.env);
+		if (isDevelopmentAuthority && await isMissing(absolute)) throw new BootConfigurationError(`${unreadableProblem(absolute, "ENOENT")}${origin} C'est l'autorité de DÉVELOPPEMENT : Nodefony la fabrique au premier \`npx nodefony development\`, jamais hors développement. Pour essayer la production sur ce poste, l'engendrer une fois (\`npx nodefony http:certificates\`) puis relancer ; sinon retirer la déclaration — une production réelle n'en a pas besoin.`);
+		const trust = await trustCaFile(file, root, context.store, origin);
+		log(`autorité sortante ${trust.file} : ${trust.added} ajoutée(s), ${trust.present} déjà présente(s)`, "INFO");
+	}
+}
+/**
+* Nomme la variable d'où vient le chemin, quand c'est `NF_TLS_CA_FILE` — la
+* déclaration que pose le gabarit d'application. Constaté sur la valeur, jamais
+* supposé : une configuration écrite à la main n'est pas attribuée à la variable.
+*/
+function originOf(absolute, root, env) {
+	const declared = env.NF_TLS_CA_FILE;
+	return declared && path.resolve(root, declared) === absolute ? " Valeur venue de NF_TLS_CA_FILE (`.env` ou environnement du processus)." : "";
+}
 /**
 * 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 +236,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,13 +248,11 @@ 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");
+	path = certificatesDirectory();
 	serverPath = resolve(this.path, "server");
-	caPath = resolve(this.path, "ca", "nodefony-root-ca.crt.pem");
+	caPath = developmentAuthorityPath(this.path);
 	publicKeyPath = resolve(this.path, "server", "publickey.pem");
 	privateKeyPath = resolve(this.path, "server", "privkey.pem");
 	certPath = resolve(this.path, "server", "cert.pem");
@@ -181,7 +371,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 +389,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 +462,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 +542,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 +564,8 @@ 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");
+		const pem = this.cert?.toString().trim() ?? "";
+		return pem === "" ? "" : `${pem}\n`;
 	}
 	async readCerticates() {
 		for (const file of this.files) try {
@@ -509,5 +719,4 @@ var Certificate = class Certificate extends Service {
 		}
 	}
 };
-//#endregion
-export { Certificate as default };
+export { addDefaultCaCertificate, caFileRemedy, certificatesDirectory, Certificate as default, developmentAuthorityPath, splitPemCertificates, trustCaFile, trustOutboundAuthorities };

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

@@ -1,7 +1,7 @@
 import HttpError from "../src/errors/httpError.js";
 import { toWsCloseCode } from "../src/context/websocket/WebsocketContext.js";
 import { Nodefony, nodefonyError } from "nodefony";
-//#region nodefony/service/error-renderer.ts
+// nodefony/service/error-renderer.ts
 /** Une donnée rejetée par la validation n'est pas une requête malformée : 422, pas 400. */
 const VALIDATION_STATUS = 422;
 /**
@@ -74,8 +74,15 @@ const INTERNAL_ERROR_KEYS = [
 * deux tests — un gate qu'on ne peut plus voir mordre.
 */
 const isProduction = () => Nodefony.getKernel()?.environment === "production";
+/** Une propriété d'une anomalie de forme inconnue, lue sans rien supposer. */
+function readIssueProperty(issue, key) {
+	return typeof issue === "object" && issue !== null ? Reflect.get(issue, key) : void 0;
+}
+/** Erreurs de validation reconnues : Zod, et celle des routes à schéma (cœur). */
+const VALIDATION_ERROR_NAMES = /* @__PURE__ */ new Set(["ZodError", "SchemaValidationError"]);
 /**
-* Reconnaît une erreur de validation Zod et en extrait les champs fautifs.
+* Reconnaît une erreur de validation — `ZodError`, ou `SchemaValidationError`
+* d'une route à schéma — et en extrait les champs fautifs.
 *
 * Reconnaissance **structurelle** (`name` + `issues`), pas `instanceof ZodError` :
 * une application peut embarquer sa propre copie de zod (résolutions npm multiples),
@@ -88,13 +95,21 @@ const isProduction = () => Nodefony.getKernel()?.environment === "production";
 * @returns les champs fautifs, ou `null` si ce n'est pas une erreur de validation.
 */
 function toValidationFields(error) {
-	const candidate = error;
-	if (error.name !== "ZodError" || !Array.isArray(candidate.issues)) return null;
-	return candidate.issues.map((issue) => ({
-		field: Array.isArray(issue.path) ? issue.path.join(".") : "",
-		message: issue.message ?? "invalide",
-		rule: issue.code
-	}));
+	const issues = Reflect.get(error, "issues");
+	if (!VALIDATION_ERROR_NAMES.has(error.name) || !Array.isArray(issues)) return null;
+	return issues.map((issue) => {
+		const path = readIssueProperty(issue, "path");
+		const message = readIssueProperty(issue, "message");
+		const code = readIssueProperty(issue, "code");
+		const part = readIssueProperty(issue, "in");
+		const field = {
+			field: Array.isArray(path) ? path.map(String).join(".") : "",
+			message: typeof message === "string" ? message : "invalide",
+			rule: typeof code === "string" ? code : void 0
+		};
+		if (typeof part === "string") field.in = part;
+		return field;
+	});
 }
 /**
 * Construit l'erreur **422** exposée au client à partir des champs fautifs.
@@ -109,7 +124,10 @@ function toValidationFields(error) {
 * reçoit `error.fields` et sait QUEL champ corriger — pas seulement que « ça a échoué ».
 */
 function toValidationError(error, fields) {
-	const summary = fields.map((f) => f.field ? `${f.field}: ${f.message}` : f.message).join(" · ");
+	const summary = fields.map((f) => {
+		const where = f.in && f.field ? `${f.in}.${f.field}` : f.in || f.field;
+		return where ? `${where}: ${f.message}` : f.message;
+	}).join(" · ");
 	const validation = new nodefonyError(`Validation failed — ${summary}`, VALIDATION_STATUS);
 	if (error.stack !== void 0) validation.stack = error.stack;
 	validation.fields = fields;
@@ -348,7 +366,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) {
@@ -429,5 +447,4 @@ var DefaultErrorRenderer = class {
 		return code;
 	}
 };
-//#endregion
-export { DefaultErrorRenderer as default, malformedIdentifierOf, schemaMismatchOf };
+export { DefaultErrorRenderer as default, malformedIdentifierOf, schemaMismatchOf, toValidationFields };