@nodefony/drizzle 10.0.0-alpha.5 → 10.0.0-alpha.6

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

@@ -9,6 +9,7 @@ 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 { repairRebuildCopy } from "../src/migrator/rebuildCopy.js";
 import { readJournal, tablesPresentIn } from "../src/migrator/adopt.js";
 import { OrmMigrateCommand } from "./migrateShared.js";
 import { listTargets } from "nodefony";
@@ -252,7 +253,14 @@ var OrmGenerate = class extends OrmMigrateCommand {
 		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);
+			let sql = await fs.readFile(file, "utf8");
+			const repair = repairRebuildCopy(sql, await this.#columnsBeforeMigration(outDir, tag));
+			if (repair.dropped.length > 0) {
+				await fs.writeFile(file, repair.sql, "utf8");
+				sql = repair.sql;
+				if (opts.json !== true) this.log(`Recopie corrigée dans ${relative(file)} — ${repair.dropped.join(", ")} ne peu${repair.dropped.length > 1 ? "vent" : "t"} pas être lue${repair.dropped.length > 1 ? "s" : ""} dans la table de départ, qui ne la${repair.dropped.length > 1 ? "s" : ""} porte pas encore. Ces colonnes recevront ce que leur « CREATE TABLE » leur donne (un défaut, ou vide) — c'est ce qu'aurait fait un « ADD COLUMN ». Le reste du fichier est intact.`, "WARNING");
+			}
+			const audit = auditMigrationSql(sql, dialect);
 			destructive.push(...audit.destructive);
 			warnings.push(...audit.blocking);
 		}
@@ -336,6 +344,42 @@ var OrmGenerate = class extends OrmMigrateCommand {
 		return ((await readJournal(outDir))?.entries ?? []).map((e) => e.tag);
 	}
 	/**
+	* Les colonnes que chaque table portait AVANT la migration qu'on vient
+	* d'écrire — lues dans le cliché qui la précède.
+	*
+	* C'est la même référence que celle sur laquelle l'outil de génération a
+	* calculé son écart : le cliché d'indice `N-1` décrit l'état d'arrivée de la
+	* migration précédente, donc l'état de DÉPART de celle-ci.
+	*
+	* Rend une fonction qui répond `null` pour toute table inconnue — absence de
+	* cliché, première migration, format inattendu. C'est ce `null` qui garantit
+	* qu'on ne réécrit jamais un SQL sur une supposition.
+	*
+	* @param outDir - dossier des migrations du dialecte.
+	* @param tag - étiquette de la migration écrite (`0004_ajout_du_titre`).
+	* @returns un lecteur de colonnes par nom de table.
+	*/
+	async #columnsBeforeMigration(outDir, tag) {
+		const index = Number.parseInt(tag.slice(0, 4), 10);
+		if (!Number.isFinite(index) || index <= 0) return () => null;
+		const file = path.join(outDir, "meta", `${String(index - 1).padStart(4, "0")}_snapshot.json`);
+		let snapshot;
+		try {
+			snapshot = JSON.parse(await fs.readFile(file, "utf8"));
+		} catch {
+			return () => null;
+		}
+		const tables = snapshot.tables;
+		if (tables === void 0 || tables === null) return () => null;
+		const byName = /* @__PURE__ */ new Map();
+		for (const [key, table] of Object.entries(tables)) {
+			const columns = table?.columns;
+			if (columns === void 0 || columns === null) continue;
+			byName.set(key.split(".").pop(), Object.keys(columns));
+		}
+		return (name) => byName.get(name) ?? null;
+	}
+	/**
 	* Écrit le rapport, en machine ou pour un humain.
 	*
 	* @returns `this`.

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

@@ -1,7 +1,9 @@
 import { action } from "../src/migrator/explain.js";
 import { openMigrationDriver } from "../src/migrator/drivers/index.js";
+import { readHistory } from "../src/migrator/history.js";
 import { readMigrationEnv, resetAllowed } from "../src/migrator/resolve.js";
 import { OrmMigrateCommand } from "./migrateShared.js";
+import { identityTablesAmong, rowsWorthKeeping } from "../src/migrator/identityTables.js";
 //#region nodefony/command/orm-reset.ts
 const options = {
 	helpGroup: "BASE DE DONNÉES",
@@ -62,10 +64,23 @@ function quoteIdent(name, dialect) {
 * production : lui laisser désigner la cible d'un effacement serait offrir la
 * seule combinaison qu'il ne faut jamais rendre possible.
 *
+* ## Ce que `--yes` ne suffit PAS à faire
+*
+* Une base qui porte des comptes, des passkeys ou des seconds facteurs n'est pas
+* une base jetable, et `--yes` ne l'efface pas : la commande refuse, nomme
+* chaque table avec son nombre de lignes, et demande `--drop-accounts` en plus.
+* Vécu : un agent a lu un refus de migration qui proposait `orm:migrate:repair`,
+* puis a tapé `orm:reset -y` — la seule voie qui détruit. Un refus bien rédigé
+* ne suffit pas : la prose informe, seule la commande contraint.
+*
+* Une base VIDE n'est pas gênée, et c'est voulu : une garde qui se lève sur le
+* cas normal s'apprend à être contournée avant le jour où elle a raison.
+*
 * @example
 * ```bash
-* nodefony orm:reset            # demande confirmation en terminal
-* nodefony orm:reset --yes      # sans question (script)
+* nodefony orm:reset                     # demande confirmation en terminal
+* nodefony orm:reset --yes               # sans question (script)
+* nodefony orm:reset --yes --drop-accounts  # ... comptes et passkeys compris
 * ```
 */
 var OrmReset = class extends OrmMigrateCommand {
@@ -73,6 +88,7 @@ var OrmReset = class extends OrmMigrateCommand {
 		super("orm:reset", "vide la base de développement d'un connecteur", cli, options);
 		this.addSharedOptions();
 		this.addOption("-y, --yes", "ne pose pas la question — pour un script ; hors terminal, l'option est obligatoire");
+		this.addOption("--drop-accounts", "accepte d'effacer des comptes, des passkeys et des seconds facteurs — sans ce drapeau, `--yes` ne le fait pas");
 	}
 	async generate(opts = {}) {
 		const resolved = this.resolveOrFail(opts, false);
@@ -99,6 +115,27 @@ var OrmReset = class extends OrmMigrateCommand {
 				}, `${style.green("La base est déjà vide")} ${style.dim(`(${resolution.dialect} : ${target})`)} — rien à faire.\n`, 0, opts.json);
 				return this;
 			}
