@nodefony/framework 10.0.0-alpha.1

package/dist/nodefony/interfaces/IAdminBroker.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IController.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IIdempotencyStore.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IResolver.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IRoute.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/index.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/service/AdminBroker.js

@@ -0,0 +1,106 @@
+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 router_default from "./router.js";
+import AdminApiController from "../controller/AdminApiController.js";
+import { ADMIN_DEFAULT_ROLE, Module, Service, injectable, resolveAdminRole } from "nodefony";
+//#region nodefony/service/AdminBroker.ts
+const serviceName = "adminBroker";
+/**
+* Implémentation du data plane admin (Studio) — collecte les {@link IAdminApi}
+* et monte `/nodefony/<namespace>/api/*` via le Router.
+*
+* Vit dans `@nodefony/framework` : seul niveau qui possède le Router. Le
+* contrat producteur (`IAdminApi`) vit dans le core (inversion de dépendance).
+*
+* @see IAdminBroker pour le contrat public + la convention de routage.
+*/
+let AdminBroker = class AdminBroker extends Service {
+	rootPrefix = "/nodefony";
+	apiSegment = "api";
+	defaultRole = ADMIN_DEFAULT_ROLE;
+	/** Producteurs enregistrés, indexés par namespace. */
+	producers = /* @__PURE__ */ new Map();
+	/** Routes résolues, indexées par nom de route (dispatch O(1)). */
+	byRouteName = /* @__PURE__ */ new Map();
+	/** Module framework propriétaire — requis pour `Router.setController`. */
+	frameworkModule;
+	/** Vrai une fois `mountAll()` exécuté (idempotence + verrou de register). */
+	mounted = false;
+	constructor(module) {
+		super(serviceName, module.container, module.notificationsCenter, module.options.adminBroker);
+		this.frameworkModule = module;
+	}
+	register(api) {
+		if (this.mounted) throw new Error(`AdminBroker: register("${api.adminNamespace}") après mountAll — routes figées`);
+		if (this.producers.has(api.adminNamespace)) throw new Error(`AdminBroker: namespace déjà enregistré "${api.adminNamespace}"`);
+		this.producers.set(api.adminNamespace, api);
+		this.log(`Admin API registered: ${api.adminNamespace}`, "DEBUG");
+		return this;
+	}
+	unregister(namespace) {
+		const existed = this.producers.delete(namespace);
+		if (existed && this.mounted) {
+			const router = this.getRouter();
+			for (const [name, r] of this.byRouteName) if (r.namespace === namespace) {
+				try {
+					router.removeRoutes(name);
+				} catch {}
+				this.byRouteName.delete(name);
+			}
+		}
+		return existed;
+	}
+	has(namespace) {
+		return this.producers.has(namespace);
+	}
+	getApi(namespace) {
+		return this.producers.get(namespace);
+	}
+	list() {
+		return Array.from(this.producers.values());
+	}
+	resolvePath(namespace, endpointPath) {
+		const tail = endpointPath.replace(/^\/+/, "");
+		return `${this.rootPrefix}/${namespace}/${this.apiSegment}/${tail}`;
+	}
+	resolve(routeName) {
+		return this.byRouteName.get(routeName);
+	}
+	routes() {
+		return Array.from(this.byRouteName.values());
+	}
+	mountAll() {
+		if (this.mounted) return;
+		for (const api of this.producers.values()) for (const endpoint of api.adminEndpoints()) {
+			const method = endpoint.method ?? "GET";
+			const role = resolveAdminRole(endpoint);
+			const path = this.resolvePath(api.adminNamespace, endpoint.path);
+			const name = `admin.${api.adminNamespace}.${method}.${endpoint.path}`;
+			const methods = [method, "WEBSOCKET"];
+			router_default.createRoute(name, {
+				path,
+				constructor: AdminApiController,
+				classMethod: "dispatch",
+				requirements: { methods }
+			});
+			this.byRouteName.set(name, {
+				name,
+				namespace: api.adminNamespace,
+				path,
+				method,
+				role,
+				endpoint
+			});
+		}
+		if (this.byRouteName.size > 0 && !Object.prototype.hasOwnProperty.call(AdminApiController.prototype, "module")) router_default.setController(AdminApiController, this.frameworkModule);
+		this.mounted = true;
+		this.log(`Admin data plane mounted: ${this.byRouteName.size} route(s)`, "DEBUG");
+	}
+	getRouter() {
+		return this.get("router");
+	}
+};
+AdminBroker = __decorate([injectable(), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module])], AdminBroker);
+var AdminBroker_default = AdminBroker;
+//#endregion
+export { AdminBroker_default as default };

