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

package/dist/nodefony/src/authenticator/FirewallRealtimeAuthenticator.js

@@ -1,7 +1,7 @@
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
 import { UserRealtimeToken } from "../realtime/UserRealtimeToken.js";
 import { Nodefony, RequestContext } from "nodefony";
-import { anonymousUser } from "@nodefony/user";
+import { authenticatedUser } from "@nodefony/user";
 //#region nodefony/src/authenticator/FirewallRealtimeAuthenticator.ts
 /**
 * Authenticator realtime des identités résolues par le **firewall** — équivalent
@@ -66,7 +66,7 @@ var FirewallRealtimeAuthenticator = class {
 	}
 	/** Une identité authentifiée a-t-elle été résolue (par le firewall) au handshake ? */
 	supports(_handshake) {
-		return isAuthenticatedUser(RequestContext.getUser());
+		return authenticatedUser() !== null;
 	}
 	/**
 	* Promeut l'identité déjà résolue (ALS) en jeton realtime — 0 lecture base.
@@ -76,15 +76,40 @@ var FirewallRealtimeAuthenticator = class {
 	*   filet défensif fail-closed → le hub ferme la socket en 4001).
 	*/
 	async authenticate(_handshake) {
-		const user = RequestContext.getUser();
-		if (!isAuthenticatedUser(user)) throw new AuthenticationError("Invalid realtime session");
+		const user = authenticatedUser();
+		if (user === null) throw new AuthenticationError("Invalid realtime session");
 		const issued = readFirewallToken();
-		const type = typeof issued?.type === "string" && issued.type ? issued.type : "session";
-		const revalidate = type === "session" ? buildSessionRevalidator(user.identifier) : this.#buildBearerRevalidator(issued, user.identifier, type);
+		const type = issuedType(issued);
+		const revalidate = this.#revalidatorFor(user, issued, type);
 		const scopes = issued ? issued.getScopes() : void 0;
 		return new UserRealtimeToken(user, revalidate, type, scopes);
 	}
 	/**
+	* Le revalidateur de l'identité que le firewall a posée sur la requête
+	* COURANTE (ALS), pour toute connexion longue — socket WebSocket ou flux SSE.
+	*
+	* Une seule règle décide qu'une identité est morte, quel que soit le
+	* transport qui la porte : c'est celle-ci, et le hub comme le noyau HTTP
+	* l'appellent au lieu de la recopier.
+	*
+	* @returns `null` pour un anonyme (rien à révoquer), sinon la fonction qui
+	*   dit si l'identité est TOUJOURS valable — fail-closed : `false` quand elle
+	*   ne peut pas le prouver.
+	*/
+	currentRevalidator() {
+		const user = authenticatedUser();
+		if (user === null) return null;
+		const issued = readFirewallToken();
+		return this.#revalidatorFor(user, issued, issuedType(issued));
+	}
+	/**
+	* Choisit la preuve de révocation selon le mode d'authentification : la
+	* session se relit, un jeton porteur se borne par `exp` et la denylist.
+	*/
+	#revalidatorFor(user, issued, type) {
+		return type === "session" ? buildSessionRevalidator(user.identifier) : this.#buildBearerRevalidator(issued, user.identifier, type);
+	}
+	/**
 	* Re-validation d'une identité portée par un **jeton** (JWT, clé API, OAuth) :
 	* rejoue les trois conditions qui tuent un jeton, sans jamais parler de session.
 	*
@@ -129,6 +154,13 @@ const EMPTY_CLAIMS = Object.freeze({});
 function secondsToMs(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value * 1e3 : null;
 }
+/**
+* Le mode d'authentification du jeton du firewall. Absent (zone historique) →
+* le mode le plus strict, la session : un repli sûr, jamais permissif.
+*/
+function issuedType(issued) {
+	return typeof issued?.type === "string" && issued.type ? issued.type : "session";
+}
 /** Le jeton posé dans l'ALS par `firewall.handleSecurity`, s'il y en a un. */
 function readFirewallToken() {
 	return RequestContext.get()?.token;
@@ -161,14 +193,5 @@ function buildSessionRevalidator(identifier) {
 		}
 	};
 }
