@nodefony/drizzle 10.0.0-alpha.1

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

@@ -0,0 +1,114 @@
+import { renderStatus } from "../src/migrator/explain.js";
+import { OrmMigrateCommand } from "./migrateShared.js";
+//#region nodefony/command/orm-migrate-repair.ts
+const options = {
+	helpGroup: "BASE DE DONNÉES",
+	showBanner: false,
+	kernelEvent: "onPostReady"
+};
+/**
+* `nodefony orm:migrate:repair` — lève les marqueurs d'échec, **après**
+* inspection humaine.
+*
+* ## Ce que « réparer » veut dire ici, et ce que ça ne veut pas dire
+*
+* Cette commande **ne répare pas la base**. Elle efface la trace d'une
+* migration qui n'a pas abouti, pour que l'applicateur accepte de reprendre.
+* C'est une déclaration : « j'ai regardé la base, elle est dans l'état que je
+* crois ».
+*
+* Pourquoi ce n'est pas automatique : quand une migration s'arrête en cours de
+* route, l'état laissé dépend de la base. PostgreSQL et SQLite annulent la
+* migration fautive entière — l'état est net. MySQL valide chaque instruction
+* de schéma au fur et à mesure, sans retour possible : la moitié des
+* changements peut être en place. Aucun programme ne peut décider à la place
+* d'un humain si cette moitié est acceptable.
+*
+* **L'ordre des gestes, et il ne s'inverse pas :**
+*
+* 1. `nodefony orm:migrate:status --json` — voir ce qui a échoué et pourquoi ;
+* 2. regarder la base elle-même, et la remettre d'aplomb si besoin ;
+* 3. `nodefony orm:migrate:repair` — lever le marqueur ;
+* 4. `nodefony orm:migrate` — reprendre.
+*
+* ## `--update-hashes` : à ne taper que sur instruction d'un message
+*
+* Ré-aligner les empreintes déclare que les fichiers modifiés APRÈS avoir été
+* appliqués sont réputés conformes. C'est presque toujours faux : les autres
+* bases ont reçu l'ancienne version et ne recevront jamais la nouvelle. Le
+* geste normal face à un fichier modifié est de le restaurer
+* (`git checkout -- migrations/`) et d'écrire une NOUVELLE migration.
+*
+* L'option existe pour le cas où l'on sait que la modification était sans effet
+* — une reformulation, un commentaire. Elle ne touche jamais la base.
+*
+* ## `--forget <source>/<tag>` : l'issue d'un historique qui MENT
+*
+* Il existait un état dont aucune commande ne sortait : une migration inscrite
+* comme réussie que personne n'a jamais exécutée — une adoption mal bornée, ou
+* une base héritée d'une version antérieure aux gardes. La base ne porte pas
+* les tables, l'historique affirme le contraire, et rien n'est « en attente ».
+* Le générateur disait alors « c'est l'historique qu'il faut reprendre » et
+* renvoyait ici ; mais cette commande ne savait lever que des marqueurs
+* d'ÉCHEC, et répondait « rien à réparer ». Trois messages vrais, aucun geste
+* — et le seul chemin restant était de détruire la base.
+*
+* `--forget` désinscrit UNE entrée nommée, pour qu'elle soit rejouée au
+* passage suivant. Bornée par construction : il faut la nommer
+* (`--forget app/0003_ajout_facture`), il n'y a ni motif ni lot. La base n'est
+* pas touchée — si la migration avait réellement été appliquée, son rejeu
+* échouera, bruyamment, ce qui est le comportement voulu.
+*/
+var OrmMigrateRepair = class extends OrmMigrateCommand {
+	constructor(cli) {
+		super("orm:migrate:repair", "lève un marqueur d'échec, sans toucher à la base", cli, options);
+		this.addSharedOptions();
+		this.addOption("-s, --source <nom>", "ne réparer que cette source (framework, app, un module) — toutes si omis");
+		this.addOption("--forget <source/tag...>", "désinscrit une migration nommée pour qu'elle soit REJOUÉE — l'issue quand l'historique affirme une migration jamais exécutée");
+		this.addOption("--update-hashes", "déclare conformes les fichiers modifiés après application — presque toujours FAUX, à ne taper que si un message le demande");
+	}
+	async generate(opts = {}) {
+		const resolved = this.resolveOrFail(opts, true);
+		if (!resolved) return this;
+		const { resolution, config } = resolved;
+		const style = this.style;
+		try {
+			const migrator = await this.migrator(resolution, config);
+			const forget = (opts.forget ?? []).map((brut) => {
+				const coupe = brut.indexOf("/");
+				if (coupe <= 0 || coupe === brut.length - 1) throw new Error(`« ${brut} » n'est pas une entrée d'historique. La forme attendue est « source/tag », par exemple « app/0003_ajout_facture » : sans la source, deux migrations de même tag ne se distinguent pas.`);
+				return {
+					source: brut.slice(0, coupe),
+					tag: brut.slice(coupe + 1)
+				};
+			});
+			const done = await migrator.repair({
+				source: opts.source,
+				updateHashes: opts.updateHashes === true,
+				forget
+			});
+			const plan = await migrator.status();
+			const report = await this.report(plan, resolution, config);
+			const payload = {
+				...report,
+				repaired: done
+			};
+			let human = "";
+			if (done.cleared.length === 0 && done.rehashed.length === 0 && done.forgotten.length === 0) human = `${style.green("Rien à réparer : aucun marqueur d'échec, aucune empreinte à ré-aligner.")}\n\n`;
+			else {
+				human = `${style.green(style.bold("✓ historique réparé"))} ${style.dim("— la base n'a pas été modifiée")}\n`;
+				for (const c of done.cleared) human += `  ${style.green("−")} marqueur d'échec levé : ${c.source}/${c.tag}\n`;
+				for (const r of done.rehashed) human += `  ${style.yellow("≈")} empreinte ré-alignée : ${r.source}/${r.tag}\n`;
+				for (const f of done.forgotten) human += `  ${style.yellow("↺")} désinscrite, sera REJOUÉE : ${f.source}/${f.tag}\n`;
+				human += "\n";
+			}
+			human += 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 { OrmMigrateRepair as default };

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

@@ -0,0 +1,67 @@
+import { renderStatus } from "../src/migrator/explain.js";
+import { OrmMigrateCommand } from "./migrateShared.js";
+//#region nodefony/command/orm-migrate-status.ts
+/**
+* `kernelEvent: "onPostReady"` — la commande LIT l'état de l'application.
+*
+* Le registre des connecteurs est peuplé au démarrage par le service du module.
+* Une commande branchée plus tôt passerait avant lui et ne trouverait rien.
+* Aucun serveur n'écoute pour autant : le profil console est respecté.
+*/
+const options = {
+	helpGroup: "BASE DE DONNÉES",
+	showBanner: false,
+	kernelEvent: "onPostReady"
+};
+/**
+* `nodefony orm:migrate:status` — dit ce que la base a reçu, ce qui reste, et
+* ce qu'il faut taper.
+*
+* **Lecture seule et sans verrou.** Elle n'écrit rien, pas même la table
+* d'historique : un état qui se consulte ne doit pas modifier ce qu'il
+* observe — et une sonde qui écrit dans la base n'est plus une sonde.
+*
+* ## Son autre métier : barrière d'intégration continue
+*
+* Le code de sortie porte le verdict, et il ne changera jamais de sens :
+*
+* | Code | Ce que ça veut dire                                                |
+* | ---- | ------------------------------------------------------------------ |
+* | `0`  | à jour — rien à faire                                              |
+* | `1`  | une action humaine est requise (migrations en attente, écart, échec) |
+* | `2`  | la commande n'a pas pu travailler (base injoignable, verrou, usage) |
+*
+* Une passe de déploiement peut donc s'arrêter dessus sans lire un mot :
+*
+* ```bash
+* nodefony orm:migrate:status --json || exit 1
+* ```
+*
+* @example Ce qu'un agent lit
+* ```bash
+* nodefony orm:migrate:status --json | jq -r '.verdict, .nextActions[0].command'
+* # pending
+* # nodefony orm:migrate
+* ```
+*/
+var OrmMigrateStatus = class extends OrmMigrateCommand {
+	constructor(cli) {
+		super("orm:migrate:status", "l'état des migrations d'un connecteur, sans écrire", cli, options);
+		this.addSharedOptions();
+	}
+	async generate(opts = {}) {
+		const resolved = this.resolveOrFail(opts, true);
+		if (!resolved) return this;
+		const { resolution, config } = resolved;
+		try {
+			const plan = await (await this.migrator(resolution, config)).status();
+			const report = await this.report(plan, resolution, config);
+			this.emitReport(report, renderStatus(report, this.style), opts.json);
+		} catch (e) {
+			this.failFrom(e, resolution.connector, opts.json, resolution.ddl);
+		}
+		return this;
+	}
+};
+//#endregion
+export { OrmMigrateStatus as default };

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

@@ -0,0 +1,141 @@
+import { EXIT, action, renderStatus } from "../src/migrator/explain.js";
+import { readMigrationEnv } from "../src/migrator/resolve.js";
+import { checkDataAdvice, dataLoss, destructiveActions, renderDestructive, scanDestructive, summarizeDestructive, touchesExistingRows } from "../src/migrator/destructive.js";
+import { OrmMigrateCommand } from "./migrateShared.js";
+//#region nodefony/command/orm-migrate.ts
+const options = {
+	helpGroup: "BASE DE DONNÉES",
+	showBanner: false,
+	kernelEvent: "onPostReady"
+};
+/**
+* `nodefony orm:migrate` — applique les migrations restantes, sous verrou.
+*
+* ## Ce que la commande fait, dans cet ordre exact
+*
+* 1. **prend le verrou** de la base (verrou natif du serveur : il se libère
+*    tout seul si le processus meurt — aucun verrou fantôme à débloquer à la
+*    main) ;
+* 2. **crée la table d'historique** si elle n'existe pas ;
+* 3. **valide TOUT** — empreintes, ordre, échecs passés, fichiers manquants ;
+* 4. **applique** les migrations une par une, chacune dans sa transaction là où
+*    la base le permet.
+*
+* La validation précède toute écriture : **un refus laisse la base
+* intacte**. C'est ce qui rend sûr de relancer la commande après un refus.
+*
+* ## Elle ne s'exécute jamais toute seule au démarrage — sauf si on le demande
+*
+* Appliquer des migrations au démarrage n'est pas un défaut, et ce n'est pas de
+* la prudence : au démarrage, plusieurs exemplaires partent en même temps. Le
+* mode `ddl: "migrate"` existe pour les déploiements à exemplaire unique et
+* s'écrit à la main. En production orchestrée, c'est un travail séparé qui
+* lance cette commande AVANT que les nouveaux exemplaires ne démarrent.
+*
+* ## Le compte qui migre n'est pas le compte qui sert
+*
+* `NF_MIGRATE_DATABASE_URL` remplace, pour cette commande seulement, la
+* connexion du connecteur. C'est le véhicule du moindre privilège : le secret
+* qui a le droit de modifier le schéma est monté dans le travail de migration,
+* et nulle part ailleurs. Elle doit désigner une connexion **directe** — un
+* répartiteur de connexions en mode transaction casse le verrou.
+*
+* @example Voir sans rien appliquer
+* ```bash
+* nodefony orm:migrate --dry-run
+* ```
+*
+* @example Dans un travail de déploiement
+* ```bash
+* NF_MIGRATE_DATABASE_URL="postgres://migrator:…@db:5432/app" nodefony orm:migrate --json
+* ```
+*/
+var OrmMigrate = class extends OrmMigrateCommand {
+	constructor(cli) {
+		super("orm:migrate", "applique les migrations en attente", cli, options);
+		this.addSharedOptions();
+		this.addOption("-n, --dry-run", "n'applique RIEN : valide et affiche le SQL qui serait exécuté");
+		this.addOption("--out-of-order", "accepte une migration plus ancienne que la dernière appliquée (trace d'une fusion de branches — à ne taper que si le message le demande)");
+		this.addOption("--ignore-missing", "accepte qu'une migration enregistrée n'ait plus de fichier (à ne taper que si le message le demande)");
+		this.addOption("--allow-destructive", "assume une migration qui SUPPRIME des données (colonne, table, lignes) — hors développement, elle est refusée sans ce drapeau");
+	}
+	async generate(opts = {}) {
+		const resolved = this.resolveOrFail(opts, true);
+		if (!resolved) return this;
+		const { resolution, config } = resolved;
+		const style = this.style;
+		try {
+			const migrator = await this.migrator(resolution, config);
+			const before = await migrator.status();
+			const findings = scanDestructive(before.pending);
+			const losses = dataLoss(findings);
+			const enDev = readMigrationEnv(this.kernel).runtime === "development";
+			if (losses.length > 0 && opts.dryRun !== true && opts.allowDestructive !== true && !enDev) {
+				this.fail(resolution.connector, "NF_MIGRATE_DESTRUCTIVE", summarizeDestructive(findings, resolution.connector), renderDestructive(findings, true), destructiveActions(resolution.connector).map((c) => action(c)), opts.json, EXIT.actionRequired);
+				return this;
+			}
+			if (findings.length > 0) process.stderr.write(style.yellow(renderDestructive(findings, false)) + "\n");
+			const run = await migrator.migrate({
+				dryRun: opts.dryRun === true,
+				outOfOrder: opts.outOfOrder === true,
+				ignoreMissing: opts.ignoreMissing === true
+			});
+			const plan = await migrator.status();
+			const report = await this.report(plan, resolution, config);
+			if (opts.dryRun === true) {
+				const pending = plan.pending;
+				const payload = {
+					formatVersion: 1,
+					connector: report.connector,
+					verdict: report.verdict,
+					exitCode: report.exitCode,
+					dryRun: true,
+					summary: report.summary,
+					nextActions: report.nextActions,
+					sources: report.sources,
+					driver: report.driver,
+					statements: pending.map((f) => ({
+						source: f.source,
+						tag: f.tag,
+						sql: [...f.statements]
+					})),
+					destructive: findings
+				};
+				let human = `${style.bold("Essai — RIEN n'a été appliqué.")}\n\n`;
+				if (findings.length > 0) human += `${style.yellow(renderDestructive(findings, false))}\n`;
+				if (pending.length === 0) human += `${style.green("Aucune migration en attente : il n'y a rien à appliquer.")}\n`;
+				else {
+					for (const f of pending) {
+						human += `${style.bold(`── ${f.source}/${f.tag}`)}\n`;
+						for (const sql of f.statements) human += `${style.dim(sql)};\n`;
+						human += "\n";
+					}
+					human += `${style.bold("Pour appliquer :")}\n  ${style.green(`nodefony orm:migrate${resolution.connector === "default" ? "" : ` --connector ${resolution.connector}`}`)}\n`;
+				}
+				this.respond(payload, human, report.exitCode, opts.json);
+				return this;
+			}
+			if (run.applied.length === 0) {
+				this.emitReport(report, `${style.green("Rien à appliquer : la base est déjà à jour.")}\n\n${renderStatus(report, style)}`, opts.json);
+				return this;
+			}
+			let human = `${style.green(style.bold(`✓ ${run.applied.length} migration(s) appliquée(s)`))} ${style.dim(`(exécution ${run.runId})`)}\n`;
+			for (const a of run.applied) human += `  ${style.green("+")} ${a.source}/${a.tag} ${style.dim(`— ${a.executionMs} ms`)}\n`;
+			human += `\n${renderStatus(report, style)}`;
+			if (touchesExistingRows(before.pending)) {
+				const conseil = checkDataAdvice(resolution.connector, report.driver);
+				if (opts.json === true) process.stderr.write(`${conseil}\n`);
+				else human += `\n${style.dim(conseil)}\n`;
+			}
+			this.emitReport(findings.length > 0 ? {
+				...report,
+				destructive: findings
+			} : report, human, opts.json);
+		} catch (e) {
+			this.failFrom(e, resolution.connector, opts.json, resolution.ddl);
+		}
+		return this;
+	}
+};
+//#endregion
+export { EXIT, action, OrmMigrate as default };

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

@@ -0,0 +1,166 @@
+import { action } from "../src/migrator/explain.js";
+import { openMigrationDriver } from "../src/migrator/drivers/index.js";
+import { readMigrationEnv, resetAllowed } from "../src/migrator/resolve.js";
+import { OrmMigrateCommand } from "./migrateShared.js";
+//#region nodefony/command/orm-reset.ts
+const options = {
+	helpGroup: "BASE DE DONNÉES",
+	showBanner: false,
+	kernelEvent: "onPostReady"
+};
+/**
+* Requête qui liste les tables du schéma COURANT de la connexion.
+*
+* Le schéma courant, et pas « toutes les bases du serveur » : c'est le
+* périmètre que la connexion adresse déjà, donc celui que l'utilisateur a
+* désigné en configurant son connecteur. Élargir serait détruire ce qu'il n'a
+* pas montré.
+*/
+const LIST_TABLES = {
+	sqlite: "SELECT name AS name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'",
+	postgres: "SELECT tablename AS name FROM pg_tables WHERE schemaname = current_schema()",
+	mysql: "SELECT table_name AS name FROM information_schema.tables WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE'"
+};
+/** Échappe un identifiant venu du catalogue de la base. */
+function quoteIdent(name, dialect) {
+	return dialect === "mysql" ? `\`${name.replace(/`/g, "``")}\`` : `"${name.replace(/"/g, "\"\"")}"`;
+}
+/**
+* `nodefony orm:reset` — vide la base de DÉVELOPPEMENT et la laisse prête à
+* être recréée.
+*
+* ## Le geste qu'elle remplace
+*
+* Jusqu'ici, le générateur d'applications disait « supprime ta base de dev, ou
+* passe par une migration » : deux gestes manuels, aucun outil, et chacun s'en
+* tirait comme il pouvait. Une seule commande à retenir pour toute l'équipe,
+* au lieu d'un arbre de décision.
+*
+* ## Ce qu'elle fait exactement
+*
+* Elle supprime **toutes les tables du schéma courant** de la connexion —
+* l'historique des migrations compris. Elle ne supprime NI la base, NI le
+* fichier : supprimer une base demande des droits d'administration que le
+* compte de l'application n'a pas, et supprimer un fichier ouvert échoue sous
+* Windows. Le résultat est le même — une base vide — et il s'obtient partout de
+* la même façon.
+*
+* Ensuite : en mode `auto` (le défaut en développement), le prochain démarrage
+* recrée le schéma depuis le code. Dans les autres modes, la commande dit quoi
+* lancer.
+*
+* ## Le refus est une LISTE BLANCHE, pas une liste noire
+*
+* Elle n'accepte de travailler que si l'environnement est `development`. Pas
+* « refusée en production » : `staging`, `preprod`, `test` et tout
+* environnement inconnu refusent aussi. La différence n'est pas théorique — une
+* garde écrite « si production » laisse passer tout ce qu'on n'a pas pensé à
+* nommer, et c'est exactement là que l'accident arrive.
+*
+* `NF_MIGRATE_DATABASE_URL` n'est **pas** lue par cette commande. Cette
+* variable porte le compte qui a le droit de modifier le schéma en
+* production : lui laisser désigner la cible d'un effacement serait offrir la
+* seule combinaison qu'il ne faut jamais rendre possible.
+*
+* @example
+* ```bash
+* nodefony orm:reset            # demande confirmation en terminal
+* nodefony orm:reset --yes      # sans question (script)
+* ```
+*/
+var OrmReset = class extends OrmMigrateCommand {
+	constructor(cli) {
+		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");
+	}
+	async generate(opts = {}) {
+		const resolved = this.resolveOrFail(opts, false);
+		if (!resolved) return this;
+		const { resolution } = resolved;
+		const style = this.style;
+		const env = readMigrationEnv(this.kernel);
+		if (!resetAllowed(env)) {
+			const observed = env.nodeEnv ?? process.env.NF_ENV ?? process.env.APP_ENV ?? "non déclaré";
+			this.fail(resolution.connector, "NF_MIGRATE_NOT_DEVELOPMENT", `Cette commande efface des données : elle n'est acceptée qu'en développement. L'environnement constaté est « ${observed} ».`, "La règle est une liste blanche : seul `development` passe. Un environnement inconnu, un `staging`, un `test` sont refusés — c'est ce qui empêche un accident sur ce que personne n'avait pensé à nommer. Pour vider une base ailleurs, fais-le avec l'outil de ta base, en sachant ce que tu fais. Sur un poste de développement, c'est l'environnement de l'application qui doit dire `development` — pas une variable posée devant la commande.", [action(`nodefony orm:migrate:status --connector ${resolution.connector} --json`)], opts.json);
+			return this;
+		}
+		const target = resolution.dialect === "sqlite" ? resolution.target.filename ?? ":memory:" : redact(resolution.target.url ?? "");
+		let driver = null;
+		try {
+			driver = await openMigrationDriver(resolution.target);
+			const tables = (await driver.query(LIST_TABLES[resolution.dialect])).map((r) => String(r.name)).filter((n) => n.length > 0).sort();
+			if (tables.length === 0) {
+				this.respond({
+					formatVersion: 1,
+					connector: resolution.connector,
+					exitCode: 0,
+					dropped: []
+				}, `${style.green("La base est déjà vide")} ${style.dim(`(${resolution.dialect} : ${target})`)} — rien à faire.\n`, 0, opts.json);
+				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);
+					return this;
+				}
+				process.stdout.write(`${style.yellow(style.bold("Effacement de la base de développement"))}\n  base    : ${style.bold(target)} ${style.dim(`(${resolution.dialect})`)}\n  tables  : ${tables.join(", ")}\n\n`);
+				await this.loadPrompts();
+				if (!await this.prompts.confirm({
+					message: `Supprimer ces ${tables.length} table(s) ?`,
+					default: false
+				})) {
+					process.stdout.write(`${style.dim("Annulé — rien n'a été touché.")}\n`);
+					return this;
+				}
+			}
+			await this.#dropAll(driver, tables, resolution.dialect);
+			const suite = resolution.ddl === "auto" ? "Le prochain démarrage recrée le schéma depuis le code." : "Applique les migrations pour recréer le schéma.";
+			const actions = resolution.ddl === "auto" ? [action("nodefony development")] : [action(`nodefony orm:migrate${resolution.connector === "default" ? "" : ` --connector ${resolution.connector}`}`)];
+			this.respond({
+				formatVersion: 1,
+				connector: resolution.connector,
+				exitCode: 0,
+				dropped: tables,
+				nextActions: actions
+			}, `${style.green(style.bold(`✓ ${tables.length} table(s) supprimée(s)`))} ${style.dim(`(${resolution.dialect} : ${target})`)}\n${tables.map((t) => `  ${style.dim("−")} ${t}`).join("\n")}\n\n${suite}\n\n${style.bold("À faire :")}\n${actions.map((a) => `  ${style.green(a.command)}`).join("\n")}\n`, 0, opts.json);
+		} catch (e) {
+			this.failFrom(e, resolution.connector, opts.json);
+		} finally {
+			await driver?.close().catch(() => void 0);
+		}
+		return this;
+	}
+	/**
+	* Supprime les tables en désarmant les clés étrangères le temps de l'opération.
+	*
+	* Sans ce désarmement, l'ordre de suppression devrait être topologique — et il
+	* est indécidable sur un cycle de références. Le désarmement porte sur la
+	* connexion de la commande seulement, et elle se ferme juste après.
+	*/
+	async #dropAll(driver, tables, dialect) {
+		if (dialect === "sqlite") await driver.exec("PRAGMA foreign_keys = OFF");
+		else if (dialect === "mysql") await driver.exec("SET FOREIGN_KEY_CHECKS = 0");
+		try {
+			for (const t of tables) {
+				const ident = quoteIdent(t, dialect);
+				await driver.exec(dialect === "postgres" ? `DROP TABLE IF EXISTS ${ident} CASCADE` : `DROP TABLE IF EXISTS ${ident}`);
+			}
+		} finally {
+			if (dialect === "sqlite") await driver.exec("PRAGMA foreign_keys = ON").catch(() => void 0);
+			else if (dialect === "mysql") await driver.exec("SET FOREIGN_KEY_CHECKS = 1").catch(() => void 0);
+		}
+	}
+};
+/** Retire le secret d'une URL de connexion avant de l'afficher. */
+function redact(url) {
+	try {
+		const u = new URL(url);
+		if (u.password) u.password = "***";
+		return u.toString();
+	} catch {
+		return url.replace(/\/\/[^@]*@/, "//***@");
+	}
+}
+//#endregion
+export { OrmReset as default };

