@nodefony/http 10.0.0-alpha.1

package/dist/nodefony/src/cookies/cookie.js

@@ -0,0 +1,258 @@
+import { extend } from "nodefony";
+import crypto from "node:crypto";
+import { parseCookie } from "cookie";
+import MS from "ms";
+//#region nodefony/src/cookies/cookie.ts
+const encode = encodeURIComponent;
+const decode = decodeURIComponent;
+const cookieDefaultSettings = {
+	maxAge: 0,
+	path: "/",
+	domain: void 0,
+	secure: true,
+	sameSite: "Lax",
+	httpOnly: true,
+	signed: false,
+	secret: "!nodefony.secret!"
+};
+function parser(strToParse) {
+	return parseCookie(strToParse);
+}
+function cookiesParser(context) {
+	let cookies = null;
+	let co = null;
+	switch (context.type) {
+		case "http":
+		case "https":
+		case "http2":
+			if (context.request.request && context.request.request.headers.cookie) cookies = context.request.request.headers.cookie;
+			if (cookies) {
+				const obj = parser(cookies);
+				for (const cookie in obj) {
+					co = new Cookie(cookie, obj[cookie]);
+					context.addRequestCookie(co);
+				}
+				if (context.response) context.request.request.cookies = context.response.cookies;
+			}
+			break;
+		case "websocket":
+		case "websocket-secure": {
+			const cookieHeader = context.request?.headers?.cookie;
+			if (cookieHeader) {
+				const parsed = parser(cookieHeader);
+				for (const name in parsed) {
+					co = new Cookie(name, parsed[name]);
+					context.addRequestCookie(co);
+				}
+			}
+			break;
+		}
+		default: throw new Error("cookiesParser Bad Type");
+	}
+}
+var Cookie = class Cookie {
+	options = {};
+	name;
+	signed;
+	value;
+	originalMaxAge;
+	expires;
+	maxAge;
+	path;
+	domain;
+	httpOnly;
+	secure;
+	sameSite;
+	priority;
+	constructor(cookiesOrName, value, options) {
+		this.options = extend({}, cookieDefaultSettings, options || {});
+		if (!cookiesOrName) throw new Error("cookie must have name");
+		this.name = cookiesOrName;
+		if (typeof cookiesOrName === "string") {
+			if (!cookiesOrName) throw new Error("cookie must have name");
+			this.name = cookiesOrName;
+			this.signed = this.options.signed;
+			this.value = this.setValue(value);
+			if (this.options.maxAge) this.originalMaxAge = this.setOriginalMaxAge(this.options.maxAge);
+			else this.originalMaxAge = void 0;
+			this.expires = this.setExpires(this.options.expires);
+			this.path = this.setPath(this.options.path);
+			this.domain = this.setDomain();
+			this.httpOnly = this.setHttpOnly(this.options.httpOnly);
+			this.secure = this.setSecure(this.options.secure);
+			this.sameSite = this.setSameSite(this.options.sameSite);
+			this.priority = this.setPriority(this.options.priority);
+		}
+		if (cookiesOrName instanceof Cookie) {
+			this.options = cookiesOrName.options;
+			this.name = cookiesOrName.name;
+			this.signed = cookiesOrName.signed;
+			this.value = cookiesOrName.value;
+			this.originalMaxAge = cookiesOrName.originalMaxAge;
+			this.expires = cookiesOrName.expires;
+			this.path = cookiesOrName.path;
+			this.domain = cookiesOrName.domain;
+			this.httpOnly = cookiesOrName.httpOnly;
+			this.secure = cookiesOrName.secure;
+			this.maxAge = cookiesOrName.maxAge;
+			this.sameSite = cookiesOrName.sameSite;
+			this.priority = cookiesOrName.priority;
+		}
+	}
+	clearCookie() {
+		this.setExpires(1);
+		this.path = "/";
+	}
+	setValue(value) {
+		if (value) value = decode(String(value));
+		if (this.signed) {
+			const secret = this.options.secret;
+			if (!secret || secret === cookieDefaultSettings.secret) throw new Error("signed cookie requires a configured secret (refusing the default/predictable secret)");
+			this.value = `s:${this.sign(value, secret)}`;
+		} else this.value = value;
+		return this.value;
+	}
+	setSecure(val) {
+		return !!val;
+	}
+	setDomain() {
+		return this.options.domain;
+	}
+	setHttpOnly(val) {
+		return !!val;
+	}
+	setPath(val) {
+		return val;
+	}
+	/**
+	* Normalise l'attribut `SameSite` vers une valeur canonique RFC 6265bis.
+	*
+	* Fallback **`Lax`** (jamais `None`) : `None` désactive la protection CSRF et
+	* impose `Secure` — ce n'est jamais un défaut sûr. Toute entrée inconnue
+	* (ancien `boolean`, casse libre) retombe sur `Lax` (fail-safe).
+	*
+	* @param val - valeur souhaitée (`Strict` / `Lax` / `None`, casse libre).
+	* @returns la forme canonique title-case.
+	*/
+	setSameSite(val) {
+		if (!val) return "Lax";
+		switch (String(val).toLowerCase()) {
+			case "strict": return "Strict";
+			case "none": return "None";
+			default: return "Lax";
+		}
+	}
+	setExpires(date) {
+		if (date) try {
+			if (date instanceof Date) this.expires = date;
+			else this.expires = new Date(date);
+		} catch (e) {
+			this.expires = void 0;
+		}
+		else {
+			const maxage = this.getMaxAge();
+			if (!maxage) this.expires = void 0;
+			else {
+				const res = (/* @__PURE__ */ new Date()).getTime() + maxage * 1e3;
+				this.expires = new Date(res);
+			}
+			return this.expires;
+		}
+		this.getMaxAge();
+		return this.expires;
+	}
+	setOriginalMaxAge(ms) {
+		if (typeof ms === "number") return ms;
+		return MS(ms) / 1e3;
+	}
+	setPriority(val) {
+		return val;
+	}
+	getMaxAge() {
+		if (this.expires && this.expires instanceof Date) {
+			const s = (this.expires.getTime() - (/* @__PURE__ */ new Date()).getTime()) / 1e3;
+			if (s > 0) this.maxAge = s;
+			else this.maxAge = void 0;
+		} else this.maxAge = this.originalMaxAge;
+		return this.maxAge;
+	}
+	toString() {
+		return `${this.name}=${encode(String(this.value))}`;
+	}
+	/**
+	* Signe une valeur de cookie : `HMAC-SHA256(value)` clé = `secret`, encodé en
+	* base64url (sûr en cookie, pas de `=`/`+`/`/`). Retourne `value.signature`
+	* → la valeur d'origine est PRÉSERVÉE (récupérable via {@link unsign}).
+	*
+	* @param val - valeur en clair à signer.
+	* @param secret - clé HMAC (le secret, JAMAIS la valeur).
+	* @returns `value.base64url(hmac)`.
+	* @throws {TypeError} si `val` n'est pas une string ou `secret` est vide.
+	*/
+	sign(val, secret) {
+		if (typeof val !== "string") throw new TypeError("cookie value required (string)");
+		if (typeof secret !== "string" || !secret) throw new TypeError("cookie secret required (non-empty string)");
+		return `${val}.${crypto.createHmac("sha256", secret).update(val).digest("base64url")}`;
+	}
+	/**
+	* Vérifie et déballe une valeur signée par {@link sign} (tolère le préfixe
+	* `s:`). Comparaison **timing-safe** (`crypto.timingSafeEqual`).
+	*
+	* @param val - valeur signée (`value.signature`, éventuellement préfixée `s:`).
+	*   Défaut : `this.value`.
+	* @param secret - clé HMAC. Défaut : `this.options.secret`.
+	* @returns la valeur en clair si la signature est valide, sinon `false`.
+	* @throws {TypeError} si les types sont invalides ou le secret est vide.
+	*/
+	unsign(val, secret) {
+		let input = val ?? this.value;
+		const key = secret ?? this.options.secret;
+		if (typeof input !== "string") throw new TypeError("unsign cookie value bad type");
+		if (typeof key !== "string" || !key) throw new TypeError("unsign cookie secret required (non-empty string)");
+		if (input.startsWith("s:")) input = input.slice(2);
+		const idx = input.lastIndexOf(".");
+		if (idx <= 0) return false;
+		const plain = input.slice(0, idx);
+		const expected = this.sign(plain, key);
+		const a = Buffer.from(input);
+		const b = Buffer.from(expected);
+		if (a.length !== b.length) return false;
+		return crypto.timingSafeEqual(a, b) ? plain : false;
+	}
+	serialize() {
+		const tab = [];
+		tab.push(this.toString());
+		const hostPrefix = this.name.startsWith("__Host-");
+		const securePrefix = this.name.startsWith("__Secure-");
+		const secure = this.secure || this.sameSite === "None" || hostPrefix || securePrefix;
+		if (this.maxAge) tab.push(`Max-Age=${this.maxAge}`);
+		if (this.domain && !hostPrefix) tab.push(`Domain=${this.domain}`);
+		const path = hostPrefix ? "/" : this.path;
+		if (path) tab.push(`Path=${path}`);
+		if (this.sameSite) tab.push(`SameSite=${this.sameSite}`);
+		if (this.expires) tab.push(`Expires=${this.expires.toUTCString()}`);
+		if (this.httpOnly) tab.push("HttpOnly");
+		if (secure) tab.push("Secure");
+		if (this.priority) tab.push(`Priority=${this.priority}`);
+		return tab.join("; ");
+	}
+	serializeWebSocket() {
+		const hostPrefix = this.name.startsWith("__Host-");
+		const securePrefix = this.name.startsWith("__Secure-");
+		const secure = this.secure || this.sameSite === "None" || hostPrefix || securePrefix;
+		const obj = {
+			name: this.name,
+			value: this.value
+		};
+		if (this.maxAge) obj.maxage = this.maxAge;
+		if (this.domain && !hostPrefix) obj.domain = this.domain;
+		const path = hostPrefix ? "/" : this.path;
+		if (path) obj.path = path;
+		if (this.expires) obj.expires = this.expires;
+		if (this.httpOnly) obj.httponly = true;
+		if (secure) obj.secure = true;
+		return obj;
+	}
+};
+//#endregion
+export { cookiesParser, Cookie as default, parser };

