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

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

@@ -0,0 +1,110 @@
+// nodefony/src/server/RealtimeConnection.ts
+/**
+* Poignée d'une connexion temps réel servie par ce processus — implémente {@link IRealtimeConnection}.
+*
+* Créée paresseusement par le contrôleur, au premier abonnement ou à la
+* première trame entrante de la connexion (jamais au welcome : une connexion
+* qui ne fait ni l'un ni l'autre n'en paie aucune). Fermée au `onFinish` de la
+* socket : les gestes du hub rendent alors `false`, et les abonnements imposés
+* en attente se soldent par un refus.
+*
+* @internal Le type public est {@link IRealtimeConnection} ; seuls le hub et le
+* contrôleur appellent les méthodes de cette classe.
+*/
+var RealtimeConnection = class {
+	#host;
+	#identify;
+	#userId = null;
+	#open = true;
+	#imposing = null;
+	/**
+	* @param host - le contrôleur qui sert la connexion.
+	* @param identify - lit l'identifiant du compte, figé au handshake ; appelé
+	*   au plus une fois.
+	*/
+	constructor(host, identify) {
+		this.#host = host;
+		this.#identify = identify;
+	}
+	/** Identifiant du compte connecté ; `null` pour l'anonyme. */
+	get userId() {
+		const identify = this.#identify;
+		if (identify !== null) {
+			this.#identify = null;
+			this.#userId = identify();
+		}
+		return this.#userId;
+	}
+	/** `false` une fois la socket fermée. */
+	get open() {
+		return this.#open;
+	}
+	/**
+	* Impose l'abonnement à `channel` — même politique, même `allow` qu'un `subscribe` du client.
+	*
+	* @returns une promesse résolue à `true` une fois l'abonnement acquitté, à
+	*   `false` s'il est refusé, si la connexion se ferme avant, ou si le client
+	*   s'en désabonne pendant l'attente.
+	*/
+	impose(channel) {
+		if (!this.#open) return Promise.resolve(false);
+		const imposing = this.#imposing ??= /* @__PURE__ */ new Map();
+		const pending = imposing.get(channel);
+		if (pending !== void 0) return new Promise((resolve) => {
+			pending.settle.push(resolve);
+		});
+		const entry = {
+			settle: [],
+			clientAsked: false
+		};
+		const verdict = new Promise((resolve) => {
+			entry.settle.push(resolve);
+		});
+		imposing.set(channel, entry);
+		this.#host.impose(channel);
+		return verdict;
+	}
+	/**
+	* Met fin à l'abonnement de cette connexion à `channel`.
+	*
+	* @returns `false` si la connexion est fermée ou n'est pas abonnée au canal.
+	*/
+	end(channel, reason) {
+		return this.#open && this.#host.end(channel, reason);
+	}
+	/** Un abonnement imposé à `channel` attend-il son verdict ? */
+	isImposing(channel) {
+		return this.#imposing?.has(channel) === true;
+	}
+	/** Le client demande `channel` pendant l'attente de son imposition : un refus lui sera dû. */
+	markClientAsked(channel) {
+		const entry = this.#imposing?.get(channel);
+		if (entry !== void 0) entry.clientAsked = true;
+	}
+	/**
+	* Solde l'abonnement imposé à `channel`, s'il y en a un.
+	*
+	* @returns `true` si le refus doit AUSSI être rendu au client (il avait
+	*   demandé ce canal) ou s'il n'y avait pas d'imposition en cours — dans les
+	*   deux cas l'appelant suit son chemin habituel ; `false` si le refus
+	*   n'appartient qu'à l'appelant serveur.
+	*/
+	settleImposed(channel, subscribed) {
+		const imposing = this.#imposing;
+		const entry = imposing?.get(channel);
+		if (imposing === null || entry === void 0) return true;
+		imposing.delete(channel);
+		if (imposing.size === 0) this.#imposing = null;
+		for (const settle of entry.settle) settle(subscribed);
+		return entry.clientAsked;
+	}
+	/** Fermeture de la socket : la poignée ne désigne plus rien, les impositions en attente échouent. */
+	close() {
+		this.#open = false;
+		const imposing = this.#imposing;
+		if (imposing === null) return;
+		this.#imposing = null;
+		for (const entry of imposing.values()) for (const settle of entry.settle) settle(false);
+	}
+};
+export { RealtimeConnection };