@nodefony/http 10.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,108 @@
+import config, { httpConfigSchema } from "./nodefony/config/config.js";
+import { defineHttpConfig, httpConfigJsonSchema } from "./nodefony/config/defineModuleConfig.js";
+import { createHttpAdminApi } from "./nodefony/service/HttpAdminApi.js";
+import { createProfilerAdminApi } from "./nodefony/service/ProfilerAdminApi.js";
+import { Profiler } from "./nodefony/src/profiler/Profiler.js";
+import HttpError from "./nodefony/src/errors/httpError.js";
+import { MemoryRateLimitStore } from "./nodefony/src/rateLimit/MemoryRateLimitStore.js";
+import { compileDomainPattern, compileDomainPatterns, compileTrustedHosts, isDomainAllowed } from "./nodefony/src/context/domainMatcher.js";
+import Cookie from "./nodefony/src/cookies/cookie.js";
+import Context from "./nodefony/src/context/Context.js";
+import { decideSend, readBackpressureOptions } from "./nodefony/src/context/websocket/wsBackpressure.js";
+import WebsocketResponse from "./nodefony/src/context/websocket/Response.js";
+import { FrameProfile } from "./nodefony/src/profiler/FrameProfile.js";
+import WebsocketContext from "./nodefony/src/context/websocket/WebsocketContext.js";
+import HttpRequest from "./nodefony/src/context/http/Request.js";
+import HttpResponse from "./nodefony/src/context/http/Response.js";
+import Http2Request from "./nodefony/src/context/http2/Request.js";
+import Http2Response from "./nodefony/src/context/http2/Response.js";
+import HttpContext from "./nodefony/src/context/http/HttpContext.js";
+import DefaultErrorRenderer, { schemaMismatchOf } from "./nodefony/service/error-renderer.js";
+import DefaultRequestLogger from "./nodefony/service/request-logger.js";
+import JsonAuditLogger from "./nodefony/service/audit-logger.js";
+import PrettyRequestLogger from "./nodefony/service/pretty-request-logger.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 http_kernel_default from "./nodefony/service/http-kernel.js";
+import server_http_default from "./nodefony/service/servers/server-http.js";
+import server_https_default from "./nodefony/service/servers/server-https.js";
+import server_websocket_default from "./nodefony/service/servers/server-websocket.js";
+import server_websocket_secure_default from "./nodefony/service/servers/server-websocket-secure.js";
+import Statics from "./nodefony/service/servers/server-static.js";
+import Network from "./nodefony/command/networkCommand.js";
+import Certificates from "./nodefony/command/certificatesCommand.js";
+import ProxyGenerate from "./nodefony/command/proxyGenerateCommand.js";
+import AssetsPublish from "./nodefony/command/assetsPublishCommand.js";
+import Session from "./nodefony/src/session/session.js";
+import { SESSION_COLUMN_ALIASES, SESSION_DEFAULT_ORDER, SESSION_DEFAULT_ORDER_SQL, SESSION_SORTABLE_FIELDS } from "./nodefony/src/session/storage/sessionSort.js";
+import sessions_service_default from "./nodefony/service/sessions/sessions-service.js";
+import Certificate from "./nodefony/service/certificates.js";
+import upload_service_default from "./nodefony/service/upload/upload-service.js";
+import { PrebuiltUi, resolveUiDelivery } from "./nodefony/src/assets/prebuiltUi.js";
+import { Kernel, Module, services } from "nodefony";
+//#region index.ts
+let Http = class Http extends Module {
+	constructor(kernel) {
+		super("http", kernel, import.meta.url, config);
+		this.addCommand(Network);
+		this.addCommand(Certificates);
+		this.addCommand(ProxyGenerate);
+		this.addCommand(AssetsPublish);
+	}
+	/**
+	* Expose le JSON Schema de la config http (dérivé du schéma Zod, flags `meta()`
+	* inclus) au data plane admin → Studio rend la config en réglages documentés
+	* (type, défaut, état, valeur effective) au lieu d'un dump brut. Override du
+	* seam {@link Module.configSchema}.
+	*/
+	configSchema() {
+		return httpConfigJsonSchema();
+	}
+	/**
+	* Phase `onRegister` : valide la config (défauts + override `module-http` +
+	* défauts kernel) via `defineHttpConfig`, puis la ré-assigne à `this.options`
+	* AVANT l'instanciation des `@services` (phase `onBoot`). Plante propre avec
+	* messages clairs si la config est invalide (convention Zod figée 2026-05-28).
+	*
+	* Config NON gelée : les services mutent `module.options` (upload `uploadDir`,
+	* certificats `serialNumber`) — cf `defineHttpConfig`.
+	*/
+	async onKernelRegister() {
+		this.options = defineHttpConfig(this.options ?? {}, this.kernel);
+		return this;
+	}
+	/**
+	* Phase `onBoot` : s'enregistre comme producteur admin (`/nodefony/http/api/*`)
+	* auprès du broker, AVANT que framework ne monte le data plane à `onReady`.
+	*
+	* Importe seulement `IAdminRegistry` (core) — jamais `@nodefony/framework`
+	* (dépendance circulaire). Le broker est résolu du container partagé.
+	*/
+	async onKernelBoot() {
+		const registry = this.kernel?.container?.get("adminBroker");
+		if (registry && !registry.has("http")) registry.register(createHttpAdminApi(this));
+		if (this.kernel?.environment !== "production") {
+			const profiler = new Profiler();
+			this.container?.set("profiler", profiler);
+			if (registry && !registry.has("profiler")) registry.register(createProfilerAdminApi(profiler));
+		}
+		return this;
+	}
+	async onKernelReady() {
+		return this;
+	}
+};
+Http = __decorate([services([
+	http_kernel_default,
+	Certificate,
+	sessions_service_default,
+	Statics,
+	server_http_default,
+	server_https_default,
+	server_websocket_default,
+	server_websocket_secure_default,
+	upload_service_default
+]), __decorateMetadata("design:paramtypes", [typeof Kernel === "undefined" ? Object : Kernel])], Http);
+var http_default = Http;
+//#endregion
+export { Context, Cookie, DefaultErrorRenderer, DefaultRequestLogger, FrameProfile, Http2Request, Http2Response, HttpContext, HttpError, http_kernel_default as HttpKernel, HttpRequest, HttpResponse, HttpResponse as Response, JsonAuditLogger, MemoryRateLimitStore, PrebuiltUi, PrettyRequestLogger, Profiler, SESSION_COLUMN_ALIASES, SESSION_DEFAULT_ORDER, SESSION_DEFAULT_ORDER_SQL, SESSION_SORTABLE_FIELDS, Session, sessions_service_default as SessionsService, WebsocketContext, WebsocketResponse, WebsocketResponse as wsResponse, compileDomainPattern, compileDomainPatterns, compileTrustedHosts, decideSend, http_default as default, defineHttpConfig, httpConfigJsonSchema, httpConfigSchema, isDomainAllowed, readBackpressureOptions, resolveUiDelivery, schemaMismatchOf };

