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

package/dist/nodefony/keycloak/keycloakAdmin.js

@@ -0,0 +1,254 @@
+import { isNodefonyKeycloakTheme, keycloakLoginTheme, realmNameFromIssuer } from "./keycloakRealmInput.js";
+// nodefony/keycloak/keycloakAdmin.ts
+/** Refus ou échec d'un appel ; le message nomme la cause et le geste suivant. */
+var KeycloakAdminError = class extends Error {
+	status;
+	/**
+	* @param message - phrase destinée à l'opérateur
+	* @param status - statut HTTP de Keycloak, `null` s'il n'a pas répondu
+	*/
+	constructor(message, status = null) {
+		super(message);
+		this.status = status;
+		this.name = "KeycloakAdminError";
+	}
+};
+const DEFAULT_TIMEOUT_MS = 1e4;
+/**
+* Marge retirée à la durée de vie du jeton : un jeton qui expire PENDANT un
+* appel rend un 401 qu'on lirait comme un compte refusé.
+*/
+const TOKEN_MARGIN_MS = 1e4;
+/**
+* Le realm et le compte d'administration d'un fournisseur, lus dans la
+* configuration de sécurité VALIDÉE.
+*
+* @param config - configuration de sécurité (`defineSecurityConfig`)
+* @param providerName - nom dans `oauth2.providers` (défaut `keycloak`)
+* @returns l'émetteur et le compte
+* @throws {KeycloakAdminError} Fournisseur absent, sans émetteur ou sans
+*   compte d'administration
+*/
+function keycloakAdminTarget(config, providerName = "keycloak") {
+	const provider = Object.hasOwn(config.oauth2.providers, providerName) ? config.oauth2.providers[providerName] : void 0;
+	if (provider?.issuer === void 0) throw new KeycloakAdminError(`aucun fournisseur « ${providerName} » avec un issuer dans oauth2.providers — il n'est monté que si ses variables NF_KEYCLOAK_* sont posées`);
+	if (provider.admin === void 0) throw new KeycloakAdminError(`oauth2.providers.${providerName}.admin absent : l'API d'administration exige le compte administrateur de Keycloak (NF_KEYCLOAK_ADMIN_USERNAME / NF_KEYCLOAK_ADMIN_PASSWORD, passés en développement seulement)`);
+	return {
+		issuer: provider.issuer,
+		admin: provider.admin
+	};
+}
+/**
+* Client de l'API d'administration d'UN realm Keycloak.
+*
+* Le jeton `admin-cli` est demandé au premier appel puis GARDÉ jusqu'à son
+* expiration ; un 401 en cours de route le renouvelle une fois. Les gardes
+* (développement seulement, https seulement) sont tenues au constructeur :
+* un client qui existe a le droit de parler.
+*/
+var KeycloakAdminClient = class {
+	/** Nom du realm administré. */
+	realm;
+	/** Origine du serveur (`https://hôte:port`). */
+	origin;
+	#admin;
+	#fetch;
+	#timeoutMs;
+	#token = null;
+	/**
+	* @param options - realm, compte, environnement, transport
+	* @throws {KeycloakAdminError} Hors développement, émetteur qui n'est pas un
+	*   realm, ou émetteur en clair
+	*/
+	constructor(options) {
+		if (options.environment !== "development") throw new KeycloakAdminError(`refusé en « ${options.environment} » : l'API d'administration exige le compte administrateur de Keycloak, réservé au développement — en production, passer par la console (Realm settings)`);
+		try {
+			this.realm = realmNameFromIssuer(options.issuer);
+		} catch (error) {
+			throw new KeycloakAdminError(error instanceof Error ? error.message : String(error));
+		}
+		const url = new URL(options.issuer);
+		if (url.protocol !== "https:") throw new KeycloakAdminError(`émetteur « ${options.issuer} » en clair : le mot de passe administrateur ne part qu'en https`);
+		this.origin = url.origin;
+		this.#admin = options.admin;
+		this.#fetch = options.fetch ?? globalThis.fetch;
+		this.#timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	}
+	/**
+	* Un appel à l'API d'administration du realm, jeton joint.
+	*
+	* @param method - verbe HTTP
+	* @param path - chemin SOUS `/admin/realms/<realm>` (`""` = le realm, `/users?…`)
+	* @param body - corps JSON, ou rien
+	* @returns la réponse brute — au consommateur de lire son statut
+	* @throws {KeycloakAdminError} Serveur injoignable ou compte refusé
+	*/
+	async request(method, path, body) {
+		const url = `${this.origin}/admin/realms/${encodeURIComponent(this.realm)}${path}`;
+		const send = async (token) => this.#call(url, {
+			method,
+			headers: {
+				authorization: `Bearer ${token}`,
+				accept: "application/json",
+				...body === void 0 ? {} : { "content-type": "application/json" }
+			},
+			...body === void 0 ? {} : { body: JSON.stringify(body) }
+		});
+		const response = await send(await this.#accessToken());
+		if (response.status !== 401) return response;
+		await response.body?.cancel();
+		this.#token = null;
+		return send(await this.#accessToken());
+	}
+	/**
+	* La représentation du realm.
+	*
+	* @returns l'objet JSON rendu par Keycloak
+	* @throws {KeycloakAdminError} Realm introuvable ou lecture refusée
+	*/
+	async getRealm() {
+		const response = await this.request("GET", "");
+		if (!response.ok) {
+			await response.body?.cancel();
+			throw new KeycloakAdminError(response.status === 404 ? `realm « ${this.realm} » introuvable sur ${this.origin}` : `lecture du realm « ${this.realm} » refusée (HTTP ${response.status})`, response.status);
+		}
+		const body = await response.json();
+		if (typeof body !== "object" || body === null || Array.isArray(body)) throw new KeycloakAdminError(`Keycloak a rendu autre chose qu'un realm pour « ${this.realm} »`);
+		return Object.fromEntries(Object.entries(body));
+	}
+	/**
+	* Change des champs du realm — et eux seuls : Keycloak ne touche pas aux
+	* champs absents d'un `PUT` partiel.
+	*
+	* @param changes - les champs à écrire
+	* @throws {KeycloakAdminError} Écriture refusée
+	*/
+	async updateRealm(changes) {
+		const response = await this.request("PUT", "", changes);
+		await response.body?.cancel();
+		if (!response.ok) throw new KeycloakAdminError(`écriture refusée sur le realm « ${this.realm} » (HTTP ${response.status})`, response.status);
+	}
+	/**
+	* Pose sur le realm le thème de connexion qui porte un habillage de `/login`.
+	*
+	* Un realm habillé par l'application (thème ni `nodefony` ni `nodefony-*`,
+	* ou aucun) n'est JAMAIS modifié : même règle que la dérivation du fichier
+	* d'import.
+	*
+	* @param skin - habillage (`loginPage.skin`, ou celui d'un aperçu)
+	* @returns le thème d'avant, celui demandé, et ce qui a été fait
+	* @throws {KeycloakAdminError} Keycloak injoignable, compte refusé, realm
+	*   introuvable
+	*/
+	async applyLoginTheme(skin) {
+		const theme = keycloakLoginTheme(skin);
+		const current = (await this.getRealm()).loginTheme;
+		const previous = typeof current === "string" && current.length > 0 ? current : null;
+		const realm = this.realm;
+		if (previous === null || !isNodefonyKeycloakTheme(previous)) return {
+			realm,
+			previous,
+			theme,
+			outcome: "unmanaged"
+		};
+		if (previous === theme) return {
+			realm,
+			previous,
+			theme,
+			outcome: "unchanged"
+		};
+		await this.updateRealm({ loginTheme: theme });
+		return {
+			realm,
+			previous,
+			theme,
+			outcome: "applied"
+		};
+	}
+	/** Le jeton `admin-cli`, gardé jusqu'à son expiration. */
+	async #accessToken() {
+		if (this.#token !== null && this.#token.expiresAt > Date.now()) return this.#token.value;
+		const response = await this.#call(`${this.origin}/realms/master/protocol/openid-connect/token`, {
+			method: "POST",
+			headers: { "content-type": "application/x-www-form-urlencoded" },
+			body: new URLSearchParams({
+				grant_type: "password",
+				client_id: "admin-cli",
+				username: this.#admin.username,
+				password: this.#admin.password
+			}).toString()
+		});
+		if (!response.ok) {
+			await response.body?.cancel();
+			throw new KeycloakAdminError(`compte administrateur refusé par Keycloak (HTTP ${response.status}, realm master) — vérifier NF_KEYCLOAK_ADMIN_USERNAME et NF_KEYCLOAK_ADMIN_PASSWORD`, response.status);
+		}
+		const payload = await response.json();
+		const field = (key) => typeof payload === "object" && payload !== null ? Object.getOwnPropertyDescriptor(payload, key)?.value : void 0;
+		const accessToken = field("access_token");
+		const expiresIn = field("expires_in");
+		if (typeof accessToken !== "string" || accessToken === "") throw new KeycloakAdminError("Keycloak n'a rendu aucun jeton d'administration");
+		const lifetimeMs = typeof expiresIn === "number" ? expiresIn * 1e3 : 0;
+		this.#token = {
+			value: accessToken,
+			expiresAt: Date.now() + lifetimeMs - TOKEN_MARGIN_MS
+		};
+		return accessToken;
+	}
+	/** Un appel réseau borné ; une panne devient une erreur qui nomme le serveur. */
+	async #call(url, init) {
+		try {
+			return await this.#fetch(url, {
+				...init,
+				signal: AbortSignal.timeout(this.#timeoutMs)
+			});
+		} catch (error) {
+			const cause = error instanceof Error && error.cause instanceof Error ? ` (${error.cause.message})` : "";
+			throw new KeycloakAdminError(`Keycloak injoignable à ${this.origin} : ${error instanceof Error ? error.message : String(error)}${cause}`);
+		}
+	}
+};
+/**
+* Le thème de connexion qu'une page servie par Keycloak charge.
+*
+* Lu sans aucun identifiant : la page d'autorisation publique charge ses
+* fichiers sous `/resources/<version>/login/<thème>/…`.
+*
+* @param html - début de la page d'autorisation
+* @returns le nom du thème, ou `null` si la page n'est pas celle de Keycloak
+*/
+function readKeycloakLoginTheme(html) {
+	const match = /\/resources\/[^/"'\s]+\/login\/([^/"'\s]+)\//u.exec(html);
+	return match?.[1] === void 0 ? null : decodeURIComponent(match[1]);
+}
+/**
+* La sonde « thème » du diagnostic d'un fournisseur : la page de Keycloak
+* suit-elle l'habillage de `/login` ?
+*
+* @param skin - habillage configuré (`loginPage.skin`)
+* @returns une fonction qui juge la page d'autorisation ; elle rend `null` —
+*   aucune sonde — sur une page qui n'est pas de Keycloak
+*/
+function keycloakLoginThemeCheck(skin) {
+	const expected = keycloakLoginTheme(skin);
+	return (html) => {
+		const active = readKeycloakLoginTheme(html);
+		if (active === null) return null;
+		if (!isNodefonyKeycloakTheme(active)) return {
+			name: "theme",
+			status: "ok",
+			message: `thème « ${active} » propre à l'application, laissé tel quel`
+		};
+		if (active === expected) return {
+			name: "theme",
+			status: "ok",
+			message: `la page de Keycloak suit l'habillage « ${skin} » (${active})`
+		};
+		return {
+			name: "theme",
+			status: "failed",
+			kind: "login-theme-mismatch",
+			message: `Keycloak affiche le thème « ${active} », l'habillage « ${skin} » demande « ${expected} » — la connexion marche, mais ne ressemble pas à /login : nodefony security:keycloak:realm --apply (ou Realm settings › Themes)`
+		};
+	};
+}
+export { KeycloakAdminClient, KeycloakAdminError, keycloakAdminTarget, keycloakLoginThemeCheck, readKeycloakLoginTheme };

package/dist/nodefony/keycloak/keycloakRealm.js

@@ -0,0 +1,259 @@
+// nodefony/keycloak/keycloakRealm.ts
+/** Le type du mapper qui ajoute une audience au jeton d'accès. */
+const AUDIENCE_MAPPER = "oidc-audience-mapper";
+/**
+* Le nom d'un mapper d'audience — stable, pour qu'une régénération réécrive
+* le même mapper au lieu d'en ajouter un.
+*/
+function audienceMapperName(realm, index) {
+	return index === 0 ? `audience-${realm}-api` : `audience-${realm}-api-${index + 1}`;
+}
+function audienceMappers(input) {
+	return input.audiences.map((audience, index) => ({
+		name: audienceMapperName(input.realm, index),
+		protocol: "openid-connect",
+		protocolMapper: AUDIENCE_MAPPER,
+		config: {
+			"included.custom.audience": audience,
+			"access.token.claim": "true",
+			"id.token.claim": "false",
+			"introspection.token.claim": "true"
+		}
+	}));
+}
+function roleObjects(roles) {
+	return roles.map((role) => role.description === void 0 ? { name: role.name } : {
+		name: role.name,
+		description: role.description
+	});
+}
+function browserClient(input) {
+	const attributes = {
+		"pkce.code.challenge.method": "S256",
+		"post.logout.redirect.uris": input.postLogoutRedirectUris.join("##")
+	};
+	if (input.backchannelLogoutUrl !== null) {
+		attributes["backchannel.logout.url"] = input.backchannelLogoutUrl;
+		attributes["backchannel.logout.session.required"] = "true";
+		attributes["backchannel.logout.revoke.offline.tokens"] = "false";
+	}
+	return {
+		clientId: input.clientId,
+		...input.clientName === void 0 ? {} : { name: input.clientName },
+		...input.clientDescription === void 0 ? {} : { description: input.clientDescription },
+		enabled: true,
+		protocol: "openid-connect",
+		publicClient: false,
+		clientAuthenticatorType: "client-secret",
+		...input.clientSecret === null ? {} : { secret: input.clientSecret },
+		standardFlowEnabled: true,
+		implicitFlowEnabled: false,
+		directAccessGrantsEnabled: false,
+		serviceAccountsEnabled: false,
+		frontchannelLogout: false,
+		redirectUris: [...input.redirectUris],
+		webOrigins: ["+"],
+		attributes,
+		protocolMappers: audienceMappers(input)
+	};
+}
+function machineClient(input, machine) {
+	return {
+		clientId: machine.clientId,
+		...machine.name === void 0 ? {} : { name: machine.name },
+		...machine.description === void 0 ? {} : { description: machine.description },
+		enabled: true,
+		protocol: "openid-connect",
+		publicClient: false,
+		clientAuthenticatorType: "client-secret",
+		...machine.secret === null ? {} : { secret: machine.secret },
+		standardFlowEnabled: false,
+		implicitFlowEnabled: false,
+		directAccessGrantsEnabled: false,
+		serviceAccountsEnabled: true,
+		protocolMappers: audienceMappers(input)
+	};
+}
+/**
+* Le rôle composite que Keycloak donne à tout compte CRÉÉ dans le realm —
+* `manage-account`, `view-profile`, `offline_access`, `uma_authorization`.
+*
+* ⚠️ Un compte IMPORTÉ ne le reçoit pas : l'import n'accorde que les rôles
+* qu'il liste. Sans lui, la console du compte rend 401 sur le profil même de
+* l'utilisateur.
+*
+* @param realm - nom du realm
+* @returns le nom du rôle par défaut
+*/
+function keycloakDefaultRole(realm) {
+	return `default-roles-${realm}`;
+}
+function userObject(realm, clientId, user) {
+	return {
+		id: user.id,
+		username: user.username,
+		enabled: true,
+		email: user.email,
+		emailVerified: true,
+		firstName: user.firstName,
+		lastName: user.lastName,
+		credentials: [{
+			type: "password",
+			value: user.password,
+			temporary: false
+		}],
+		realmRoles: [keycloakDefaultRole(realm)],
+		...user.clientRoles === void 0 || user.clientRoles.length === 0 ? {} : { clientRoles: { [clientId]: [...user.clientRoles] } }
+	};
+}
+/**
+* Construit le realm d'import complet d'une application.
+*
+* @param input - ce que la configuration de l'application dit du realm
+* @returns le realm, prêt à être sérialisé par {@link renderKeycloakRealm}
+*/
+function buildKeycloakRealm(input) {
+	const roles = {};
+	if (input.realmRoles.length > 0) roles.realm = roleObjects(input.realmRoles);
+	if (input.clientRoles.length > 0) roles.client = { [input.clientId]: roleObjects(input.clientRoles) };
+	const clients = [browserClient(input)];
+	if (input.machine !== null) clients.push(machineClient(input, input.machine));
+	return {
+		realm: input.realm,
+		displayName: input.displayName ?? input.realm,
+		enabled: true,
+		sslRequired: "external",
+		registrationAllowed: false,
+		loginWithEmailAllowed: true,
+		...input.themes?.login === void 0 ? {} : { loginTheme: input.themes.login },
+		...input.themes?.account === void 0 ? {} : { accountTheme: input.themes.account },
+		...input.themes?.email === void 0 ? {} : { emailTheme: input.themes.email },
+		...input.themes?.admin === void 0 ? {} : { adminTheme: input.themes.admin },
+		internationalizationEnabled: true,
+		supportedLocales: ["fr", "en"],
+		defaultLocale: "fr",
+		clients,
+		...Object.keys(roles).length === 0 ? {} : { roles },
+		...input.users === void 0 || input.users.length === 0 ? {} : { users: input.users.map((u) => userObject(input.realm, input.clientId, u)) },
+		rememberMe: true
+	};
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function objects(value) {
+	return Array.isArray(value) ? value.filter(isObject) : [];
+}
+/**
+* Les champs qu'un client hérite du realm existant quand il y figure : un nom,
+* un texte, un secret machine sont écrits par un humain, pas par la config.
+*/
+const CLIENT_KEPT = /* @__PURE__ */ new Set(["name", "description"]);
+function mergeClient(existing, derived, keepSecret) {
+	const merged = { ...existing };
+	for (const [key, value] of Object.entries(derived)) {
+		if (CLIENT_KEPT.has(key) && key in existing) continue;
+		if (key === "secret" && keepSecret && key in existing) continue;
+		if (key === "attributes" && isObject(existing.attributes) && isObject(value)) {
+			merged.attributes = {
+				...existing.attributes,
+				...value
+			};
+			continue;
+		}
+		if (key === "protocolMappers") {
+			merged.protocolMappers = [...objects(existing.protocolMappers).filter((m) => m.protocolMapper !== AUDIENCE_MAPPER), ...objects(value)];
+			continue;
+		}
+		merged[key] = value;
+	}
+	return merged;
+}
+function mergeRoles(existing, derived) {
+	const kept = objects(existing);
+	const names = new Set(kept.map((r) => r.name));
+	return [...kept, ...objects(derived).filter((r) => !names.has(r.name))];
+}
+/**
+* Fond un realm dérivé de la config dans le realm d'import existant.
+*
+* Ce que la configuration DIT est réécrit : nom du realm, thèmes déclarés,
+* client navigateur (flux, URL de retour, audience, déconnexion), client
+* machine (flux, audience). Ce qu'un humain a écrit SURVIT : comptes,
+* titre, noms et textes des clients, secret machine, rôles déjà déclarés,
+* mappers qui ne sont pas d'audience, clients et clés inconnus. Régénérer
+* ne détruit donc rien de ce que la console a ajouté.
+*
+* @param existing - le realm lu sur disque (JSON quelconque)
+* @param derived - le realm construit par {@link buildKeycloakRealm}
+* @returns le realm fusionné
+* @throws Si `existing` n'est pas un objet JSON
+*/
+function mergeKeycloakRealm(existing, derived) {
+	if (!isObject(existing)) throw new TypeError("le realm existant n'est pas un objet JSON");
+	const merged = { ...existing };
+	for (const [key, value] of Object.entries(derived)) if (!(key in merged)) merged[key] = value;
+	merged.realm = derived.realm ?? merged.realm ?? null;
+	for (const key of [
+		"loginTheme",
+		"accountTheme",
+		"emailTheme",
+		"adminTheme"
+	]) {
+		const theme = derived[key];
+		if (theme !== void 0) merged[key] = theme;
+	}
+	const derivedClients = objects(derived.clients);
+	const existingClients = objects(existing.clients);
+	const browserId = derivedClients[0]?.clientId;
+	const clients = existingClients.map((client) => {
+		const match = derivedClients.find((d) => d.clientId === client.clientId);
+		if (match === void 0) return client;
+		return mergeClient(client, match, match.clientId !== browserId);
+	});
+	for (const client of derivedClients) if (!existingClients.some((c) => c.clientId === client.clientId)) clients.push(client);
+	merged.clients = clients;
+	if (isObject(derived.roles)) {
+		const roles = isObject(existing.roles) ? { ...existing.roles } : {};
+		if (derived.roles.realm !== void 0) roles.realm = mergeRoles(roles.realm, derived.roles.realm);
+		if (isObject(derived.roles.client)) {
+			const byClient = isObject(roles.client) ? { ...roles.client } : {};
+			for (const [clientId, list] of Object.entries(derived.roles.client)) byClient[clientId] = mergeRoles(byClient[clientId], list);
+			roles.client = byClient;
+		}
+		merged.roles = roles;
+	}
+	return merged;
+}
+/** Largeur au-delà de laquelle un tableau se déplie (celle de prettier). */
+const PRINT_WIDTH = 80;
+function renderValue(value, indent, lead) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	const inner = `${indent}  `;
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "[]";
+		if (value.every((v) => v === null || typeof v !== "object")) {
+			const flat = `[${value.map((v) => JSON.stringify(v)).join(", ")}]`;
+			if (lead + flat.length + 1 <= PRINT_WIDTH) return flat;
+		}
+		return `[\n${value.map((v) => `${inner}${renderValue(v, inner, inner.length)}`).join(",\n")}\n${indent}]`;
+	}
+	const entries = Object.entries(value);
+	if (entries.length === 0) return "{}";
+	return `{\n${entries.map(([key, v]) => {
+		const head = `${inner}${JSON.stringify(key)}: `;
+		return `${head}${renderValue(v, inner, head.length)}`;
+	}).join(",\n")}\n${indent}}`;
+}
+/**
+* Sérialise un realm comme le dépôt l'écrit : deux espaces, tableaux de
+* valeurs simples sur une ligne quand ils tiennent en 80 colonnes, fin de
+* ligne — la forme que prettier donne au fichier versionné.
+*
+* @param realm - le realm à écrire
+* @returns le texte du fichier d'import
+*/
+function renderKeycloakRealm(realm) {
+	return `${renderValue(realm, "", 0)}\n`;
+}
+export { buildKeycloakRealm, keycloakDefaultRole, mergeKeycloakRealm, renderKeycloakRealm };

