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

package/README.md

@@ -11,7 +11,7 @@ Adapter [Drizzle ORM](https://orm.drizzle.team/) pour Nodefony, branché sur
 ## Installation
 
 ```bash
-npm install @nodefony/drizzle drizzle-orm better-sqlite3
+npm install @nodefony/drizzle@alpha drizzle-orm better-sqlite3
 ```
 
 ## Utilisation comme module Nodefony (bootable)

package/dist/_virtual/{_@oxc-project_runtime@0.149.0 → _@oxc-project_runtime@0.150.0}/helpers/esm/decorate.js

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.149.0/helpers/esm/decorate.js
+//#region \0@oxc-project+runtime@0.150.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);

package/dist/_virtual/{_@oxc-project_runtime@0.149.0 → _@oxc-project_runtime@0.150.0}/helpers/esm/decorateMetadata.js

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.149.0/helpers/esm/decorateMetadata.js
+//#region \0@oxc-project+runtime@0.150.0/helpers/esm/decorateMetadata.js
 function __decorateMetadata(k, v) {
 	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }

package/dist/index.js

@@ -13,6 +13,7 @@ import { appMigrationsDir, buildMigrator, knownConnectors, readMigrationEnv, res
 import { DrizzleRepository } from "./nodefony/src/orm-core/DrizzleRepository.js";
 import { DrizzleTransaction } from "./nodefony/src/orm-core/DrizzleTransaction.js";
 import { DrizzleOrm } from "./nodefony/src/orm-core/DrizzleOrm.js";
+import { seedEntityRow } from "./nodefony/src/orm-core/seedRow.js";
 import "./nodefony/src/orm-core/index.js";
 import DrizzleService from "./nodefony/service/DrizzleService.js";
 import { TOKEN_ENTITY_NAMES, accessTokenTable, createAccessTokenTable, createDeniedJtiTable, createSubjectRevocationTable, createTokenEntities, deniedJtiTable, registerTokenEntities, subjectRevocationTable } from "./nodefony/entity/tokenEntity.js";
@@ -36,8 +37,8 @@ import OrmMigrateStatus from "./nodefony/command/orm-migrate-status.js";
 import OrmMigrateBaseline from "./nodefony/command/orm-migrate-baseline.js";
 import OrmMigrateRepair from "./nodefony/command/orm-migrate-repair.js";
 import OrmReset from "./nodefony/command/orm-reset.js";
-import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.149.0/helpers/esm/decorateMetadata.js";
-import __decorate from "./_virtual/_@oxc-project_runtime@0.149.0/helpers/esm/decorate.js";
+import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.150.0/helpers/esm/decorateMetadata.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.150.0/helpers/esm/decorate.js";
 import SessionStorage from "./nodefony/src/SessionStorage.js";
 import "./nodefony/src/migrator/index.js";
 import { DrizzleUserRepository } from "./nodefony/src/DrizzleUserRepository.js";
@@ -102,4 +103,4 @@ let Drizzle = class Drizzle extends Module {
 Drizzle = __decorate([services([DrizzleService]), __decorateMetadata("design:paramtypes", [typeof Kernel === "undefined" ? Object : Kernel])], Drizzle);
 var drizzle_default = Drizzle;
 //#endregion
-export { APP_RANK, APP_SOURCE, AUDIT_ENTITY_NAMES, DDL_MODES, DEFAULT_LOCK_TIMEOUT_MS, DIVERGENCE_MODES, DrizzleAuditStore, DrizzleIdempotencyStore, DrizzleMigrator, DrizzleOrm, DrizzleRepository, DrizzleService, DrizzleTokenStore, DrizzleTotpSecretStore, DrizzleTransaction, DrizzleUserRepository, DrizzleWebAuthnCredentialStore, DrizzleWebhookStore, EXIT, FORMAT_MARKER, FRAMEWORK_CONNECTOR, FRAMEWORK_RANK, FRAMEWORK_SOURCE, HISTORY_TABLE, IDEMPOTENCY_ENTITY_NAME, MIGRATE_URL_ENV, MIGRATION_CHECK_MODES, MIGRATION_FORMAT_VERSION, MYSQL_LOCK_NAME_SQL, MigrationVerdictError, PG_LOCK_KEY, SESSION_CONNECTOR, SESSION_ENTITY_NAME, SessionStorage, TOKEN_ENTITY_NAMES, TOTP_SECRET_ENTITY, WEBAUTHN_CREDENTIAL_ENTITY, WEBHOOK_ENDPOINT_ENTITY, accessTokenTable, action, appMigrationsDir, auditEventTable, buildMigrator, buildReport, createAccessTokenTable, createAuditEntities, createAuditEventTable, createDeniedJtiTable, createIdempotencyEntities, createIdempotencyTable, createSessionEntity, createSessionTable, createSubjectRevocationTable, createTokenEntities, createTotpSecretEntity, createTotpSecretTable, createUserEntity, createUserTable, createWebAuthnCredentialEntity, createWebAuthnCredentialTable, createWebhookEndpointEntity, createWebhookEndpointTable, drizzle_default as default, defaultMigrationSources, defineDrizzleConfig, deniedJtiTable, drizzleConfigJsonSchema, drizzleConfigSchema, exitCodeOf, frameworkMigrationsDir, idempotencyKeyTable, isFrameworkFallbackEntity, knownConnectors, loadSources, meaningOf, migrationHash, openMigrationDriver, orderSources, readMigrationEnv, registerAuditEntities, registerDrizzleFrameworkStores, registerIdempotencyEntities, registerSessionEntity, registerTokenEntities, registerTotpSecretEntity, registerUserEntity, registerWebAuthnCredentialEntity, registerWebhookEndpointEntity, renderRefusal, renderStatus, resetAllowed, resolveCheckMode, resolveConnector, resolveDdlMode, resolveDivergenceMode, sessionTable, styleFor, subjectRevocationTable, totpSecretTable, userTable, verdictOf, webAuthnCredentialTable, webhookEndpointTable };
+export { APP_RANK, APP_SOURCE, AUDIT_ENTITY_NAMES, DDL_MODES, DEFAULT_LOCK_TIMEOUT_MS, DIVERGENCE_MODES, DrizzleAuditStore, DrizzleIdempotencyStore, DrizzleMigrator, DrizzleOrm, DrizzleRepository, DrizzleService, DrizzleTokenStore, DrizzleTotpSecretStore, DrizzleTransaction, DrizzleUserRepository, DrizzleWebAuthnCredentialStore, DrizzleWebhookStore, EXIT, FORMAT_MARKER, FRAMEWORK_CONNECTOR, FRAMEWORK_RANK, FRAMEWORK_SOURCE, HISTORY_TABLE, IDEMPOTENCY_ENTITY_NAME, MIGRATE_URL_ENV, MIGRATION_CHECK_MODES, MIGRATION_FORMAT_VERSION, MYSQL_LOCK_NAME_SQL, MigrationVerdictError, PG_LOCK_KEY, SESSION_CONNECTOR, SESSION_ENTITY_NAME, SessionStorage, TOKEN_ENTITY_NAMES, TOTP_SECRET_ENTITY, WEBAUTHN_CREDENTIAL_ENTITY, WEBHOOK_ENDPOINT_ENTITY, accessTokenTable, action, appMigrationsDir, auditEventTable, buildMigrator, buildReport, createAccessTokenTable, createAuditEntities, createAuditEventTable, createDeniedJtiTable, createIdempotencyEntities, createIdempotencyTable, createSessionEntity, createSessionTable, createSubjectRevocationTable, createTokenEntities, createTotpSecretEntity, createTotpSecretTable, createUserEntity, createUserTable, createWebAuthnCredentialEntity, createWebAuthnCredentialTable, createWebhookEndpointEntity, createWebhookEndpointTable, drizzle_default as default, defaultMigrationSources, defineDrizzleConfig, deniedJtiTable, drizzleConfigJsonSchema, drizzleConfigSchema, exitCodeOf, frameworkMigrationsDir, idempotencyKeyTable, isFrameworkFallbackEntity, knownConnectors, loadSources, meaningOf, migrationHash, openMigrationDriver, orderSources, readMigrationEnv, registerAuditEntities, registerDrizzleFrameworkStores, registerIdempotencyEntities, registerSessionEntity, registerTokenEntities, registerTotpSecretEntity, registerUserEntity, registerWebAuthnCredentialEntity, registerWebhookEndpointEntity, renderRefusal, renderStatus, resetAllowed, resolveCheckMode, resolveConnector, resolveDdlMode, resolveDivergenceMode, seedEntityRow, sessionTable, styleFor, subjectRevocationTable, totpSecretTable, userTable, verdictOf, webAuthnCredentialTable, webhookEndpointTable };

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

@@ -3,7 +3,7 @@ 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 { appMigrationsDir, generateApplyAllowed, readMigrationEnv } 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";
@@ -62,6 +62,17 @@ const options = {
 * nodefony orm:migrate        # ou : le travail de déploiement
 * ```
 *
+* @example En développement — écrire ET appliquer en un seul geste
+* ```bash
+* nodefony orm:generate --name ajout_du_titre --apply
+* ```
+* `--apply` n'est rien d'autre qu'un `orm:migrate` enchaîné : la commande
+* DÉLÈGUE, elle ne rejoue pas l'application pour son compte. Toutes les gardes
+* du verbe d'application valent donc à l'identique — refus du destructif sans
+* `--allow-destructive`, verrou, historique. Refusé hors développement : un
+* déploiement n'écrit pas ses migrations au moment de les appliquer, il
+* applique celles que la revue de code a validées.
+*
 * @example Ce que le modèle déclaratif ne peut pas déduire
 * ```bash
 * nodefony orm:generate --custom --name vue_des_ventes
@@ -75,6 +86,7 @@ var OrmGenerate = class extends OrmMigrateCommand {
 		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");
+		this.addOption("--apply", "applique la migration dans la foulée (développement seulement) — écrire puis appliquer en un seul geste");
 	}
 	/**
 	* Racine de l'application — c'est depuis là que l'outil est lancé.
@@ -118,7 +130,7 @@ var OrmGenerate = class extends OrmMigrateCommand {
 					dialect: resolution.dialect,
 					name
 				});
-				return this.#emit({
+				return await this.#emit({
 					formatVersion: 1,
 					connector,
 					generated: true,
@@ -230,7 +242,7 @@ var OrmGenerate = class extends OrmMigrateCommand {
 				], opts.json, EXIT.actionRequired);
 				return this;
 			}
-			return this.#emit({
+			return await this.#emit({
 				formatVersion: 1,
 				connector,
 				generated: false,
@@ -273,7 +285,7 @@ var OrmGenerate = class extends OrmMigrateCommand {
 			], opts.json, EXIT.actionRequired, discovery);
 			return this;
 		}
-		return this.#emit({
+		return await this.#emit({
 			formatVersion: 1,
 			connector,
 			generated: true,
@@ -384,17 +396,69 @@ var OrmGenerate = class extends OrmMigrateCommand {
 	*
 	* @returns `this`.
 	*/
-	#emit(report, opts, headline) {
+	/**
+	* Écrit le compte rendu de génération, puis enchaîne l'application si
+	* `--apply` est posé.
+	*
+	* 🔴 **En sortie machine, `--apply` ne produit qu'UN document** : celui de
+	* l'application, qui porte le verdict final. Le compte rendu de génération
+	* part alors sur la sortie d'ERREUR — libre par contrat — plutôt que d'écrire
+	* deux objets à la suite sur la sortie standard, ce qui casserait tout `| jq`
+	* sans qu'aucune erreur ne le dise.
+	*
+	* @param report - le rapport de génération.
+	* @param opts - options reçues.
+	* @param headline - la première ligne, déjà rédigée par l'appelant.
+	* @returns `this`, la sortie ayant été écrite.
+	*/
+	async #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`;
+		if (report.generated && opts.apply !== true) human += `\n${style.bold("À faire :")}\n  ${style.dim("relire le fichier, puis")} ${style.green("nodefony orm:migrate")}\n  ${style.dim("ou, en développement, les deux d'un geste :")} ${style.green("nodefony orm:generate --apply")}\n`;
+		if (report.generated && opts.apply === true) {
+			if (opts.json === true) process.stderr.write(human.endsWith("\n") ? human : `${human}\n`);
+			else process.stdout.write(human.endsWith("\n") ? human : `${human}\n`);
+			await this.#applyNow(opts, report.connector);
+			return this;
+		}
 		this.respond(report, human, EXIT.ok, opts.json);
 		return this;
 	}
+	/**
+	* Enchaîne l'application quand `--apply` est posé.
+	*
+	* DÉLÈGUE au verbe `orm:migrate` par son point d'entrée public
+	* ({@link Cli.getCommand}) : rejouer ici l'application aurait produit une
+	* SECONDE implémentation du même geste, qui aurait divergé de la première au
+	* premier réglage — et c'est précisément elle qui porte le refus du
+	* destructif, le verrou et l'écriture de l'historique.
+	*
+	* Refusé hors développement, sans drapeau pour le lever : générer puis
+	* appliquer dans le même souffle suppose qu'on relit le SQL entre les deux,
+	* ce que personne ne fait sur un serveur. En production, la migration a été
+	* écrite, relue et versionnée ailleurs ; `orm:migrate` l'applique.
+	*
+	* @param opts - options reçues, passées telles quelles au verbe d'application.
+	* @param connector - connecteur résolu, pour le message de refus.
+	* @returns `true` si la main a été passée (la sortie est déjà écrite).
+	*/
+	async #applyNow(opts, connector) {
+		if (!generateApplyAllowed(readMigrationEnv(this.kernel))) {
+			this.fail(connector, "NF_MIGRATE_NOT_DEVELOPMENT", "« --apply » n'existe qu'en développement.", "Écrire une migration et l'appliquer dans le même geste suppose qu'on relit le SQL produit entre les deux — ce que personne ne fait sur un serveur. Hors développement, la migration a été écrite, relue et versionnée ailleurs : c'est « orm:migrate » qui l'applique, et lui seul.", [action("nodefony orm:migrate")], opts.json, EXIT.actionRequired);
+			return true;
+		}
+		const migrate = (this.kernel?.getModule("drizzle"))?.commands?.["orm:migrate"];
+		if (!migrate) {
+			this.fail(connector, "NF_MIGRATE_UNAVAILABLE", "Le verbe « orm:migrate » est introuvable : la migration a été ÉCRITE mais n'a pas été appliquée.", "« --apply » ne fait qu'enchaîner ce verbe ; sans lui, il n'y a rien à enchaîner.", [action("nodefony orm:migrate")], opts.json);
+			return true;
+		}
+		await migrate.generate(opts);
+		return true;
+	}
 };
 //#endregion
 export { OrmGenerate as default };

package/dist/nodefony/service/DrizzleService.js

@@ -2,7 +2,7 @@ import { buildReport, isAheadOnly, meaningOf } from "../src/migrator/explain.js"
 import { defaultConnectorFilename } from "../src/connectorTarget.js";
 import { defaultMigrationSources } from "../src/migrator/paths.js";
 import { DrizzleMigrator } from "../src/migrator/DrizzleMigrator.js";
-import { appMigrationsDir, readMigrationEnv, resetAllowed, resolveCheckMode, resolveDdlMode } from "../src/migrator/resolve.js";
+import { appMigrationsDir, appVersionsMigrations, readMigrationEnv, resetAllowed, resolveCheckMode, resolveDdlMode } from "../src/migrator/resolve.js";
 import { describeDivergence } from "../src/migrator/divergence.js";
 import { DrizzleOrm } from "../src/orm-core/DrizzleOrm.js";
 import "../src/orm-core/index.js";
@@ -122,7 +122,7 @@ var DrizzleService = class extends Service {
 	/** Connecte un connecteur (crée le dossier de la base SQLite si nécessaire). */
 	async #connectOne(name, cfg, connect = true) {
 		const dialect = cfg.dialect ?? "sqlite";
-		const ddl = resolveDdlMode(cfg.ddl, readMigrationEnv(this.kernel));
+		const ddl = resolveDdlMode(cfg.ddl, readMigrationEnv(this.kernel), appVersionsMigrations(appMigrationsDir(this.kernel, this.#config().migrations?.dir ?? "migrations")));
 		let filename;
 		if (dialect === "sqlite") {
 			filename = cfg.filename ?? this.#defaultFilename(name);

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

@@ -1,4 +1,5 @@
 import { MIGRATE_URL_ENV, MigrationLockTimeoutError, MigrationVerdictError } from "./types.js";
+import { alreadyInTargetState } from "./explain.js";
 import { openMigrationDriver } from "./drivers/index.js";
 import { deleteFailed, ensureHistorySchema, finishHistory, forgetEntries, insertHistory, readHistory } from "./history.js";
 import "./paths.js";
@@ -51,6 +52,21 @@ const ERROR_MAX_LENGTH = 2e3;
 * celle qu'il trouve seul est de recréer la base, ce qui emporte les données.
 */
 const REPRISE_SANS_DESTRUCTION = "REPRENDRE ne demande PAS de recréer la base. Deux voies, selon ce qui a échoué : corriger le fichier de migration puis lever le marqueur (« orm:migrate:repair ») et reprendre — un fichier corrigé après un échec est rejoué tel quel, son empreinte n'est pas comparée ; ou, si la mise au point demande plusieurs essais, la faire sur une base d'essai en posant « " + MIGRATE_URL_ENV + " », qui détourne la commande vers une AUTRE base et laisse celle-ci intacte — sous PowerShell, poser la variable s'écrit « $env:" + MIGRATE_URL_ENV + " = \"…\" », « env » n'y existant pas. Écrire la migration suivante est toujours préférable à défaire ce qui est déjà appliqué.";
+/**
+* La troisième voie de reprise — celle qu'aucun message ne nommait.
+*
+* Les deux voies écrites jusqu'ici (corriger le fichier, ou travailler sur une
+* base d'essai) supposent toutes deux que le fichier a tort. Quand le moteur
+* répond « c'est déjà ainsi », ni l'une ni l'autre ne mène quelque part : le
+* SQL est juste, la base est conforme, et rejouer redira la même chose. Sans
+* cette phrase, la boucle `repair` → `migrate` → même refus n'a pas de sortie
+* — et la seule qu'un agent trouve seul est de recréer la base.
+*
+* @param source - source de la migration (`app` ou `framework`).
+* @param tag - identité de la migration en échec.
+* @returns le paragraphe à insérer dans le verdict.
+*/
+const alreadyInTargetStateAdvice = (source, tag) => `Ce que dit ce message, c'est que la base est DÉJÀ dans l'état que cette migration vise : l'objet qu'elle crée existe, ou celui qu'elle retire n'a jamais existé sous ce nom. Corriger le fichier ne servira donc à rien, et le rejouer redira la même chose — c'est la boucle dans laquelle on tourne si on s'obstine. VÉRIFIE d'abord l'état réel (« nodefony inspect entities --json », ou le schéma de la table concernée) ; s'il correspond bien à ce que « ${source}/${tag} » voulait obtenir, la migration est SANS OBJET sur cette base : déclare-la appliquée plutôt que de la rejouer, avec « nodefony orm:migrate:baseline --up-to ${tag} ». Une cause courante en développement : la table a été créée par le schéma DÉRIVÉ du démarrage, qui pose les contraintes sans les nommer, là où une migration les nomme.`;
 var DrizzleMigrator = class {
 	#options;
 	#now;
@@ -592,7 +608,7 @@ var DrizzleMigrator = class {
 			tag: file.tag,
 			facts: { error: truncate(cause.message) },
 			actions: this.#recoveryActions()
-		}, `La migration « ${file.tag} » (source « ${file.source} ») a échoué : ${truncate(cause.message)}\n\n${state}\n\nSon échec est INSCRIT : le prochain passage refusera de reprendre tant que le marqueur n'aura pas été levé, après inspection.\n\n${REPRISE_SANS_DESTRUCTION}`);
+		}, `La migration « ${file.tag} » (source « ${file.source} ») a échoué : ${truncate(cause.message)}\n\n${state}\n\nSon échec est INSCRIT : le prochain passage refusera de reprendre tant que le marqueur n'aura pas été levé, après inspection.\n\n` + (alreadyInTargetState(cause.message) ? `${alreadyInTargetStateAdvice(file.source, file.tag)}\n\n` : "") + REPRISE_SANS_DESTRUCTION);
 	}
 	/**
 	* Les gestes qui sortent d'une migration en échec — **sans toucher à la base**.

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

@@ -64,23 +64,82 @@ const PATTERNS = [
 	}
 ];
 /**
-* Reconnaît la recréation de table de SQLite, et l'exclut de la perte de données.
-*
-* SQLite ne sait pas modifier une colonne : l'outil de génération produit alors
-* la ronde connue — créer `__new_x`, y recopier les lignes de `x`, supprimer
-* `x`, renommer. Ce `DROP TABLE` est **structurel**, les données ont été
-* recopiées juste avant ; le signaler comme une perte ferait crier au loup à
-* chaque changement de colonne, et le garde serait désarmé au bout de trois
-* fois.
-*
-* ⚠️ Ce n'est pas une garantie que rien n'est perdu : si une colonne
-* n'apparaît pas dans le `INSERT … SELECT`, ses données disparaissent bel et
-* bien. C'est pourquoi la recréation reste SIGNALÉE, avec le geste — lire le
-* SQL —, et seulement déclassée en avertissement.
+* Le SQL d'une migration, qu'on le reçoive découpé ou d'un bloc.
+*
+* Les deux formes existent pour de bon : l'audit d'APPLICATION travaille sur
+* les instructions déjà séparées, celui de GÉNÉRATION sur le fichier entier.
 */
-function isTableRebuild(statements) {
-	const joint = statements.join("\n");
-	return /\bCREATE\s+TABLE\s+[`"']?__new_/i.test(joint) && /\bINSERT\s+INTO\s+[`"']?__new_/i.test(joint);
+function asSql(sql) {
+	return typeof sql === "string" ? sql : sql.join("\n");
+}
+/** Un nom de table tel qu'il s'écrit en SQL, guillemets facultatifs. */
+const IDENT = "[`\"']?(\\w+)[`\"']?";
+/**
+* Les tables qu'une migration RECONSTRUIT, par la ronde que SQLite impose.
+*
+* 🔴 **La convention de nommage n'est PAS la règle.** La version précédente
+* cherchait le préfixe `__new_` que produit l'outil de génération : elle ne
+* reconnaissait donc une reconstruction que si c'est LUI qui l'avait écrite.
+* Une migration reprise à la main — cas courant, et mesuré sur un agent réel
+* qui avait nommé sa table d'étape `articles_new` — retombait sur
+* « supprime une table et TOUTES ses lignes », sur un SQL qui ne perd rien.
+*
+* Ce qui fait une reconstruction, c'est la RONDE, quels que soient les noms :
+* une table d'étape est créée, les lignes de la table visée y sont recopiées,
+* la visée est supprimée, et l'étape prend sa place. Les quatre doivent être
+* présentes dans le même fichier, et se RÉPONDRE — c'est le renommage final
+* qui dit quelle table d'étape appartient à quelle table visée.
+*
+* ⚠️ Ce n'est pas une garantie que rien n'est perdu : si une colonne n'apparaît
+* pas dans le `INSERT … SELECT`, ses données disparaissent bel et bien. La
+* reconstruction reste donc SIGNALÉE, avec le geste — lire le SQL —, et
+* seulement déclassée en avertissement.
+*
+* @param sql - les instructions de la migration, ou le fichier entier.
+* @returns les tables reconstruites, en minuscules ; vide s'il n'y en a aucune.
+*/
+function rebuiltTables(sql) {
+	const joint = asSql(sql);
+	const out = /* @__PURE__ */ new Set();
+	const renames = joint.matchAll(new RegExp(`\\bALTER\\s+TABLE\\s+${IDENT}\\s+RENAME\\s+TO\\s+${IDENT}`, "gi"));
+	for (const rename of renames) {
+		const staging = rename[1];
+		const target = rename[2];
+		if (staging === void 0 || target === void 0) continue;
+		const created = new RegExp(`\\bCREATE\\s+TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?[\`"']?${staging}[\`"']?\\b`, "i");
+		const copied = new RegExp(`\\bINSERT\\s+INTO\\s+[\`"']?${staging}[\`"']?[\\s\\S]{0,4000}?\\bFROM\\s+[\`"']?${target}[\`"']?\\b`, "i");
+		const dropped = new RegExp(`\\bDROP\\s+TABLE\\s+(?:IF\\s+EXISTS\\s+)?[\`"']?${target}[\`"']?\\b`, "i");
+		if (created.test(joint) && copied.test(joint) && dropped.test(joint)) out.add(target.toLowerCase());
+	}
+	return out;
+}
+/**
+* Les tables qu'un SQL SUPPRIME, dans l'ordre où il les nomme.
+*
+* Exportée pour que l'audit de génération et celui d'application lisent la
+* MÊME chose : deux extractions écrites séparément divergeraient, et l'une des
+* deux surfaces se mettrait à refuser ce que l'autre laisse passer.
+*
+* @param sql - les instructions de la migration, ou le fichier entier.
+* @returns les noms supprimés, en minuscules.
+*/
+function droppedTables(sql) {
+	return [...asSql(sql).matchAll(new RegExp(`\\bDROP\\s+TABLE\\s+(?:IF\\s+EXISTS\\s+)?${IDENT}`, "gi"))].map((m) => m[1]).filter((n) => n !== void 0).map((n) => n.toLowerCase());
+}
+/**
+* L'instruction fait-elle partie de la mécanique d'une reconstruction ?
+*
+* Le verdict porte sur la table que CETTE instruction touche, jamais sur le
+* fichier entier : une migration qui reconstruit `articles` et supprime
+* `brouillons` doit continuer de signaler la seconde.
+*/
+function isRebuildMechanics(statement, kind, rebuilt) {
+	if (kind === "drop-table") return droppedTables(statement).some((name) => rebuilt.has(name));
+	if (kind === "rename") {
+		const target = new RegExp(`\\bRENAME\\s+TO\\s+${IDENT}`, "i").exec(statement)?.[1];
+		return target !== void 0 && rebuilt.has(target.toLowerCase());
+	}
+	return false;
 }
 /** Borne une instruction pour l'affichage, sans jamais la déformer. */
 function truncate(statement) {
@@ -96,10 +155,10 @@ function truncate(statement) {
 function scanDestructive(files) {
 	const out = [];
 	for (const file of files) {
-		const rebuild = isTableRebuild(file.statements);
+		const rebuilt = rebuiltTables(file.statements);
 		for (const statement of file.statements) for (const p of PATTERNS) {
 			if (!p.re.test(statement)) continue;
-			const structurel = rebuild && (p.kind === "drop-table" || p.kind === "rename");
+			const structurel = isRebuildMechanics(statement, p.kind, rebuilt);
 			out.push({
 				source: file.source,
 				tag: file.tag,
@@ -210,4 +269,4 @@ function checkDataAdvice(connector, target) {
 	return `Ces migrations ont modifié des tables qui portaient déjà des lignes. Pour VÉRIFIER que les données ont suivi, ne repars pas d'une base vide : ce sont ces lignes-là qui sont la réponse, les effacer efface la question. Deux moyens. Compter et regarder sur place — « SELECT COUNT(*) » sur les tables touchées, et les valeurs des colonnes nouvellement remplies. Ou rejouer le même lot sur une COPIE, sans toucher à celle-ci : ${copy}, puis désigne-la par NF_MIGRATE_DATABASE_URL :\n  NF_MIGRATE_DATABASE_URL=${url} nodefony orm:migrate${suffixe}\n  (PowerShell : $env:NF_MIGRATE_DATABASE_URL = "${url}" ; nodefony orm:migrate${suffixe})`;
 }
 //#endregion
-export { checkDataAdvice, dataLoss, destructiveActions, renderDestructive, scanDestructive, summarizeDestructive, touchesExistingRows };
+export { checkDataAdvice, dataLoss, destructiveActions, droppedTables, rebuiltTables, renderDestructive, scanDestructive, summarizeDestructive, touchesExistingRows };

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

@@ -450,6 +450,8 @@ function renderStatus(report, style) {
 	if (report.sources.length === 0) out += `  ${style.dim("aucune source de migrations")}\n`;
 	if (report.divergence && !namesEverything(report.divergence)) out += renderDivergence(report.divergence, style);
 	out += `\n${renderBlocks(style, report.summary, meaningOf(report.verdict), report.nextActions)}`;
+	if (report.exitCode === EXIT.actionRequired) out += `\n${style.dim("code de sortie 1 — une action est requise, ce n'est pas un échec.")}\n`;
+	else if (report.exitCode === EXIT.error) out += `\n${style.dim("code de sortie 2 — la commande n'a pas pu travailler.")}\n`;
 	return out;
 }
 /** Combien d'écarts on déroule à l'écran avant de renvoyer au `--json`. */
@@ -561,5 +563,44 @@ const REFUSAL_MEANING = {
 	NF_MIGRATE_JOURNAL_MISMATCH: "Le journal d'une source annonce une migration dont le fichier n'est pas dans le dossier. La source est incohérente avec elle-même : une copie incomplète, un fichier ignoré par le gestionnaire de versions, ou un paquet publié sans ses migrations. Rien n'a été appliqué — l'applicateur ne devine jamais le contenu d'un fichier absent.",
 	NF_MIGRATE_UNKNOWN_SOURCE: "La source demandée n'est pas déclarée par cette application. Filtrer sur un nom inconnu ne touche aucune ligne et rend pourtant « rien à réparer » : le marqueur d'échec resterait en place, et la migration suivante échouerait pour la même raison."
 };
+/**
+* Les moteurs, chacun dans sa langue, disant « c'est DÉJÀ ainsi ».
+*
+* Reconnaître ce cas change le conseil du tout au tout : la migration n'a pas
+* échoué parce que la base est cassée, mais parce qu'elle est **déjà dans
+* l'état visé**. Le geste n'est alors ni de corriger le SQL ni de recréer la
+* base — c'est de déclarer la migration appliquée.
+*/
+const ALREADY_IN_TARGET_STATE = [
+	/\bno such (index|column|table|trigger|view)\b/iu,
+	/\b(table|index|trigger|view)\b.*\balready exists\b/iu,
+	/\bduplicate column name\b/iu,
+	/\balready exists\b/iu,
+	/\bdoes not exist\b/iu,
+	/\bduplicate key name\b/iu,
+	/\bcan't drop\b/iu,
+	/\bcheck that (column|it|the) .*exists\b/iu
+];
+/**
+* L'échec vient-il de ce que la base est DÉJÀ dans l'état que la migration vise ?
+*
+* Le cas est fréquent et sa sortie n'était nommée nulle part : le message de
+* reprise proposait de corriger le fichier ou de travailler sur une base
+* d'essai, deux voies qui ne mènent à rien quand le fichier est juste et la
+* base déjà conforme. Un agent placé devant ce refus tourne alors en rond
+* — `repair` lève le marqueur, `migrate` rejoue, le moteur redit la même
+* chose — puis finit par recréer la base, ce qui emporte les données.
+*
+* Constaté sur un agent tiers : un `DROP INDEX messages_content_unique` sur une
+* base dont l'unicité avait été posée INLINE par le DDL de démarrage, donc sans
+* index nommé. Trente-cinq minutes, deux bases détruites, la boucle brisée à la
+* main.
+*
+* @param message - le message d'erreur rendu par le moteur.
+* @returns `true` si l'échec dit « c'est déjà ainsi ».
+*/
+function alreadyInTargetState(message) {
+	return ALREADY_IN_TARGET_STATE.some((pattern) => pattern.test(message));
+}
 //#endregion
-export { EXIT, MIGRATION_FORMAT_VERSION, action, buildReport, describeDiscovery, divergenceIsBlocking, exitCodeOf, isAheadOnly, meaningOf, refusalInMode, renderRefusal, renderStatus, styleFor, verdictOf };
+export { EXIT, MIGRATION_FORMAT_VERSION, action, alreadyInTargetState, buildReport, describeDiscovery, divergenceIsBlocking, exitCodeOf, isAheadOnly, meaningOf, refusalInMode, renderRefusal, renderStatus, styleFor, verdictOf };

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

@@ -1,5 +1,6 @@
 import { FORMAT_MARKER } from "./types.js";
 import { MigrationToolError, generationFailed, generationNeedsAnswer, generationToolMissing, introspectFailed } from "./refusals.js";
+import { droppedTables, rebuiltTables } from "./destructive.js";
 import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
@@ -149,6 +150,10 @@ const DESTRUCTIVE_PATTERNS = [
 	{
 		id: "drop-table",
 		pattern: /\bDROP\s+TABLE\b/i,
+		detect: (code) => {
+			const rebuilt = rebuiltTables(code);
+			return droppedTables(code).some((table) => !rebuilt.has(table));
+		},
 		what: "supprime une table ET toutes ses lignes",
 		todo: "sauvegarder, puis appliquer en deux temps (cf expand/contract)"
 	},

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

@@ -4,6 +4,7 @@ import { defaultMigrationSources } from "./paths.js";
 import { DrizzleMigrator } from "./DrizzleMigrator.js";
 import { parseDatabaseUrl, sqliteFilenameFromUrl } from "nodefony";
 import { ormRegistry } from "@nodefony/orm-core";
+import fs from "node:fs";
 import path from "node:path";
 //#region nodefony/src/migrator/resolve.ts
 /**
@@ -52,6 +53,25 @@ function resetAllowed(env) {
 	return env.runtime === "development" && env.nodeEnv !== "test";
 }
 /**
+* `orm:generate --apply` est-il recevable dans cet environnement ?
+*
+* Écrire une migration et l'appliquer dans le même souffle suppose qu'on relit
+* le SQL produit entre les deux — ce que personne ne fait sur un serveur.
+* Ailleurs qu'en développement, la migration a été écrite, relue et versionnée
+* en amont : `orm:migrate` l'applique, et lui seul. Aucun drapeau ne lève ce
+* refus, pour la même raison que {@link resetAllowed} n'en a pas.
+*
+* Même forme que `resetAllowed`, et c'est voulu : les deux disent « geste de
+* développement », et deux rédactions de la même condition finiraient par
+* diverger sans que rien ne le signale.
+*
+* @param env - environnement constaté.
+* @returns `true` si l'enchaînement est recevable.
+*/
+function generateApplyAllowed(env) {
+	return env.runtime === "development" && env.nodeEnv !== "test";
+}
+/**
 * Le mode de schéma qui s'applique à un connecteur.
 *
 * Règle des défauts, et son pourquoi : **appliquer des migrations au démarrage
@@ -63,13 +83,63 @@ function resetAllowed(env) {
 * - tout le reste → `none` : personne ne touche au schéma au démarrage, un
 *   travail externe applique les migrations avant que le trafic n'arrive.
 *
+* 🔴 **Une application qui VERSIONNE des migrations bascule en `migrate`, même
+* en développement.** Deux fabricants du même schéma ne s'accordent pas, et
+* rien ne le signale tant qu'on ne les fait pas se rencontrer : le DDL dérivé
+* pose une contrainte d'unicité INLINE et anonyme (`content text NOT NULL
+* UNIQUE`), là où le générateur de migrations raisonne sur un index NOMMÉ
+* (`messages_content_unique`). La migration suivante émet alors un
+* `DROP INDEX` d'un index qui n'a jamais existé, échoue sur `no such index`,
+* inscrit son marqueur — et la réparation ne peut rien y faire, puisque le
+* fichier est inapplicable. Vécu sur un agent tiers : trente-cinq minutes de
+* `repair`/`baseline`/`reset`, deux bases détruites, la boucle brisée à la main.
+* La condition est délibérément « l'application EN A », pas « elle en a en
+* attente » : dès la première migration écrite, le schéma leur appartient.
+* Elle est bornée au développement RÉEL, jamais à `NODE_ENV=test` : une suite
+* lance un exemplaire par worker, et appliquer des migrations depuis plusieurs
+* processus au démarrage est précisément ce que la règle ci-dessus refuse.
+* Un `ddl` écrit dans la configuration gagne toujours — c'est un choix, pas une
+* déduction.
+*
 * @param explicit - valeur écrite dans la configuration du connecteur, si elle l'est.
 * @param env - environnement constaté.
+* @param appHasMigrations - l'application versionne au moins une migration.
 * @returns le mode effectif.
 */
-function resolveDdlMode(explicit, env) {
+function resolveDdlMode(explicit, env, appHasMigrations = false) {
 	if (explicit) return explicit;
-	return env.runtime === "development" || env.nodeEnv === "test" ? "auto" : "none";
+	if (env.runtime === "development" || env.nodeEnv === "test") return appHasMigrations && env.nodeEnv !== "test" ? "migrate" : "auto";
+	return "none";
+}
+/**
+* L'application versionne-t-elle au moins une migration ?
+*
+* Lecture SYNCHRONE et bornée à un `readdirSync` par connecteur au démarrage —
+* hors de tout chemin de requête. Elle doit l'être : le mode de schéma se
+* décide avant la connexion, et le rendre asynchrone propagerait un `await`
+* dans toute la chaîne de résolution pour une réponse qui ne change jamais
+* pendant la vie du processus.
+*
+* Un dossier absent, illisible ou vide répond `false` — l'application n'a alors
+* rien à appliquer, et `auto` reste le bon défaut de démarrage rapide.
+*
+* @param dir - dossier de migrations de l'application ({@link appMigrationsDir}).
+* @returns `true` si au moins un fichier `.sql` y est versionné, à un niveau
+*   ou sous un sous-dossier de dialecte (`migrations/postgres/0001_x.sql`).
+*/
+function appVersionsMigrations(dir) {
+	if (!dir) return false;
+	try {
+		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+			if (entry.isFile() && entry.name.endsWith(".sql")) return true;
+			if (entry.isDirectory() && entry.name !== "meta") {
+				if (fs.readdirSync(path.join(dir, entry.name)).some((name) => name.endsWith(".sql"))) return true;
+			}
+		}
+	} catch {
+		return false;
+	}
+	return false;
 }
 /**
 * La conduite de la sonde de disponibilité face à un schéma en retard.
@@ -217,7 +287,7 @@ function resolveConnector(connector, config, env, kernel, options = {}) {
 			url: fromMigrateUrl && dialect !== "sqlite" ? parsedUrl.url : base.url
 		},
 		fromMigrateUrl,
-		ddl: resolveDdlMode(declared.ddl, env)
+		ddl: resolveDdlMode(declared.ddl, env, appVersionsMigrations(appMigrationsDir(kernel, config.migrations.dir)))
 	};
 }
 /**
@@ -278,4 +348,4 @@ function resolveDivergenceMode(config) {
 	return config.migrations.divergence;
 }
 //#endregion
-export { MIGRATE_URL_ENV, appMigrationsDir, buildMigrator, knownConnectors, readMigrationEnv, resetAllowed, resolveCheckMode, resolveConnector, resolveDdlMode, resolveDivergenceMode };
+export { MIGRATE_URL_ENV, appMigrationsDir, appVersionsMigrations, buildMigrator, generateApplyAllowed, knownConnectors, readMigrationEnv, resetAllowed, resolveCheckMode, resolveConnector, resolveDdlMode, resolveDivergenceMode };