nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/cli/scaffold/steps.js

@@ -0,0 +1,40 @@
+//#region src/cli/scaffold/steps.ts
+/**
+* Étapes qui SUIVENT l'écriture d'un scaffold.
+*
+* Le moteur (`engine.ts`) est pur : il écrit des fichiers et s'arrête là. Mais
+* du code écrit n'est pas encore du code qui tourne — il reste à installer les
+* dépendances, construire, vérifier les types. Ces étapes sont donc décrites
+* ICI, une fois, et exécutées par chaque front à sa façon : le CLI hérite du
+* terminal de l'utilisateur, Studio streame chaque ligne sur un canal temps
+* réel. Les deux manières de LES MONTRER sont légitimement différentes ; ce qui
+* ne doit pas diverger, c'est CE QU'ELLES SONT.
+*
+* La commande de chaque étape est figée côté serveur. Un front n'envoie jamais
+* qu'un identifiant d'étape, jamais une ligne de commande : c'est ce qui sépare
+* « piloter un générateur » de « exécuter du shell à distance ».
+*/
+/** Étapes possibles, dans leur ordre d'exécution naturel. */
+const SCAFFOLD_STEPS = [
+	"install",
+	"build",
+	"typecheck"
+];
+/** Arguments passés à `npm` pour chaque étape. */
+const SCAFFOLD_STEP_COMMANDS = {
+	install: ["install"],
+	build: ["run", "build"],
+	typecheck: ["run", "typecheck"]
+};
+/** Ce que chaque étape apporte — affiché avant de la lancer. */
+const SCAFFOLD_STEP_LABELS = {
+	install: "installe les dépendances (pour un module, c'est aussi ce qui pose le lien de workspace qui le rend chargeable)",
+	build: "construit le code que le kernel chargera (`dist/`)",
+	typecheck: "vérifie les types sans rien émettre"
+};
+/** Une étape connue ? (garde des entrées venues du réseau). */
+function isScaffoldStep(value) {
+	return typeof value === "string" && SCAFFOLD_STEPS.includes(value);
+}
+//#endregion
+export { SCAFFOLD_STEPS, SCAFFOLD_STEP_COMMANDS, SCAFFOLD_STEP_LABELS, isScaffoldStep };

package/dist/node/cli/scaffold/userContractSource.js

