@nodefony/http 10.0.0-alpha.1

package/dist/nodefony/service/servers/server-websocket-secure.js

@@ -0,0 +1,104 @@
+import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js";
+import http_kernel_default from "../http-kernel.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateParam.js";
+import { startHeartbeat, trackPong } from "./wsHeartbeat.js";
+import { Module, Service, inject } from "nodefony";
+import Ws, { WebSocketServer } from "ws";
+//#region nodefony/service/servers/server-websocket-secure.ts
+let WebsocketSecure = class WebsocketSecure extends Service {
+	httpKernel;
+	module;
+	ready = false;
+	server = null;
+	port;
+	domain;
+	protocol = "1.1";
+	family = null;
+	scheme = "wss";
+	address = null;
+	type = "websocket-secure";
+	infos = null;
+	/** Timer keep-alive (UN par serveur). `null` si désactivé ou pas démarré. */
+	heartbeatTimer = null;
+	constructor(module, httpKernel) {
+		super("server-websocket-secure", module.container, module.notificationsCenter, module.options.websocketSecure);
+		this.httpKernel = httpKernel;
+		this.module = module;
+		this.port = this.setPort();
+		this.domain = this.kernel?.domain;
+		this.ready = false;
+	}
+	setPort() {
+		if (this.kernel?.options.servers?.https) return this.kernel?.options.servers?.https?.port || 0;
+		return 0;
+	}
+	async createServer(serverHttps) {
+		return new Promise((resolve, reject) => {
+			try {
+				this.infos = serverHttps.server.address();
+				if (this.infos) {
+					this.port = this.infos.port;
+					this.address = this.infos.address;
+					this.family = this.infos.family;
+					this.protocol = serverHttps.protocol;
+				}
+				this.server = new WebSocketServer({
+					...this.options ?? {},
+					server: serverHttps.server,
+					clientTracking: true
+				});
+				this.server.on("connection", this.onConnection.bind(this));
+				this.heartbeatTimer = startHeartbeat(this.server, this.options);
+				this.kernel?.prependOnceListener("onTerminate", this.terminate.bind(this));
+				if (this.server) this.ready = true;
+				this.module.fire("onServersReady", this.type, this);
+				return resolve(this.server);
+			} catch (e) {
+				this.log(e, "ERROR");
+				return reject(e);
+			}
+		});
+	}
+	onConnection(ws, req) {
+		trackPong(ws);
+		this.httpKernel.onWebsocketRequest(ws, req, this.type).catch(() => {
+			process.nextTick(() => {});
+		});
+	}
+	terminate() {
+		return new Promise((resolve, reject) => {
+			if (this.heartbeatTimer) {
+				clearInterval(this.heartbeatTimer);
+				this.heartbeatTimer = null;
+			}
+			if (this.server && this.ready) {
+				const shutdownMsg = JSON.stringify({ nodefony: { state: "shutDown" } });
+				this.server.clients.forEach((client) => {
+					if (client.readyState === Ws.OPEN) {
+						client.send(shutdownMsg);
+						client.close(1001, "Server shutting down");
+					}
+				});
+				setTimeout(() => {
+					try {
+						this.server?.close();
+						this.log(` SHUTDOWN WEBSOCKET Server is listening on DOMAIN : ${this.domain}    PORT : ${this.port}`, "INFO");
+						return resolve(true);
+					} catch (e) {
+						return reject(e);
+					}
+				}, 300);
+				return;
+			}
+			return resolve(true);
+		});
+	}
+	showBanner() {
+		if (this.infos) this.log(`Server Listen on ${this.scheme}://${this.infos.address}:${this.infos.port} Family: ${this.infos.family} Protocol : ${this.protocol}`);
+	}
+};
+WebsocketSecure = __decorate([__decorateParam(1, inject("HttpKernel")), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module, typeof http_kernel_default === "undefined" ? Object : http_kernel_default])], WebsocketSecure);
+var server_websocket_secure_default = WebsocketSecure;
+//#endregion
+export { server_websocket_secure_default as default };

package/dist/nodefony/service/servers/server-websocket.js