package/dist/nodefony/src/errors/httpError.js

@@ -0,0 +1,69 @@
+import { clc, nodefonyError } from "nodefony";
+//#region nodefony/src/errors/httpError.ts
+const exclude = {
+	context: true,
+	resolver: true,
+	container: true,
+	secure: true,
+	request: true,
+	response: true
+};
+const jsonHttpError = {
+	configurable: true,
+	writable: true,
+	value() {
+		const alt = {};
+		const storeKey = function(key) {
+			if (key in exclude) return;
+			alt[key] = this[key];
+		};
+		Object.getOwnPropertyNames(this).forEach(storeKey, this);
+		return alt;
+	}
+};
+var HttpError = class extends nodefonyError {
+	context;
+	response;
+	request;
+	url;
+	controller;
+	action;
+	jsonResponse;
+	constructor(message, code, context) {
+		super(message, code);
+		this.context = context;
+		this.response = context?.response;
+		this.request = context?.request;
+		this.url = this.context?.url;
+		if (this.response && code) this.response.statusCode = code;
+		if (!this.message) this.message = (context?.response)?.body?.toString() || (context?.response)?.statusMessage || (context?.response)?.getStatusMessage();
+		const resolver = context?.resolver;
+		this.controller = resolver?.controller?.name ?? void 0;
+		this.action = resolver?.actionName ?? void 0;
+		const res = context?.response;
+		if (res) this.jsonResponse = `${res.statusCode} ${res.statusMessage ?? ""}`.trim();
+	}
+	toString() {
+		if (this.context) return `${clc.red(this.message)}
+    ${clc.blue("Name :")} ${this.name}
+    ${clc.blue("Type :")} ${this.errorType}
+    ${clc.green("Controller :")} ${this.controller}
+    ${clc.green("Action :")} ${this.action}
+    ${clc.blue("Url :")} ${this.url}
+      ${clc.red("Code :")} ${this.code}
+      ${clc.red("Message :")} ${this.message}
+      ${clc.red("Response :")} ${this.jsonResponse}
+    ${clc.green("Stack :")} ${this.stack}`;
+		return `${clc.red(this.message)}
+    ${clc.blue("Name :")} ${this.name}
+    ${clc.blue("Type :")} ${this.errorType}
+
+      ${clc.red("Code :")} ${this.code}
+      ${clc.red("Message :")} ${this.message}
+      ${clc.red("Response :")} ${this.jsonResponse}
+    ${clc.green("Stack :")} ${this.stack}`;
+	}
+};
+Object.defineProperty(HttpError.prototype, "toJSON", jsonHttpError);
+//#endregion
+export { HttpError as default };