@@ -0,0 +1,133 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+//#region src/cli/scaffold/userContractSource.ts
+/**
+* Lit le contrat de colonnes de l'utilisateur DANS l'application cible.
+*
+* La liste ne peut pas vivre dans le générateur : elle appartient à
+* `@nodefony/user`, et une seconde copie ici divergerait — exactement ce que la
+* source unique a supprimé. Elle est donc résolue depuis l'application, ce qui a
+* un second mérite : c'est la version que CETTE application a installée qui est
+* écrite dans son entité, jamais celle du dépôt qui a produit le générateur.
+*
+* @param appRoot - racine de l'application où l'entité sera écrite.
+* @returns les colonnes du contrat, dans l'ordre où le module les publie.
+* @throws Error si le module d'identité n'est pas installé — sans lui, il n'y a
+*   pas d'utilisateur à générer, et deviner les colonnes serait le pire choix.
+*/
+function readUserContract(appRoot) {
+	const requireFromApp = createRequire(path.join(appRoot, "package.json"));
+	let module;
+	try {
+		module = requireFromApp("@nodefony/user");
+	} catch {
+		throw new Error("create entity User : le module d'identité « @nodefony/user » n'est pas installé dans cette application — sans lui il n'y a pas d'utilisateur à générer.\n  → l'ajouter : npm install @nodefony/user");
+	}
+	const columns = module.USER_COLUMNS;
+	if (!Array.isArray(columns) || columns.length === 0) throw new Error("create entity User : « @nodefony/user » n'expose pas son contrat de colonnes (`USER_COLUMNS`) — version trop ancienne pour que l'entité puisse être écrite sans deviner.\n  → mettre le module à jour");
+	return columns;
+}
+/**
+* Le nom de la table des utilisateurs, LU dans l'application cible.
+*
+* Il ne se déduit pas du nom de l'entité : l'utilisateur est la seule table que
+* le framework interroge en SQL natif, sous un nom écrit en dur. Appliquer la
+* règle du pluriel produirait `users` face à un SQL qui lit `User` — la
+* recherche par compte externe ne trouverait plus rien, sans lever, et chaque
+* connexion créerait un compte de plus.
+*
+* Lu depuis l'application, comme les colonnes : c'est la version installée LÀ
+* qui décide, pas celle du dépôt qui a produit le générateur.
+*
+* @param appRoot - racine de l'application où l'entité sera écrite.
+* @returns le nom de la table, tel que le contrat le publie.
+* @throws Error si le module d'identité est absent ou trop ancien pour le
+*   publier — deviner ce nom est le pire des choix possibles.
+*/
+function userTableName(appRoot) {
+	const requireFromApp = createRequire(path.join(appRoot, "package.json"));
+	let module;
+	try {
+		module = requireFromApp("@nodefony/user");
+	} catch {
+		throw new Error("create entity User : le module d'identité « @nodefony/user » n'est pas installé dans cette application — sans lui il n'y a pas d'utilisateur à générer.\n  → l'ajouter : npm install @nodefony/user");
+	}
+	const name = module.USER_TABLE_NAME;
+	if (typeof name !== "string" || name.length === 0) throw new Error("create entity User : « @nodefony/user » n'expose pas le nom de la table des utilisateurs (`USER_TABLE_NAME`) — version trop ancienne. Le deviner produirait une table que le SQL du framework n'interroge pas.\n  → mettre le module à jour");
+	return name;
+}
+/**
+* Traduction d'un type LOGIQUE du contrat vers le vocabulaire de champ du
+* générateur — le seul endroit qui connaisse les deux.
+*/
+const FIELD_TYPE_BY_CONTRACT = {
+	uuid: "uuid",
+	string: "string",
+	"string[]": "json",
+	boolean: "bool",
+	object: "json",
+	"object[]": "json",
+	date: "date"
+};
+/**
+* Convertit les colonnes du contrat en champs du générateur.
+*
+* La clé primaire est écartée : le générateur la produit lui-même, et le contrat
+* n'en dit que le type. Les horodatages passent par `defaultNow` — « maintenant »
+* n'est pas une valeur littérale que la grammaire sache écrire.
+*
+* Les valeurs par défaut sont OBTENUES du contrat, pas devinées : la fabrique est
+* appelée, et son résultat sérialisé. C'est ce qui garantit qu'un défaut ajouté
+* au contrat apparaît dans les entités générées ensuite, sans toucher ici.
+*
+* @param columns - le contrat, tel que l'application l'a installé.
+* @returns les champs, dans l'ordre du contrat.
+*/
+function userContractFields(columns) {
+	const fields = [];
+	for (const column of columns) {
+		if (column.origin === "identity") continue;
+		const type = FIELD_TYPE_BY_CONTRACT[column.type];
+		if (!type) throw new Error(`create entity User : le contrat déclare la colonne « ${column.name} » avec un type inconnu du générateur (« ${column.type} ») — « @nodefony/user » est plus récent que cette version de la ligne de commande.`);
+		const field = {
+			name: column.name,
+			type,
+			nullable: column.nullable,
+			unique: column.unique === true,
+			indexed: false
+		};
+		if (column.origin === "audit") {
+			field.defaultNow = true;
+			if (column.refreshedOnWrite) field.refreshedOnWrite = true;
+		} else if (column.makeDefault) {
+			const value = column.makeDefault();
+			field.defaultValue = typeof value === "string" ? value : JSON.stringify(value);
+		}
+		fields.push(field);
+	}
+	return fields;
+}
+/**
+* Refuse un champ métier obligatoire qui n'aurait aucune valeur par défaut.
+*
+* Le framework CRÉE des utilisateurs sans connaître ces champs — au semis d'un
+* administrateur, à la première connexion par un fournisseur externe. Un champ
+* obligatoire qu'il ne peut pas renseigner fait échouer ces chemins, et le
+* prototype a montré comment : le semis échoue avec un **code de sortie 0**,
+* l'application démarre, et il n'y a simplement aucun administrateur.
+*
+* Le même champ pose un second problème, plus tard : ajouté à une table déjà
+* peuplée, un `ADD COLUMN … NOT NULL` sans défaut est refusé par le serveur.
+* Une seule règle ferme les deux.
+*
+* @param fields - les champs demandés par l'utilisateur (hors contrat).
+* @throws Error en nommant le champ et les deux façons de le rendre acceptable.
+*/
+function assertUserFieldsAreFillable(fields) {
+	const orphans = fields.filter((f) => !f.nullable && f.defaultValue === void 0 && !f.defaultNow);
+	if (orphans.length === 0) return;
+	const names = orphans.map((f) => f.name).join(", ");
+	throw new Error(`create entity User : le(s) champ(s) « ${names} » sont obligatoires et sans valeur par défaut. Le framework crée des utilisateurs sans les connaître (semis d'un administrateur, première connexion par un fournisseur externe) : ces créations échoueraient, et le semis échoue SANS code d'erreur — l'application démarre alors sans administrateur.\n  → les rendre facultatifs : ${orphans.map((f) => `${f.name}:${f.type}?`).join(" ")}\n  → ou leur donner un défaut : ${orphans.map((f) => `${f.name}:${f.type}=<valeur>`).join(" ")}`);
+}
+//#endregion
+export { assertUserFieldsAreFillable, readUserContract, userContractFields, userTableName };