package/dist/nodefony/service/Eta.js

@@ -0,0 +1,68 @@
+import Template from "../src/Template.js";
+import { extend, injectable } from "nodefony";
+import { readFile } from "node:fs/promises";
+import { Eta as Eta$1 } from "eta";
+//#region nodefony/service/Eta.ts
+/**
+* Options par défaut du moteur Eta.
+*
+* `autoEscape: true` = échappement HTML par défaut sur `<%= %>` (protection XSS,
+* cf exigence sécurité Nodefony). Sortie brute volontaire via `<%~ %>`.
+* `useWith: true` = variables exposées nues (`<%= name %>`) comme EJS — DX
+* familière, migration des vues `.ejs` → `.eta` verbatim.
+* `cache: false` par défaut — réactivé en prod par {@link Template} (env).
+*/
+const defaultOption = {
+	autoEscape: true,
+	useWith: true,
+	cache: false
+};
+/**
+* Moteur de template **Eta** — unique moteur de Nodefony (remplace EJS + Twig).
+*
+* Choisi pour : écrit en TypeScript (types fournis, pas de `@types/*`), ESM
+* natif, autoescape, et délimiteurs `<% %>` / `<%= %>` qui ne collisionnent pas
+* avec la syntaxe TS/JSON/JSX — décisif pour la génération de code (scaffold
+* `module:create`) autant que pour le rendu HTML serveur.
+*
+* Le `Controller` lit le fichier de vue (via `FileClass`) puis appelle
+* {@link Eta.render} avec la chaîne ; `renderFile` est fourni pour les usages
+* directs (CLI/Builder) qui partent d'un chemin.
+*/
+injectable();
+var Eta = class extends Template {
+	constructor(module) {
+		const engine = new Eta$1(extend(true, {}, defaultOption));
+		super("template", engine, module, extend(true, {}, defaultOption));
+		this.engine.configure({ cache: this.cache });
+	}
+	/**
+	* Rend un template depuis une chaîne source (chemin chaud du Controller).
+	*
+	* @param str - source du template Eta
+	* @param data - locals injectés dans le template
+	* @returns le rendu HTML/texte
+	*/
+	async render(str, data = {}) {
+		return this.engine.renderStringAsync(str, data);
+	}
+	/**
+	* Rend un template depuis un chemin de fichier (lecture async non bloquante).
+	*
+	* @param path - chemin absolu du fichier `.eta`
+	* @param data - locals injectés dans le template
+	* @returns le rendu HTML/texte
+	* @throws Si la lecture ou le parsing échoue (loggé en ERROR).
+	*/
+	async renderFile(path, data = {}) {
+		try {
+			const src = await readFile(path, { encoding: "utf8" });
+			return await this.engine.renderStringAsync(src, data);
+		} catch (e) {
+			this.log(e, "ERROR");
+			throw e;
+		}
+	}
+};
+//#endregion
+export { Eta as default };

package/dist/nodefony/service/IdempotencyStore.js