@@ -0,0 +1,104 @@
+import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js";
+import http_kernel_default from "../http-kernel.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateParam.js";
+import { startHeartbeat, trackPong } from "./wsHeartbeat.js";
+import { Module, Service, inject } from "nodefony";
+import Ws, { WebSocketServer } from "ws";
+//#region nodefony/service/servers/server-websocket.ts
+let Websocket = class Websocket extends Service {
+	httpKernel;
+	module;
+	ready = false;
+	server = null;
+	port;
+	domain;
+	protocol = "1.1";
+	family = null;
+	scheme = "ws";
+	address = null;
+	type = "websocket";
+	infos = null;
+	/** Timer keep-alive (UN par serveur). `null` si désactivé ou pas démarré. */
+	heartbeatTimer = null;
+	constructor(module, httpKernel) {
+		super("server-websocket", module.container, module.notificationsCenter, module.options.websocket);
+		this.httpKernel = httpKernel;
+		this.module = module;
+		this.port = this.setPort();
+		this.domain = this.kernel?.domain;
+		this.ready = false;
+	}
+	setPort() {
+		if (this.kernel?.options.servers?.http) return this.kernel?.options.servers?.http?.port || 0;
+		return 0;
+	}
+	async createServer(serverHttp) {
+		return new Promise((resolve, reject) => {
+			try {
+				this.infos = serverHttp.server.address();
+				if (this.infos) {
+					this.port = this.infos.port;
+					this.address = this.infos.address;
+					this.family = this.infos.family;
+					this.protocol = serverHttp.protocol;
+				}
+				this.server = new WebSocketServer({
+					...this.options ?? {},
+					server: serverHttp.server,
+					clientTracking: true
+				});
+				this.server.on("connection", this.onConnection.bind(this));
+				this.heartbeatTimer = startHeartbeat(this.server, this.options);
+				this.kernel?.prependOnceListener("onTerminate", this.terminate.bind(this));
+				if (this.server) this.ready = true;
+				this.module.fire("onServersReady", this.type, this);
+				return resolve(this.server);
+			} catch (e) {
+				this.log(e, "ERROR");
+				return reject(e);
+			}
+		});
+	}
+	onConnection(ws, req) {
+		trackPong(ws);
+		this.httpKernel.onWebsocketRequest(ws, req, this.type).catch(() => {
+			process.nextTick(() => {});
+		});
+	}
+	terminate() {
+		return new Promise((resolve, reject) => {
+			if (this.heartbeatTimer) {
+				clearInterval(this.heartbeatTimer);
+				this.heartbeatTimer = null;
+			}
+			if (this.server && this.ready) {
+				const shutdownMsg = JSON.stringify({ nodefony: { state: "shutDown" } });
+				this.server.clients.forEach((client) => {
+					if (client.readyState === Ws.OPEN) {
+						client.send(shutdownMsg);
+						client.close(1001, "Server shutting down");
+					}
+				});
+				setTimeout(() => {
+					try {
+						this.server?.close();
+						this.log(` SHUTDOWN WEBSOCKET Server is listening on DOMAIN : ${this.domain}    PORT : ${this.port}`, "INFO");
+						return resolve(true);
+					} catch (e) {
+						return reject(e);
+					}
+				}, 300);
+				return;
+			}
+			return resolve(true);
+		});
+	}
+	showBanner() {
+		if (this.infos) this.log(`Server Listen on ${this.scheme}://${this.infos.address}:${this.infos.port} Family: ${this.infos.family} Protocol : ${this.protocol}`);
+	}
+};
+Websocket = __decorate([__decorateParam(1, inject("HttpKernel")), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module, typeof http_kernel_default === "undefined" ? Object : http_kernel_default])], Websocket);
+var server_websocket_default = Websocket;
+//#endregion
+export { server_websocket_default as default };

package/dist/nodefony/service/servers/serverShutdown.js

