@nodefony/drizzle 10.0.0-alpha.1

package/dist/_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js

@@ -0,0 +1,9 @@
+//#region \0@oxc-project+runtime@0.148.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);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { __decorate as default };

package/dist/_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js

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

package/dist/index.js

@@ -0,0 +1,105 @@
+import config, { DDL_MODES, DIVERGENCE_MODES, MIGRATION_CHECK_MODES, drizzleConfigSchema } from "./nodefony/config/config.js";
+import { defineDrizzleConfig, drizzleConfigJsonSchema } from "./nodefony/config/defineModuleConfig.js";
+import { FORMAT_MARKER, HISTORY_TABLE, MIGRATE_URL_ENV, MigrationVerdictError } from "./nodefony/src/migrator/types.js";
+import { EXIT, MIGRATION_FORMAT_VERSION, action, buildReport, exitCodeOf, meaningOf, renderRefusal, renderStatus, styleFor, verdictOf } from "./nodefony/src/migrator/explain.js";
+import { MYSQL_LOCK_NAME_SQL } from "./nodefony/src/migrator/drivers/mysqlDriver.js";
+import { PG_LOCK_KEY } from "./nodefony/src/migrator/drivers/postgresDriver.js";
+import { openMigrationDriver } from "./nodefony/src/migrator/drivers/index.js";
+import { APP_RANK, APP_SOURCE, FRAMEWORK_RANK, FRAMEWORK_SOURCE, defaultMigrationSources, frameworkMigrationsDir } from "./nodefony/src/migrator/paths.js";
+import { migrationHash } from "./nodefony/src/migrator/hash.js";
+import { loadSources, orderSources } from "./nodefony/src/migrator/sources.js";
+import { DEFAULT_LOCK_TIMEOUT_MS, DrizzleMigrator } from "./nodefony/src/migrator/DrizzleMigrator.js";
+import { appMigrationsDir, buildMigrator, knownConnectors, readMigrationEnv, resetAllowed, resolveCheckMode, resolveConnector, resolveDdlMode, resolveDivergenceMode } from "./nodefony/src/migrator/resolve.js";
+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 "./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";
+import { AUDIT_ENTITY_NAMES, auditEventTable, createAuditEntities, createAuditEventTable, registerAuditEntities } from "./nodefony/entity/auditEventEntity.js";
+import { WEBAUTHN_CREDENTIAL_ENTITY, createWebAuthnCredentialEntity, createWebAuthnCredentialTable, registerWebAuthnCredentialEntity, webAuthnCredentialTable } from "./nodefony/entity/webAuthnCredentialEntity.js";
+import { TOTP_SECRET_ENTITY, createTotpSecretEntity, createTotpSecretTable, registerTotpSecretEntity, totpSecretTable } from "./nodefony/entity/totpSecretEntity.js";
+import { WEBHOOK_ENDPOINT_ENTITY, createWebhookEndpointEntity, createWebhookEndpointTable, registerWebhookEndpointEntity, webhookEndpointTable } from "./nodefony/entity/webhookEndpointEntity.js";
+import { IDEMPOTENCY_ENTITY_NAME, createIdempotencyEntities, createIdempotencyTable, idempotencyKeyTable, registerIdempotencyEntities } from "./nodefony/entity/idempotencyEntity.js";
+import { SESSION_CONNECTOR, SESSION_ENTITY_NAME, createSessionEntity, createSessionTable, registerSessionEntity, sessionTable } from "./nodefony/entity/sessionEntity.js";
+import { createUserEntity, createUserTable, registerUserEntity, userTable } from "./nodefony/entity/userTable.js";
+import { DrizzleTokenStore } from "./nodefony/src/DrizzleTokenStore.js";
+import { DrizzleAuditStore } from "./nodefony/src/DrizzleAuditStore.js";
+import { DrizzleWebAuthnCredentialStore } from "./nodefony/src/DrizzleWebAuthnCredentialStore.js";
+import { DrizzleTotpSecretStore } from "./nodefony/src/DrizzleTotpSecretStore.js";
+import { DrizzleWebhookStore } from "./nodefony/src/DrizzleWebhookStore.js";
+import { DrizzleIdempotencyStore } from "./nodefony/src/DrizzleIdempotencyStore.js";
+import { FRAMEWORK_CONNECTOR, isFrameworkFallbackEntity, registerDrizzleFrameworkStores } from "./nodefony/registerStores.js";
+import OrmGenerate from "./nodefony/command/orm-generate.js";
+import OrmMigrate from "./nodefony/command/orm-migrate.js";
+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.148.0/helpers/esm/decorateMetadata.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.148.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";
+import { Kernel, Module, services } from "nodefony";
+import { wireOrmAdminPlane } from "@nodefony/orm-core";
+import { registerUserStore } from "@nodefony/user";
+//#region index.ts
+/**
+* `@nodefony/drizzle` — module Drizzle ORM (driver `better-sqlite3`) sur
+* `@nodefony/orm-core`.
+*
+* **Module bootable** : enregistré dans `@modules()`, son {@link DrizzleService}
+* connecte au boot un {@link DrizzleOrm} par connecteur configuré (ORM par défaut
+* SQL recommandé). Expose aussi les **classes adapter** (orm-core) pour un usage
+* direct/banc-test. driver concret du socle multi-ORM (avec Mongoose) ; type-safe-first (a figé la forme des opérateurs riches, ADR-0003 #3).
+*/
+let Drizzle = class Drizzle extends Module {
+	constructor(kernel) {
+		super("drizzle", kernel, import.meta.url, config);
+		this.addCommand(OrmGenerate);
+		this.addCommand(OrmMigrate);
+		this.addCommand(OrmMigrateStatus);
+		this.addCommand(OrmMigrateBaseline);
+		this.addCommand(OrmMigrateRepair);
+		this.addCommand(OrmReset);
+	}
+	/** JSON Schema de la config drizzle → data plane admin (config riche Studio). */
+	configSchema() {
+		return drizzleConfigJsonSchema();
+	}
+	/**
+	* Valide la config (défauts + `module.options` + surcharge env) au boot via
+	* `defineDrizzleConfig`, et l'expose au container sous `drizzleConfig` pour que
+	* le `DrizzleService` la consomme. Plante propre si la config est invalide
+	* (convention Zod, alignée sur `@nodefony/mongoose` — audit config ORM 2026-06).
+	*/
+	async onKernelRegister() {
+		const validated = defineDrizzleConfig(this.options ?? {});
+		this.options = validated;
+		registerUserStore("drizzle");
+		if (validated.frameworkEntities !== false) {
+			const dialect = validated.connectors?.default?.dialect ?? "sqlite";
+			const report = registerDrizzleFrameworkStores(dialect);
+			if (report.unported.length) this.log(`schéma framework : entités non portées sur "${dialect}" → stores drizzle indisponibles pour [${report.unported.join(", ")}] (chantier multi-dialecte Ph.2.1)`, "WARNING");
+			if (report.appOwned.length) this.log(`schéma framework : entités déjà enregistrées par l'app [${report.appOwned.join(", ")}] — auto-register respecte l'app`, "DEBUG");
+			if (report.registered.length) this.log(`schéma framework déclaré sur "${FRAMEWORK_CONNECTOR}" (${dialect}) : [${report.registered.join(", ")}]`, "DEBUG");
+		}
+		return this;
+	}
+	/**
+	* Monte le data plane ORM (`/nodefony/orm/api/*` + providers santé/flux pour la
+	* sonde cluster et le drill Studio) via {@link wireOrmAdminPlane}. Branchement
+	* GLOBAL (couvre tous les ORM) et idempotent — factorisé en orm-core (C5), chaque
+	* driver l'invoque à l'identique. orm-core étant une lib pure, c'est un module
+	* driver qui le déclenche (avant le `mountAll` de framework à `onKernelReady`).
+	*/
+	async onKernelBoot() {
+		wireOrmAdminPlane(this.kernel);
+		return this;
+	}
+};
+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 };