package/dist/nodefony/config/config.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+//#region nodefony/config/config.ts
+/**
+* @nodefony/drizzle — CONFIGURATION DU MODULE (schéma Zod = source unique).
+*
+* ⭐ TL;DR : CE SCHÉMA EST LA CONFIG. Chaque `.default(...)` = la valeur d'usine ;
+* changer un défaut du module = ÉDITER ICI (et nulle part ailleurs). L'app, elle,
+* surcharge via `use("@nodefony/...", { … })` dans SON `nodefony.config.ts`.
+*
+* RÈGLE D'OR (ADR-0006) : ce fichier porte le **schéma Zod commenté** (type +
+* validation + défaut + doc) ET matérialise les défauts via `parse({})`. Aucune
+* valeur n'est re-tapée ailleurs. Le builder (`defineDrizzleConfig`) et les types
+* (`interfaces/IDrizzleConfig.ts`) importent le schéma D'ICI (nœud bas : ce fichier
+* n'importe que `zod` → pas de cycle).
+*
+* Convention figée (cf `feedback_config_validation_zod` + audit config ORM
+* 2026-06), alignée sur `@nodefony/mongoose`/`@nodefony/redis`/`@nodefony/realtime`.
+*
+* ⚠️ Le schéma reste **PUR** : `filename` est **optionnel SANS défaut** — le chemin
+* SQLite par défaut dépend de `kernel.path` (indisponible à l'évaluation du schéma)
+* et est résolu au boot par `DrizzleService`. Aucune lecture `process.env` ici
+* (l'env est appliqué dans `defineDrizzleConfig`).
+*
+* SURCHARGE (précédence croissante — cf ADR-0006) :
+*   • App (typé)         : `use("@nodefony/drizzle", { connectors: { … } })` ;
+*   • Par environnement  : infra database `NF_DATABASE_URL`/`DATABASE_URL`
+*     (dialecte déduit du scheme, appliqué dans `defineDrizzleConfig`) ;
+*   • Déploiement/Docker : `NF__DRIZZLE__<CHEMIN>=valeur` (override env générique).
+*/
+/**
+* Dialectes SQL supportés par l'adapter Drizzle. `sqlite` (better-sqlite3) est le
+* défaut bootable ; `postgres` (pg) / `mysql` (mysql2) sont des drivers chargés en
+* LAZY (`optionalDependencies` + `await import` au connect) — un framework doit
+* porter ses entités sur les bases majeures (cf chantier portabilité multi-dialecte).
+*/
+const SQL_DIALECTS = [
+	"sqlite",
+	"postgres",
+	"mysql"
+];
+/**
+* Stratégies de fabrication du schéma d'un connecteur.
+*
+* Trois valeurs, et pas une de plus : ce qui fait le schéma est soit le
+* démarrage à partir du code (`auto`), soit le démarrage à partir des fichiers
+* de migration (`migrate`), soit personne (`none`). Un quatrième mode serait un
+* mélange, donc un comportement que personne ne saurait décrire dans un
+* incident.
+*/
+const DDL_MODES = [
+	"auto",
+	"migrate",
+	"none"
+];
+/**
+* Conduites de la sonde de disponibilité quand le schéma est en retard.
+*
+* `fail` retient la mise en service (le processus ne reçoit pas de trafic),
+* `warn` journalise et sert quand même, `off` ne regarde pas.
+*/
+const MIGRATION_CHECK_MODES = [
+	"fail",
+	"warn",
+	"off"
+];
+/**
+* Conduites face à une base qui ne correspond plus au code alors que
+* l'historique est complet.
+*
+* Le défaut est `report` — et il est structurel, pas prudent : une application
+* qui écrit des migrations libres (vues, déclencheurs, colonnes ajoutées à une
+* table d'entité) a une base légitimement différente du schéma déclaré, en
+* permanence. Faire tomber sa mise en service dessus rendrait le constat
+* inutilisable, donc mort. Superviser ne fait pas tomber un déploiement.
+*/
+const DIVERGENCE_MODES = [
+	"report",
+	"fail",
+	"off"
+];
+const connectorSchema = z.strictObject({
+	dialect: z.enum(SQL_DIALECTS).default("sqlite").describe("Dialecte SQL du connecteur : `sqlite` (défaut, driver better-sqlite3, `filename`) · `postgres` (driver `pg`, `url`) · `mysql` (driver `mysql2`, `url`). pg/mysql sont des `optionalDependencies` chargées en lazy au connect — l'app installe le driver de son déploiement."),
+	filename: z.string().min(1).optional().describe("Fichier SQLite du connecteur (dialecte `sqlite`). OMIS → résolu au boot sous le répertoire de données de l'application : `<app>/var/databases/nodefony-drizzle.db` pour le connecteur `default`, `nodefony-<connecteur>.db` pour les autres. `:memory:` = base éphémère en mémoire (tests). Surchargé par le infra database `NF_DATABASE_URL=sqlite:…` pour le connecteur primaire."),
+	url: z.string().min(1).optional().describe("Chaîne de connexion des dialectes `postgres`/`mysql` (`postgres://user:pass@host:port/db`, `mysql://…`). Requise pour ces dialectes (ignorée en `sqlite`). Porte le secret → jamais loggée (rédaction au describe)."),
+	ddl: z.enum(DDL_MODES).optional().describe("Qui fabrique le schéma de ce connecteur, et quand. `auto` : le démarrage crée les tables manquantes depuis le code ET ajoute les colonnes qui manquent quand elles acceptent le vide (développement — strictement additif, jamais destructeur). `migrate` : le démarrage applique les migrations sous verrou (un seul exemplaire assumé — VPS, docker compose, sqlite). `none` : personne ne touche au schéma au démarrage, un travail externe lance `nodefony orm:migrate` avant le déploiement (production orchestrée). OMIS → résolu par environnement au boot : développement et test → `auto`, tout le reste → `none`.")
+}).describe("Définition d'une connexion Drizzle (driver selon `dialect` : better-sqlite3 / pg / mysql2).");
+const drizzleConfigSchema = z.strictObject({
+	connectors: z.record(z.string(), connectorSchema).default(() => ({ default: connectorSchema.parse({}) })).describe("Connexions indexées par nom (= clé dans le `ormRegistry`). Défaut : un connecteur `default` (fichier SQLite résolu au boot). Le nom `default` (≠ `nodefony` de Mongoose) isole l'entité `session` dans le `entityRegistry` process-wide si les deux ORM cohabitent."),
+	migrations: z.strictObject({
+		dir: z.string().default("migrations").describe("Dossier des migrations de l'APPLICATION, relatif à la racine de l'application — celle que le kernel connaît, jamais le répertoire courant du processus (un espace de travail en a plusieurs). Un sous-dossier par dialecte (`migrations/postgres`). Le dossier du framework, lui, est livré dans le paquet et n'a rien à déclarer ici."),
+		check: z.enum(MIGRATION_CHECK_MODES).optional().describe("Conduite de la sonde de disponibilité quand `ddl` n'est pas `auto` et que le schéma est en retard. `fail` : la mise en service est RETENUE (`/readyz` répond 503) jusqu'à ce que les migrations soient appliquées — le processus redevient disponible tout seul, sans redéploiement. `warn` : journalisé, le trafic passe quand même. `off` : rien. OMIS → résolu par environnement : production → `fail`, reste → `warn`."),
+		lockTimeoutMs: z.number().int().positive().default(3e4).describe("Délai maximal d'attente du verrou d'application des migrations (ms). Passé ce délai la commande s'arrête sur le code 2 en disant qui tient le verrou : un processus qui attend sans limite derrière un travail mort n'annonce jamais sa panne."),
+		divergence: z.enum(DIVERGENCE_MODES).default("report").describe("Conduite quand l'historique est complet, rien n'est en attente, ET que la base ne correspond pourtant pas au schéma déclaré (modification faite à la main, correctif d'urgence non reporté). `report` (défaut) : journalisé et affiché, la sonde reste verte. `fail` : compte comme un écart et retient la mise en service — à n'activer que si aucune migration libre ne touche les tables d'entités. `off` : rien.")
+	}).default(() => ({
+		dir: "migrations",
+		lockTimeoutMs: 3e4,
+		divergence: "report"
+	})).describe("Réglages des migrations de schéma (dossier de l'application, sonde de disponibilité, verrou, dérive). Les commandes sont `nodefony orm:migrate`, `orm:migrate:status`, `orm:migrate:baseline`, `orm:migrate:repair` et `orm:reset`."),
+	frameworkEntities: z.boolean().default(true).describe("Déclare le schéma framework sur le connecteur `default` (tokens, audit, webauthn, webhooks, idempotence — tables créées au connect) et rend les stores correspondants sélectionnables par nom (`drizzle`). `false` = module data-only (aucune entité ni fabrique framework).")
+}).describe("Configuration de @nodefony/drizzle.");
+/**
+* Défauts du module, matérialisés depuis le schéma (source unique). Toujours
+* valides par construction ; passés au `super(..., config)` du Module class.
+*/
+const config = drizzleConfigSchema.parse({});
+//#endregion
+export { DDL_MODES, DIVERGENCE_MODES, MIGRATION_CHECK_MODES, SQL_DIALECTS, config as default, drizzleConfigSchema };

