@nodefony/http 10.0.0-alpha.1

package/dist/nodefony/service/upload/upload-service.js

@@ -0,0 +1,171 @@
+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 { Cli, FileClass, Module, Service, inject } from "nodefony";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+//#region nodefony/service/upload/upload-service.ts
+/** Test d'existence non bloquant (`fsp.access`) — remplace `existsSync`. */
+const existsAsync = async (p) => {
+	try {
+		await fsp.access(p);
+		return true;
+	} catch {
+		return false;
+	}
+};
+let upload = class upload extends Service {
+	httpKernel;
+	path;
+	module;
+	constructor(module, httpKernel) {
+		super("upload", httpKernel?.container, httpKernel.notificationsCenter);
+		this.httpKernel = httpKernel;
+		this.module = module;
+		this.kernel?.once("onBoot", async () => {
+			this.options = this.httpKernel.options;
+			if (path.isAbsolute(this.options.upload.uploadDir)) this.path = this.options.upload.uploadDir;
+			else this.path = path.resolve(`${this.kernel?.path}/${this.options.upload.uploadDir}`);
+			try {
+				await fsp.mkdir(this.path, { recursive: true });
+			} catch (e) {
+				this.path = "/tmp";
+				this.options.upload.uploadDir = this.path;
+				this.log(e, "DEBUG");
+			}
+		});
+	}
+	/**
+	* Construit un `UploadedFile` à partir d'un fichier multipart parsé —
+	* **async, non bloquant** (stat via `fsp.lstat`, plus de `lstatSync` par
+	* fichier uploadé).
+	*
+	* @param file - fichier parsé (forme neutre `IParsedUploadFile`, busboy).
+	* @param name - nom de champ (fallback si pas de `originalFilename`).
+	* @returns le `UploadedFile` hydraté.
+	*/
+	async createUploadFile(file, name) {
+		return UploadedFile.create(file, name);
+	}
+	log(pci, severity, msgid, msg) {
+		if (this.syslog) {
+			if (!msgid) msgid = "HTTP UPLOAD";
+			return this.syslog.log(pci, severity, msgid, msg);
+		}
+		throw new Error(`Syslog not ready`);
+	}
+};
+upload = __decorate([__decorateParam(1, inject("HttpKernel")), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module, typeof http_kernel_default === "undefined" ? Object : http_kernel_default])], upload);
+var UploadedFile = class UploadedFile extends FileClass {
+	parsedFile;
+	size;
+	prettySize;
+	filename;
+	lastModifiedDate;
+	hashAlgorithm;
+	hash;
+	constructor(parsedFile, name, options) {
+		super(parsedFile.filepath, options);
+		this.parsedFile = parsedFile;
+		this.size = this.getSize();
+		this.prettySize = this.getPrettySize();
+		this.filename = this.realName(name);
+		this.mimeType = this.getMimeType();
+		this.lastModifiedDate = this.parsedFile.mtime;
+		this.hashAlgorithm = this.parsedFile.hashAlgorithm;
+		this.hash = this.parsedFile.hash;
+	}
+	/**
+	* Construit un `UploadedFile` SANS `lstatSync` bloquant — stat résolu en async
+	* (`FileClass.stat`). À utiliser dans le pipeline d'upload (per-request).
+	*
+	* @param parsedFile - fichier multipart parsé (forme neutre busboy).
+	* @param name - nom de champ (fallback de nom).
+	* @returns le `UploadedFile` hydraté (stats async).
+	* @remarks Nommée `create` (pas `from`) pour ne pas entrer en conflit avec la
+	*   signature statique de `FileClass.from(path)` (TS2417).
+	*/
+	static async create(parsedFile, name) {
+		const file = new UploadedFile(parsedFile, name, { defer: true });
+		await file.stat();
+		return file;
+	}
+	getSize() {
+		return this.parsedFile.size;
+	}
+	getPrettySize() {
+		return Cli.niceBytes(this.parsedFile.size);
+	}
+	realName(name) {
+		return this.parsedFile.originalFilename || name || this.parsedFile.newFilename;
+	}
+	getMimeType() {
+		if (this.parsedFile) return this.parsedFile.mimetype || super.getMimeType(this.filename);
+		return super.getMimeType();
+	}
+	/**
+	* Nom de fichier SÛR à poser dans un dossier de destination.
+	*
+	* `filename` vient de `originalFilename`, c'est-à-dire de l'en-tête multipart :
+	* **une donnée d'attaquant**. Le fichier temporaire, lui, est protégé (nom
+	* généré) — mais dès que l'application écrit `file.move("/var/uploads")`, c'est
+	* ce nom client qui compose la destination, et `path.resolve` honore les `..` :
+	* `../../etc/cron.d/x` sortait du dossier visé.
+	*
+	* On ne garde donc que le dernier segment, en coupant sur les DEUX séparateurs
+	* (un client Windows envoie `..\\..\\x`, que `path.basename` POSIX ne découpe
+	* pas). Reste `.`/`..`/vide → on retombe sur le nom du fichier temporaire,
+	* jamais sur quelque chose que le client contrôle.
+	*
+	* @returns un nom de fichier sans aucune composante de chemin.
+	*/
+	#safeTargetName() {
+		const cleaned = ((this.filename || this.name || "").split(/[/\\]/).pop() ?? "").trim();
+		if (cleaned === "" || cleaned === "." || cleaned === "..") return path.basename(this.parsedFile.filepath);
+		return cleaned;
+	}
+	move(target) {
+		if (fs.existsSync(target)) {
+			const newFile = new FileClass(target);
+			if (newFile.isDirectory()) {
+				const n = path.resolve(newFile.path, this.#safeTargetName());
+				return super.move(n);
+			}
+		}
+		const dirname = path.dirname(target);
+		if (fs.existsSync(dirname)) {
+			if (target === dirname) {
+				const name = path.resolve(target, this.#safeTargetName());
+				return super.move(name);
+			} else return super.move(target);
+		}
+		throw fs.lstatSync(dirname);
+	}
+	/**
+	* Variante **async** de `move()` — déplace le fichier uploadé sans bloquer
+	* l'event-loop (`fsp.access`/`fsp.rename` via `FileClass.moveAsync`).
+	* À préférer dans le pipeline (controller).
+	*
+	* @param target - destination (fichier ou dossier existant).
+	* @returns nouvelle instance `FileClass` (hydratée async) sur la destination.
+	*/
+	async moveAsync(target) {
+		const dest = target;
+		if (await existsAsync(dest)) {
+			const newFile = await FileClass.from(dest);
+			if (newFile.isDirectory()) return super.moveAsync(path.resolve(newFile.path, this.#safeTargetName()));
+		}
+		const dirname = path.dirname(dest);
+		if (await existsAsync(dirname)) {
+			if (dest === dirname) return super.moveAsync(path.resolve(dest, this.#safeTargetName()));
+			return super.moveAsync(dest);
+		}
+		await fsp.lstat(dirname);
+		throw new Error(`upload moveAsync: target dir not found: ${dirname}`);
+	}
+};
+var upload_service_default = upload;
+//#endregion
+export { UploadedFile, upload_service_default as default, upload };

package/dist/nodefony/src/assets/collectAssets.js

@@ -0,0 +1,34 @@
+import { stripTrailingSlashes } from "nodefony";
+import { join } from "node:path";
+//#region nodefony/src/assets/collectAssets.ts
+/** Normalise un préfixe en segment de chemin (`/_assets/x/` → `_assets/x`). */
+const prefixToSegment = (prefix) => stripTrailingSlashes(prefix.replace(/^\/+/, ""));
+/**
+* Construit le plan de publication des assets : pour chaque source unique
+* (dédupliquée par préfixe — le DERNIER gagne, comme `addMount`), calcule le
+* dossier cible `outDir/<préfixe-en-chemin>` miroir de l'URL.
+*
+* PUR (0 I/O) → testable. La copie réelle + le manifeste sont faits par la
+* commande `assets:publish`. L'upload (S3/CDN/rsync) reste à l'orchestrateur :
+* Nodefony assemble l'arbre, le déploiement le pousse (cloud-native).
+*
+* @param sources dossiers + préfixes (mounts natifs + bundles frontend)
+* @param outDir racine ABSOLUE de l'arbre de sortie (ex. `<root>/dist-assets`)
+* @returns plan ordonné, 1 entrée par préfixe unique
+*/
+function planAssetPublish(sources, outDir) {
+	const byPrefix = /* @__PURE__ */ new Map();
+	for (const s of sources) byPrefix.set(s.prefix, s.dir);
+	const plan = [];
+	for (const [prefix, dir] of byPrefix) {
+		const seg = prefixToSegment(prefix);
+		plan.push({
+			prefix,
+			dir,
+			target: seg ? join(outDir, seg) : outDir
+		});
+	}
+	return plan;
+}
+//#endregion
+export { planAssetPublish };

package/dist/nodefony/src/assets/prebuiltUi.js

@@ -0,0 +1,125 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region nodefony/src/assets/prebuiltUi.ts
+/**
+* Résout le mode de livraison de l'UI embarquée d'un module.
+*
+* Pattern universel des admin-UI embarquées (bull-board, GraphiQL, profiler
+* Symfony) : le consommateur ne compile JAMAIS l'UI d'un module tiers — les
+* assets sont pré-buildés au publish et servis statiques. Le mode `vite`
+* (HMR) n'a de sens que là où les sources existent (repo self-hosted, `--link`).
+*
+* PUR hormis deux `existsSync` (boot uniquement, jamais dans le hot path).
+*
+* @returns le mode effectif + la raison à logger (fail-loud si `none`)
+*/
+function resolveUiDelivery(opts) {
+	const requested = opts.requested ?? "auto";
+	const hasSources = fs.existsSync(opts.sourcesDir);
+	const hasPrebuilt = fs.existsSync(opts.distIndex);
+	if (requested === "vite") {
+		if (!opts.hasFrontendService) return {
+			mode: "none",
+			reason: `ui: "vite" forced but @nodefony/frontend service is not registered`
+		};
+		if (!hasSources) return {
+			mode: "none",
+			reason: `ui: "vite" forced but frontend sources are missing (${opts.sourcesDir})`
+		};
+		return {
+			mode: "vite",
+			reason: `ui: "vite" forced by config`
+		};
+	}
+	if (requested === "static") {
+		if (!hasPrebuilt) return {
+			mode: "none",
+			reason: `ui: "static" forced but prebuilt index is missing (${opts.distIndex})`
+		};
+		return {
+			mode: "static",
+			reason: `ui: "static" forced by config`
+		};
+	}
+	if (opts.environment === "development" && opts.hasFrontendService) {
+		if (hasSources) return {
+			mode: "vite",
+			reason: "auto → vite (development + frontend service + sources)"
+		};
+	}
+	if (hasPrebuilt) return {
+		mode: "static",
+		reason: `auto → static (prebuilt assets ${path.dirname(opts.distIndex)})`
+	};
+	return {
+		mode: "none",
+		reason: `auto → none: no Vite path (dev+frontend+sources) and no prebuilt index (${opts.distIndex}) — did the package ship its "prepack" UI build?`
+	};
+}
+/**
+* Livraison STATIQUE de l'UI pré-buildée d'un module (mode `static`).
+*
+* Deux responsabilités, zéro dépendance à @nodefony/frontend :
+*  1. {@link mount} — sert `distDir` sous `publicPath` via `server-static`
+*     (assets hashés immuables produits par `vite build` au publish).
+*  2. {@link renderIndex} — document HTML d'entrée (l'`index.html` transformé
+*     par Vite, tags déjà réécrits vers `publicPath`), nonce CSP injecté par
+*     requête. Le SPA fallback reste au controller du module (routes littérales,
+*     cf. StudioController).
+*
+* Perf : l'index est lu UNE fois (lazy, caché) ; seule l'injection du nonce
+* coûte un `replaceAll` par rendu — route d'entrée UI, jamais un hot path.
+*/
+var PrebuiltUi = class {
+	publicPath;
+	distDir;
+	indexPath;
+	/** Template HTML caché — `null` tant que non lu (lazy). */
+	template = null;
+	constructor(opts) {
+		let p = opts.publicPath.trim();
+		if (!p.startsWith("/")) p = `/${p}`;
+		if (!p.endsWith("/")) p = `${p}/`;
+		this.publicPath = p.replace(/\/{2,}/g, "/");
+		this.distDir = opts.distDir;
+		this.indexPath = path.join(this.distDir, opts.indexFile ?? "index.html");
+	}
+	/**
+	* Monte `distDir` sous `publicPath` auprès de `server-static` (résolu par
+	* nom). Si le service n'existe pas encore (module chargé avant http), un
+	* retry unique est armé sur `onReady`.
+	*
+	* @returns `true` si monté immédiatement, `false` si différé/indisponible
+	*          (l'appelant loggue — ce helper n'a pas de logger)
+	*/
+	mount(container, kernel) {
+		const stat = container?.get?.("server-static");
+		if (stat?.addMount) {
+			stat.addMount(this.publicPath, this.distDir);
+			return true;
+		}
+		kernel?.once("onReady", () => {
+			(container?.get?.("server-static"))?.addMount?.(this.publicPath, this.distDir);
+		});
+		return false;
+	}
+	/**
+	* Document HTML d'entrée de l'UI (index pré-buildé par Vite).
+	*
+	* @param nonce nonce CSP de la requête (`Context.cspNonce`) — injecté sur
+	*              chaque `<script>` ; les assets `src` same-origin passent déjà
+	*              par `'self'`, le nonce couvre un éventuel inline Vite.
+	* @returns le HTML, ou un commentaire HTML fail-loud si l'index est absent
+	*/
+	renderIndex(nonce) {
+		if (this.template === null) try {
+			this.template = fs.readFileSync(this.indexPath, "utf8");
+		} catch {
+			return `<!DOCTYPE html><!-- prebuilt UI index missing: ${this.indexPath} -->`;
+		}
+		if (!nonce) return this.template;
+		return this.template.replaceAll("<script", `<script nonce="${nonce}"`);
+	}
+};
+//#endregion
+export { PrebuiltUi, resolveUiDelivery };