package/dist/nodefony/src/profiler/FrameProfile.js

@@ -0,0 +1,95 @@
+//#region nodefony/src/profiler/FrameProfile.ts
+/**
+* Profil d'**une invocation** du pont RPC (une frame `api.request`), et non de
+* la connexion qui la porte.
+*
+* Pourquoi un objet séparé du `Context` : un `WebsocketContext` vit pour toute
+* la **connexion**, alors qu'une socket peut porter des centaines d'invocations,
+* concurrentes de surcroît. Empiler leurs phases sur le contexte produirait une
+* timeline **cumulative** (donc fausse) et ferait croître `Context.phases` sans
+* borne. Le profil naît et meurt donc avec la frame ; il voyage dans l'ALS
+* (`RequestContext.payload.invocation`), seul canal déjà per-invocation traversé
+* par le Resolver, le controller et les adapters ORM.
+*
+* Il satisfait **structurellement** ce que `Profiler.collect()` lit d'un
+* contexte : aucune connaissance du transport n'est requise côté Profiler, un
+* profil de frame s'y collecte comme une requête HTTP (`kind: "ws"`).
+*
+* Coût : **rien n'est alloué** quand le profiler dev est absent ET le timing
+* éteint (production) — le pont n'ouvre alors aucun profil.
+*/
+var FrameProfile = class {
+	requestId;
+	type;
+	scheme;
+	method;
+	url;
+	remoteAddress;
+	traceparent;
+	security;
+	securityTrace;
+	/** Phases de CETTE frame (vide si le timing est éteint). */
+	phases = [];
+	/**
+	* Buffer ORM de CETTE frame — `null` hors profiling. C'est ce buffer que le
+	* kernel refusait d'allouer au handshake (il aurait cumulé N messages) : par
+	* invocation, il redevient exact, et le SQL se replace dans le waterfall.
+	*/
+	profilerQueries;
+	/** Resolver de la frame — porte route / controller / action. */
+	resolver = null;
+	/** Statut HTTP-équivalent de l'invocation (200, 403, 404…). */
+	response = null;
+	error = null;
+	timing;
+	constructor(init) {
+		this.requestId = init.requestId;
+		this.type = init.type;
+		this.scheme = init.scheme;
+		this.method = init.method;
+		this.url = init.url;
+		this.remoteAddress = init.remoteAddress;
+		this.traceparent = init.traceparent;
+		this.security = init.security;
+		this.securityTrace = init.securityTrace;
+		this.timing = init.timing;
+		this.profilerQueries = init.queries ? [] : null;
+	}
+	/**
+	* Ouvre une phase. Contrairement au `Context`, l'index est un **scan arrière**
+	* (pas de `Map<nom, index>`) : une frame porte une poignée de phases, et une
+	* phase peut être ré-entrante (une action qui en déclenche une autre) — la
+	* table par nom, elle, écraserait la première occurrence.
+	*/
+	phaseStart(name) {
+		if (!this.timing) return;
+		this.phases.push({
+			name,
+			startMs: performance.now()
+		});
+	}
+	/** Ferme la DERNIÈRE phase ouverte de ce nom (idempotent). */
+	phaseEnd(name) {
+		if (!this.timing) return;
+		for (let i = this.phases.length - 1; i >= 0; i--) {
+			const p = this.phases[i];
+			if (p.name === name && p.endMs === void 0) {
+				p.endMs = performance.now();
+				p.durationMs = p.endMs - p.startMs;
+				return;
+			}
+		}
+	}
+	/**
+	* Fige l'issue de l'invocation (statut + erreur éventuelle) avant collecte.
+	*
+	* @param status - statut HTTP-équivalent (200 ; 403/404/409… pour un refus).
+	* @param error - l'erreur qui a interrompu la frame, le cas échéant.
+	*/
+	finish(status, error) {
+		this.response = { statusCode: status };
+		if (error !== void 0 && error !== null) this.error = { message: error instanceof Error ? error.message : String(error) };
+	}
+};
+//#endregion
+export { FrameProfile, FrameProfile as default };

