@nodefony/drizzle 10.0.0-alpha.1

package/dist/nodefony/command/orm-generate.js

@@ -0,0 +1,356 @@
+import { HISTORY_TABLE } from "../src/migrator/types.js";
+import { EXIT, action } from "../src/migrator/explain.js";
+import { openMigrationDriver } from "../src/migrator/drivers/index.js";
+import { frameworkMigrationsDir } from "../src/migrator/paths.js";
+import { createdTables, frameworkTables, loadSources } from "../src/migrator/sources.js";
+import { appMigrationsDir } from "../src/migrator/resolve.js";
+import { summarizeGap } from "../src/migrator/schemaDiff.js";
+import { gapAgainstDeclared } from "../src/migrator/divergence.js";
+import { auditMigrationSql, runGenerate, stampFormatMarker } from "../src/migrator/kit.js";
+import { collectTables, entityFilesOf, missingProviders, registeredTables, usurpedTables, writeCustomMigration, writeKitConfig, writeSchemaModule } from "../src/migrator/appSchema.js";
+import { checkMigrationName } from "../src/migrator/name.js";
+import { readJournal, tablesPresentIn } from "../src/migrator/adopt.js";
+import { OrmMigrateCommand } from "./migrateShared.js";
+import { listTargets } from "nodefony";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region nodefony/command/orm-generate.ts
+/**
+* `kernelEvent: "onPostReady"` — la commande LIT l'état de l'application.
+*
+* Le registre des entités est peuplé au démarrage, module par module. Une
+* commande branchée plus tôt passerait avant lui : elle ne trouverait rien à
+* contrôler, et laisserait passer une migration amputée. Aucun serveur n'écoute
+* pour autant — le profil console est respecté.
+*/
+const options = {
+	helpGroup: "BASE DE DONNÉES",
+	showBanner: false,
+	kernelEvent: "onPostReady"
+};
+/**
+* `nodefony orm:generate` — écrit la migration qui fera passer la base au
+* schéma que décrivent les entités de l'application.
+*
+* ## Ce que l'utilisateur n'a pas à connaître
+*
+* Rien de `drizzle-kit`. Ni son installation, ni sa configuration par dialecte,
+* ni la notion de « schéma matérialisé », ni son dossier de sortie, ni le format
+* de son journal. Il tape un verbe et un nom. La commande découvre les fichiers
+* d'entités par la convention du générateur, écrit ce qu'il faut dans un dossier
+* de travail qu'elle efface ensuite, et pilote l'outil — dont elle EXIGE la
+* preuve qu'il a travaillé, parce qu'il rend 0 même quand il échoue.
+*
+* ## Ce qu'elle refuse, et pourquoi elle le refuse plutôt que de continuer
+*
+* Une migration est **immuable une fois appliquée**. Une migration amputée n'est
+* pas un désagrément qu'on rattrape à la génération suivante : elle grave dans
+* l'historique une table qui n'existera jamais, et toute base qui l'a reçue
+* restera incomplète. Trois situations valent donc un arrêt qui NOMME :
+*
+* - un fichier d'entité qui ne s'importe pas (le schéma serait incomplet) ;
+* - une entité enregistrée qu'aucun fichier ne fournit (idem, et c'est le
+*   contrôle que le registre est le seul à pouvoir faire) ;
+* - un fichier de l'application qui fournit une table du FRAMEWORK — la
+*   migration porterait un second `CREATE TABLE` de cette table, qui échoue sur
+*   toute base déjà migrée, c'est-à-dire en production et nulle part ailleurs.
+*
+* @example Le cas courant
+* ```bash
+* nodefony orm:generate --name ajout_du_titre
+* nodefony orm:migrate        # ou : le travail de déploiement
+* ```
+*
+* @example Ce que le modèle déclaratif ne peut pas déduire
+* ```bash
+* nodefony orm:generate --custom --name vue_des_ventes
+* # → un fichier SQL vide, déjà inscrit au journal : à écrire à la main.
+* ```
+*/
+var OrmGenerate = class extends OrmMigrateCommand {
+	constructor(cli) {
+		super("orm:generate", "écrit la migration qui aligne la base sur les entités", cli, options);
+		this.addSharedOptions();
+		this.addOption("-n, --name <nom>", "nom de la migration, en minuscules et « _ » — il entre dans le tag, qui est immuable une fois publié");
+		this.addOption("--custom", "écrit un fichier SQL VIDE et son entrée de journal, sans rien déduire : vues, déclencheurs, clés étrangères, remplissages");
+		this.addOption("--allow-destructive", "accepte une migration qui SUPPRIME des données — à ne poser qu'après avoir relu le fichier produit");
+	}
+	/**
+	* Racine de l'application — c'est depuis là que l'outil est lancé.
+	*
+	* @returns le chemin absolu de la racine.
+	*/
+	#projectRoot() {
+		return this.kernel.path;
+	}
+	/**
+	* Vérifie le nom, ou arrête la commande en disant pourquoi.
+	*
+	* @param opts - options reçues.
+	* @returns le nom validé, ou `null` si la commande est déjà arrêtée.
+	*/
+	#nameOrFail(opts, connector) {
+		const verdict = checkMigrationName(opts.name);
+		if (verdict.ok) return verdict.name;
+		this.fail(connector, "NF_GENERATE_NAME", verdict.reason, "Le nom entre dans le tag du fichier, et un tag ne se renomme plus une fois la migration appliquée quelque part : c'est lui qui dit à chaque base ce qu'elle a déjà reçu. Il devient aussi un nom de fichier sur trois systèmes — un espace, un accent ou une majuscule produisent un fichier qui ne se retrouve pas d'une machine à l'autre. Choisis-le pour qu'il se lise dans six mois : ce qui change, pas quand.", [action(`nodefony orm:generate --name ${verdict.suggestion ?? "ajout_du_titre"}`)], opts.json, EXIT.actionRequired);
+		return null;
+	}
+	async generate(opts = {}) {
+		const resolved = this.resolveOrFail(opts, false);
+		if (!resolved) return this;
+		const { resolution, config } = resolved;
+		const connector = resolution.connector;
+		const name = this.#nameOrFail(opts, connector);
+		if (name === null) return this;
+		const root = this.#projectRoot();
+		const migrationsDir = appMigrationsDir(this.kernel, config.migrations.dir);
+		if (migrationsDir === void 0) {
+			this.fail(connector, "NF_MIGRATE_UNAVAILABLE", "La racine de l'application n'a pas pu être résolue : impossible de savoir où écrire les migrations.", "Le dossier des migrations se résout depuis la racine de l'application, jamais depuis le répertoire courant — sans quoi la commande serait juste ou fausse selon l'endroit d'où on la tape.", [action("nodefony inspect config --json")], opts.json);
+			return this;
+		}
+		const outDir = path.join(migrationsDir, resolution.dialect);
+		const relative = (p) => path.relative(root, p).split(path.sep).join("/");
+		try {
+			if (opts.custom === true) {
+				const { tag, file } = await writeCustomMigration({
+					outDir,
+					dialect: resolution.dialect,
+					name
+				});
+				return this.#emit({
+					formatVersion: 1,
+					connector,
+					generated: true,
+					tag,
+					files: [relative(file)],
+					warnings: [],
+					unreadable: [],
+					otherDialect: [],
+					driver: {
+						kind: "sql",
+						dialect: resolution.dialect,
+						dir: relative(outDir)
+					}
+				}, opts, `Migration LIBRE ${tag} — le fichier est VIDE, et déjà inscrit au journal.`);
+			}
+			return await this.#generateFromEntities(opts, connector, resolution.target, root, outDir, name, relative);
+		} catch (e) {
+			this.failFrom(e, connector, opts.json, resolution.ddl);
+			return this;
+		}
+	}
+	/**
+	* Le chemin nominal : découvrir, contrôler, générer, prouver.
+	*
+	* @returns `this`, la commande ayant déjà écrit sa sortie.
+	*/
+	async #generateFromEntities(opts, connector, database, root, outDir, name, relative) {
+		const dialect = database.dialect;
+		const files = [];
+		for (const target of listTargets(root)) files.push(...await entityFilesOf(target.dir));
+		const { tables: found, unreadable: rawUnreadable } = await collectTables(files);
+		const unreadable = rawUnreadable.map((u) => ({
+			file: relative(u.file),
+			cause: u.cause
+		}));
+		const frameworkRoot = path.dirname(await frameworkMigrationsDir());
+		const belongsToFramework = (file) => !path.relative(frameworkRoot, file).startsWith("..");
+		const mine = found.filter((t) => !belongsToFramework(t.file));
+		const tables = mine.filter((t) => t.dialect === dialect);
+		const otherDialect = mine.filter((t) => t.dialect !== dialect).map((t) => ({
+			table: t.tableName,
+			dialect: t.dialect ?? "inconnu",
+			file: relative(t.file)
+		}));
+		const discovery = {
+			filesScanned: files.length,
+			tables: tables.map((t) => t.tableName),
+			otherDialect,
+			unreadable
+		};
+		const framework = new Set(await frameworkTables(dialect));
+		const usurped = usurpedTables(tables, framework);
+		if (usurped.length > 0) {
+			const list = usurped.map((t) => `  • « ${t.tableName} », exportée par ${relative(t.file)} (${t.exportName})`).join("\n");
+			this.fail(connector, "NF_GENERATE_FRAMEWORK_TABLE", `L'application fournit ${usurped.length} table(s) qui appartiennent au framework :\n${list}`, "Rien n'a été écrit. Ces tables sont créées par les migrations du framework, appliquées AVANT celles de l'application. Les décrire ici produirait un second « CREATE TABLE » pour la même table : la migration passerait sur une base vierge et échouerait sur toute base déjà migrée — c'est-à-dire en production, et nulle part ailleurs. Pour pointer vers une table du framework, garder la référence dans le code de l'entité sans la RÉ-EXPORTER ; pour une vraie clé étrangère SQL, écrire une migration libre (--custom).", [action(`nodefony orm:generate --custom --name lien_${name}`)], opts.json, EXIT.actionRequired);
+			return this;
+		}
+		const provided = new Set(tables.map((t) => t.tableName));
+		const missing = missingProviders(registeredTables(connector), provided, framework).map(({ entity, table }) => `  • entité « ${entity} » → table « ${table} »`);
+		if (missing.length > 0) {
+			const cause = unreadable.length > 0 ? `\n\nCe sont peut-être ces fichiers, qui n'ont pas pu être lus :\n${unreadable.map((u) => `  • ${u.file} — ${u.cause}`).join("\n")}` : "";
+			this.fail(connector, "NF_GENERATE_MISSING_ENTITY", `${missing.length} entité(s) enregistrée(s) ne sont fournies par aucun fichier lisible :\n${missing.join("\n")}${cause}`, "Rien n'a été écrit. Les migrations se produisent à partir des FICHIERS — l'outil qui les écrit est un process séparé, il ne voit pas les objets d'une application démarrée — et ces fichiers sont cherchés sous « nodefony/entity/ » dans l'application et dans chacun de ses modules. Une entité déclarée ailleurs, ou portée par un fichier qui ne s'importe pas seul, est invisible pour la génération : la migration serait écrite SANS sa table, et une migration ne se corrige pas — elle se remplace par une suivante, sur toutes les bases qui ont déjà reçu la première.", [action("nodefony inspect entities --json")], opts.json, EXIT.actionRequired);
+			return this;
+		}
+		const work = path.join(root, "node_modules", ".cache", "nodefony", "orm-generate");
+		const schemaFile = path.join(work, `schema.${dialect}.ts`);
+		const configFile = path.join(work, `drizzle.${dialect}.config.ts`);
+		const before = await this.#tags(outDir);
+		const decrites = new Set(createdTables((await loadSources([{
+			name: "app",
+			dir: path.dirname(outDir),
+			rank: 1
+		}], dialect)).files));
+		if (!tables.some((t) => decrites.has(t.tableName))) {
+			const refusal = await this.#alreadyInDatabase(opts, connector, name, tables, database);
+			if (refusal !== null) return refusal;
+		}
+		try {
+			await writeSchemaModule(schemaFile, tables);
+			await writeKitConfig({
+				file: configFile,
+				projectRoot: root,
+				schemaFile,
+				outDir,
+				dialect,
+				excludedTables: [...framework, HISTORY_TABLE]
+			});
+			runGenerate({
+				cwd: root,
+				configRel: relative(configFile),
+				name,
+				label: `le connecteur « ${connector} » (${dialect})`,
+				regenerateCommand: `nodefony orm:generate --name ${name}`
+			});
+		} finally {
+			await fs.rm(work, {
+				recursive: true,
+				force: true
+			});
+		}
+		const added = (await this.#tags(outDir)).filter((t) => !before.includes(t));
+		if (added.length === 0) {
+			const gap = await gapAgainstDeclared(connector);
+			if (gap !== null) {
+				this.fail(connector, "NF_GENERATE_DATABASE_BEHIND", `Rien à écrire, et pourtant la base ne porte pas le schéma déclaré : ${summarizeGap(gap)}.`, "Les fichiers de migration décrivent déjà ce que le code déclare — il n'y a donc rien de neuf à générer. Mais la base, elle, ne l'a pas reçu : son historique affirme des migrations qu'elle n'a pas exécutées. C'est l'HISTORIQUE qu'il faut reprendre, pas le schéma — et surtout pas la base, qu'il ne sert à rien de refaire. Le premier geste MONTRE : le statut dit, source par source, ce que l'historique prétend appliqué. Repère la ou les migrations qui décrivent ce qui manque ci-dessus, puis désinscris-les NOMMÉMENT : elles seront rejouées au passage suivant. La base n'est pas touchée par cette désinscription ; si une migration avait bien été appliquée, son rejeu échouera, et c'est ce qu'on veut.", [
+					action(`nodefony orm:migrate:status --connector ${connector} --json`),
+					action(`nodefony orm:migrate:repair --connector ${connector} --forget app/<tag>`),
+					action(`nodefony orm:migrate --connector ${connector}`)
+				], opts.json, EXIT.actionRequired);
+				return this;
+			}
+			return this.#emit({
+				formatVersion: 1,
+				connector,
+				generated: false,
+				tag: null,
+				files: [],
+				warnings: [],
+				unreadable,
+				otherDialect,
+				driver: {
+					kind: "sql",
+					dialect,
+					dir: relative(outDir)
+				}
+			}, opts, "Le schéma n'a pas bougé : il n'y avait rien à écrire.");
+		}
+		stampFormatMarker(outDir);
+		const destructive = [];
+		const warnings = [];
+		const written = [];
+		for (const tag of added) {
+			const file = path.join(outDir, `${tag}.sql`);
+			written.push(relative(file));
+			const audit = auditMigrationSql(await fs.readFile(file, "utf8"), dialect);
+			destructive.push(...audit.destructive);
+			warnings.push(...audit.blocking);
+		}
+		if (destructive.length > 0 && opts.allowDestructive !== true) {
+			const list = destructive.map((r) => `  • ${r.id} : ${r.what}\n    → ${r.todo}`).join("\n");
+			this.fail(connector, "NF_GENERATE_DESTRUCTIVE", `Cette migration DÉTRUIT des données :\n${list}\n\nLes fichiers ont été écrits — les RELIRE avant toute décision :\n${written.map((f) => `  ${f}`).join("\n")}`, "Ils ne sont pas effacés : ce sont eux qu'il faut lire pour décider, et les supprimer priverait de la seule chose à regarder. C'est leur mise en service qui est refusée. S'il s'agit d'un renommage mal interprété, annuler ces fichiers avec l'outil de gestion de versions puis regénérer dans un terminal interactif, et répondre « renamed » : l'outil produit alors un RENAME, et les données suivent. Si la perte est ASSUMÉE, il n'y a rien à regénérer — les fichiers sont là : c'est l'application qui décide, et elle a sa propre garde.", [
+				action(`git checkout -- ${relative(outDir)}`),
+				action(`nodefony orm:migrate --connector ${connector} --dry-run`),
+				action(`nodefony orm:migrate --connector ${connector}`)
+			], opts.json, EXIT.actionRequired, discovery);
+			return this;
+		}
+		return this.#emit({
+			formatVersion: 1,
+			connector,
+			generated: true,
+			tag: added[added.length - 1],
+			files: written,
+			warnings,
+			unreadable,
+			otherDialect,
+			driver: {
+				kind: "sql",
+				dialect,
+				dir: relative(outDir)
+			}
+		}, opts, `Migration ${added.join(", ")} écrite depuis ${tables.length} table(s).`);
+	}
+	/**
+	* Demande à la BASE lesquelles de ces tables elle porte déjà.
+	*
+	* Ouvre un pilote le temps du contrôle, et le referme quoi qu'il arrive : la
+	* commande vit dans un processus court, mais une connexion laissée ouverte
+	* retient un descripteur et, sur un serveur, une place dans le réservoir.
+	*
+	* Une base injoignable rend une liste VIDE, jamais une erreur : ce contrôle
+	* existe pour éviter un refus infondé, il ne doit pas en créer un. Qui
+	* travaille hors connexion garde le droit d'écrire sa migration.
+	*
+	* @param target - coordonnées de la base visée.
+	* @param tables - tables que la migration créerait.
+	* @returns celles que la base porte déjà, éventuellement aucune.
+	*/
+	async #presentInDatabase(target, tables) {
+		let driver = null;
+		try {
+			driver = await openMigrationDriver(target);
+			return await tablesPresentIn(driver, tables);
+		} catch {
+			return [];
+		} finally {
+			if (driver !== null) try {
+				await driver.close();
+			} catch {}
+		}
+	}
+	/**
+	* Refuse d'écrire le schéma initial sur une base qui porte déjà ces tables.
+	*
+	* @param opts - options reçues (porte le choix du format de sortie).
+	* @param connector - connecteur visé.
+	* @param name - nom demandé, cité dans le geste à rejouer après adoption.
+	* @param tables - tables que l'application fournit pour ce dialecte.
+	* @returns `this` si la commande a refusé, `null` s'il n'y a rien à redire.
+	*/
+	async #alreadyInDatabase(opts, connector, name, tables, target) {
+		const presentTables = await this.#presentInDatabase(target, tables.map((t) => t.tableName));
+		if (presentTables.length === 0) return null;
+		const adopter = action(`nodefony orm:migrate:baseline --from-database --connector ${connector}`);
+		const complete = presentTables.length === tables.length;
+		this.fail(connector, "NF_GENERATE_DATABASE_NOT_ADOPTED", complete ? `Rien n'a été écrit : aucune migration n'existe encore, et la base porte déjà TOUTES les tables déclarées (${presentTables.join(", ")}).` : `Rien n'a été écrit : aucune migration n'existe encore, et la base porte déjà ${presentTables.length} des ${tables.length} tables à créer (${presentTables.join(", ")}).`, complete ? "Une première migration décrit la création du schéma. Écrite ici, elle porterait un « CREATE TABLE » de tables qui existent, avec leurs données : elle ne s'appliquerait jamais. Et comme la base porte déjà tout ce que le code déclare, il n'y a AUCUN écart à écrire. La commande ci-dessous lit le schéma SUR la base et en fait votre première migration — rien n'est exécuté dessus, et elle s'applique telle quelle sur une base vierge. Inutile de regénérer ensuite : il n'y aurait rien de plus à écrire. La suite redevient ordinaire — le champ que vous ajouterez produira un « ALTER TABLE »." : "Une première migration décrit la création du schéma. Écrite ici, elle porterait un « CREATE TABLE » de tables qui existent, avec leurs données : elle ne s'appliquerait jamais, et l'adopter graverait dans l'historique un schéma que la base n'a pas. Cette base doit d'abord être ADOPTÉE — sa migration de référence se lit sur elle, pas sur le code, et rien n'est exécuté dessus. La suite redevient ordinaire : le champ ajouté produit alors un « ALTER TABLE ».", complete ? [adopter] : [adopter, action(`nodefony orm:generate --name ${name} --connector ${connector}`)], opts.json, EXIT.actionRequired);
+		return this;
+	}
+	/**
+	* Tags actuellement inscrits au journal d'un dossier de sortie.
+	*
+	* @param outDir - dossier `<migrations>/<dialecte>`.
+	* @returns les tags, ou `[]` si rien n'a encore été généré.
+	*/
+	async #tags(outDir) {
+		return ((await readJournal(outDir))?.entries ?? []).map((e) => e.tag);
+	}
+	/**
+	* Écrit le rapport, en machine ou pour un humain.
+	*
+	* @returns `this`.
+	*/
+	#emit(report, opts, headline) {
+		const style = this.style;
+		let human = `${style.green("✓")} ${headline}\n`;
+		if (report.files.length > 0) human += `\n${report.files.map((f) => `  + ${f}`).join("\n")}\n`;
+		if (report.otherDialect.length > 0) human += `\n${style.dim(`Écrites pour un autre moteur, donc hors de cette migration :`)}\n` + report.otherDialect.map((o) => `  • ${o.table} (${o.dialect}) — ${o.file}`).join("\n") + "\n";
+		if (report.unreadable.length > 0) human += `\n${style.dim("Fichiers d'entités non lus (aucune entité enregistrée n'en dépend) :")}\n` + report.unreadable.map((u) => `  • ${u.file} — ${u.cause}`).join("\n") + "\n";
+		if (report.warnings.length > 0) human += `\n${style.bold("⚠️  À REGARDER avant d'appliquer")} (rien n'est détruit — mais l'application peut cesser de répondre le temps de l'opération, ou la migration ÉCHOUER si la table porte déjà des lignes) :\n` + report.warnings.map((r) => `  • ${r.id} : ${r.what}\n    → ${r.todo}`).join("\n") + "\n";
+		if (report.generated) human += `\n${style.bold("À faire :")}\n  ${style.dim("relire le fichier, puis")} ${style.green("nodefony orm:migrate")}\n`;
+		this.respond(report, human, EXIT.ok, opts.json);
+		return this;
+	}
+};
+//#endregion
+export { OrmGenerate as default };