package/dist/nodefony/config/defineModuleConfig.js

@@ -0,0 +1,63 @@
+import { drizzleConfigSchema } from "./config.js";
+import { parseModuleConfig, resolveInfra, sqliteFilenameFromUrl } from "nodefony";
+import { z } from "zod";
+//#region nodefony/config/defineModuleConfig.ts
+/**
+* Applique la surcharge par variables d'environnement APRÈS le parse Zod.
+*
+* Le schéma reste pur ; l'env est une couche explicite par-dessus. Précédence :
+* env > config app > défauts.
+*
+* - Infra `database` (`NF_DATABASE_URL`, alias `DATABASE_URL`) de famille SQL →
+*   dialecte + cible du connecteur primaire (`default`, sinon le premier) :
+*   `sqlite:…` → `filename` ; `postgres://…`/`mysql://…` → `url`. Une URL
+*   `mongodb://` est IGNORÉE ici (l'infra appartient alors à `@nodefony/mongoose`).
+*/
+function applyEnvOverrides(config) {
+	const database = resolveInfra(process.env).database;
+	if (database && database.family === "sql" && database.dialect) {
+		const target = config.connectors.default ? "default" : Object.keys(config.connectors)[0];
+		const connector = target ? config.connectors[target] : void 0;
+		if (connector) {
+			connector.dialect = database.dialect;
+			if (database.dialect === "sqlite") {
+				connector.filename = sqliteFilenameFromUrl(database.url);
+				delete connector.url;
+			} else {
+				connector.url = database.url;
+				delete connector.filename;
+			}
+		}
+	}
+	return config;
+}
+/**
+* Builder type-safe de la configuration de `@nodefony/drizzle`.
+*
+* ⭐ TL;DR : MACHINERIE DE BOOT — on n'édite (presque) jamais ce fichier. Même
+* pattern que `nodefony.config.ts` ↔ `defineConfig()` du core : `config.ts` PORTE
+* la config (schéma + défauts), `define<X>Config()` la VALIDE au boot (parse +
+* env + freeze) et publie le JSON Schema Studio.
+*
+* Aligné sur `defineMongooseConfig` (l'autre driver ORM) : source unique
+* (`./config.ts`), VALIDE + applique l'ENV + GÈLE. Le **chemin SQLite par défaut**
+* (kernel-dépendant) n'est PAS résolu ici (schéma pur) mais dans `DrizzleService`
+* au boot — cf audit config ORM 2026-06 §3.2.
+*
+* @param config - configuration brute (sections omises = défauts sûrs).
+* @returns config validée, surchargée par l'env, et gelée.
+* @throws ZodError si la config est invalide.
+*/
+function defineDrizzleConfig(config = {}) {
+	const parsed = parseModuleConfig(drizzleConfigSchema, config, "@nodefony/drizzle");
+	return Object.freeze(applyEnvOverrides(parsed));
+}
+/**
+* JSON Schema introspectable de la config Drizzle — destiné au formulaire
+* d'édition Studio (futur) et à la documentation générée.
+*/
+function drizzleConfigJsonSchema() {
+	return z.toJSONSchema(drizzleConfigSchema);
+}
+//#endregion
+export { defineDrizzleConfig, drizzleConfigJsonSchema };