package/dist/node/cli/scaffold/versions.js

@@ -0,0 +1,57 @@
+//#region src/cli/scaffold/versions.ts
+/**
+* Catalogue UNIQUE des versions npm émises par les scaffolds (`create app`,
+* `create front`, lots suivants) — la SEULE table à toucher quand une dep
+* tierce bouge. Les paquets `nodefony`/`@nodefony/*` n'y figurent PAS : leurs
+* versions sont dynamiques (`it.nodefonyVersion` = la version du paquet qui
+* scaffolde) → une release du framework ne réécrit AUCUN template.
+*
+* Anti-dérive : `create.test.ts` compare ce catalogue aux versions RÉELLES du
+* monorepo (racine + core) — bumper une dep du repo sans répercuter ici fait
+* échouer le banc, jamais une divergence silencieuse.
+*/
+const SCAFFOLD_VERSIONS = {
+	zod: "^4.4.3",
+	tslib: "2.8.1",
+	"drizzle-orm": "0.45.2",
+	"better-sqlite3": "13.0.3",
+	pg: "8.23.0",
+	mysql2: "3.24.3",
+	"drizzle-kit": "0.31.10",
+	"@node-rs/argon2": "^2.0.2",
+	"@types/node": "^26.4.0",
+	"@typescript/native-preview": "^7.0.0-dev.0",
+	oxlint: "^1.75.0",
+	prettier: "^3.9.5",
+	rolldown: "^1.2.7",
+	typescript: "^6.0.3",
+	vitest: "^5.0.0",
+	vite: "^8.1.4",
+	react: "^19.2.7",
+	"react-dom": "^19.2.7",
+	"@vitejs/plugin-react": "^6.0.3",
+	"@types/react": "^19.2.17",
+	"@types/react-dom": "^19.2.3",
+	vue: "^3.5.39",
+	"@vitejs/plugin-vue": "^6.0.7",
+	svelte: "^5.56.8",
+	"@sveltejs/vite-plugin-svelte": "^7.3.0",
+	"@angular/core": "^22.1.5",
+	"@angular/common": "^22.1.5",
+	"@angular/platform-browser": "^22.1.5",
+	"@analogjs/vite-plugin-angular": "^2.7.1",
+	"@angular/build": "^22.1.7",
+	"@angular/compiler-cli": "^22.1.5"
+};
+/** Sous-ensemble du catalogue (helper des tables par framework). */
+function pick(...names) {
+	const out = {};
+	for (const n of names) {
+		const v = SCAFFOLD_VERSIONS[n];
+		if (!v) throw new Error(`version absente du catalogue scaffold : ${n}`);
+		out[n] = v;
+	}
+	return out;
+}
+//#endregion
+export { SCAFFOLD_VERSIONS, pick };