package/dist/nodefony/command/orm-migrate-baseline.js

@@ -0,0 +1,208 @@
+import { HISTORY_TABLE } from "../src/migrator/types.js";
+import { EXIT, MIGRATION_FORMAT_VERSION, action, renderStatus } from "../src/migrator/explain.js";
+import { frameworkTables } from "../src/migrator/sources.js";
+import { appMigrationsDir } from "../src/migrator/resolve.js";
+import { summarizeGap } from "../src/migrator/schemaDiff.js";
+import { gapAgainstDeclared } from "../src/migrator/divergence.js";
+import { stampFormatMarker } from "../src/migrator/kit.js";
+import { registeredTables } from "../src/migrator/appSchema.js";
+import { checkMigrationName } from "../src/migrator/name.js";
+import { adoptFromDatabase, readJournal } from "../src/migrator/adopt.js";
+import { OrmMigrateCommand } from "./migrateShared.js";
+import path from "node:path";
+//#region nodefony/command/orm-migrate-baseline.ts
+const options = {
+	helpGroup: "BASE DE DONNÉES",
+	showBanner: false,
+	kernelEvent: "onPostReady"
+};
+/**
+* `nodefony orm:migrate:baseline` — déclare une base existante « à niveau »,
+* SANS exécuter une seule instruction de schéma.
+*
+* ## Quand on en a besoin
+*
+* La base contient déjà les tables — parce qu'on branche Nodefony sur une base
+* qui existait avant, ou parce que le schéma a été créé autrement (mode `auto`
+* en développement) — mais aucune migration n'y est enregistrée. Appliquer les
+* migrations dans cet état exécuterait des créations de tables qui existent
+* déjà, et échouerait.
+*
+* ## Pourquoi ce n'est PAS automatique
+*
+* Adopter tout seul retirerait le filet qui protège de la pire erreur : se
+* tromper de base. Une adresse de base héritée d'un autre environnement, et
+* l'outil déclarerait « à niveau » une base qui n'a rien à voir — puis
+* appliquerait dessus les migrations suivantes. La documentation de Flyway
+* elle-même met en garde contre son propre mode automatique pour cette raison.
+*
+* **Vérifie que c'est la bonne base avant de taper cette commande.** Elle ne
+* modifie pas le schéma, mais elle change ce que le framework CROIT du schéma —
+* et tout le reste en découle.
+*
+* ## Ce qu'elle fait exactement
+*
+* Elle inscrit dans l'historique, comme appliquées avec succès et une durée
+* nulle, les migrations qui n'y sont pas encore. Rejouée, elle n'inscrit que ce
+* qui manque : elle est donc sûre à relancer.
+*
+* ## Ce qu'elle REFUSE
+*
+* Adopter, c'est affirmer que la base est à l'état que décrivent ces
+* migrations. Quand la base s'écarte du schéma déclaré, l'affirmation serait
+* fausse — et une affirmation fausse gravée dans l'historique n'est rattrapable
+* par aucune commande. La commande constate donc la base AVANT d'écrire, et
+* refuse (`NF_MIGRATE_BASELINE_AMBIGUOUS`) en nommant ce qui manque.
+*
+* Trois cas y échappent, et pour la même raison — la garde n'a plus rien à
+* deviner : `--up-to`, qui borne l'adoption explicitement ; `--from-database`,
+* dont la référence DÉCRIT la base et rend donc l'affirmation vraie par
+* construction ; et une cible détournée par `NF_MIGRATE_DATABASE_URL`, où la
+* comparaison porterait sur la base de la configuration et non sur celle qu'on
+* migre.
+*
+* ## Une base qui n'a JAMAIS eu de migrations — `--from-database`
+*
+* Adopter suppose des fichiers à inscrire. Une application passée du mode
+* dérivé, où le démarrage fabrique le schéma, au mode de production n'en a
+* aucun : sa base porte tout, son dossier de migrations est vide. Sans
+* référence, la première génération décrirait ce que le CODE déclare — un
+* schéma que cette base n'a peut-être jamais eu, si quelqu'un vient de changer
+* une entité — et l'inscrire graverait une affirmation fausse.
+*
+* `--from-database` LIT le schéma de la base et en écrit la migration de
+* référence, puis l'inscrit. Rien n'est exécuté sur la base. La suite redevient
+* ordinaire : le champ ajouté produit un `ALTER TABLE`.
+*
+* @example Adopter jusqu'à une migration précise
+* ```bash
+* nodefony orm:migrate:baseline --up-to 0003_audit_severity
+* nodefony orm:migrate            # applique la suite normalement
+* ```
+*
+* @example Reprendre une base qui existait avant toute migration
+* ```bash
+* nodefony orm:migrate:baseline --from-database   # la référence est LUE sur la base
+* nodefony orm:generate --name ajout_du_slug      # produit un ALTER, plus un CREATE
+* nodefony orm:migrate                            # applique
+* ```
+*/
+var OrmMigrateBaseline = class extends OrmMigrateCommand {
+	constructor(cli) {
+		super("orm:migrate:baseline", "déclare une base déjà peuplée comme à niveau", cli, options);
+		this.addSharedOptions();
+		this.addOption("--up-to <tag>", "dernière migration inscrite (incluse) — ex. 0003_audit_severity ; toutes si omis");
+		this.addOption("--from-database", "LIT le schéma de la base pour en écrire la migration de référence, puis l'inscrit — pour une base qui existait avant toute migration");
+		this.addOption("--name <nom>", "nom de la migration de référence écrite par --from-database (défaut : base_existante)");
+	}
+	/**
+	* Écrit la migration de référence en LISANT la base, puis l'inscrit.
+	*
+	* ## Pourquoi la référence vient de la base, et non du code
+	*
+	* Le générateur ne connaît que les fichiers. Sans instantané de départ, il
+	* décrit ce que le CODE déclare — c'est-à-dire, si quelqu'un vient de changer
+	* une entité, un schéma que la base n'a jamais eu. L'adopter graverait cette
+	* affirmation dans l'historique, et la colonne manquante ne s'appliquerait
+	* plus jamais. Lue sur la base, la référence est vraie par construction : elle
+	* décrit ce qui est là.
+	*
+	* ## Ce qui est écrit, et ce qui ne l'est pas
+	*
+	* Un fichier de migration et son instantané, dans le dossier de l'application.
+	* **Aucune instruction n'est exécutée sur la base** — l'inscription qui suit
+	* déclare appliquée une migration qui décrit un état déjà atteint.
+	*
+	* @param opts - options reçues.
+	* @param resolution - connecteur prêt.
+	* @param config - configuration validée du module.
+	* @returns ce qui a été écrit, ou `null` si la commande a déjà refusé.
+	*/
+	async #fromDatabase(opts, resolution, config) {
+		const root = this.kernel.path;
+		const dir = appMigrationsDir(this.kernel, config.migrations.dir);
+		if (dir === void 0) {
+			this.fail(resolution.connector, "NF_MIGRATE_UNAVAILABLE", "La racine de l'application n'a pas pu être résolue : impossible de savoir où écrire la migration de référence.", "Le dossier des migrations se résout depuis la racine de l'application, jamais depuis le répertoire courant — sans quoi la commande serait juste ou fausse selon l'endroit d'où on la tape.", [action("nodefony inspect config --json")], opts.json);
+			return null;
+		}
+		const outDir = path.join(dir, resolution.dialect);
+		const journal = await readJournal(outDir);
+		if (journal !== null && journal.entries.length > 0) {
+			this.fail(resolution.connector, "NF_MIGRATE_BASELINE_NOT_EMPTY", `Rien n'a été écrit : ce dossier porte déjà ${journal.entries.length} migration(s) (${outDir}).`, "La lecture de la base ne sert qu'à DÉMARRER un historique qui n'existe pas encore. Ici il en existe un : c'est lui qui fait foi, et la base s'adopte alors telle quelle. Si ces migrations décrivent bien l'état de la base, `orm:migrate:baseline` sans option les inscrit ; si elles décrivent autre chose, c'est un écart à regarder, pas une référence à réécrire.", [action(`nodefony orm:migrate:status --connector ${resolution.connector} --json`), action(`nodefony orm:migrate:baseline --connector ${resolution.connector}`)], opts.json, EXIT.actionRequired);
+			return null;
+		}
+		const verdict = checkMigrationName(opts.name ?? "base_existante");
+		if (!verdict.ok) {
+			this.fail(resolution.connector, "NF_GENERATE_NAME", verdict.reason, "Le nom entre dans le tag de la migration de référence, et un tag ne se renomme plus une fois inscrit : c'est lui qui dit à chaque base ce qu'elle a déjà reçu.", [action(`nodefony orm:migrate:baseline --from-database --name ${verdict.suggestion ?? "base_existante"}`)], opts.json, EXIT.actionRequired);
+			return null;
+		}
+		const adopted = await adoptFromDatabase({
+			projectRoot: root,
+			outDir,
+			dialect: resolution.dialect,
+			target: resolution.target,
+			excludedTables: [...await frameworkTables(resolution.dialect), HISTORY_TABLE],
+			declaredTables: registeredTables(resolution.connector).map((t) => t.table),
+			name: verdict.name,
+			workDir: path.join(root, "node_modules", ".cache", "nodefony", "orm-adopt")
+		});
+		stampFormatMarker(outDir);
+		return adopted;
+	}
+	async generate(opts = {}) {
+		const resolved = this.resolveOrFail(opts, true);
+		if (!resolved) return this;
+		const { resolution, config } = resolved;
+		const style = this.style;
+		try {
+			let reference = null;
+			if (opts.fromDatabase === true) {
+				reference = await this.#fromDatabase(opts, resolution, config);
+				if (reference === null) return this;
+			}
+			const migrator = await this.migrator(resolution, config);
+			if (opts.upTo === void 0 && opts.fromDatabase !== true && !resolution.fromMigrateUrl) {
+				const gap = await gapAgainstDeclared(resolution.connector);
+				if (gap !== null) {
+					this.fail(resolution.connector, "NF_MIGRATE_BASELINE_AMBIGUOUS", `La base ne correspond pas au schéma déclaré : ${summarizeGap(gap)}. Rien n'a été inscrit.`, "Adopter reviendrait à déclarer appliquées des migrations que cette base n'a jamais reçues — une affirmation fausse gravée dans l'historique, qu'aucune commande ne peut ensuite rattraper. Dis jusqu'où la base suit avec `--up-to <tag>` : les migrations postérieures resteront en attente et s'appliqueront normalement.", [action(`nodefony orm:migrate:status --connector ${resolution.connector}`), action(`nodefony orm:migrate:baseline --up-to <tag> --connector ${resolution.connector}`)], opts.json, EXIT.actionRequired);
+					return this;
+				}
+			}
+			const adopted = await migrator.baseline(opts.upTo);
+			const plan = await migrator.status();
+			const report = await this.report(plan, resolution, config);
+			const payload = {
+				...report,
+				adopted: adopted.map((a) => ({
+					source: a.source,
+					tag: a.tag
+				})),
+				...reference === null ? {} : { reference: {
+					tag: reference.tag,
+					file: reference.file,
+					runnable: reference.runnable,
+					extraTables: reference.extraTables
+				} }
+			};
+			let human = "";
+			if (reference !== null) {
+				human += `${style.green(style.bold(`✓ Référence ${reference.tag} écrite en LISANT la base`))} ${style.dim("— aucune instruction n'a été exécutée dessus")}\n  ${style.dim(reference.file)}\n`;
+				if (reference.extraTables.length > 0) human += `${style.bold("⚠️  Tables LUES sans être déclarées par l'application")} : ${reference.extraTables.join(", ")}.\n  ${style.dim("La prochaine génération proposera de les SUPPRIMER — relire le fichier avant.")}\n`;
+				if (!reference.runnable) human += `${style.bold("⚠️  Son corps est resté en COMMENTAIRE")} — une base montée depuis ces fichiers sortirait VIDE. Relire le fichier avant de créer un environnement.\n`;
+				human += "\n";
+			}
+			if (adopted.length === 0) human += `${style.green("Rien à déclarer : toutes les migrations connues sont déjà enregistrées.")}\n\n` + renderStatus(report, style);
+			else {
+				human += `${style.green(style.bold(`✓ ${adopted.length} migration(s) déclarée(s) comme appliquée(s)`))} ${style.dim("— aucun SQL n'a été exécuté")}\n`;
+				for (const a of adopted) human += `  ${style.green("=")} ${a.source}/${a.tag}\n`;
+				human += `\n${renderStatus(report, style)}`;
+			}
+			this.respond(payload, human, report.exitCode, opts.json);
+		} catch (e) {
+			this.failFrom(e, resolution.connector, opts.json, resolution.ddl);
+		}
+		return this;
+	}
+};
+//#endregion
+export { MIGRATION_FORMAT_VERSION, action, OrmMigrateBaseline as default };