package/dist/nodefony/keycloak/keycloakRealmInput.js

@@ -0,0 +1,123 @@
+import { KEYCLOAK_THEME_NAME } from "./scaffold.js";
+import { DEFAULT_LOGIN_PAGE_SKIN } from "nodefony";
+// nodefony/keycloak/keycloakRealmInput.ts
+/** Erreur de dérivation : la config ne permet pas d'écrire un realm. */
+var KeycloakRealmError = class extends Error {
+	name = "KeycloakRealmError";
+};
+/**
+* Le nom du realm, lu dans l'émetteur (`https://kc.example/realms/<nom>`).
+*
+* @throws {KeycloakRealmError} Si l'émetteur n'a pas la forme Keycloak
+*/
+function realmNameFromIssuer(issuer) {
+	if (issuer === void 0) throw new KeycloakRealmError("le fournisseur n'a pas d'`issuer` : c'est l'adresse du realm (https://…/realms/<nom>)");
+	let pathname;
+	try {
+		pathname = new URL(issuer).pathname;
+	} catch {
+		throw new KeycloakRealmError(`issuer « ${issuer} » n'est pas une URL`);
+	}
+	const match = /\/realms\/([^/]+)\/?$/u.exec(pathname);
+	if (match?.[1] === void 0) throw new KeycloakRealmError(`issuer « ${issuer} » ne finit pas par /realms/<nom> : ce n'est pas l'adresse d'un realm Keycloak`);
+	return decodeURIComponent(match[1]);
+}
+/** Les ressources de toutes les zones qui acceptent des jetons tiers. */
+function externalJwtResources(config) {
+	const resources = [];
+	for (const area of Object.values(config.areas)) {
+		if (!area.authenticators.includes("external-jwt")) continue;
+		if (area.resource !== void 0 && !resources.includes(area.resource)) resources.push(area.resource);
+	}
+	return resources;
+}
+/** Le chemin du callback, réécrit en celui de la déconnexion par canal arrière. */
+function backchannelPath(callbackPath) {
+	return callbackPath.replace(/\/callback\/?$/u, "/backchannel-logout");
+}
+/**
+* Dérive, depuis la configuration EFFECTIVE de l'application, ce que son realm
+* Keycloak doit dire.
+*
+* - **Client** : `clientId`, et son secret hors production.
+* - **URL de retour** : `redirectUri` du fournisseur, plus — hors production —
+*   le même chemin sur chaque serveur local (http ET https), parce que
+*   l'application répond sur les deux et que Keycloak compare au caractère près.
+* - **Audience** : `audiences` du fournisseur, sinon la `resource` de chaque
+*   zone `external-jwt`. Une audience qu'aucune zone ne porte est DITE : le
+*   jeton serait refusé partout.
+* - **Rôles** : les clés de `roleMapping`, rangées selon `rolesSource`.
+*
+* @param ctx - la configuration et le décor de l'application
+* @returns l'entrée du constructeur de realm et les constats
+* @throws {KeycloakRealmError} Si le fournisseur est absent ou sans émetteur
+*/
+/**
+* Le thème Keycloak de connexion qui porte un habillage de la page `/login`.
+*
+* @param skin - habillage (`loginPage.skin`)
+* @returns `nodefony` pour l'habillage par défaut, `nodefony-<habillage>` sinon
+*   (thème enfant livré sous `keycloak/themes/`)
+*/
+function keycloakLoginTheme(skin) {
+	return skin === DEFAULT_LOGIN_PAGE_SKIN ? KEYCLOAK_THEME_NAME : `${KEYCLOAK_THEME_NAME}-${skin}`;
+}
+/**
+* Dit si un thème Keycloak est l'un de ceux que livre Nodefony.
+*
+* @param theme - nom du thème
+* @returns `true` pour `nodefony` et `nodefony-<habillage>`
+*/
+function isNodefonyKeycloakTheme(theme) {
+	return theme === "nodefony" || theme.startsWith(`nodefony-`);
+}
+function deriveKeycloakRealmInput(ctx) {
+	const provider = ctx.config.oauth2.providers[ctx.providerName];
+	if (provider === void 0) {
+		const known = Object.keys(ctx.config.oauth2.providers);
+		throw new KeycloakRealmError(`aucun fournisseur « ${ctx.providerName} » dans oauth2.providers` + (known.length > 0 ? ` (déclarés : ${known.join(", ")})` : " — il n'est monté que si ses variables NF_KEYCLOAK_* sont posées"));
+	}
+	const warnings = [];
+	const realm = realmNameFromIssuer(provider.issuer);
+	const callback = new URL(provider.redirectUri);
+	const origins = [];
+	if (!ctx.production) {
+		const host = callback.hostname;
+		if (ctx.servers.httpsPort !== null) origins.push(`https://${host}:${ctx.servers.httpsPort}`);
+		if (ctx.servers.httpPort !== null) origins.push(`http://${host}:${ctx.servers.httpPort}`);
+	}
+	if (!origins.includes(callback.origin)) origins.unshift(callback.origin);
+	const redirectUris = origins.map((o) => `${o}${callback.pathname}`);
+	const backOrigin = ctx.backchannelOrigin ?? (ctx.production || ctx.servers.httpPort === null ? callback.origin : `http://host.docker.internal:${ctx.servers.httpPort}`);
+	const resources = externalJwtResources(ctx.config);
+	const audiences = provider.audiences ?? resources;
+	for (const audience of audiences) if (!resources.includes(audience)) warnings.push(`audience « ${audience} » : aucune zone external-jwt ne porte cette resource — un jeton qui la porte est refusé partout`);
+	if (provider.audiences === void 0 && resources.length > 1) warnings.push(`${resources.length} zones external-jwt, audiences déduites de TOUTES — écrire oauth2.providers.${ctx.providerName}.audiences si l'une doit refuser ses jetons`);
+	const sources = provider.rolesSource ?? ["client"];
+	const roles = Object.entries(provider.roleMapping ?? {}).map(([name, to]) => ({
+		name,
+		description: `Traduit en ${to} par la table roleMapping du fournisseur ${ctx.providerName}.`
+	}));
+	if (sources.includes("groups") && roles.length > 0) warnings.push("rolesSource « groups » : les groupes et leur mapper se déclarent dans la console Keycloak, ce realm ne les écrit pas");
+	const skin = ctx.config.loginPage.skin;
+	const current = ctx.currentLoginTheme ?? null;
+	const loginTheme = current !== null && isNodefonyKeycloakTheme(current) ? keycloakLoginTheme(skin) : null;
+	if (loginTheme === null && skin !== DEFAULT_LOGIN_PAGE_SKIN) warnings.push(`loginPage.skin « ${skin} » non appliqué à Keycloak : le realm ` + (current === null ? "ne déclare aucun thème de connexion" : `utilise le thème « ${current} », qui n'est pas un thème Nodefony`) + ` — poser loginTheme « ${keycloakLoginTheme(skin)} » à la main si c'est voulu`);
+	return {
+		input: {
+			realm,
+			clientId: provider.clientId,
+			clientSecret: ctx.production ? null : provider.clientSecret,
+			redirectUris,
+			postLogoutRedirectUris: origins.map((o) => `${o}/*`),
+			backchannelLogoutUrl: `${backOrigin}${backchannelPath(callback.pathname)}`,
+			audiences,
+			clientRoles: sources.includes("client") ? roles : [],
+			realmRoles: sources.includes("realm") ? roles : [],
+			machine: ctx.machine,
+			...loginTheme === null ? {} : { themes: { login: loginTheme } }
+		},
+		warnings
+	};
+}
+export { KeycloakRealmError, deriveKeycloakRealmInput, isNodefonyKeycloakTheme, keycloakLoginTheme, realmNameFromIssuer };