package/dist/node/cli/scaffold/writer.js

@@ -0,0 +1,172 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+//#region src/cli/scaffold/writer.ts
+/**
+* Au-delà de cette taille, le diff ligne à ligne n'est plus calculé (la matrice
+* de programmation dynamique est quadratique). Les fichiers qu'un scaffold
+* RÉÉCRIT sont des `index.ts`, des `package.json`, une config — deux ordres de
+* grandeur en dessous ; la borne n'existe que pour qu'un cas aberrant dégrade
+* l'affichage au lieu de figer le terminal.
+*/
+const DIFF_MAX_LINES = 1e3;
+/**
+* Diff ligne à ligne de deux contenus (plus longue sous-séquence commune).
+*
+* Calculé au MOTEUR, et non dans chaque front : le CLI (`--dry-run`) et la
+* préview Studio montrent le même changement, et un rendu qui diverge du plan
+* réellement exécuté serait pire que pas de préview du tout.
+*
+* Au-delà de {@link DIFF_MAX_LINES} lignes, rend le remplacement en bloc —
+* exact, mais sans détail.
+*/
+function diffLines(before, after) {
+	const a = before.split("\n");
+	const b = after.split("\n");
+	if (a.length > DIFF_MAX_LINES || b.length > DIFF_MAX_LINES) return [...a.map((text) => ({
+		kind: "remove",
+		text
+	})), ...b.map((text) => ({
+		kind: "add",
+		text
+	}))];
+	const width = b.length + 1;
+	const lcs = new Uint32Array((a.length + 1) * width);
+	for (let i = a.length - 1; i >= 0; i--) for (let j = b.length - 1; j >= 0; j--) lcs[i * width + j] = a[i] === b[j] ? lcs[(i + 1) * width + j + 1] + 1 : Math.max(lcs[(i + 1) * width + j], lcs[i * width + j + 1]);
+	const diff = [];
+	let i = 0;
+	let j = 0;
+	while (i < a.length && j < b.length) if (a[i] === b[j]) {
+		diff.push({
+			kind: "keep",
+			text: a[i++]
+		});
+		j++;
+	} else if (lcs[(i + 1) * width + j] >= lcs[i * width + j + 1]) diff.push({
+		kind: "remove",
+		text: a[i++]
+	});
+	else diff.push({
+		kind: "add",
+		text: b[j++]
+	});
+	while (i < a.length) diff.push({
+		kind: "remove",
+		text: a[i++]
+	});
+	while (j < b.length) diff.push({
+		kind: "add",
+		text: b[j++]
+	});
+	return diff;
+}
+/**
+* Système de fichiers TRANSACTIONNEL du scaffold : toutes les écritures sont
+* retenues en mémoire, et ne touchent le disque qu'au {@link ScaffoldWriter.commit}
+* final.
+*
+* POURQUOI le moteur ne peut pas écrire au fil de l'eau : un scaffold est une
+* suite d'étapes dont plusieurs peuvent REFUSER *après* les premières écritures
+* — nom de classe déjà pris, `@controllers([...])` introuvable, tag eta résiduel,
+* workspace de link manquant. Écrire puis lever laisse un projet à moitié
+* modifié, alors que l'utilisateur lit un message d'erreur et croit
+* légitimement que rien n'a bougé (il a perdu son fichier). En différant le
+* disque, « refuser » redevient un non-événement : aucune garde n'a besoin
+* d'être placée avant les rendus, et une garde ajoutée demain est
+* automatiquement sûre.
+*
+* La transaction sert AUSSI de source du dry-run : ne pas committer, c'est
+* exactement simuler — sans une seconde implémentation du moteur qui dériverait.
+*
+* Les LECTURES passent par la transaction (`read`/`exists`/`listDir`) : une
+* étape doit voir ce que les précédentes ont produit. Sans cela, câbler deux
+* décorateurs dans le même `index.ts` perdrait la première insertion, et le
+* controller d'un module tout juste rendu ne trouverait pas sa cible.
+*
+* Portée : les fichiers du PROJET. Les templates et le paquet `nodefony`
+* lui-même se lisent directement — ils sont en lecture seule.
+*/
+var ScaffoldWriter = class {
+	/** Chemin absolu → contenu en attente, dans l'ordre d'écriture. */
+	#pending = /* @__PURE__ */ new Map();
+	/** Contenu à jour du fichier — écriture en attente d'abord, sinon disque. */
+	read(file) {
+		return this.#pending.get(file) ?? readFileSync(file, "utf8");
+	}
+	/**
+	* Le chemin existe-t-il, une fois la transaction appliquée ? Vrai aussi pour
+	* un DOSSIER qui n'existe encore que par les fichiers en attente qu'il
+	* contient (`modules/blog/` pendant `create module`).
+	*/
+	exists(file) {
+		if (this.#pending.has(file) || existsSync(file)) return true;
+		const prefix = `${file}${path.sep}`;
+		for (const pending of this.#pending.keys()) if (pending.startsWith(prefix)) return true;
+		return false;
+	}
+	/**
+	* Entrées d'un dossier, disque et transaction fusionnés — la vue dont
+	* `listTargets` a besoin pour voir un module qui n'est pas encore committé.
+	*/
+	listDir(dir) {
+		const entries = /* @__PURE__ */ new Map();
+		if (existsSync(dir)) for (const entry of readdirSync(dir, { withFileTypes: true })) entries.set(entry.name, entry.isDirectory());
+		const prefix = `${dir}${path.sep}`;
+		for (const pending of this.#pending.keys()) {
+			if (!pending.startsWith(prefix)) continue;
+			const rest = pending.slice(prefix.length);
+			const sep = rest.indexOf(path.sep);
+			entries.set(sep === -1 ? rest : rest.slice(0, sep), sep !== -1);
+		}
+		return [...entries].map(([name, isDirectory]) => ({
+			name,
+			isDirectory
+		}));
+	}
+	/** Retient une écriture. Rien ne touche le disque avant {@link commit}. */
+	write(file, content) {
+		this.#pending.set(file, content);
+	}
+	/**
+	* Écritures prévues, dans l'ordre — matière du dry-run et de la préview.
+	*
+	* L'état « existait déjà » est relu ICI (et non à `write`) : entre les deux,
+	* seule la transaction a pu changer, et elle est justement ce qu'on décrit.
+	*/
+	changes() {
+		const changes = [];
+		for (const [file, content] of this.#pending) if (existsSync(file)) changes.push({
+			path: file,
+			kind: "overwrite",
+			content,
+			previous: readFileSync(file, "utf8")
+		});
+		else changes.push({
+			path: file,
+			kind: "create",
+			content
+		});
+		return changes;
+	}
+	/** Nombre d'écritures en attente. */
+	get size() {
+		return this.#pending.size;
+	}
+	/**
+	* Applique la transaction sur le disque, dans l'ordre d'écriture.
+	*
+	* Ce n'est PAS atomique au sens du système de fichiers (aucune API portable
+	* ne l'offre pour un arbre) : une panne disque en cours de vidage laisse un
+	* résultat partiel. Ce que la transaction garantit, c'est qu'aucune décision
+	* du moteur — garde, validation, rendu cassé — ne peut plus produire ce
+	* résultat partiel, ce qui était le seul cas observé en pratique.
+	*/
+	commit() {
+		for (const [file, content] of this.#pending) {
+			mkdirSync(path.dirname(file), { recursive: true });
+			writeFileSync(file, content);
+		}
+		this.#pending.clear();
+	}
+};
+//#endregion
+export { ScaffoldWriter, diffLines };