@@ -0,0 +1,31 @@
+import { createHttpTerminator } from "http-terminator";
+//#region nodefony/service/servers/serverShutdown.ts
+/**
+* Fabrique le terminator de drain graceful d'un serveur HTTP/HTTPS/HTTP2.
+*
+* Au `terminate()` (shutdown SIGTERM/docker stop) : les requêtes in-flight se
+* terminent (header `connection: close` injecté sur les réponses en cours), les
+* sockets idle sont fermées immédiatement, et tout ce qui reste après
+* `shutdownTimeout` ms est détruit de force. Le terminator appelle lui-même
+* `server.close()` — ne pas le rappeler derrière.
+*
+* ⚠️ Les sockets WebSocket upgradées (sans réponse HTTP en cours) sont détruites
+* SANS frame Close par le terminator → les serveurs WS doivent fermer leurs
+* clients (close 1001) AVANT ce drain. Garanti par l'ordre des listeners
+* `onTerminate` : WS/WSS s'attachent en `prependOnceListener`, les serveurs
+* HTTP en `once`.
+*
+* @param server - serveur Node à drainer (créé, pas forcément listening)
+* @param shutdownTimeout - délai de drain en ms avant destruction forcée
+* @returns le terminator à invoquer au shutdown
+*/
+function createDrainTerminator(server, shutdownTimeout) {
+	return createHttpTerminator({
+		server,
+		gracefulTerminationTimeout: shutdownTimeout ?? 5e3
+	});
+}
+/** Drain par défaut (ms) — même valeur que le défaut Zod `servers.*.shutdownTimeout`. */
+const DEFAULT_SHUTDOWN_TIMEOUT = 5e3;
+//#endregion
+export { DEFAULT_SHUTDOWN_TIMEOUT, createDrainTerminator };

package/dist/nodefony/service/servers/wsHeartbeat.js

@@ -0,0 +1,64 @@
+import Ws from "ws";
+//#region nodefony/service/servers/wsHeartbeat.ts
+/**
+* Arme le suivi keep-alive d'UNE connexion : initialise l'horodatage de vie et
+* attache l'unique listener `pong` qui le rafraîchit.
+*
+* Le listener `pong` vit et meurt avec la socket (l'émetteur EST la socket `ws`,
+* détruite au `close`/`terminate`) → aucun `removeListener` explicite à prévoir.
+* Un seul listener par connexion, c'est le pair-event obligatoire du ping.
+*
+* @param ws - la socket fraîchement connectée
+*/
+const trackPong = (ws) => {
+	const sock = ws;
+	sock._nfLastPong = performance.now();
+	sock._nfPingedAt = 0;
+	ws.on("pong", () => {
+		ws._nfLastPong = performance.now();
+	});
+};
+/**
+* Démarre le heartbeat keep-alive du serveur : détecte les connexions zombies
+* (half-open — TCP encore ouvert mais le pair a disparu sans frame Close) et les
+* `terminate()` pour libérer slot mémoire + descripteur de fichier.
+*
+* Sémantique (fidèle à l'ancienne lib `websocket`) : un ping est émis tous les
+* `keepaliveInterval` ms ; si aucun `pong` n'arrive dans les `keepaliveGracePeriod`
+* ms qui suivent ce ping, la socket est détruite. Temps de réclamation borné par
+* `keepaliveInterval + keepaliveGracePeriod` (+ une granularité de tick).
+*
+* PERF (hot path WS) : **UN seul `setInterval` par serveur** — jamais un timer par
+* connexion. Chaque tick ne lit/écrit que des `number` sur la socket → 0 allocation
+* sur le chemin nominal. `unref()` pour ne pas retenir le process à l'arrêt. Le timer
+* DOIT être `clearInterval` au shutdown (cf appelant).
+*
+* @param server - le `WebSocketServer` dont on surveille `clients`
+* @param options - knobs keep-alive (depuis la config Zod du module)
+* @returns le timer à nettoyer au shutdown, ou `null` si le keep-alive est désactivé
+*/
+const startHeartbeat = (server, options) => {
+	const interval = options.keepaliveInterval ?? 0;
+	if (interval <= 0) return null;
+	const grace = options.keepaliveGracePeriod ?? 0;
+	const timer = setInterval(() => {
+		const now = performance.now();
+		for (const client of server.clients) {
+			if (client.readyState !== Ws.OPEN) continue;
+			const sock = client;
+			if (sock._nfLastPong === void 0) sock._nfLastPong = now;
+			if ((sock._nfPingedAt ?? 0) > sock._nfLastPong) {
+				if (now - sock._nfPingedAt > grace) client.terminate();
+				continue;
+			}
+			if (now - sock._nfLastPong >= interval) {
+				sock._nfPingedAt = now;
+				client.ping();
+			}
+		}
+	}, Math.max(250, grace > 0 ? Math.min(interval, grace) : interval));
+	timer.unref?.();
+	return timer;
+};
+//#endregion
+export { startHeartbeat, trackPong };