package/dist/nodefony/command/assetsPublishCommand.js

@@ -0,0 +1,102 @@
+import { planAssetPublish } from "../src/assets/collectAssets.js";
+import { Command } from "nodefony";
+import { existsSync } from "node:fs";
+import fsp from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+//#region nodefony/command/assetsPublishCommand.ts
+const options = {
+	helpGroup: "FRONT ET RÉSEAU",
+	showBanner: false,
+	kernelEvent: "onReady"
+};
+/** Compte récursivement les fichiers d'un dossier (borné par le FS). */
+async function countFiles(dir) {
+	let n = 0;
+	let entries;
+	try {
+		entries = await fsp.readdir(dir, { withFileTypes: true });
+	} catch {
+		return 0;
+	}
+	for (const e of entries) if (e.isDirectory()) n += await countFiles(join(dir, e.name));
+	else n += 1;
+	return n;
+}
+/**
+* Commande CLI `assets:publish` — assemble TOUS les assets statiques servables
+* (publics de module montés sous `/<module>/` + bundles `@nodefony/frontend`
+* sous `/_assets/<name>/`) dans UN arbre `dist-assets/` miroir des préfixes
+* d'URL, plus un `manifest.json`.
+*
+* Provider-agnostic — Nodefony ASSEMBLE, l'orchestrateur PUBLIE (cloud-native) :
+* `aws s3 sync dist-assets s3://bucket`, `rsync`, upload CI… Pas de dépendance
+* cloud embarquée dans le framework. Combine avec `frontend.assetBaseUrl` pour
+* que les URLs émises pointent le CDN qui sert cet arbre.
+*/
+var AssetsPublish = class extends Command {
+	constructor(cli) {
+		super("assets:publish", "rassemble les fichiers statiques pour un CDN", cli, options);
+		this.addOption("-o, --out <dir>", "output directory (default ./dist-assets)");
+		this.addOption("--clean", "remove the output directory first");
+		this.addOption("--json", "print a machine-readable summary");
+	}
+	async generate(opts) {
+		const outDir = opts.out ? isAbsolute(opts.out) ? opts.out : resolve(process.cwd(), opts.out) : join(process.cwd(), "dist-assets");
+		const sources = this.collectSources();
+		if (sources.length === 0) {
+			this.log("Aucune source d'assets (0 mount natif, 0 bundle frontend) — rien à publier.", "WARNING");
+			return this;
+		}
+		if (opts.clean && existsSync(outDir)) await fsp.rm(outDir, {
+			recursive: true,
+			force: true
+		});
+		const plan = planAssetPublish(sources, outDir);
+		const manifest = {
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			outDir,
+			sources: []
+		};
+		for (const p of plan) {
+			if (!existsSync(p.dir)) {
+				this.log(`Source absente, ignorée : ${p.prefix} → ${p.dir} (build manquant ?)`, "WARNING");
+				continue;
+			}
+			await fsp.mkdir(p.target, { recursive: true });
+			await fsp.cp(p.dir, p.target, { recursive: true });
+			const files = await countFiles(p.target);
+			manifest.sources.push({
+				prefix: p.prefix,
+				dir: p.dir,
+				files
+			});
+			this.log(`publish ${p.prefix} → ${p.target} (${files} fichiers)`, "INFO");
+		}
+		await fsp.writeFile(join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+		if (opts.json) process.stdout.write(JSON.stringify(manifest, null, 2) + "\n");
+		else {
+			const total = manifest.sources.reduce((s, x) => s + x.files, 0);
+			this.log(`${manifest.sources.length} source(s), ${total} fichiers → ${outDir}. Déployez avec votre outil (ex. \`aws s3 sync ${outDir} s3://bucket\`).`, "INFO");
+		}
+		return this;
+	}
+	/** Sources = mounts natifs (`server-static`) + bundles `@nodefony/frontend`. */
+	collectSources() {
+		const modules = this.kernel?.getModules?.() ?? {};
+		const sources = [];
+		const staticSvc = modules["http"]?.get("server-static");
+		staticSvc?.mountModulePublics?.();
+		for (const m of staticSvc?.mounts ?? []) sources.push({
+			prefix: m.prefix,
+			dir: m.dir
+		});
+		const frontendSvc = modules["frontend"]?.get("frontend");
+		for (const e of frontendSvc?.listEntries?.() ?? []) sources.push({
+			prefix: e.publicPath,
+			dir: e.outDir
+		});
+		return sources;
+	}
+};
+//#endregion
+export { AssetsPublish as default };

package/dist/nodefony/command/certificatesCommand.js

@@ -0,0 +1,47 @@
+import { Command } from "nodefony";
+import { inspect } from "node:util";
+//#region nodefony/command/certificatesCommand.ts
+const options = {
+	helpGroup: "FRONT ET RÉSEAU",
+	showBanner: false,
+	kernelEvent: "onBoot"
+};
+/**
+* Commande CLI `certificates` — (re)génère et inspecte le certificat TLS de
+* DÉVELOPPEMENT. La génération reste un confort de dev : en production, fournir
+* un vrai certificat (`certificates.strategy: "explicit"`).
+*
+* Réutilise le service `certificates` du module `@nodefony/http` (source unique)
+* → la commande, le boot auto et un futur endpoint Studio appellent le même code.
+*/
+var Certificates = class extends Command {
+	constructor(cli) {
+		super("http:certificates", "engendre ou inspecte le certificat TLS de dev", cli, options);
+		this.addOption("-f, --force", "regenerate even if a valid certificate already exists");
+		this.addOption("-j, --json", "output the certificate summary as JSON");
+	}
+	async generate(opts) {
+		const service = (this.kernel?.getModules()?.["http"])?.get("certificates") ?? null;
+		if (!service) {
+			this.log("Service 'certificates' introuvable (module @nodefony/http non chargé).", "ERROR");
+			return this;
+		}
+		await service.loadForge();
+		await service.generateServerCertificates(Boolean(opts.force));
+		const info = await service.describe();
+		if (opts.json) process.stdout.write(`${JSON.stringify(info, void 0, 2)}\n`);
+		else {
+			process.stdout.write(`${inspect(info, {
+				colors: process.stdout.isTTY,
+				depth: 4
+			})}\n`);
+			if (info.caPath) process.stdout.write(`
+Requête vérifiée (NE PAS utiliser -k / rejectUnauthorized:false) :
+  curl --cacert ${info.caPath} https://localhost:5152/\n  NODE_EXTRA_CA_CERTS=${info.caPath} node mon-script.mjs\n`);
+			else process.stdout.write("\nCA dans le trust store système (mkcert) → requête vérifiée sans flag :\n  curl https://localhost:5152/\n");
+		}
+		return this;
+	}
+};
+//#endregion
+export { Certificates as default };

package/dist/nodefony/command/networkCommand.js

@@ -0,0 +1,27 @@
+import { Command } from "nodefony";
+import { inspect } from "node:util";
+//#region nodefony/command/networkCommand.ts
+const options = {
+	helpGroup: "FRONT ET RÉSEAU",
+	showBanner: false,
+	kernelEvent: "onRegister"
+};
+var Network = class extends Command {
+	constructor(cli) {
+		super("http:network", "les interfaces réseau et adresses de cette machine", cli, options);
+		this.addArgument("[interface]", "Selection interface example eth0 ");
+		this.addOption("-j, --json", "get json");
+	}
+	async generate(arg, opts) {
+		let network = this.kernel?.getNetwork();
+		let result = {};
+		if (arg) {
+			if (network?.interfaces[arg]) result = network?.interfaces[arg];
+		} else result = network?.interfaces;
+		if (opts.json) process.stdout.write(`${JSON.stringify(result, void 0, " ")}\n`);
+		else process.stdout.write(`${inspect(result, { colors: process.stdout.isTTY })}\n`);
+		return this;
+	}
+};
+//#endregion
+export { Network as default };

package/dist/nodefony/command/proxyGenerateCommand.js

@@ -0,0 +1,66 @@
+import { defaultIntrospection, generateHaproxyConfig, generateNginxConfig } from "../src/proxy/generateProxyConfig.js";
+import { Command } from "nodefony";
+import fsp from "node:fs/promises";
+//#region nodefony/command/proxyGenerateCommand.ts
+const options = {
+	helpGroup: "FRONT ET RÉSEAU",
+	showBanner: false,
+	kernelEvent: "onReady"
+};
+/**
+* Commande CLI `proxy:generate <nginx|haproxy>` — génère une configuration
+* reverse-proxy DÉRIVÉE de l'introspection Nodefony (domaines de confiance,
+* dossiers statiques servis, ports). Évite d'écrire la conf à la main et de la
+* laisser diverger ; résout le « trou statiques multi-modules » côté nginx.
+*/
+var ProxyGenerate = class extends Command {
+	constructor(cli) {
+		super("proxy:generate", "engendre une configuration nginx ou haproxy", cli, options);
+		this.addArgument("<target>", "nginx | haproxy");
+		this.addOption("-o, --out <file>", "write to file instead of stdout");
+		this.addOption("-b, --backend <host>", "backend host the proxy connects to (default 127.0.0.1)");
+		this.addOption("-l, --listen <port>", "proxy listen port (default 80)");
+		this.addOption("--reencrypt", "re-encrypt to the HTTPS backend (TLS proxy↔backend) instead of clear");
+	}
+	async generate(target, opts) {
+		if (target !== "nginx" && target !== "haproxy") {
+			this.log(`Cible inconnue '${target}' — attendu: nginx | haproxy.`, "ERROR");
+			return this;
+		}
+		const intro = this.buildIntrospection(opts);
+		const conf = target === "nginx" ? generateNginxConfig(intro) : generateHaproxyConfig(intro);
+		if (opts.out) {
+			await fsp.writeFile(opts.out, conf, "utf8");
+			this.log(`Configuration ${target} écrite → ${opts.out}`, "INFO");
+		} else process.stdout.write(conf);
+		return this;
+	}
+	/** Construit le modèle d'introspection depuis le kernel + le service statique. */
+	buildIntrospection(opts) {
+		const module = this.kernel?.getModules()?.["http"];
+		const httpOpts = module?.options ?? {};
+		const servers = (this.kernel?.options)?.servers;
+		const staticSvc = module?.get("server-static");
+		staticSvc?.mountModulePublics?.();
+		const staticRoots = staticSvc?.servers ? Object.keys(staticSvc.servers) : [];
+		const mounts = (staticSvc?.mounts ?? []).map((m) => ({
+			prefix: m.prefix,
+			dir: m.dir
+		}));
+		return {
+			...defaultIntrospection,
+			domains: httpOpts.trustedHosts ?? [],
+			backendHost: opts.backend ?? "127.0.0.1",
+			httpPort: Number(servers?.http?.port) || defaultIntrospection.httpPort,
+			httpsPort: Number(servers?.https?.port) || defaultIntrospection.httpsPort,
+			staticRoots,
+			mounts,
+			listen: opts.listen ? Number(opts.listen) : defaultIntrospection.listen,
+			reencrypt: Boolean(opts.reencrypt),
+			maxBodyBytes: Number(httpOpts.maxBodySize) || 0,
+			keepaliveIntervalMs: Number(httpOpts.websocket?.keepaliveInterval) || 0
+		};
+	}
+};
+//#endregion
+export { ProxyGenerate as default };