package/dist/nodefony/command/migrateShared.js

@@ -0,0 +1,247 @@
+import { HISTORY_TABLE, MigrationVerdictError } from "../src/migrator/types.js";
+import { EXIT, action, describeDiscovery, refusalInMode, renderRefusal, styleFor } from "../src/migrator/explain.js";
+import { missingHistoryColumn } from "../src/migrator/history.js";
+import { buildMigrator, readMigrationEnv, resolveConnector } from "../src/migrator/resolve.js";
+import { MigrationToolError, describeResolutionRefusal, moduleAbsent } from "../src/migrator/refusals.js";
+import { composeReport } from "../src/migrator/status.js";
+import { Command, resolveColorEnabled } from "nodefony";
+//#region nodefony/command/migrateShared.ts
+/**
+* Socle commun des commandes `orm:*` — ce qui garantit qu'aucune d'elles ne
+* laisse l'utilisateur, humain ou agent, devant une sortie muette.
+*
+* ## Les quatre garanties, et pourquoi elles vivent ICI
+*
+* 1. **Toute sortie porte un geste.** Succès, attente, refus ou panne : la
+*    commande écrit le fait, ce qu'il signifie, et la ligne exacte à copier.
+*    Écrites dans chaque commande, ces trois parties finiraient par manquer
+*    dans celle qu'on écrit un jour de fatigue — c'est justement celle qu'on
+*    rencontre en incident.
+* 2. **`--json` est un flux PUR.** La sortie standard n'appartient qu'aux
+*    données : un objet, une ligne, rien d'autre. Y compris en échec — un agent
+*    qui a demandé du JSON doit pouvoir lire l'échec comme il lit le succès. Le
+*    journal du démarrage, lui, est déjà écarté vers la sortie d'erreur par le
+*    cœur, qui reconnaît `--json` dans les arguments avant même de brancher le
+*    journal.
+* 3. **Aucune exception ne remonte nue.** Une pile d'appels n'est pas un
+*    message : elle ne dit ni ce qui s'est passé, ni quoi faire. Tout est
+*    rattrapé et traduit.
+* 4. **La grille des codes de sortie est tenue en un seul endroit** — `0` à
+*    jour ou appliqué, `1` action requise, `2` la commande n'a pas pu faire son
+*    travail. Cette grille part chez l'utilisateur dans des passes
+*    d'intégration continue et des travaux de déploiement : la réaffecter plus
+*    tard casserait des contrôles qu'on ne voit pas.
+*/
+/** Nom du module qui porte la configuration des connecteurs SQL. */
+const MODULE_NAME = "drizzle";
+/**
+* Classe de base des commandes `orm:*`.
+*
+* Elle n'impose rien du verbe : chaque commande écrit son `generate`. Elle
+* impose la FORME de ce qui sort, parce que c'est cette forme qui fait la
+* différence entre un outil qu'on sait utiliser et un outil qu'on subit.
+*/
+var OrmMigrateCommand = class extends Command {
+	/**
+	* Faut-il colorer la sortie ?
+	*
+	* 🔴 La question n'est PAS « est-ce un terminal ? », et la confondre avec ça
+	* a deux conséquences que personne ne signale :
+	*
+	* - **`NO_COLOR` est ignoré.** C'est une convention publique
+	*   (no-color.org) qu'un utilisateur pose une fois pour toutes ses commandes ;
+	*   la manquer rend une sortie illisible sur un terminal à palette
+	*   inhabituelle, et le framework passe pour cassé.
+	* - **`FORCE_COLOR` est ignoré.** Sans lui, aucune sortie colorée n'est
+	*   CAPTURABLE : ni dans un fichier, ni dans une passe d'intégration continue
+	*   qui sait rendre les couleurs, ni dans un rapport de validation. On ne peut
+	*   alors pas relire ce que l'exploitant voit vraiment.
+	*
+	* La règle vit au CŒUR (`resolveColorEnabled`), qui sert déjà les journaux :
+	* la réécrire ici en ferait une SECONDE implémentation, et les deux
+	* divergeraient — le journal obéirait à `NO_COLOR`, la commande non.
+	*/
+	get tty() {
+		return resolveColorEnabled(process.stdout.isTTY === true);
+	}
+	/** Mise en forme, neutralisée hors terminal. */
+	get style() {
+		return styleFor(this.tty);
+	}
+	/**
+	* Configuration validée du module qui porte les connecteurs SQL.
+	*
+	* @returns la configuration, ou `null` si le module n'est pas chargé.
+	*/
+	drizzleConfig() {
+		const mod = (this.kernel?.modules)?.[MODULE_NAME];
+		return mod ? mod.config : null;
+	}
+	/**
+	* Écrit une charge utile sur la sortie standard et pose le code de sortie.
+	*
+	* `process.exitCode` et jamais `process.exit()` : couper le processus laisse
+	* la sortie standard non vidée, et un `| jq` reçoit alors un objet tronqué —
+	* un échec qui ressemble à un défaut de la commande.
+	*
+	* @param payload - l'objet, en mode machine.
+	* @param human - le texte, en mode humain.
+	* @param exitCode - `0`, `1` ou `2`.
+	* @param json - la commande a-t-elle reçu `--json` ?
+	*/
+	respond(payload, human, exitCode, json) {
+		if (json === true) process.stdout.write(`${JSON.stringify(payload)}\n`);
+		else process.stdout.write(human.endsWith("\n") ? human : `${human}\n`);
+		if (exitCode !== 0) process.exitCode = exitCode;
+	}
+	/**
+	* Arrête la commande en disant le fait, la cause et le geste.
+	*
+	* @param connector - connecteur concerné (ou le nom demandé).
+	* @param code - code d'arrêt stable, lu par les machines.
+	* @param summary - le fait, en français.
+	* @param meaning - ce que ça veut dire.
+	* @param actions - les commandes exactes à copier.
+	* @param json - la commande a-t-elle reçu `--json` ?
+	* @param exitCode - `2` par défaut : la commande n'a pas pu travailler.
+	* @param discovery - ce que la découverte des entités a vu, quand le refus
+	*   peut avoir pour cause un schéma déclaré amputé.
+	*/
+	fail(connector, code, summary, meaning, actions, json, exitCode = EXIT.error, discovery) {
+		const style = this.style;
+		const payload = {
+			formatVersion: 1,
+			connector,
+			exitCode,
+			error: {
+				code,
+				summary,
+				meaning,
+				nextActions: actions,
+				...discovery ? { discovery } : {}
+			}
+		};
+		let human = `${style.red(style.bold("Impossible"))} ${style.dim(`[${code}]`)}\n\n${summary}\n`;
+		if (meaning) human += `\n${style.dim(meaning)}\n`;
+		if (discovery) human += describeDiscovery(discovery, style);
+		if (actions.length > 0) {
+			human += `\n${style.bold("À faire :")}\n`;
+			for (const a of actions) human += `  ${style.green(a.command)}\n`;
+		}
+		if (json === true) process.stdout.write(`${JSON.stringify(payload)}\n`);
+		else process.stderr.write(human);
+		process.exitCode = exitCode;
+	}
+	/**
+	* Résout le connecteur demandé, ou ARRÊTE la commande en le disant.
+	*
+	* Les **trois** réponses sont un contrat public, et elles restent distinctes :
+	* un connecteur inconnu, un connecteur porté par un ORM sans migrations, un
+	* connecteur prêt. Le jour où un second ORM apporte ses propres migrations,
+	* seule la deuxième cesse de sortir pour ses connecteurs — répondre « ne
+	* porte pas de migrations » à un connecteur qui en porte serait un message
+	* FAUX, et un message faux publié est appris par les scripts qui le lisent.
+	*
+	* @param opts - options de la commande (connecteur, mode machine).
+	* @param allowMigrateUrl - la commande honore-t-elle {@link MIGRATE_URL_ENV} ?
+	* @returns le connecteur prêt, ou `null` si la commande est déjà arrêtée.
+	*/
+	resolveOrFail(opts, allowMigrateUrl) {
+		const wanted = opts.connector ?? "default";
+		const config = this.drizzleConfig();
+		if (!config) {
+			const refusal = moduleAbsent();
+			this.fail(wanted, refusal.code, refusal.summary, refusal.meaning, refusal.nextActions, opts.json, refusal.exitCode);
+			return null;
+		}
+		const resolution = resolveConnector(wanted, config, readMigrationEnv(this.kernel), this.kernel, { allowMigrateUrl });
+		if (resolution.kind !== "ready") {
+			const refusal = describeResolutionRefusal(wanted, resolution, config);
+			this.fail(wanted, refusal.code, refusal.summary, refusal.meaning, refusal.nextActions, opts.json, refusal.exitCode);
+			return null;
+		}
+		return {
+			resolution,
+			config
+		};
+	}
+	/**
+	* Construit l'applicateur d'un connecteur résolu.
+	*
+	* @param resolution - connecteur prêt.
+	* @param config - configuration validée.
+	* @returns l'applicateur, sources chargées.
+	*/
+	async migrator(resolution, config) {
+		return buildMigrator(resolution, config, this.kernel);
+	}
+	/**
+	* Compose la charge utile d'un état.
+	*
+	* L'assemblage lui-même vit dans `migrator/status.ts` : le plan
+	* d'administration publie le MÊME objet, et deux assemblages divergeaient
+	* d'un champ à l'autre sans qu'aucun test ne le voie.
+	*
+	* @param plan - plan calculé par l'applicateur, en lecture seule.
+	* @param resolution - connecteur prêt (porte le mode de schéma effectif).
+	* @param config - configuration validée du module.
+	* @returns la charge utile, prête pour `--json` comme pour l'écran.
+	*/
+	async report(plan, resolution, config) {
+		return composeReport(plan, resolution, config, this.kernel);
+	}
+	failFrom(e, connector, json, ddl) {
+		if (e instanceof MigrationVerdictError) {
+			const style = this.style;
+			const enMode = ddl ? refusalInMode(e.verdict.code, ddl, connector) : null;
+			const payload = {
+				formatVersion: 1,
+				connector,
+				exitCode: e.verdict.code === "NF_MIGRATE_LOCK_TIMEOUT" ? EXIT.error : EXIT.actionRequired,
+				error: {
+					code: e.verdict.code,
+					summary: e.message,
+					meaning: enMode?.meaning ?? "",
+					nextActions: enMode?.actions ?? [...e.verdict.nextActions]
+				}
+			};
+			if (json === true) process.stdout.write(`${JSON.stringify(payload)}\n`);
+			else process.stderr.write(renderRefusal(e.verdict, e.message, style, ddl));
+			process.exitCode = payload.exitCode;
+			return;
+		}
+		if (e instanceof MigrationToolError) {
+			const { code, summary, meaning, nextActions, exitCode } = e.refusal;
+			this.fail(connector, code, summary, meaning, nextActions, json, exitCode);
+			return;
+		}
+		const cause = e instanceof Error ? e.message : String(e);
+		const column = missingHistoryColumn(cause);
+		if (column !== null) {
+			this.fail(connector, "NF_MIGRATE_HISTORY_FOREIGN", `La table « ${HISTORY_TABLE} » de cette base n'est pas celle du framework : la colonne « ${column} » y manque. Rien n'a été appliqué.`, `Une table de ce nom existe déjà, avec d'autres colonnes — le framework ne la remplace jamais, et ne peut pas la lire. Deux provenances, deux gestes. Base d'ESSAI fabriquée à la main : ne pas écrire l'historique soi-même, mais COPIER la base d'origine (le fichier en sqlite, un export « pg_dump » / « mysqldump » ailleurs) — c'est cette copie qui porte déjà le bon historique. Base RÉELLE venue d'un autre outil de migration : la table porte le même nom par coïncidence ; la renommer, ou faire porter le framework sur une autre base. Dans tous les cas la base n'est PAS en cause : elle a répondu, et ce n'est pas une question de droits.`, [action("nodefony orm:migrate:status --json"), action("nodefony inspect config --json")], json, EXIT.actionRequired);
+			return;
+		}
+		this.fail(connector, "NF_MIGRATE_UNAVAILABLE", `La commande n'a pas pu travailler sur le connecteur « ${connector} » : ${cause}`, "La commande s'est arrêtée sans avoir pu nommer la cause. Les deux explications les plus fréquentes : la base n'a pas répondu, ou le compte utilisé n'a pas les droits nécessaires — celui qui migre a besoin de pouvoir créer et modifier des tables, ce que le compte qui sert le trafic n'a normalement pas. Avant de reprendre, CONSTATER l'état : `orm:migrate:status` dit ce que la base porte et ce que l'historique en dit.", [action("nodefony orm:migrate:status --json"), action("nodefony inspect config --json")], json);
+	}
+	/**
+	* Écrit un état lu et pose son code de sortie.
+	*
+	* @param report - charge utile complète.
+	* @param human - rendu humain déjà composé.
+	* @param json - la commande a-t-elle reçu `--json` ?
+	*/
+	emitReport(report, human, json) {
+		this.respond(report, human, report.exitCode, json);
+	}
+	/** Déclare les deux options que toutes les commandes de migration portent. */
+	addSharedOptions() {
+		this.addOption("-c, --connector <nom>", "connecteur SQL visé (défaut : default) — c'est une clé de `connectors` dans la configuration");
+		this.addOption("-j, --json", "sortie machine : un objet sur la sortie standard, le journal sur la sortie d'erreur (`| jq` sûr)");
+	}
+	/** Le CLI courant, typé — utilisé pour les réglages de boot silencieux. */
+	get cliKernel() {
+		return this.cli;
+	}
+};
+//#endregion
+export { OrmMigrateCommand };