@nodefony/realtime 10.0.0-beta.6 → 10.0.0-beta.7

package/dist/nodefony/src/server/admissionBudget.js

@@ -33,12 +33,12 @@ var AdmissionBudget = class {
 	#timedOutTotal = 0;
 	#saturatedTotal = 0;
 	#authenticateTimedOutTotal = 0;
-	#windowStart = -Infinity;
+	#windowStart = -1e400;
 	#windowTimeouts = 0;
 	#openUntil = 0;
-	#lastTimeoutWarn = -Infinity;
-	#lastThrowWarn = -Infinity;
-	#lastAuthenticateWarn = -Infinity;
+	#lastTimeoutWarn = -1e400;
+	#lastThrowWarn = -1e400;
+	#lastAuthenticateWarn = -1e400;
 	/** Applique les bornes de la configuration (boot, cold path). */
 	configure(limits) {
 		this.authenticateTimeoutMs = limits.authenticateTimeoutMs;
@@ -159,18 +159,18 @@ var AdmissionBudget = class {
 	reset() {
 		this.authenticateTimeoutMs = 1e4;
 		this.#authenticateTimedOutTotal = 0;
-		this.#lastAuthenticateWarn = -Infinity;
+		this.#lastAuthenticateWarn = -1e400;
 		this.timeoutMs = 5e3;
 		this.maxPerConnection = 8;
 		this.#maxTotal = 512;
 		this.#pending = 0;
 		this.#timedOutTotal = 0;
 		this.#saturatedTotal = 0;
-		this.#windowStart = -Infinity;
+		this.#windowStart = -1e400;
 		this.#windowTimeouts = 0;
 		this.#openUntil = 0;
-		this.#lastTimeoutWarn = -Infinity;
-		this.#lastThrowWarn = -Infinity;
+		this.#lastTimeoutWarn = -1e400;
+		this.#lastThrowWarn = -1e400;
 	}
 };
 export { ADMISSION_GRANTED, AUTHENTICATE_TIMED_OUT, AdmissionBudget };

package/dist/nodefony/src/server/channelPolicyRegistry.js

@@ -1,4 +1,5 @@
-import { declaresAction, getChannelPoliciesOf, isAdmissionClass } from "../../decorators/realtimeDecorators.js";
+import { declaresAction, getDeclaredChannelPolicies, isAdmissionClass, samePolicy } from "../../decorators/realtimeDecorators.js";
+import { samePresence } from "./channelPresence.js";
 import { BootConfigurationError, Injector } from "nodefony";
 // nodefony/src/server/channelPolicyRegistry.ts
 /**
@@ -14,26 +15,47 @@ import { BootConfigurationError, Injector } from "nodefony";
 * @param ctor - constructeur du contrôleur.
 * @param resolveAdmission - résolution des classes d'admission ; `null` hors
 *   démarrage, et le hub refuse alors une politique qui en désigne une.
-* @throws BootConfigurationError Politique illisible, `allow` posé sur une
-*   action, ou classe d'admission non résolue.
+* Chaque nom est déclaré au hub SORTE PAR SORTE (lecture, écriture), sans
+* héritage : le hub les fusionne avec les motifs de toutes les classes
+* (ADR-0022 §6, décision 1 quater). Deux classes qui déclarent la même sorte
+* différemment sous un même nom refusent le démarrage : la seconde effaçait la
+* première sans un mot.
+*
+* @throws BootConfigurationError Politique illisible ou contredite, `allow`
+*   posé sur une action ou sur une écriture distincte de la lecture, classe
+*   d'admission non résolue, ou deux classes en désaccord sur un nom.
 */
 function registerControllerPolicies(hub, ctor, resolveAdmission) {
 	if (hub.hasPolicyOwner(ctor)) return;
-	const policies = getChannelPoliciesOf(ctor);
-	if (policies !== null) for (const name in policies) {
-		const policy = policies[name];
-		if (policy === void 0) continue;
-		const allow = policy.allow;
-		let admission;
-		if (allow !== void 0) {
-			if (declaresAction(ctor, name)) throw new BootConfigurationError(`${typeof ctor === "function" ? ctor.name : "(contrôleur)"} : « allow » est posé sur l'action « ${name} » — il ne s'applique qu'aux canaux (demandé au subscribe). Une action se garde par authenticated, roles ou scopes.`);
-			if (isAdmissionClass(allow) && resolveAdmission !== null) admission = resolveAdmission(allow, name);
+	const declared = getDeclaredChannelPolicies(ctor);
+	if (declared !== null) {
+		const owner = typeof ctor === "function" ? ctor.name : "(contrôleur)";
+		for (const [name, { read, write }] of Object.entries(declared.kinds)) {
+			if (write?.allow !== void 0 && read !== null && !samePolicy(read, write)) throw new BootConfigurationError(`${owner} : « allow » est posé sur l'écriture du canal « ${name} », qui déclare aussi une lecture différente — il ne s'applique qu'à la lecture (demandé au subscribe). Le poser sur @RealtimeChannel ; l'écriture se garde par authenticated, roles ou scopes.`);
+			const allow = (read ?? write)?.allow;
+			let admission;
+			if (allow !== void 0) {
+				if (declaresAction(ctor, name)) throw new BootConfigurationError(`${owner} : « allow » est posé sur l'action « ${name} » — il ne s'applique qu'aux canaux (demandé au subscribe). Une action se garde par authenticated, roles ou scopes.`);
+				if (isAdmissionClass(allow) && resolveAdmission !== null) admission = resolveAdmission(allow, name);
+			}
+			if (read !== null) claim(hub, name, "read", ctor, owner, read);
+			if (write !== null) claim(hub, name, "write", ctor, owner, write);
+			hub.declareChannelPolicy(name, read, write, admission);
 		}
-		hub.registerChannelPolicy(name, policy, admission);
+		for (const name of declared.actions) hub.declareActionDefault(name);
 	}
 	hub.addPolicyOwner(ctor);
 }
 /**
+* Revendique une sorte de politique d'un nom pour cette classe — refuse le démarrage si une AUTRE classe en a déclaré une différente : le registre est unique par nom, une seule s'appliquerait.
+*/
+function claim(hub, name, kind, ctor, owner, policy) {
+	const previous = hub.claimChannelPolicy(name, kind, ctor, policy);
+	if (previous === null || previous.owner === ctor || samePolicy(previous.policy, policy) && samePresence(previous.policy, policy)) return;
+	const which = kind === "read" ? "LECTURE" : "ÉCRITURE";
+	throw new BootConfigurationError(`canal temps réel « ${name} » : ${previous.ownerName} et ${owner} déclarent des politiques de ${which} différentes sous ce nom — le registre est unique par nom, une seule s'appliquerait. Les accorder, ou renommer l'un des canaux.`);
+}
+/**
 * Fabrique la résolution des classes d'admission du démarrage : portée singleton exigée, instance du conteneur réutilisée, sinon construite UNE fois par l'injecteur.
 *
 * @param get - l'instance déjà construite d'une classe : le démarrage la lit

package/dist/nodefony/src/server/channelPolicyResolution.js

@@ -0,0 +1,191 @@
+import { isAdmissionClass, samePolicy } from "../../decorators/realtimeDecorators.js";
+import { BootConfigurationError, USER_CHANNEL_PREFIX, isOwnUserChannel } from "nodefony";
+// nodefony/src/server/channelPolicyResolution.ts
+/**
+* Règle d'admission prête à appeler d'une politique, ou `null` sans `allow`.
+*
+* Une flèche se retient telle quelle. Une classe exige son instance — résolue au
+* démarrage, jamais ici : le hub n'a pas d'injecteur, et résoudre à la première
+* poignée de main laisserait sans politique un exemplaire qui n'émet que des
+* webhooks. La méthode est liée une fois, et la règle se construit une fois :
+* le `subscribe` n'alloue rien et n'appelle qu'une fonction.
+*
+* @throws BootConfigurationError La politique désigne une classe d'admission et
+*   aucune instance de CETTE classe n'est fournie.
+*/
+function admissionRuleOf(name, policy, admission) {
+	const allow = policy.allow;
+	if (allow === void 0) return null;
+	const anonymous = policy.anonymous === true;
+	if (!isAdmissionClass(allow)) return {
+		allow,
+		anonymous
+	};
+	if (!(admission instanceof allow)) throw new BootConfigurationError(`canal temps réel « ${name} » : la classe d'admission ${allow.name} n'a pas été résolue au démarrage du noyau. Son contrôleur doit être déclaré par @controllers dans un module : c'est là que le framework l'inscrit et résout ses dépendances.`);
+	return {
+		allow: admission.allow.bind(admission),
+		anonymous
+	};
+}
+/**
+* Construit une déclaration et sa vue seule : lecture déclarée, sinon l'écriture, sinon le défaut d'action ; écriture gardée seulement si elle exige autre chose que la lecture.
+*
+* @param name - nom exact ou motif (pour les messages).
+* @param read - lecture déclarée, ou `null`.
+* @param write - écriture déclarée, ou `null`.
+* @param fallback - défaut fermé d'une action, ou `null`.
+* @param admission - instance de la classe d'admission quand la politique qui
+*   sert de lecture en désigne une.
+*/
+function declarationOf(name, read, write, fallback, admission) {
+	const policy = read ?? write ?? fallback;
+	return {
+		read,
+		write,
+		fallback,
+		instance: admission,
+		self: policy === null ? null : {
+			policy,
+			write: read !== null && write !== null && !samePolicy(read, write) ? write : null,
+			admission: admissionRuleOf(name, policy, admission)
+		}
+	};
+}
+/**
+* Politique INTÉGRÉE du canal personnel `user:<id>` (ADR-0022 §6, D1) — connexion authentifiée, admise sur SON canal seulement.
+*
+* Constante de module : elle ne s'inscrit nulle part, donc aucun `clear()`,
+* aucun ordre de démarrage, aucun oubli ne peut la retirer. Elle sert de REPLI
+* de LECTURE aux noms `user:…` : seule une déclaration qui vise `user:`
+* (nom exact, ou motif dont le littéral commence par `user:`) la remplace — un
+* motif attrape-tout (`*`) ne retire pas la garde « son canal seulement ».
+*/
+const USER_CHANNEL_DECLARATION = Object.freeze({
+	read: Object.freeze({
+		authenticated: true,
+		allow: isOwnUserChannel
+	}),
+	write: null,
+	fallback: null,
+	instance: void 0,
+	self: Object.freeze({
+		policy: Object.freeze({
+			authenticated: true,
+			allow: isOwnUserChannel
+		}),
+		write: null,
+		admission: Object.freeze({
+			allow: isOwnUserChannel,
+			anonymous: false
+		})
+	})
+});
+/**
+* Résout les politiques d'un nom (ADR-0022 §6, décision 1 quater) : la LECTURE appartient à la déclaration la plus spécifique qui déclare quelque chose sur ce nom ; l'ÉCRITURE vient de la plus spécifique qui déclare une écriture.
+*
+* L'ordre de spécificité : le nom exact, puis les motifs du plus spécifique au
+* plus général. Pourquoi deux règles et non une :
+* - la LECTURE reste à la déclaration propriétaire du nom (déclarée, sinon
+*   héritée de sa propre écriture) : une commande `task:start` déclarée par
+*   `@RealtimeInbound` sous une famille `task:*` à `allow` ne devient pas un
+*   canal à membres, et une écriture exacte ne voit pas sa lecture s'ouvrir par
+*   un motif plus général ;
+* - l'ÉCRITURE descend jusqu'au motif qui en déclare une : elle s'ajoute à la
+*   lecture (une trame entrante exige les deux), elle ne peut que durcir — une
+*   écriture de famille (`mix:*` réservée) n'est plus perdue sur un nom exact
+*   qui ne déclare que sa lecture.
+*
+* Ensuite : un nom `user:…` sans déclaration qui le vise garde la politique
+* intégrée du canal personnel (un motif qui ne vise pas `user:` est ignoré) ;
+* une action sans politique (nom exact qui ne déclare rien) prend la lecture du
+* motif qui la couvre et le défaut fermé pour écriture — un motif de lecture
+* public ne l'ouvre donc pas.
+*
+* Rend la vue d'une déclaration quand une seule suffit (aucune allocation) ;
+* n'alloue que si l'écriture vient d'une autre déclaration que la lecture.
+*
+* @param name - nom résolu.
+* @param exact - déclaration exacte de ce nom, ou `undefined`.
+* @param patterns - motifs, triés du plus spécifique au plus général, ou `null`.
+* @returns les politiques, ou `null` si aucune ne couvre le nom.
+*/
+function resolveDeclaredPolicies(name, exact, patterns) {
+	const declares = (d) => d.read !== null || d.write !== null;
+	let owner = exact !== void 0 && declares(exact) ? exact : null;
+	let writeFrom = exact !== void 0 && exact.write !== null ? exact : null;
+	const isUser = name.startsWith(USER_CHANNEL_PREFIX);
+	if ((owner === null || writeFrom === null) && patterns !== null) for (const pattern of patterns) {
+		if (isUser && !pattern.source.startsWith(USER_CHANNEL_PREFIX)) continue;
+		if (!pattern.re.test(name)) continue;
+		if (owner === null && declares(pattern)) owner = pattern;
+		if (writeFrom === null && pattern.write !== null) writeFrom = pattern;
+		if (owner !== null && writeFrom !== null) break;
+	}
+	let write = writeFrom?.write ?? null;
+	if (write === null && exact !== void 0 && !declares(exact)) write = exact.fallback;
+	let own = owner?.self ?? null;
+	if (own === null) {
+		if (isUser) own = USER_CHANNEL_DECLARATION.self;
+		else return exact?.self ?? null;
+		if (own === null) return null;
+	}
+	const distinct = write === null || samePolicy(own.policy, write) ? null : write;
+	if (distinct === own.write) return own;
+	return {
+		policy: own.policy,
+		write: distinct,
+		admission: own.admission
+	};
+}
+/** Échantillon d'un motif : son littéral, chaque `*` vidé — un nom qu'il couvre toujours. */
+function sampleOf(pattern) {
+	return pattern.source.split("*").join("");
+}
+/**
+* Deux déclarations peuvent-elles s'appliquer au MÊME nom ? Exact : le même nom, ou couvert par le motif ; deux motifs : l'un couvre l'échantillon de l'autre.
+*
+* Prudente : elle répond « oui » dès qu'un nom commun est plausible — elle sert à
+* refuser un démarrage ambigu, jamais à ouvrir un accès.
+*/
+function couldOverlap(a, b) {
+	if (a.pattern === null && b.pattern === null) return a.name === b.name;
+	if (a.pattern === null) return b.pattern?.re.test(a.name) === true;
+	if (b.pattern === null) return a.pattern.re.test(b.name);
+	return a.pattern.re.test(sampleOf(b.pattern)) || b.pattern.re.test(sampleOf(a.pattern));
+}
+/**
+* Défaut de l'ensemble des déclarations qui refuse le démarrage, ou `null` : une ÉCRITURE à `allow` qui s'appliquerait sous une lecture différente (son `allow` ne serait évalué nulle part), ou — face à un verrou qui ne juge pas l'écriture — une écriture qui diffère d'une lecture qu'elle peut rencontrer.
+*
+* Cold path (inscription d'une politique, pose du verrou) : toutes les paires.
+*
+* @param exact - déclarations exactes, par nom.
+* @param patterns - déclarations par motif.
+* @param writeJudged - le verrou en place sait juger l'écriture (ou aucun verrou).
+* @returns le message du refus, ou `null`.
+*/
+function policyDeclarationsDefect(exact, patterns, writeJudged) {
+	const all = [];
+	if (exact !== null) for (const [name, decl] of exact) all.push({
+		name,
+		pattern: null,
+		decl
+	});
+	for (const pattern of patterns ?? []) all.push({
+		name: pattern.source,
+		pattern,
+		decl: pattern
+	});
+	for (const writer of all) {
+		const write = writer.decl.write;
+		if (write === null) continue;
+		for (const reader of all) {
+			const read = reader.decl.read;
+			if (read === null || samePolicy(read, write)) continue;
+			if (reader !== writer && !couldOverlap(writer, reader)) continue;
+			if (write.allow !== void 0) return `canal temps réel « ${writer.name} » : « allow » est posé sur l'écriture du canal « ${writer.name} », qui rencontre une lecture différente (« ${reader.name} ») — il ne s'applique qu'à la lecture (demandé au subscribe). Le poser sur @RealtimeChannel ; l'écriture se garde par authenticated, roles ou scopes.`;
+			if (!writeJudged) return `canal temps réel « ${writer.name} » : il déclare une politique d'ÉCRITURE distincte de sa lecture, et le verrou des trames posé sur le hub ne sait pas la juger (il ne déclare pas « judgesWrite ») — l'écriture resterait ouverte. Aligner @nodefony/security sur la version de @nodefony/realtime.`;
+		}
+	}
+	return null;
+}
+export { USER_CHANNEL_DECLARATION, admissionRuleOf, declarationOf, policyDeclarationsDefect, resolveDeclaredPolicies };