package/dist/nodefony/src/profiler/Profiler.js

@@ -0,0 +1,139 @@
+//#region nodefony/src/profiler/Profiler.ts
+/** Durée totale = (fin de la dernière phase terminée) − (début de la 1ère). */
+function totalDuration(phases) {
+	if (phases.length === 0) return null;
+	const first = phases[0];
+	if (typeof first.startMs !== "number") return null;
+	let end = first.startMs;
+	for (const p of phases) {
+		const e = p.startMs + (p.durationMs ?? 0);
+		if (e > end) end = e;
+	}
+	const d = end - first.startMs;
+	return d >= 0 ? Math.round(d * 1e3) / 1e3 : null;
+}
+/** Capacité par défaut du ring buffer (assez pour une session de debug). */
+const DEFAULT_CAP = 500;
+var Profiler = class {
+	_buf = /* @__PURE__ */ new Map();
+	_cap;
+	constructor(cap = DEFAULT_CAP) {
+		this._cap = cap > 0 ? cap : DEFAULT_CAP;
+	}
+	/**
+	* Snapshot un `Context` en fin de requête. Tolérant aux champs absents
+	* (handshake WS, erreur précoce). À appeler AVANT `context.clean()`.
+	*
+	* @param ctx - le Context HTTP/WS terminé (lu en structurel, jamais muté).
+	*/
+	collect(ctx) {
+		const requestId = ctx.requestId;
+		if (!requestId) return;
+		const phases = ctx.phases ?? [];
+		const entry = {
+			requestId,
+			ts: Date.now(),
+			kind: ctx.type === "websocket" || ctx.type === "websocket-secure" ? "ws" : "http",
+			method: ctx.method ?? null,
+			url: ctx.url ?? "",
+			scheme: ctx.scheme ?? "",
+			status: ctx.response?.statusCode ?? (ctx.error ? 500 : null),
+			durationMs: totalDuration(phases),
+			route: ctx.resolver?.route?.name ?? null,
+			controller: ctx.resolver?.controller?.name ?? null,
+			action: ctx.resolver?.actionName ?? null,
+			remoteAddress: ctx.remoteAddress ?? null,
+			user: readUser(ctx),
+			traceparent: ctx.traceparent ?? null,
+			error: ctx.error?.message ?? null,
+			phases: phases.map((p) => ({
+				name: p.name,
+				startMs: p.startMs,
+				durationMs: p.durationMs ?? null
+			})),
+			queries: ctx.profilerQueries && ctx.profilerQueries.length > 0 ? ctx.profilerQueries : void 0,
+			security: readSecurity(ctx)
+		};
+		this._buf.delete(requestId);
+		this._buf.set(requestId, entry);
+		if (this._buf.size > this._cap) {
+			const oldest = this._buf.keys().next().value;
+			if (oldest !== void 0) this._buf.delete(oldest);
+		}
+	}
+	/** Profil complet d'une requête, ou `undefined` si évincé/inconnu. */
+	get(requestId) {
+		return this._buf.get(requestId);
+	}
+	/**
+	* Résumés des requêtes les plus récentes (récent → ancien), capés à `limit`.
+	*/
+	recent(limit = 60) {
+		const out = [];
+		const entries = [...this._buf.values()];
+		for (let i = entries.length - 1; i >= 0 && out.length < limit; i--) {
+			const e = entries[i];
+			out.push({
+				requestId: e.requestId,
+				ts: e.ts,
+				kind: e.kind,
+				method: e.method,
+				url: e.url,
+				status: e.status,
+				durationMs: e.durationMs,
+				route: e.route,
+				error: e.error
+			});
+		}
+		return out;
+	}
+	/** Nombre de profils en mémoire. */
+	get size() {
+		return this._buf.size;
+	}
+	/** Vide le ring buffer. */
+	clear() {
+		this._buf.clear();
+	}
+};
+/**
+* Croise la ZONE (ce qui était possible) et la TRACE (ce qui s'est passé).
+*
+* Hors zone firewall → `undefined` (pas de section « Sécurité » vide côté
+* client). Zone publique traversée sans trace → `outcome: "public"` : la
+* requête a bien croisé une zone, qui n'exigeait simplement rien.
+*/
+function readSecurity(ctx) {
+	const area = ctx.security;
+	if (!area) return void 0;
+	const t = ctx.securityTrace ?? null;
+	const isProtected = area.security === true;
+	return {
+		zone: area.name ?? null,
+		protected: isProtected,
+		mode: area.mode ?? null,
+		candidates: area.authenticators ? [...area.authenticators] : [],
+		authenticator: t?.authenticator ?? null,
+		outcome: t?.outcome ?? (isProtected ? null : "public"),
+		reason: t?.reason ?? null,
+		roles: t?.roles ?? null
+	};
+}
+/**
+* Identité de la requête.
+*
+* `context.user` n'est PAS la source de vérité en zone firewall : le token
+* résolu vit dans l'ALS (`RequestContext`), qui n'est plus lisible au teardown
+* où `collect()` s'exécute. Sans le repli sur la trace, une requête pleinement
+* authentifiée (rôles compris) s'afficherait « anonyme ».
+*/
+function readUser(ctx) {
+	const u = ctx.user;
+	if (u && typeof u === "object") {
+		const username = u.username;
+		if (typeof username === "string") return username;
+	}
+	return ctx.securityTrace?.user ?? null;
+}
+//#endregion
+export { Profiler, Profiler as default };