@@ -0,0 +1,136 @@
+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 { Module, Service, assertPageQuery, injectable } from "nodefony";
+//#region nodefony/service/IdempotencyStore.ts
+const serviceName = "idempotencyStore";
+/** Réponses mémorisées : 10 min (un rejeu plausible reste dans cette fenêtre). */
+const DEFAULT_TTL_MS = 6e5;
+/** Bail d'une entrée *in-flight* : 60 s (au-delà = exécution réputée abandonnée). */
+const DEFAULT_LEASE_MS = 6e4;
+/** Borne mémoire : nombre max d'entrées (éviction FIFO de la plus ancienne). */
+const DEFAULT_CAP = 1e3;
+/**
+* Implémentation **mémoire** (per-pod) de {@link IIdempotencyStore} — cache borné
+* de dédup des mutations admin rejouées.
+*
+* Vit dans `@nodefony/framework` (niveau qui possède le data plane admin) et
+* s'enregistre comme service DI `idempotencyStore` (manifeste `@services`).
+*
+* **Perf/mémoire** : `Map` allouée **lazy** au 1ᵉʳ `begin` (le store ne sert que
+* les mutations admin = cold path) ; aucun timer/listener (purge passive +
+* éviction FIFO au cap, payées seulement quand on écrit). Aucun coût tant
+* qu'aucune mutation idempotente n'est invoquée.
+*
+* @see IIdempotencyStore pour le contrat + l'invariant de scope de la clé.
+*/
+let MemoryIdempotencyStore = class MemoryIdempotencyStore extends Service {
+	/** Entrées vivantes — `null` tant qu'aucun `begin` n'a eu lieu (lazy alloc). */
+	entries = null;
+	ttlMs = DEFAULT_TTL_MS;
+	leaseMs = DEFAULT_LEASE_MS;
+	cap = DEFAULT_CAP;
+	constructor(module) {
+		super(serviceName, module.container, module.notificationsCenter, void 0);
+	}
+	get size() {
+		return this.entries === null ? 0 : this.entries.size;
+	}
+	/**
+	* {@inheritDoc IIdempotencyStore.listPage}
+	*
+	* La collection est déjà en RAM et **bornée par le cap** : le tri porte sur
+	* des références, seule la page devient des vues. Les entrées expirées sont
+	* exclues à la LECTURE (la purge d'ici est passive : elle n'a lieu qu'à
+	* l'écriture) — sinon on montrerait comme vivante une clé déjà rejouable.
+	*/
+	listPage(query) {
+		assertPageQuery(query, "offset");
+		const limit = Math.max(1, Math.floor(query.limit));
+		const offset = Math.max(0, Math.floor(query.offset ?? 0));
+		const now = Date.now();
+		const prefix = query.q !== void 0 && query.q.length > 0 ? query.q : null;
+		const matched = [];
+		for (const pair of this.entries ?? []) {
+			const [key, entry] = pair;
+			if (now > entry.expiresAt) continue;
+			if (prefix !== null && !key.startsWith(prefix)) continue;
+			if (query.state !== void 0 && entry.kind !== query.state) continue;
+			matched.push(pair);
+		}
+		matched.sort((a, b) => a[1].expiresAt - b[1].expiresAt || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+		const items = matched.slice(offset, offset + limit).map(([key, entry]) => ({
+			key,
+			state: entry.kind,
+			expiresAtMs: entry.expiresAt,
+			hasResponse: entry.kind === "done"
+		}));
+		return Promise.resolve({
+			items,
+			total: query.withTotal === false ? void 0 : matched.length,
+			limit,
+			offset,
+			hasNext: offset + items.length < matched.length
+		});
+	}
+	begin(key, fingerprint) {
+		const entries = this.entries ?? (this.entries = /* @__PURE__ */ new Map());
+		const now = Date.now();
+		const existing = entries.get(key);
+		if (existing !== void 0 && now <= existing.expiresAt) {
+			if (existing.fingerprint !== fingerprint) return { state: "mismatch" };
+			if (existing.kind === "done") return {
+				state: "replayed",
+				response: existing.response
+			};
+			return { state: "in-flight" };
+		}
+		if (existing !== void 0) entries.delete(key);
+		entries.set(key, {
+			kind: "in-flight",
+			fingerprint,
+			expiresAt: now + this.leaseMs
+		});
+		return { state: "fresh" };
+	}
+	complete(key, response) {
+		const entries = this.entries;
+		if (entries === null) return;
+		const existing = entries.get(key);
+		if (existing === void 0 || existing.kind !== "in-flight") return;
+		entries.set(key, {
+			kind: "done",
+			fingerprint: existing.fingerprint,
+			response,
+			expiresAt: Date.now() + this.ttlMs
+		});
+		this.evictIfNeeded();
+	}
+	abort(key) {
+		const entries = this.entries;
+		if (entries === null) return;
+		const existing = entries.get(key);
+		if (existing !== void 0 && existing.kind === "in-flight") entries.delete(key);
+	}
+	/**
+	* Borne la taille : purge passive des expirées rencontrées, puis éviction FIFO
+	* (la plus ancienne insérée) jusqu'à repasser sous le cap. Appelé au `complete`
+	* (seul point qui fait croître durablement la Map).
+	*/
+	evictIfNeeded() {
+		const entries = this.entries;
+		if (entries === null || entries.size <= this.cap) return;
+		const now = Date.now();
+		for (const [k, e] of entries) {
+			if (now > e.expiresAt) entries.delete(k);
+			if (entries.size <= this.cap) return;
+		}
+		for (const k of entries.keys()) {
+			entries.delete(k);
+			if (entries.size <= this.cap) return;
+		}
+	}
+};
+MemoryIdempotencyStore = __decorate([injectable(), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module])], MemoryIdempotencyStore);
+var IdempotencyStore_default = MemoryIdempotencyStore;
+//#endregion
+export { IdempotencyStore_default as default };