+			const identity = identityTablesAmong(tables);
+			if (identity.length > 0 && opts.dropAccounts !== true) {
+				const counted = [];
+				for (const entry of identity) {
+					const countRows = await driver.query(`SELECT COUNT(*) AS n FROM ${quoteIdent(entry.table, resolution.dialect)}`);
+					counted.push({
+						...entry,
+						rows: Number(countRows[0]?.n ?? 0)
+					});
+				}
+				const atRisk = counted.filter((c) => rowsWorthKeeping(c, c.rows));
+				if (atRisk.length > 0) {
+					let repairable = false;
+					try {
+						repairable = (await readHistory(driver)).some((row) => !row.success || row.finishedAt === null);
+					} catch {}
+					const connectorArg = resolution.connector === "default" ? "" : ` --connector ${resolution.connector}`;
+					this.fail(resolution.connector, "NF_MIGRATE_RESET_HAS_ACCOUNTS", `Cette base porte des données qui ne se reconstituent pas : ${atRisk.map((c) => `${c.table} (${c.rows})`).join(", ")}.`, `${atRisk.map((c) => `  · ${c.table} — ${c.holds}`).join("\n")}\n\n` + (repairable ? "Une migration a échoué et son marqueur est posé : c'est probablement ce que tu cherches à débloquer. `orm:migrate:repair` lève le marqueur SANS rien effacer, et écrire la migration suivante vaut toujours mieux que défaire ce qui est appliqué.\n\n" : "") + "Si ces données ne comptent pour personne — base d'essai, exemplaire jetable —, relance avec `--drop-accounts` en plus de `--yes` : le drapeau dit que tu as vu la liste ci-dessus.", repairable ? [action(`nodefony orm:migrate:repair${connectorArg}`), action(`nodefony orm:migrate:status${connectorArg} --json`)] : [action(`nodefony orm:migrate:status${connectorArg} --json`)], opts.json, 1);
+					return this;
+				}
+			}
 			if (opts.yes !== true) {
 				if (opts.json === true || !process.stdin.isTTY) {
 					this.fail(resolution.connector, "NF_MIGRATE_CONFIRM_REQUIRED", `Cette commande va supprimer ${tables.length} table(s) de « ${target} » (${resolution.dialect}) : ${tables.join(", ")}.`, "Hors terminal — ou en sortie machine, où un dialogue n'a pas sa place —, il n'y a personne pour répondre à une question, et un effacement ne se déduit pas d'un silence. Relance avec `--yes` si c'est bien ce que tu veux.", [action(`nodefony orm:reset --yes${resolution.connector === "default" ? "" : ` --connector ${resolution.connector}`}`)], opts.json, 1);

package/dist/nodefony/service/DrizzleService.js

@@ -186,10 +186,12 @@ var DrizzleService = class extends Service {
 	* donc vivant, refuse le trafic, dit pourquoi — et repart tout seul.
 	*/
 	async #applySchemaPolicy(name, ddl, cfg, dialect, filename) {
-		if (ddl === "auto") return;
 		const kernel = this.kernel;
 		const config = this.#config();
-		const check = resolveCheckMode(config.migrations?.check, readMigrationEnv(kernel));
+		const env = readMigrationEnv(kernel);
+		const check = resolveCheckMode(config.migrations?.check, env);
+		const adviseOnly = ddl === "auto";
+		if (adviseOnly && (check === "off" || env.runtime !== "development")) return;
 		const target = {
 			dialect,
 			filename,
@@ -202,6 +204,10 @@ var DrizzleService = class extends Service {
 			sources,
 			lockTimeoutMs: config.migrations?.lockTimeoutMs
 		});
+		if (adviseOnly) {
+			await this.#publishReadiness(name, migrator, ddl, "warn");
+			return;
+		}
 		if (ddl === "migrate") try {
 			const prevu = await migrator.status();
 			const losses = dataLoss(scanDestructive(prevu.pending));
@@ -247,7 +253,7 @@ var DrizzleService = class extends Service {
 			});
 			const enAvance = isAheadOnly(plan);
 			const ok = report.exitCode === 0 || enAvance;
-			kernel.setReadiness(readinessName(name), ok, report.summary, check === "fail");
+			kernel.setReadiness(readinessName(name), ok, report.summary, check === "fail", report.nextActions[0]?.command);
 			if (enAvance) this.log(`Drizzle « ${name} » : la base porte ${plan.missing.length} migration(s) que ce code ne connaît pas — elle est EN AVANCE. C'est attendu pendant un déploiement progressif ou après un retour arrière ; rien à appliquer, le processus peut servir.`, "INFO");
 			else if (!ok) this.log(`Drizzle « ${name} » : ${report.summary}\n  ${meaningOf(report.verdict)}\n` + (check === "fail" ? "  → le trafic est RETENU (/readyz répond 503) jusqu'à ce que ce soit réglé ; /livez reste vert, ce processus n'est pas malade.\n" : `  → le trafic passe quand même (migrations.check: "warn").\n`) + report.nextActions.map((a) => `  À faire : ${a.command}`).join("\n"), check === "fail" ? "CRITIC" : "WARNING");
 			else if (check === "fail") this.log(`Drizzle « ${name} » : schéma à jour — le processus peut servir.`, "INFO");

package/dist/nodefony/src/migrator/identityTables.js

@@ -0,0 +1,53 @@
+//#region nodefony/src/migrator/identityTables.ts
+const IDENTITY_TABLES = [
+	{
+		name: "User",
+		holds: "des comptes que rien ne repose — un semis ne recrée que l'admin",
+		reseededRows: 1
+	},
+	{
+		name: "webauthn_credential",
+		holds: "les passkeys — liées à l'appareil, personne ne peut les réémettre",
+		reseededRows: 0
+	},
+	{
+		name: "totp_secret",
+		holds: "les seconds facteurs — il faudra re-scanner un code",
+		reseededRows: 0
+	}
+];
+/**
+* Les tables d'identité PRÉSENTES parmi celles qu'on s'apprête à supprimer.
+*
+* La comparaison ignore la casse : sqlite conserve `User` tel quel, d'autres
+* moteurs replient en minuscules, et une garde sensible à la casse serait
+* inopérante sur la moitié des dialectes — c'est-à-dire exactement là où l'on
+* croirait être protégé.
+*
+* @param tables - noms lus dans le catalogue de la base.
+* @returns les entrées d'identité correspondantes, avec le nom RÉEL de la table.
+*/
+function identityTablesAmong(tables) {
+	const found = [];
+	for (const known of IDENTITY_TABLES) {
+		const match = tables.find((t) => t.toLowerCase() === known.name.toLowerCase());
+		if (match !== void 0) found.push({
+			table: match,
+			holds: known.holds,
+			reseededRows: known.reseededRows
+		});
+	}
+	return found;
+}
+/**
+* Y a-t-il quelque chose à PERDRE dans cette table ?
+*
+* @param found - table d'identité présente en base.
+* @param rows - nombre de lignes constaté.
+* @returns `true` si la perte dépasse ce qu'un semis repose.
+*/
+function rowsWorthKeeping(found, rows) {
+	return rows > found.reseededRows;
+}
+//#endregion
+export { IDENTITY_TABLES, identityTablesAmong, rowsWorthKeeping };

package/dist/nodefony/src/migrator/kit.js

@@ -1,5 +1,5 @@
 import { FORMAT_MARKER } from "./types.js";
-import { MigrationToolError, generationToolMissing } from "./refusals.js";
+import { MigrationToolError, generationFailed, generationNeedsAnswer, generationToolMissing, introspectFailed } from "./refusals.js";
 import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
@@ -54,8 +54,9 @@ function resolveDrizzleKitBin(from) {
 *   relatif à `cwd`), `name` (nom imposé de la migration), `label` (ce qui est
 *   cité dans l'erreur).
 * @returns la sortie complète de l'outil (sortie standard puis sortie d'erreur).
-* @throws Error si le code est non nul, ou si rien ne prouve que la génération a
-*   eu lieu — l'absence de preuve n'est JAMAIS lue comme « rien à faire ».
+* @throws MigrationToolError si le code est non nul, ou si rien ne prouve que la
+*   génération a eu lieu — l'absence de preuve n'est JAMAIS lue comme « rien à
+*   faire ». Le refus porte la sortie de l'outil, jamais une hypothèse.
 */
 function runGenerate({ cwd, configRel, name, label, regenerateCommand }) {
 	const result = spawnSync(process.execPath, [
@@ -69,11 +70,8 @@ function runGenerate({ cwd, configRel, name, label, regenerateCommand }) {
 	});
 	const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
 	if (result.status !== 0 || !generationHappened(output)) {
-		if (isInteractivePromptFailure(output)) {
-			const replay = regenerateCommand ?? `nodefony orm:generate --name ${name}`;
-			throw new Error(`Un RENOMMAGE probable a été détecté sur ${label}, et il faut trancher.\n\n  drizzle-kit ne peut pas deviner votre intention : une colonne qui\n  disparaît et une autre qui apparaît, c'est soit un renommage — les\n  données SUIVENT —, soit une suppression puis un ajout — les données\n  sont PERDUES. Il pose donc la question, et il n'y a pas de terminal\n  ici pour y répondre.\n\n  Rejouer la commande dans un terminal interactif :\n    ${replay}\n\n  ⚠️ Après avoir répondu « renamed », RELIRE le fichier produit : quand\n  une colonne est renommée ET que son type change, l'outil n'écrit que\n  le renommage et OUBLIE le changement de type (drizzle-orm#3826).`);
-		}
-		throw new Error(`La génération n'a pas eu lieu sur ${label} (code ${result.status}). Ne rien conclure de ce silence : l'outil rend 0 même en échec.\n` + output.trim());
+		if (isInteractivePromptFailure(output)) throw new MigrationToolError(generationNeedsAnswer(label, regenerateCommand ?? `nodefony orm:generate --name ${name}`));
+		throw new MigrationToolError(generationFailed(label, result.status, output));
 	}
 	return output;
 }
@@ -95,7 +93,7 @@ function runGenerate({ cwd, configRel, name, label, regenerateCommand }) {
 *   (configuration, chemin relatif à `cwd`), `label` (ce qui est cité en cas
 *   d'échec).
 * @returns la sortie complète de l'outil.
-* @throws Error si le code est non nul.
+* @throws MigrationToolError si le code est non nul.
 */
 function runIntrospect({ cwd, configRel, label }) {
 	const result = spawnSync(process.execPath, [
@@ -107,7 +105,7 @@ function runIntrospect({ cwd, configRel, label }) {
 		encoding: "utf8"
 	});
 	const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-	if (result.status !== 0) throw new Error(`La lecture du schéma de ${label} a échoué (code ${result.status}).\n` + output.trim());
+	if (result.status !== 0) throw new MigrationToolError(introspectFailed(label, result.status, output));
 	return output;
 }
 /**

package/dist/nodefony/src/migrator/rebuildCopy.js

@@ -0,0 +1,89 @@
+//#region nodefony/src/migrator/rebuildCopy.ts
+/**
+* Répare la recopie d'une recréation de table SQLite.
+*
+* 🔴 Le défaut que ce module ferme, mesuré sur deux applications fraîches :
+* quand une migration doit à la fois MODIFIER une colonne et en AJOUTER une,
+* SQLite ne sait pas altérer sur place — l'outil de génération produit alors la
+* ronde connue (créer `__new_x`, y recopier les lignes de `x`, supprimer `x`,
+* renommer). Sa recopie liste les colonnes de la table d'ARRIVÉE, la colonne
+* neuve comprise, et va donc la LIRE dans la table de départ, où elle n'existe
+* pas encore. La migration échoue sur `no such column` et laisse un marqueur
+* qui bloque tous les passages suivants — l'utilisateur se retrouve devant
+* trois commandes qui refusent, et la seule issue apparente est de détruire la
+* base.
+*
+* La réparation est déterministe et sans jugement : une colonne que la table de
+* départ ne porte pas ne peut pas être recopiée, donc elle sort des DEUX
+* listes. Elle recevra ce que son `CREATE TABLE` lui donne — un défaut, ou
+* `NULL`. C'est exactement ce qu'aurait fait un `ADD COLUMN`.
+*
+* ⚠️ On ne touche à RIEN dès qu'un élément de la recopie n'est pas une simple
+* colonne citée — une expression, un appel de fonction, un alias — ni quand les
+* colonnes de la table de départ sont inconnues. Réécrire ce qu'on n'a pas
+* compris coûterait plus cher que le défaut qu'on répare.
+*/
+/**
+* La ronde de recréation, telle que l'outil de génération l'écrit.
+*
+* Tout est nommé : lire ces morceaux par POSITION obligerait à recompter à
+* chaque retouche de l'expression, et une erreur y serait silencieuse — on
+* réécrirait la mauvaise moitié de la recopie.
+*/
+const REBUILD_COPY = /(?<head>INSERT\s+INTO\s+[`"']?__new_[A-Za-z0-9_]+[`"']?\s*\(\s*)(?<into>[^)]*?)(?<middle>\s*\)\s*SELECT\s+)(?<select>.*?)(?<tail>\s+FROM\s+[`"']?(?<source>[A-Za-z0-9_]+)[`"']?)/gis;
+/** Une colonne citée, telle qu'elle apparaît dans les deux listes. */
+const QUOTED_COLUMN = /^[`"']?(?<name>[A-Za-z0-9_]+)[`"']?$/u;
+/** Découpe une liste de colonnes, en gardant l'écriture exacte de chacune. */
+function splitColumns(list) {
+	return list.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+/** Le nom nu d'une colonne citée, ou `null` si ce n'en est pas une. */
+function bareName(token) {
+	return QUOTED_COLUMN.exec(token)?.groups?.name ?? null;
+}
+/**
+* Retire de la recopie les colonnes que la table de départ ne porte pas.
+*
+* @param sql - le SQL de la migration, tel que l'outil vient de l'écrire.
+* @param columnsOf - les colonnes d'une table AVANT cette migration ; `null`
+*   quand on ne les connaît pas — auquel cas rien n'est touché, car on ne
+*   réécrit jamais sur une supposition.
+* @returns le SQL réparé et la liste de ce qui a été retiré.
+*/
+function repairRebuildCopy(sql, columnsOf) {
+	const dropped = [];
+	return {
+		sql: sql.replace(REBUILD_COPY, (...args) => {
+			const match = args[0];
+			const groups = args[args.length - 1];
+			if (groups === void 0) return match;
+			const { head, into, middle, select, tail, source } = groups;
+			if (head === void 0 || into === void 0 || middle === void 0 || select === void 0 || tail === void 0 || source === void 0) return match;
+			const known = columnsOf(source);
+			if (known === null) return match;
+			const intoColumns = splitColumns(into);
+			const selectColumns = splitColumns(select);
+			if (intoColumns.length !== selectColumns.length) return match;
+			const carried = new Set(known);
+			const keptInto = [];
+			const keptSelect = [];
+			const removed = [];
+			for (let i = 0; i < intoColumns.length; i++) {
+				const target = bareName(intoColumns[i]);
+				const read = bareName(selectColumns[i]);
+				if (target === null || read === null) return match;
+				if (carried.has(read)) {
+					keptInto.push(intoColumns[i]);
+					keptSelect.push(selectColumns[i]);
+				} else removed.push(`${source}.${read}`);
+			}
+			if (removed.length === 0) return match;
+			if (keptInto.length === 0) return match;
+			dropped.push(...removed);
+			return `${head}${keptInto.join(", ")}${middle}${keptSelect.join(", ")}${tail}`;
+		}),
+		dropped
+	};
+}
+//#endregion
+export { repairRebuildCopy };

package/dist/nodefony/src/migrator/refusals.js

@@ -41,6 +41,88 @@ function generationToolMissing() {
 	};
 }
 /**
+* Sortie d'un outil tiers, prête à être citée dans une explication.
+*
+* Elle est indentée pour se distinguer de la prose qui l'entoure, et BORNÉE par
+* la fin : une pile d'appels se termine par ce qui a cassé, jamais par ce qui a
+* démarré. La troncature s'ANNONCE — une sortie coupée en silence fait chercher
+* une cause dans la moitié qu'on n'a pas montrée.
+*
+* @param output - sortie complète de l'outil (standard puis erreur).
+* @param maxLines - nombre de lignes conservées, depuis la fin.
+* @returns le bloc cité, ou une phrase disant qu'il n'y avait rien.
+*/
+function formatToolOutput(output, maxLines = 40) {
+	const lines = output.split("\n").map((line) => line.trimEnd()).filter((line) => line.length > 0);
+	if (lines.length === 0) return "  (l'outil n'a rien écrit du tout)";
+	const kept = lines.slice(-maxLines);
+	return [...kept.length < lines.length ? [`  […] ${lines.length - kept.length} ligne(s) plus haut, non citées`] : [], ...kept.map((line) => `  ${line}`)].join("\n");
+}
+/**
+* L'outil de génération pose une QUESTION, et aucun terminal n'y répond.
+*
+* C'est le cas d'une colonne qui disparaît pendant qu'une autre apparaît :
+* renommage (les données suivent) ou suppression puis ajout (les données sont
+* perdues) — l'outil ne peut pas le deviner, et il a raison de demander.
+*
+* @param label - ce qui était généré, tel qu'on le cite à l'utilisateur.
+* @param replay - la commande à rejouer dans un terminal interactif.
+* @returns le refus, prêt pour la ligne de commande comme pour l'écran.
+*/
+function generationNeedsAnswer(label, replay) {
+	return {
+		code: "NF_GENERATE_NEEDS_ANSWER",
+		summary: `Un RENOMMAGE probable a été détecté sur ${label}, et il faut trancher — rien n'a été écrit.`,
+		meaning: "Une colonne disparaît et une autre apparaît : c'est soit un renommage — les données SUIVENT —, soit une suppression puis un ajout — les données sont PERDUES. L'outil ne peut pas deviner l'intention, il pose donc la question, et il n'y a pas de terminal ici pour y répondre. La base n'est pas en cause : elle n'a même pas été interrogée. ⚠️ Après avoir répondu « renamed », RELIRE le fichier produit : quand une colonne est renommée ET que son type change, l'outil n'écrit que le renommage et oublie le changement de type (drizzle-orm#3826).",
+		nextActions: [action(replay)],
+		exitCode: 2
+	};
+}
+/**
+* L'outil de génération s'est arrêté, et ce qu'il a dit est remonté TEL QUEL.
+*
+* 🔴 Ne JAMAIS remplacer sa sortie par une hypothèse. Le fourre-tout des
+* commandes de migration explique tout par une base injoignable ou des droits
+* manquants : sur un schéma qui retire une colonne, les deux sont FAUX, et ils
+* envoient vérifier une base qui répond très bien pendant que la cause est dans
+* le fichier d'entité qu'on vient d'éditer. Un message d'erreur est cru PARCE
+* QU'il est précis.
+*
+* @param label - ce qui était généré, tel qu'on le cite à l'utilisateur.
+* @param status - code de sortie observé (il vaut `0` même en échec).
+* @param output - sortie complète de l'outil.
+* @returns le refus, prêt pour la ligne de commande comme pour l'écran.
+*/
+function generationFailed(label, status, output) {
+	return {
+		code: "NF_GENERATE_TOOL_FAILED",
+		summary: `La génération n'a pas eu lieu sur ${label} — rien n'a été écrit.`,
+		meaning: `Ne rien conclure du code de sortie : l'outil rend 0 même en échec (observé : ${status ?? "aucun"}). Ce qu'il a dit, mot pour mot :\n\n${formatToolOutput(output)}\n\nLa base n'est PAS en cause, et ce n'est pas une question de droits : écrire une migration ne l'interroge pas. La comparaison se fait entre les ENTITÉS déclarées et les instantanés des migrations déjà écrites — c'est donc du côté du schéma déclaré qu'il faut regarder.`,
+		nextActions: [action("nodefony inspect entities")],
+		exitCode: 2
+	};
+}
+/**
+* La lecture du schéma d'une base existante a échoué.
+*
+* Contrairement à la génération, celle-ci INTERROGE la base : une base muette
+* ou des droits insuffisants sont ici des explications légitimes.
+*
+* @param label - ce qui était lu, tel qu'on le cite à l'utilisateur.
+* @param status - code de sortie observé.
+* @param output - sortie complète de l'outil.
+* @returns le refus, prêt pour la ligne de commande comme pour l'écran.
+*/
+function introspectFailed(label, status, output) {
+	return {
+		code: "NF_INTROSPECT_FAILED",
+		summary: `La lecture du schéma de ${label} a échoué — rien n'a été écrit.`,
+		meaning: `Code de sortie : ${status ?? "aucun"}. Ce que l'outil a dit, mot pour mot :\n\n${formatToolOutput(output)}\n\nCette étape-ci, contrairement à la génération, INTERROGE la base : une base qui ne répond pas, ou un compte sans le droit de lire le catalogue, sont des explications plausibles — la sortie ci-dessus tranche.`,
+		nextActions: [action("nodefony inspect config --json")],
+		exitCode: 2
+	};
+}
+/**
 * Erreur portant un {@link IResolutionRefusal} déjà composé.
 *
 * Elle existe pour que la CAUSE porte son propre remède jusqu'à la sortie de la
@@ -140,4 +222,4 @@ function describeResolutionRefusal(wanted, resolution, config) {
 	};
 }
 //#endregion
-export { MigrationToolError, describeResolutionRefusal, generationToolMissing, moduleAbsent, notConfigured };
+export { MigrationToolError, describeResolutionRefusal, formatToolOutput, generationFailed, generationNeedsAnswer, generationToolMissing, introspectFailed, moduleAbsent, notConfigured };

package/dist/types/nodefony/command/orm-reset.d.ts

@@ -3,6 +3,7 @@ import { OrmMigrateCommand, type IMigrateSharedOptions } from "./migrateShared.j
 /** Options propres à la remise à zéro d'une base de développement. */
 interface IResetOptions extends IMigrateSharedOptions {
     yes?: boolean;
+    dropAccounts?: boolean;
 }
 /**
  * `nodefony orm:reset` — vide la base de DÉVELOPPEMENT et la laisse prête à
@@ -41,10 +42,23 @@ interface IResetOptions extends IMigrateSharedOptions {
  * production : lui laisser désigner la cible d'un effacement serait offrir la
  * seule combinaison qu'il ne faut jamais rendre possible.
  *
+ * ## Ce que `--yes` ne suffit PAS à faire
+ *
+ * Une base qui porte des comptes, des passkeys ou des seconds facteurs n'est pas
+ * une base jetable, et `--yes` ne l'efface pas : la commande refuse, nomme
+ * chaque table avec son nombre de lignes, et demande `--drop-accounts` en plus.
+ * Vécu : un agent a lu un refus de migration qui proposait `orm:migrate:repair`,
+ * puis a tapé `orm:reset -y` — la seule voie qui détruit. Un refus bien rédigé
+ * ne suffit pas : la prose informe, seule la commande contraint.
+ *
+ * Une base VIDE n'est pas gênée, et c'est voulu : une garde qui se lève sur le
+ * cas normal s'apprend à être contournée avant le jour où elle a raison.
+ *
  * @example
  * ```bash
- * nodefony orm:reset            # demande confirmation en terminal
- * nodefony orm:reset --yes      # sans question (script)
+ * nodefony orm:reset                     # demande confirmation en terminal
+ * nodefony orm:reset --yes               # sans question (script)
+ * nodefony orm:reset --yes --drop-accounts  # ... comptes et passkeys compris
  * ```
  */
 declare class OrmReset extends OrmMigrateCommand {

package/dist/types/nodefony/src/migrator/identityTables.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Tables dont la perte n'est PAS rattrapable — et le seuil à partir duquel elle
+ * ne l'est plus.
+ *
+ * ## Pourquoi une liste, et pas « toutes les tables »
+ *
+ * Vider une base de développement est un geste normal et fréquent : une garde
+ * qui crie à chaque fois s'apprend à être contournée, et le jour où elle aurait
+ * raison, personne ne la lira. Elle ne doit donc se lever que sur ce qui ne se
+ * reconstitue pas.
+ *
+ * ## Ce qui se reconstitue, et qui n'est donc PAS ici
+ *
+ * - une `session` se refait par un login ;
+ * - un `access_token` (jeton personnel, jeton de rafraîchissement) se réémet de
+ *   la même façon, et il est de toute façon révocable et daté ;
+ * - un `audit_event` est une trace, un `idempotency_key` un cache.
+ *
+ * Une **passkey**, non : elle est liée à la puce de l'appareil, et personne ne
+ * peut la réémettre à la place de son porteur. Un **second facteur** non plus :
+ * il faut re-scanner un code. Un **compte**, cela dépend — voir ci-dessous.
+ *
+ * ## Le seuil : ce qu'un semis d'application repose tout seul
+ *
+ * Une application générée sème son compte d'administration à chaque démarrage
+ * (`nodefony/security/provisionUsers.ts`). Ce compte-là n'est pas perdu quand on
+ * vide la base : il revient au prochain boot. Compter `User` dès la première
+ * ligne ferait donc crier la garde sur TOUTE application fraîche — exactement le
+ * cas normal qu'il ne faut pas gêner. Au-delà, en revanche, quelqu'un a
+ * travaillé : un compte créé à la main n'a aucune source qui le repose.
+ *
+ * Vécu, et c'est la mesure qui fixe le seuil : l'accident a emporté **trois**
+ * comptes, dont deux créés à la main.
+ *
+ * ## Pourquoi une liste écrite ici
+ *
+ * Le cœur tient déjà la table des entités du framework
+ * (`cli/scaffold/reservedEntities.ts`), mais elle n'est pas publiée par le
+ * paquet `nodefony` et elle répond à une autre question — « ce nom est-il
+ * libre ? », pas « cette table porte-t-elle de l'irremplaçable ? ». La frontière
+ * de paquets rend la copie inévitable ; elle n'est pas laissée à la bonne
+ * volonté : `identityTables.test.ts` confronte chaque nom à celui du cœur, et
+ * tombe si l'un disparaît ou change d'orthographe.
+ *
+ * ⚠️ `User` appartient à l'APPLICATION (le cœur le marque `appOwned`) : c'est
+ * elle qui en porte le schéma et les migrations. Son nom est néanmoins celui que
+ * le framework lit partout, donc celui qu'on retrouve en base.
+ */
+/** Une table d'identité : son nom en base, ce qu'elle porte, et son seuil. */
+export interface IIdentityTable {
+    /** Nom tel qu'il apparaît dans le catalogue de la base. */
+    readonly name: string;
+    /** Ce qui disparaît avec elle, dit à l'utilisateur. */
+    readonly holds: string;
+    /**
+     * Nombre de lignes qu'un semis d'application repose au prochain démarrage.
+     *
+     * En deçà ou à égalité, il n'y a rien à perdre et la garde se tait. `0` =
+     * aucune ligne ne se repose, la première compte.
+     */
+    readonly reseededRows: number;
+}
+export declare const IDENTITY_TABLES: readonly IIdentityTable[];
+/** Une table d'identité trouvée en base, avec son nom RÉEL et son seuil. */
+export interface IIdentityTableFound {
+    /** Nom tel qu'il est réellement écrit dans le catalogue. */
+    readonly table: string;
+    /** Ce qui disparaît avec elle. */
+    readonly holds: string;
+    /** Lignes qu'un semis repose (cf {@link IIdentityTable.reseededRows}). */
+    readonly reseededRows: number;
+}
+/**
+ * Les tables d'identité PRÉSENTES parmi celles qu'on s'apprête à supprimer.
+ *
+ * La comparaison ignore la casse : sqlite conserve `User` tel quel, d'autres
+ * moteurs replient en minuscules, et une garde sensible à la casse serait
+ * inopérante sur la moitié des dialectes — c'est-à-dire exactement là où l'on
+ * croirait être protégé.
+ *
+ * @param tables - noms lus dans le catalogue de la base.
+ * @returns les entrées d'identité correspondantes, avec le nom RÉEL de la table.
+ */
+export declare function identityTablesAmong(tables: readonly string[]): IIdentityTableFound[];
+/**
+ * Y a-t-il quelque chose à PERDRE dans cette table ?
+ *
+ * @param found - table d'identité présente en base.
+ * @param rows - nombre de lignes constaté.
+ * @returns `true` si la perte dépasse ce qu'un semis repose.
+ */
+export declare function rowsWorthKeeping(found: IIdentityTableFound, rows: number): boolean;

package/dist/types/nodefony/src/migrator/kit.d.ts

@@ -46,8 +46,9 @@ export declare function resolveDrizzleKitBin(from: string): string;
  *   relatif à `cwd`), `name` (nom imposé de la migration), `label` (ce qui est
  *   cité dans l'erreur).
  * @returns la sortie complète de l'outil (sortie standard puis sortie d'erreur).
- * @throws Error si le code est non nul, ou si rien ne prouve que la génération a
- *   eu lieu — l'absence de preuve n'est JAMAIS lue comme « rien à faire ».
+ * @throws MigrationToolError si le code est non nul, ou si rien ne prouve que la
+ *   génération a eu lieu — l'absence de preuve n'est JAMAIS lue comme « rien à
+ *   faire ». Le refus porte la sortie de l'outil, jamais une hypothèse.
  */
 export declare function runGenerate({ cwd, configRel, name, label, regenerateCommand, }: {
     cwd: string;
@@ -75,7 +76,7 @@ export declare function runGenerate({ cwd, configRel, name, label, regenerateCom
  *   (configuration, chemin relatif à `cwd`), `label` (ce qui est cité en cas
  *   d'échec).
  * @returns la sortie complète de l'outil.
- * @throws Error si le code est non nul.
+ * @throws MigrationToolError si le code est non nul.
  */
 export declare function runIntrospect({ cwd, configRel, label, }: {
     cwd: string;

package/dist/types/nodefony/src/migrator/rebuildCopy.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Répare la recopie d'une recréation de table SQLite.
+ *
+ * 🔴 Le défaut que ce module ferme, mesuré sur deux applications fraîches :
+ * quand une migration doit à la fois MODIFIER une colonne et en AJOUTER une,
+ * SQLite ne sait pas altérer sur place — l'outil de génération produit alors la
+ * ronde connue (créer `__new_x`, y recopier les lignes de `x`, supprimer `x`,
+ * renommer). Sa recopie liste les colonnes de la table d'ARRIVÉE, la colonne
+ * neuve comprise, et va donc la LIRE dans la table de départ, où elle n'existe
+ * pas encore. La migration échoue sur `no such column` et laisse un marqueur
+ * qui bloque tous les passages suivants — l'utilisateur se retrouve devant
+ * trois commandes qui refusent, et la seule issue apparente est de détruire la
+ * base.
+ *
+ * La réparation est déterministe et sans jugement : une colonne que la table de
+ * départ ne porte pas ne peut pas être recopiée, donc elle sort des DEUX
+ * listes. Elle recevra ce que son `CREATE TABLE` lui donne — un défaut, ou
+ * `NULL`. C'est exactement ce qu'aurait fait un `ADD COLUMN`.
+ *
+ * ⚠️ On ne touche à RIEN dès qu'un élément de la recopie n'est pas une simple
+ * colonne citée — une expression, un appel de fonction, un alias — ni quand les
+ * colonnes de la table de départ sont inconnues. Réécrire ce qu'on n'a pas
+ * compris coûterait plus cher que le défaut qu'on répare.
+ */
+/** Ce que la réparation a changé, pour pouvoir le DIRE plutôt que le taire. */
+export interface IRebuildCopyRepair {
+    /** Le SQL, réparé si besoin ; identique à l'entrée sinon. */
+    readonly sql: string;
+    /** Les colonnes retirées de la recopie, en `table.colonne`. */
+    readonly dropped: readonly string[];
+}
+/**
+ * Retire de la recopie les colonnes que la table de départ ne porte pas.
+ *
+ * @param sql - le SQL de la migration, tel que l'outil vient de l'écrire.
+ * @param columnsOf - les colonnes d'une table AVANT cette migration ; `null`
+ *   quand on ne les connaît pas — auquel cas rien n'est touché, car on ne
+ *   réécrit jamais sur une supposition.
+ * @returns le SQL réparé et la liste de ce qui a été retiré.
+ */
+export declare function repairRebuildCopy(sql: string, columnsOf: (table: string) => readonly string[] | null): IRebuildCopyRepair;

package/dist/types/nodefony/src/migrator/refusals.d.ts

@@ -17,6 +17,8 @@ export type CommandFailureCode =
  | "NF_MIGRATE_UNAVAILABLE"
 /** Confirmation requise et non donnée. */
  | "NF_MIGRATE_CONFIRM_REQUIRED"
+/** La base porte des comptes : `--yes` ne suffit pas à les effacer. */
+ | "NF_MIGRATE_RESET_HAS_ACCOUNTS"
 /** Des migrations en attente SUPPRIMENT des données, hors développement. */
  | "NF_MIGRATE_DESTRUCTIVE"
 /** Adopter TOUT graverait une affirmation fausse : la base ne suit pas. */
@@ -33,6 +35,12 @@ export type CommandFailureCode =
  | "NF_GENERATE_DATABASE_BEHIND"
 /** L'outil qui ÉCRIT les migrations n'est pas installé. */
  | "NF_GENERATE_TOOL_MISSING"
+/** L'outil de génération pose une question, et il n'y a pas de terminal. */
+ | "NF_GENERATE_NEEDS_ANSWER"
+/** L'outil de génération s'est arrêté ; ce qu'il a dit est remonté tel quel. */
+ | "NF_GENERATE_TOOL_FAILED"
+/** La lecture du schéma d'une base existante a échoué. */
+ | "NF_INTROSPECT_FAILED"
 /** Le schéma initial serait écrit sur une base qui porte DÉJÀ ces tables. */
  | "NF_GENERATE_DATABASE_NOT_ADOPTED"
 /** L'adoption par lecture de la base, demandée alors qu'il existe déjà des migrations. */
@@ -124,6 +132,59 @@ export interface IResolutionRefusal {
  * @returns le refus, avec le geste qui répare.
  */
 export declare function generationToolMissing(): IResolutionRefusal;
+/**
+ * Sortie d'un outil tiers, prête à être citée dans une explication.
+ *
+ * Elle est indentée pour se distinguer de la prose qui l'entoure, et BORNÉE par
+ * la fin : une pile d'appels se termine par ce qui a cassé, jamais par ce qui a
+ * démarré. La troncature s'ANNONCE — une sortie coupée en silence fait chercher
+ * une cause dans la moitié qu'on n'a pas montrée.
+ *
+ * @param output - sortie complète de l'outil (standard puis erreur).
+ * @param maxLines - nombre de lignes conservées, depuis la fin.
+ * @returns le bloc cité, ou une phrase disant qu'il n'y avait rien.
+ */
+export declare function formatToolOutput(output: string, maxLines?: number): string;
+/**
+ * L'outil de génération pose une QUESTION, et aucun terminal n'y répond.
+ *
+ * C'est le cas d'une colonne qui disparaît pendant qu'une autre apparaît :
+ * renommage (les données suivent) ou suppression puis ajout (les données sont
+ * perdues) — l'outil ne peut pas le deviner, et il a raison de demander.
+ *
+ * @param label - ce qui était généré, tel qu'on le cite à l'utilisateur.
+ * @param replay - la commande à rejouer dans un terminal interactif.
+ * @returns le refus, prêt pour la ligne de commande comme pour l'écran.
+ */
+export declare function generationNeedsAnswer(label: string, replay: string): IResolutionRefusal;
+/**
+ * L'outil de génération s'est arrêté, et ce qu'il a dit est remonté TEL QUEL.
+ *
+ * 🔴 Ne JAMAIS remplacer sa sortie par une hypothèse. Le fourre-tout des
+ * commandes de migration explique tout par une base injoignable ou des droits
+ * manquants : sur un schéma qui retire une colonne, les deux sont FAUX, et ils
+ * envoient vérifier une base qui répond très bien pendant que la cause est dans
+ * le fichier d'entité qu'on vient d'éditer. Un message d'erreur est cru PARCE
+ * QU'il est précis.
+ *
+ * @param label - ce qui était généré, tel qu'on le cite à l'utilisateur.
+ * @param status - code de sortie observé (il vaut `0` même en échec).
+ * @param output - sortie complète de l'outil.
+ * @returns le refus, prêt pour la ligne de commande comme pour l'écran.
+ */
+export declare function generationFailed(label: string, status: number | null, output: string): IResolutionRefusal;
+/**
+ * La lecture du schéma d'une base existante a échoué.
+ *
+ * Contrairement à la génération, celle-ci INTERROGE la base : une base muette
+ * ou des droits insuffisants sont ici des explications légitimes.
+ *
+ * @param label - ce qui était lu, tel qu'on le cite à l'utilisateur.
+ * @param status - code de sortie observé.
+ * @param output - sortie complète de l'outil.
+ * @returns le refus, prêt pour la ligne de commande comme pour l'écran.
+ */
+export declare function introspectFailed(label: string, status: number | null, output: string): IResolutionRefusal;
 /**
  * Erreur portant un {@link IResolutionRefusal} déjà composé.
  *

package/docs/migrations.md

@@ -106,6 +106,9 @@ nodefony orm:migrate:repair
 
 # Développement seulement : supprime et recrée la base du connecteur.
 nodefony orm:reset
+
+# … et si la base porte des comptes, des passkeys ou des seconds facteurs :
+nodefony orm:reset --yes --drop-accounts
 ```
 
 Toutes acceptent `--connector <nom>` (défaut : `default`) et `--json`. Le flux `--json` est **pur** :
@@ -508,6 +511,23 @@ conforme, la clé est ABSENTE** (jamais un objet vide) : `.divergence == null` s
 L'écran lisible en dit autant : le résumé nomme les trois premières entrées de chaque famille, et la
 liste complète ne se déroule que lorsqu'elle ne tient plus dans la phrase.
 
+### Ce que `--yes` ne suffit pas à effacer
+
+`orm:reset` **refuse** sur une base qui porte de l'irremplaçable, et nomme ce qu'elle allait
+supprimer avec le nombre de lignes : des comptes au-delà de celui que votre semis repose, des
+passkeys (liées à l'appareil — personne ne peut les réémettre), des seconds facteurs. Il faut alors
+`--drop-accounts` en plus de `--yes` : le drapeau dit que vous avez vu la liste.
+
+Ce qui se reconstitue ne déclenche rien — une session et un jeton se refont par un login, une trace
+d'audit est une trace. Et **une application fraîche n'est pas gênée** : le compte d'administration
+que son semis repose à chaque démarrage ne compte pas comme une perte. Une garde qui se lève sur le
+cas normal s'apprend à être contournée avant le jour où elle a raison.
+
+Quand une migration a échoué et que son marqueur est posé, le refus nomme d'abord
+`orm:migrate:repair` — qui lève le marqueur **sans rien effacer**. C'est le seul moment où l'on sait
+que la voie non destructrice s'applique, et c'est exactement la situation où l'on est tenté de tout
+remettre à zéro.
+
 Les gestes proposés suivent **l'environnement** : `orm:reset` efface, elle n'est acceptée qu'en
 développement, et elle n'est donc proposée que là. Ailleurs, la sortie renvoie vers l'écriture d'une
 migration correctrice (`orm:generate --custom`) puis son application.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodefony/drizzle",
-  "version": "10.0.0-alpha.5",
+  "version": "10.0.0-alpha.6",
   "description": "Moteur SQL de Nodefony sur Drizzle ORM (SQLite, PostgreSQL, MySQL) : dépôts typés, migrations de schéma et adoption d'une base existante",
   "nodefony": {
     "storeKind": "durable",
@@ -60,30 +60,30 @@
     "zod": "^4.6.1"
   },
   "devDependencies": {
-    "@nodefony/framework": "^10.0.0-alpha.5",
-    "@nodefony/http": "^10.0.0-alpha.5",
-    "@nodefony/orm-core": "^10.0.0-alpha.5",
-    "@nodefony/security": "^10.0.0-alpha.5",
-    "@nodefony/user": "^10.0.0-alpha.5",
+    "@nodefony/framework": "^10.0.0-alpha.6",
+    "@nodefony/http": "^10.0.0-alpha.6",
+    "@nodefony/orm-core": "^10.0.0-alpha.6",
+    "@nodefony/security": "^10.0.0-alpha.6",
+    "@nodefony/user": "^10.0.0-alpha.6",
     "@types/better-sqlite3": "9.6.0",
     "@types/node": "26.5.1",
     "@types/pg": "8.23.1",
     "better-sqlite3": "13.0.3",
     "drizzle-kit": "0.31.10",
     "mysql2": "3.24.4",
-    "nodefony": "^10.0.0-alpha.5",
+    "nodefony": "^10.0.0-alpha.6",
     "pg": "8.23.0",
     "rimraf": "6.1.3"
   },
   "peerDependencies": {
-    "@nodefony/framework": "^10.0.0-alpha.5",
-    "@nodefony/http": "^10.0.0-alpha.5",
-    "@nodefony/orm-core": "^10.0.0-alpha.5",
-    "@nodefony/security": "^10.0.0-alpha.5",
-    "@nodefony/user": "^10.0.0-alpha.5",
+    "@nodefony/framework": "^10.0.0-alpha.6",
+    "@nodefony/http": "^10.0.0-alpha.6",
+    "@nodefony/orm-core": "^10.0.0-alpha.6",
+    "@nodefony/security": "^10.0.0-alpha.6",
+    "@nodefony/user": "^10.0.0-alpha.6",
     "better-sqlite3": "^13.0.0",
     "mysql2": "^3.24.0",
-    "nodefony": "^10.0.0-alpha.5",
+    "nodefony": "^10.0.0-alpha.6",
     "pg": "^8.23.0"
   },
   "repository": {