-/**
-* Vrai si `user` est un utilisateur AUTHENTIFIÉ (≠ anonyme). Le firewall pose
-* `token.getUser()` dans l'ALS : soit l'`IUser` réel, soit `anonymousUser`
-* (singleton). Tout ce qui n'est pas l'anonyme et porte un `identifier` est
-* une identité valide.
-*/
-function isAuthenticatedUser(user) {
-	return !!user && user !== anonymousUser && typeof user.identifier === "string";
-}
 //#endregion
 export { FirewallRealtimeAuthenticator, FirewallRealtimeAuthenticator as default };

package/dist/nodefony/src/authenticator/JwtAuthenticator.js

@@ -134,6 +134,7 @@ var JwtAuthenticator = class {
 		ut.setAttribute("scopes", scopes);
 		ut.setAttribute("jti", payload.jti);
 		ut.setAttribute("claims", payload);
+		ut.setAttribute("issuer", payload.iss);
 		return ut;
 	}
 	async #resolveUserOrReject(sub) {

package/dist/nodefony/src/authenticator/UserPasswordAuthenticator.js

@@ -24,22 +24,32 @@ var UserPasswordAuthenticator = class {
 	#verifier = null;
 	#resolveVerifier;
 	#throttler;
+	#transport;
 	/**
 	* @param resolveVerifier - résolution lazy de la source de vérification
 	*   (typiquement `container.get("users")`) — appelée au premier login.
 	* @param throttler - limiteur de tentatives (backoff NIST), `null` = désactivé.
+	* @param transport - politique du transport des secrets, `null` = aucune.
 	*/
-	constructor(resolveVerifier, throttler = null) {
+	constructor(resolveVerifier, throttler = null, transport = null) {
 		this.#resolveVerifier = resolveVerifier;
 		this.#throttler = throttler;
+		this.#transport = transport;
 	}
 	/** La requête porte-t-elle un en-tête `Authorization: Basic ...` ? */
 	supports(context) {
 		const auth = context.request?.headers.authorization;
 		return typeof auth === "string" && BASIC_SCHEME.test(auth);
 	}
-	/** Décode l'enveloppe Basic — un contenu malformé donne un credential vide (échec uniforme). */
+	/**
+	* Décode l'enveloppe Basic — un contenu malformé donne un credential vide
+	* (échec uniforme).
+	*
+	* @throws InsecureTransportError (403) — en production, en-tête reçu hors
+	*   TLS : refusé avant même d'être décodé.
+	*/
 	createToken(context) {
+		this.#transport?.assert(context, "basic");
 		const auth = context.request?.headers.authorization;
 		const decoded = Buffer.from(auth.replace(BASIC_SCHEME, ""), "base64").toString("utf8");
 		const sep = decoded.indexOf(":");
@@ -86,7 +96,7 @@ var UserPasswordAuthenticator = class {
 	onFailure(_context, _error) {
 		return Promise.resolve();
 	}
-	/** Challenge RFC 7235 posé par le firewall sur les 401 de la zone. */
+	/** Challenge RFC 9110 §11 posé par le firewall sur les 401 de la zone. */
 	challenge() {
 		return "Basic realm=\"nodefony\", charset=\"UTF-8\"";
 	}

package/dist/nodefony/src/authenticator/authenticatorRegistry.js

@@ -1,3 +1,4 @@
+import { compileProviderRoleMapping } from "../oauth/providerRoles.js";
 import { AnonymousAuthenticator } from "./AnonymousAuthenticator.js";
 import { SessionAuthenticator } from "./SessionAuthenticator.js";
 import { UserPasswordAuthenticator } from "./UserPasswordAuthenticator.js";
@@ -26,11 +27,12 @@ function listAuthenticatorFactories() {
 registerAuthenticatorFactory("anonymous", () => new AnonymousAuthenticator());
 registerAuthenticatorFactory("userpassword", ({ container }) => {
 	const throttler = container.get("loginThrottler") ?? null;
+	const transport = container.get("credentialTransport") ?? null;
 	return new UserPasswordAuthenticator(() => {
 		const verifier = container.get("users");
 		if (!verifier) throw new Error("UserPasswordAuthenticator: aucun service \"users\" (IPasswordVerifier) dans le container — enregistrer un UserService au boot de l'application.");
 		return verifier;
-	}, throttler);
+	}, throttler, transport);
 });
 registerAuthenticatorFactory("session", ({ container }) => {
 	return new SessionAuthenticator(() => {
@@ -50,7 +52,12 @@ registerAuthenticatorFactory("external-jwt", ({ container, config }) => {
 			subjectMapping: i.subjectMapping
 		})),
 		subjectPolicy: rs.subjectPolicy,
-		ephemeralRoles: rs.ephemeralRoles
+		ephemeralRoles: rs.ephemeralRoles,
+		oauthProviders: Object.entries(config.oauth2.providers).flatMap(([name, p]) => p.issuer ? [{
+			name,
+			issuer: p.issuer,
+			roleMapping: compileProviderRoleMapping(p)
+		}] : [])
 	});
 });
 registerAuthenticatorFactory("apikey", ({ container, config }) => {

package/dist/nodefony/src/authenticator/bearer.js

@@ -1,2 +1 @@
-import { bearerToken } from "nodefony";
-export { bearerToken };
+export { bearerToken } from "nodefony";

package/dist/nodefony/src/boot/publicRoutesNotice.js

@@ -0,0 +1,27 @@
+import { isFrameworkZone } from "nodefony";
+//#region nodefony/src/boot/publicRoutesNotice.ts
+/**
+* Le point d'attention « routes métier publiques » du bilan de démarrage.
+*
+* Hors d'une zone du pare-feu, une requête n'est jamais authentifiée : son
+* identité n'est pas résolue, et une route métier qu'on croyait protégée
+* répond à n'importe qui. Les seules zones présentes sont alors les aires du
+* framework (`/nodefony/*`) ; on le DIT au démarrage, avec la recette.
+*
+* La classification « applicative ou framework » n'est pas recopiée : elle
+* vient du cœur (`isFrameworkZone`), qui l'applique aussi au tableau des zones.
+*
+* @param zones - zones montées (`firewall.describe().zones`).
+* @returns le point à déclarer, ou `null` si une zone applicative existe.
+*/
+function publicRoutesNotice(zones) {
+	if (zones.some((z) => !isFrameworkZone(z))) return null;
+	return {
+		code: "FIREWALL_PUBLIC_ROUTES",
+		level: "warning",
+		message: "Tes routes métier sont PUBLIQUES — aucune zone de pare-feu ne les couvre",
+		fix: "use(\"@nodefony/security\", { areas: { main: { pattern: \"^/api\", authenticators: [\"session\"] } } })"
+	};
+}
+//#endregion
+export { publicRoutesNotice };

package/dist/nodefony/src/entryPoint.js

@@ -0,0 +1,39 @@
+import { loginPagePath, safeRedirectPath } from "nodefony";
+//#region nodefony/src/entryPoint.ts
+/**
+* Dit si une requête refusée est la NAVIGATION d'un navigateur — le seul cas
+* où conduire à la page de connexion aide, au lieu de casser un client.
+*
+* `GET` ou `HEAD`, `Accept` qui demande du HTML, et `Sec-Fetch-Mode: navigate`
+* quand l'en-tête est présent : un `fetch()` d'une page porte `cors` ou
+* `same-origin` même s'il accepte du HTML, et recevrait une page de connexion
+* à la place de ses données.
+*
+* @param request - la requête refusée
+* @returns `true` pour une navigation
+*/
+function isBrowserNavigation(request) {
+	const method = request.method?.toUpperCase();
+	if (method !== "GET" && method !== "HEAD") return false;
+	if (request.accept?.toLowerCase().includes("text/html") !== true) return false;
+	return request.fetchMode === void 0 || request.fetchMode.toLowerCase() === "navigate";
+}
+/**
+* L'adresse de la page de connexion pour un visiteur refusé :
+* `<entryPoint>?from=<chemin demandé>`, composée par `loginPagePath` (cœur).
+* Le chemin demandé repasse par `safeRedirectPath` — la seule garde
+* anti-redirection ouverte du framework, que la page de connexion appliquera
+* de nouveau au retour.
+*
+* @param entryPoint - chemin de la page de connexion (vérifié au boot)
+* @param request - la requête refusée
+* @returns l'adresse du `Location`, ou `null` quand ce n'est pas une
+*   navigation, ou quand la page demandée EST la page de connexion
+*/
+function entryPointLocation(entryPoint, request) {
+	if (!isBrowserNavigation(request)) return null;
+	if (request.path.split("?", 1)[0] === entryPoint.split("?", 1)[0]) return null;
+	return loginPagePath(safeRedirectPath(request.path), entryPoint);
+}
+//#endregion
+export { entryPointLocation, isBrowserNavigation };

package/dist/nodefony/src/oauth/clientCredentials.js

@@ -0,0 +1,40 @@
+import { postTokenRequest } from "./oauth2Client.js";
+import { discoverAuthorizationServer } from "./metadata.js";
+//#region nodefony/src/oauth/clientCredentials.ts
+/**
+* Obtient un jeton d'accès pour un programme, par le flux `client_credentials`
+* (RFC 6749 §4.4), auprès d'un émetteur découvert (RFC 8414).
+*
+* C'est la voie de l'appelant MACHINE : il s'authentifie avec son propre
+* secret, et le jeton rendu le désigne lui, pas un utilisateur. La même
+* authentification de client que l'échange de code ({@link postTokenRequest}) —
+* une seule implémentation, pour qu'aucune règle ne diverge d'un flux à l'autre.
+*
+* @param request - émetteur, identité du client, portées et ressource.
+* @returns Les jetons rendus ; `accessToken()` est celui à présenter en `Bearer`.
+* @throws Error - secret vide, émetteur invalide ou injoignable, métadonnées discordantes.
+* @throws OAuth2RequestError - le serveur a refusé (`invalid_client` : secret
+*   faux ; `unauthorized_client` : le client n'a pas droit à ce flux).
+*/
+async function requestClientCredentialsToken(request) {
+	if (request.clientSecret.length === 0) throw new Error(`client « ${request.clientId} » : secret vide — le flux client_credentials n'existe que pour un client confidentiel (RFC 6749 §4.4).`);
+	const server = await discoverAuthorizationServer(request.issuer, {
+		discoveryUrl: request.discoveryUrl,
+		...request.fetch ? { fetch: request.fetch } : {},
+		...request.timeoutMs !== void 0 ? { timeoutMs: request.timeoutMs } : {}
+	});
+	const body = new URLSearchParams();
+	body.set("grant_type", "client_credentials");
+	if (request.scopes !== void 0 && request.scopes.length > 0) body.set("scope", request.scopes.join(" "));
+	if (request.resource !== void 0) body.set("resource", request.resource);
+	return postTokenRequest({
+		tokenEndpoint: server.tokenEndpoint,
+		clientId: request.clientId,
+		clientSecret: request.clientSecret,
+		clientAuthMethod: request.clientAuthMethod ?? "client_secret_basic",
+		fetch: request.fetch,
+		timeoutMs: request.timeoutMs
+	}, body);
+}
+//#endregion
+export { requestClientCredentialsToken };

package/dist/nodefony/src/oauth/metadata.js

@@ -1,5 +1,5 @@
 import { readJsonObjectBounded } from "./httpJson.js";
-import { canonicalIssuer, issuerMetadataUrls, validateIssuerMetadata } from "nodefony";
+import { canonicalIssuer, isBackChannelTransportAllowed, metadataCandidateUrls, validateIssuerMetadata } from "nodefony";
 //#region nodefony/src/oauth/metadata.ts
 /**
 * **Découverte des métadonnées d'un serveur d'autorisation** (RFC 8414) — la face
@@ -22,6 +22,19 @@ import { canonicalIssuer, issuerMetadataUrls, validateIssuerMetadata } from "nod
 const DISCOVERY_TIMEOUT_MS = 1e4;
 /** Au-delà, le document n'est plus un document de métadonnées — on refuse de lire. */
 const MAX_METADATA_BYTES = 1048576;
+/**
+* Rend un échec de transport LISIBLE : `fetch` (undici) ne dit que
+* `fetch failed` et range la vraie raison dans `cause` — certificat refusé,
+* connexion refusée, nom introuvable. Sans elle, « métadonnées introuvables »
+* envoie chercher un émetteur absent quand c'est la confiance TLS qui manque.
+*/
+function describeTransportFailure(error) {
+	if (!(error instanceof Error)) return String(error);
+	const cause = error.cause;
+	if (!(cause instanceof Error)) return error.message;
+	const code = cause.code;
+	return typeof code === "string" ? `${error.message} (${code} : ${cause.message})` : `${error.message} (${cause.message})`;
+}
 async function fetchMetadataDocument(url, options) {
 	const response = await (options.fetch ?? globalThis.fetch)(url, {
 		headers: {
@@ -34,7 +47,7 @@ async function fetchMetadataDocument(url, options) {
 	if (!response.ok) throw new Error(`${url} → HTTP ${response.status}`);
 	return readJsonObjectBounded(response, MAX_METADATA_BYTES, url);
 }
-function requireEndpoint(document, field, issuer) {
+function requireEndpoint(document, field, issuer, backChannelOf) {
 	const value = document[field];
 	if (typeof value !== "string" || value.length === 0) throw new Error(`métadonnées de « ${issuer} » : champ « ${field} » absent (RFC 8414 §2).`);
 	let url;
@@ -43,10 +56,20 @@ function requireEndpoint(document, field, issuer) {
 	} catch {
 		throw new Error(`métadonnées de « ${issuer} » : « ${field} » n'est pas une URL.`);
 	}
-	if (url.protocol !== "https:") throw new Error(`métadonnées de « ${issuer} » : « ${field} » doit être en https.`);
+	if (!(backChannelOf === void 0 ? url.protocol === "https:" : isBackChannelTransportAllowed(url, backChannelOf))) throw new Error(`métadonnées de « ${issuer} » : « ${field} » doit être en https` + (backChannelOf === void 0 ? "." : ` (ou en http sur l'origine de discoveryUrl « ${backChannelOf} »).`));
 	return value;
 }
 /**
+* Point d'entrée FACULTATIF : absent ⇒ `null` ; présent, il obéit aux mêmes
+* règles qu'un point requis (URL https) — un serveur qui publie un point
+* malformé se signale à la découverte, pas au premier clic de l'utilisateur.
+*/
+function optionalEndpoint(document, field, issuer) {
+	const value = document[field];
+	if (value === void 0 || value === null) return null;
+	return requireEndpoint(document, field, issuer);
+}
+/**
 * Interroge un serveur d'autorisation et rend ses points d'entrée.
 *
 * Les URL candidates sont celles du cœur (`issuerMetadataUrls`, ordre normatif
@@ -56,30 +79,34 @@ function requireEndpoint(document, field, issuer) {
 * d'entrée — la même attaque que le paramètre `iss` couvre au retour (RFC 9207).
 *
 * @param rawIssuer - identifiant d'émetteur tel qu'écrit en configuration.
-* @param options - transport injectable et délai d'attente.
+* @param options - transport injectable, délai d'attente, adresse de découverte.
 * @returns Les points d'entrée, prêts pour `OAuth2Client`.
 * @throws Error - émetteur mal formé, document introuvable, incomplet, ou `issuer` discordant.
 */
 async function discoverAuthorizationServer(rawIssuer, options = {}) {
 	const issuer = canonicalIssuer(rawIssuer);
 	const failures = [];
-	for (const candidate of issuerMetadataUrls(issuer)) {
+	const discoveryUrl = options.discoveryUrl;
+	for (const candidate of metadataCandidateUrls(issuer, discoveryUrl)) {
 		let document;
 		try {
 			document = await fetchMetadataDocument(candidate, options);
 		} catch (error) {
-			failures.push(error instanceof Error ? error.message : String(error));
+			failures.push(describeTransportFailure(error));
 			continue;
 		}
-		const identity = validateIssuerMetadata(document, issuer);
+		const identity = validateIssuerMetadata(document, issuer, discoveryUrl);
 		const methods = document.code_challenge_methods_supported;
+		const idTokenAlgs = document.id_token_signing_alg_values_supported;
 		return {
 			issuer: identity.issuer,
 			jwksUri: identity.jwksUri,
 			authorizationEndpoint: requireEndpoint(document, "authorization_endpoint", issuer),
-			tokenEndpoint: requireEndpoint(document, "token_endpoint", issuer),
+			tokenEndpoint: requireEndpoint(document, "token_endpoint", issuer, discoveryUrl),
 			codeChallengeMethodsSupported: Array.isArray(methods) ? methods.filter((m) => typeof m === "string") : null,
-			issParameterSupported: document.authorization_response_iss_parameter_supported === true
+			issParameterSupported: document.authorization_response_iss_parameter_supported === true,
+			endSessionEndpoint: optionalEndpoint(document, "end_session_endpoint", issuer),
+			idTokenSigningAlgValuesSupported: Array.isArray(idTokenAlgs) ? idTokenAlgs.filter((a) => typeof a === "string") : null
 		};
 	}
 	throw new Error(`métadonnées introuvables pour « ${issuer} » — ${failures.join(" ; ")}`);

package/dist/nodefony/src/oauth/oauth2Client.js

@@ -79,11 +79,21 @@ var OAuth2RequestError = class extends Error {
 	code;
 	/** Description lisible fournie par le serveur, ou `null`. */
 	description;
-	constructor(code, description) {
+	/**
+	* Statut HTTP de la réponse, ou `null` s'il n'est pas connu.
+	*
+	* Le code `error` ne suffit pas toujours à dire QUI est refusé : la RFC 6749
+	* §5.2 réserve `401` à l'échec d'authentification du client, et Keycloak
+	* répond `unauthorized_client` en `401` sur un secret faux — le même code
+	* qu'en `400` pour un flux que le client n'a pas le droit d'employer.
+	*/
+	status;
+	constructor(code, description, status = null) {
 		super(description === null ? code : `${code}: ${description}`);
 		this.name = "OAuth2RequestError";
 		this.code = code;
 		this.description = description;
+		this.status = status;
 	}
 };
 /**
@@ -229,38 +239,55 @@ var OAuth2Client = class {
 		body.set("code", request.code);
 		body.set("redirect_uri", this.#options.redirectUri);
 		if (request.codeVerifier !== null) body.set("code_verifier", request.codeVerifier);
-		const headers = {
-			"Content-Type": "application/x-www-form-urlencoded",
-			Accept: "application/json",
-			"User-Agent": "nodefony"
-		};
-		switch (this.#options.clientAuthMethod) {
-			case "client_secret_basic":
-				headers.Authorization = `Basic ${this.#basicCredentials()}`;
-				break;
-			case "client_secret_post":
-				body.set("client_id", this.#options.clientId);
-				body.set("client_secret", this.#options.clientSecret);
-				break;
-			case "none": body.set("client_id", this.#options.clientId);
-		}
-		const response = await (this.#options.fetch ?? globalThis.fetch)(this.#options.tokenEndpoint, {
-			method: "POST",
-			headers,
-			body: body.toString(),
-			redirect: "error",
-			signal: AbortSignal.timeout(this.#options.timeoutMs ?? TOKEN_REQUEST_TIMEOUT_MS)
-		});
-		const data = await readJsonObjectBounded(response, MAX_TOKEN_RESPONSE_BYTES, `point de jeton (HTTP ${response.status})`);
-		if (typeof data.error === "string") throw new OAuth2RequestError(data.error, typeof data.error_description === "string" ? data.error_description : null);
-		if (!response.ok) throw new Error(`Point de jeton en échec (HTTP ${response.status}).`);
-		return new OAuth2Tokens(data);
-	}
-	#basicCredentials() {
-		const id = formUrlencode(this.#options.clientId);
-		const secret = formUrlencode(this.#options.clientSecret);
-		return Buffer.from(`${id}:${secret}`, "utf8").toString("base64");
+		return postTokenRequest(this.#options, body);
 	}
 };
+/**
+* Présente une requête au point de jeton et rend les jetons (RFC 6749 §5.1).
+*
+* SEULE implémentation de l'authentification du client et de la lecture de la
+* réponse : l'échange de code et le flux `client_credentials` y passent tous
+* deux, pour qu'une règle (méthode déclarée, redirection refusée, réponse
+* bornée, refus lu sur `error`) ne diverge jamais entre deux flux.
+*
+* @param client - point de jeton et identité du client.
+* @param body - corps de la requête, `grant_type` compris ; l'identité du
+*   client y est ajoutée selon la méthode déclarée.
+* @throws OAuth2RequestError - le serveur a refusé, en nommant la cause (RFC 6749 §5.2).
+* @throws Error - réponse inintelligible, hors gabarit, ou serveur injoignable.
+*/
+async function postTokenRequest(client, body) {
+	const headers = {
+		"Content-Type": "application/x-www-form-urlencoded",
+		Accept: "application/json",
+		"User-Agent": "nodefony"
+	};
+	switch (client.clientAuthMethod) {
+		case "client_secret_basic":
+			headers.Authorization = `Basic ${basicCredentials(client)}`;
+			break;
+		case "client_secret_post":
+			body.set("client_id", client.clientId);
+			body.set("client_secret", client.clientSecret);
+			break;
+		case "none": body.set("client_id", client.clientId);
+	}
+	const response = await (client.fetch ?? globalThis.fetch)(client.tokenEndpoint, {
+		method: "POST",
+		headers,
+		body: body.toString(),
+		redirect: "error",
+		signal: AbortSignal.timeout(client.timeoutMs ?? TOKEN_REQUEST_TIMEOUT_MS)
+	});
+	const data = await readJsonObjectBounded(response, MAX_TOKEN_RESPONSE_BYTES, `point de jeton (HTTP ${response.status})`);
+	if (typeof data.error === "string") throw new OAuth2RequestError(data.error, typeof data.error_description === "string" ? data.error_description : null, response.status);
+	if (!response.ok) throw new Error(`Point de jeton en échec (HTTP ${response.status}).`);
+	return new OAuth2Tokens(data);
+}
+function basicCredentials(client) {
+	const id = formUrlencode(client.clientId);
+	const secret = formUrlencode(client.clientSecret);
+	return Buffer.from(`${id}:${secret}`, "utf8").toString("base64");
+}
 //#endregion
-export { OAuth2Client, OAuth2RequestError, OAuth2Tokens, createCodeChallenge, generateCodeVerifier, generateState };
+export { OAuth2Client, OAuth2RequestError, OAuth2Tokens, createCodeChallenge, generateCodeVerifier, generateState, postTokenRequest };

package/dist/nodefony/src/oauth/oauthProviderRegistry.js

@@ -5,22 +5,55 @@ const factories = /* @__PURE__ */ new Map();
 /**
 * Enregistre (ou remplace) la fabrique d'un fournisseur OAuth. Appelée par les
 * builtins au chargement, et par une application pour ses fournisseurs.
+*
+* @param name - nom sous lequel le fournisseur se configure (`oauth2.providers.<name>`).
+* @param factory - fabrique du fournisseur.
+* @param registration - exigences de configuration, vérifiées au démarrage.
 */
-function registerOAuthProvider(name, factory) {
-	factories.set(name, factory);
+function registerOAuthProvider(name, factory, registration = {}) {
+	factories.set(name, {
+		factory,
+		requiresIssuer: registration.requiresIssuer === true
+	});
 }
 /** Fabrique d'un fournisseur par nom, ou `undefined` si inconnu. */
 function getOAuthProviderFactory(name) {
-	return factories.get(name);
+	return factories.get(name)?.factory;
+}
+/** `true` si le fournisseur nommé a déclaré exiger un émetteur en configuration. */
+function oauthProviderRequiresIssuer(name) {
+	return factories.get(name)?.requiresIssuer === true;
 }
 /** Noms enregistrés (validation boot, introspection Studio, tests). */
 function listOAuthProviders() {
 	return [...factories.keys()];
 }
+/**
+* Paramètre d'autorisation que lit le thème Keycloak livré (`template.ftl`)
+* pour afficher l'écran dans le thème de l'application (`light` | `dark`).
+*/
+const KEYCLOAK_THEME_PARAMETER = "nf_theme";
+/**
+* Ajoute le thème demandé ({@link IAuthorizationRequest.theme}) à l'URL
+* d'autorisation d'un fournisseur Keycloak, sous {@link KEYCLOAK_THEME_PARAMETER}.
+*
+* @param provider - fournisseur OIDC découvert, inchangé pour tout le reste
+* @returns le même fournisseur, dont l'URL d'autorisation porte le thème
+*/
+function withKeycloakThemeHint(provider) {
+	return {
+		...provider,
+		createAuthorizationURL(request) {
+			const url = provider.createAuthorizationURL(request);
+			if (request.theme === "light" || request.theme === "dark") url.searchParams.set(KEYCLOAK_THEME_PARAMETER, request.theme);
+			return url;
+		}
+	};
+}
 const GOOGLE_ISSUER = "https://accounts.google.com";
 registerOAuthProvider("google", (ctx) => createDiscoveredOidcProvider("google", ctx, { issuer: GOOGLE_ISSUER }));
-registerOAuthProvider("keycloak", (ctx) => createDiscoveredOidcProvider("keycloak", ctx));
-registerOAuthProvider("oidc", (ctx) => createDiscoveredOidcProvider("oidc", ctx));
+registerOAuthProvider("keycloak", async (ctx) => withKeycloakThemeHint(await createDiscoveredOidcProvider("keycloak", ctx)), { requiresIssuer: true });
+registerOAuthProvider("oidc", (ctx) => createDiscoveredOidcProvider("oidc", ctx), { requiresIssuer: true });
 registerOAuthProvider("github", createGithubProvider);
 //#endregion
-export { getOAuthProviderFactory, listOAuthProviders, registerOAuthProvider };
+export { KEYCLOAK_THEME_PARAMETER, getOAuthProviderFactory, listOAuthProviders, oauthProviderRequiresIssuer, registerOAuthProvider, withKeycloakThemeHint };