package/dist/nodefony/service/router.js

@@ -0,0 +1,243 @@
+import Route from "../src/Route.js";
+import { routeExpectsBodyStream } from "../decorators/routerDecorators.js";
+import Resolver from "../src/Resolver.js";
+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 { Module, Service, injectable } from "nodefony";
+import { HttpError, isDomainAllowed } from "@nodefony/http";
+//#region nodefony/service/router.ts
+var _Router;
+let routeNoticePromoted = null;
+function collectSupportedMethods(route) {
+	const set = /* @__PURE__ */ new Set();
+	const m = route.requirements?.methods;
+	if (typeof m === "string") m.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean).forEach((x) => set.add(x));
+	else if (Array.isArray(m)) m.map((s) => String(s).toUpperCase()).forEach((x) => set.add(x));
+	return set;
+}
+const routes = [];
+const serviceName = "router";
+const REG_NON_LITERAL = /[{}*+?()[\]^$|\\]/;
+const NO_LITERALS = [];
+/**
+* Préfixe LITTÉRAL d'un chemin de route : tout ce qui précède son premier
+* caractère non littéral, en minuscules. Le motif compilé étant ancré (`^…$`),
+* un chemin que cette route peut servir commence FORCÉMENT par ce préfixe —
+* c'est ce qui autorise à écarter la route sans exécuter son motif.
+*
+* ⚠️ Garde ASCII. Le pré-filtre compare `cleanPath.toLowerCase()` à ce préfixe,
+* or `toLowerCase()` (repli Unicode complet) et le drapeau `i` du motif (repli
+* simple) ne traitent PAS la casse de la même façon hors ASCII : comparer les
+* deux pourrait écarter une route qui matche — un 404 à la place d'une réponse.
+* On tronque donc le préfixe au premier caractère non ASCII : filtrer moins est
+* toujours correct, filtrer à tort ne l'est jamais.
+*
+* @param path - chemin déclaré de la route (`undefined` pour une route sans chemin).
+* @returns le préfixe exploitable, ou `""` quand il n'y en a pas (route jamais filtrée).
+*/
+function literalPrefix(path) {
+	if (path === void 0) return "";
+	const cut = path.search(REG_NON_LITERAL);
+	const head = cut === -1 ? path : path.slice(0, cut);
+	for (let i = 0; i < head.length; i++) if (head.charCodeAt(i) > 127) return head.slice(0, i).toLowerCase();
+	return head.toLowerCase();
+}
+let routeIndex = null;
+function invalidateRouteIndex() {
+	routeIndex = null;
+}
+function buildRouteIndex() {
+	const statics = /* @__PURE__ */ new Map();
+	const dynamics = [];
+	for (let i = 0; i < routes.length; i++) {
+		const route = routes[i];
+		const path = route.path;
+		if (path !== void 0 && route.variables.length === 0 && !REG_NON_LITERAL.test(path)) {
+			const key = path.toLowerCase();
+			let list = statics.get(key);
+			if (list === void 0) {
+				list = [];
+				statics.set(key, list);
+			}
+			list.push({
+				route,
+				pos: i,
+				prefix: ""
+			});
+		} else dynamics.push({
+			route,
+			pos: i,
+			prefix: literalPrefix(path)
+		});
+	}
+	return routeIndex = {
+		statics,
+		dynamics,
+		length: routes.length,
+		first: routes[0],
+		last: routes[routes.length - 1]
+	};
+}
+let Router = class Router extends Service {
+	static {
+		_Router = this;
+	}
+	static routes = routes;
+	routes = _Router.routes;
+	singletonControllers = null;
+	constructor(module) {
+		super(serviceName, module.container, module.notificationsCenter, module.options.router);
+	}
+	/**
+	* Retourne l'instance singleton d'une classe controller `@Scope("singleton")`,
+	* en la créant au premier appel via `create`. On cache la **promesse** (pas
+	* l'instance) : N requêtes concurrentes pendant la création (`initialize()`
+	* async) attendent le MÊME travail — jamais deux instances (race de création
+	* éliminée structurellement).
+	*
+	* @param ctor - la classe controller (clé du cache).
+	* @param create - fabrique exécutée une seule fois (instantiate + initialize).
+	* @returns la promesse de l'instance partagée.
+	*/
+	getSingletonController(ctor, create) {
+		if (this.singletonControllers == null) this.singletonControllers = /* @__PURE__ */ new Map();
+		let instance = this.singletonControllers.get(ctor);
+		if (!instance) {
+			instance = create();
+			this.singletonControllers.set(ctor, instance);
+		}
+		return instance;
+	}
+	/**
+	* Résout une route pour un contexte donné.
+	*
+	* @param context - le contexte HTTP/WS courant (porte container, méthode, URL…).
+	* @param cleanPathOverride - quand fourni, le matching se fait sur CE pathname au
+	*   lieu de `context.request.url` — permet de router un path **porté par un message**
+	*   (WS-RPC `invoke`) vers une action, sans muter l'URL de la connexion (état partagé).
+	*   `undefined` (cas hot path normal) → comportement inchangé.
+	* @param methodOverride - méthode HTTP **logique** à exiger en plus du transport
+	*   WEBSOCKET (pont WS-RPC `api.request` d'une MUTATION) : lève l'ambiguïté
+	*   GET-via-WS / POST-via-WS sur un même chemin (`context.method` = "WEBSOCKET").
+	*   `undefined` (GET/HTTP) → match historique sur `context.method`.
+	* @returns un `Resolver` (`.resolve === true` si une route a matché).
+	*/
+	resolve(context, cleanPathOverride, methodOverride) {
+		const resolver = new Resolver(context);
+		resolver.methodOverride = methodOverride ?? null;
+		const cleanPath = cleanPathOverride ?? Route.cleanPathname(context);
+		let index = routeIndex;
+		if (index === null || index.length !== routes.length || index.first !== routes[0] || index.last !== routes[routes.length - 1]) index = buildRouteIndex();
+		const cleanPathLower = cleanPath !== void 0 ? cleanPath.toLowerCase() : void 0;
+		const literals = cleanPathLower !== void 0 ? index.statics.get(cleanPathLower) ?? NO_LITERALS : NO_LITERALS;
+		const dynamics = index.dynamics;
+		const litCount = literals.length;
+		const dynCount = dynamics.length;
+		let li = 0;
+		let di = 0;
+		while (li < litCount || di < dynCount) {
+			let route;
+			if (li < litCount && (di >= dynCount || literals[li].pos < dynamics[di].pos)) route = literals[li++].route;
+			else {
+				const candidate = dynamics[di++];
+				if (candidate.prefix !== "" && cleanPathLower !== void 0 && !cleanPathLower.startsWith(candidate.prefix)) continue;
+				route = candidate.route;
+			}
+			try {
+				if (resolver.match(route, context, cleanPath)) {
+					if (routeNoticePromoted === null) routeNoticePromoted = this.kernel?.environment !== "production";
+					if (routeNoticePromoted) this.log(`Match route : ${route.name}`, "NOTICE");
+					resolver.exception = void 0;
+					routeExpectsBodyStream(route);
+					return resolver;
+				}
+			} catch (e) {
+				this.log(`Match route exception : ${route.name} ${e}`, "DEBUG");
+				resolver.exception = e;
+				continue;
+			}
+		}
+		if (context.method !== "WEBSOCKET" && cleanPath !== void 0) {
+			const path = cleanPath || "/";
+			const allowed = /* @__PURE__ */ new Set();
+			for (const route of routes) {
+				const servesDomain = !route.hostRegexp || isDomainAllowed(route.hostRegexp, context.domain);
+				if (route.pattern && route.pattern.test(path) && servesDomain) collectSupportedMethods(route).forEach((x) => allowed.add(x));
+			}
+			if (allowed.size > 0) {
+				const allowHeader = Array.from(allowed).join(", ");
+				const err = new HttpError(`Method ${context.method} Not Allowed`, 405, context);
+				const methodErr = err;
+				methodErr.allow = allowHeader;
+				methodErr.type = "method";
+				context.response?.setHeaders({ Allow: allowHeader });
+				throw err;
+			}
+		}
+		if (resolver.exception) {
+			switch (resolver.exception.code) {
+				case 405: context.response?.setHeaders({ Allow: resolver.exception.allow });
+			}
+			throw resolver.exception;
+		}
+		return resolver;
+	}
+	resolveController(contex, name) {
+		const resolver = new Resolver(contex);
+		resolver.parsePathernController(name);
+		return resolver;
+	}
+	matchRoutes(path) {
+		let result = [];
+		for (const route of routes) {
+			let res = route.pattern?.exec(path);
+			if (res) result.push(res);
+		}
+		return result;
+	}
+	getRoutes(name) {
+		if (name) return routes.find((route) => route.name === name);
+		return routes;
+	}
+	setRoute() {}
+	removeRoutes(name) {
+		if (name) {
+			const index = routes.findIndex((route) => route.name === name);
+			if (index !== -1) {
+				routes.splice(index, 1);
+				invalidateRouteIndex();
+			} else throw new Error(`Route ${name} not found.`);
+		} else {
+			routes.length = 0;
+			invalidateRouteIndex();
+		}
+	}
+	static createRoute(name, obj) {
+		const routenew = new Route(name, obj);
+		routes.push(routenew);
+		invalidateRouteIndex();
+		return routenew;
+	}
+	static setController(myconstructor, module) {
+		Object.defineProperty(myconstructor.prototype, "module", {
+			value: module,
+			writable: false
+		});
+		const key = `${module.name}:${myconstructor.name}`;
+		if (Module.controllers[key]) module.log(/* @__PURE__ */ new Error(`Controller already exist ${key}`), "WARNING");
+		for (const r of routes) if (r.controller === myconstructor) r.module = { name: module.name };
+		return Module.controllers[key] = myconstructor;
+	}
+	/**
+	* Retourne les routes enregistrées pour un controller donné — utilisé par
+	* le décorateur `@controllers` pour logger chaque route depuis le module
+	* propriétaire (msgid `MODULE <name>` au lieu de `KERNEL`).
+	*/
+	static getRoutesForController(myconstructor) {
+		return routes.filter((r) => r.controller === myconstructor);
+	}
+};
+Router = _Router = __decorate([injectable(), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module])], Router);
+var router_default = Router;
+//#endregion
+export { router_default as default };