@nodefony/drizzle 10.0.0-alpha.1

package/dist/nodefony/registerStores.js

@@ -0,0 +1,218 @@
+import { DrizzleOrm } from "./src/orm-core/DrizzleOrm.js";
+import "./src/orm-core/index.js";
+import { TOKEN_ENTITY_NAMES, registerTokenEntities } from "./entity/tokenEntity.js";
+import { AUDIT_ENTITY_NAMES, registerAuditEntities } from "./entity/auditEventEntity.js";
+import { WEBAUTHN_CREDENTIAL_ENTITY, registerWebAuthnCredentialEntity } from "./entity/webAuthnCredentialEntity.js";
+import { TOTP_SECRET_ENTITY, registerTotpSecretEntity } from "./entity/totpSecretEntity.js";
+import { WEBHOOK_ENDPOINT_ENTITY, registerWebhookEndpointEntity } from "./entity/webhookEndpointEntity.js";
+import { IDEMPOTENCY_ENTITY_NAME, createIdempotencyTable, registerIdempotencyEntities } from "./entity/idempotencyEntity.js";
+import { SESSION_CONNECTOR, SESSION_ENTITY_NAME, registerSessionEntity } from "./entity/sessionEntity.js";
+import { registerUserEntity, userTableColumns } from "./entity/userTable.js";
+import { DrizzleTokenStore } from "./src/DrizzleTokenStore.js";
+import { DrizzleAuditStore } from "./src/DrizzleAuditStore.js";
+import { DrizzleWebAuthnCredentialStore } from "./src/DrizzleWebAuthnCredentialStore.js";
+import { DrizzleTotpSecretStore } from "./src/DrizzleTotpSecretStore.js";
+import { DrizzleWebhookStore } from "./src/DrizzleWebhookStore.js";
+import { DrizzleIdempotencyStore } from "./src/DrizzleIdempotencyStore.js";
+import { entityRegistry, ormRegistry } from "@nodefony/orm-core";
+import { assertUserContract } from "@nodefony/user";
+import { getAuditStoreFactory, getTokenStoreFactory, getTotpStoreFactory, getWebAuthnStoreFactory, getWebhookStoreFactory, registerAuditStore, registerTokenStore, registerTotpStore, registerWebAuthnStore, registerWebhookStore } from "@nodefony/security";
+import { getIdempotencyStoreFactory, registerIdempotencyStore } from "@nodefony/framework";
+//#region nodefony/registerStores.ts
+/**
+* AUTO-ENREGISTREMENT des backends framework portés par Drizzle — « charger le
+* module = ses backends deviennent sélectionnables par simple nom ».
+*
+* Appelé par `Drizzle.onKernelRegister` (config validée → dialecte du connecteur
+* `default` connu, AVANT le connect de `onBoot` → les tables sont créées au
+* connect). Remplace l'« approche B » historique où chaque application devait
+* câbler `registerXStore(...)` + `registerXEntities(...)` à la main.
+*
+* Deux garde-fous préservent la main de l'application (customisation) :
+* - **entité** : `entityRegistry.has(name, orm)` → une entité déjà enregistrée
+*   par l'app est respectée (jamais de doublon-throw) ;
+* - **fabrique** : `getXStoreFactory("drizzle")` → une fabrique déjà posée par
+*   l'app garde la main (le registre est premier-arrivé-premier-servi ici).
+*
+* Une brique dont l'entité n'est PAS portée sur le dialecte configuré n'est NI
+* déclarée NI fabricable : les registres reflètent le RÉEL (`listXStores()` ne
+* promet jamais un backend qui échouerait), et la sélectionner échoue franc au
+* boot (« store inconnu ») — jamais de table fantôme ni d'erreur SQL différée.
+*/
+/**
+* Connecteur conventionnel qui héberge le schéma framework (même convention que
+* `SESSION_CONNECTOR` : `"default"` pour Drizzle, `"nodefony"` pour Mongoose).
+*/
+const FRAMEWORK_CONNECTOR = "default";
+/** Portage par entité (chantier multi-dialecte — Ph.2.1 allume les cases). */
+const ALL_DIALECTS = [
+	"sqlite",
+	"postgres",
+	"mysql"
+];
+const IDEMPOTENCY_PORTED = ALL_DIALECTS;
+const SESSION_PORTED = ALL_DIALECTS;
+const TOKEN_PORTED = ALL_DIALECTS;
+const WEBAUTHN_PORTED = ALL_DIALECTS;
+const TOTP_PORTED = ALL_DIALECTS;
+const USER_PORTED = ALL_DIALECTS;
+const AUDIT_PORTED = ALL_DIALECTS;
+const WEBHOOK_PORTED = ALL_DIALECTS;
+/**
+* Les entités que le REPLI a posées, par connecteur — `<connecteur>:<entité>`.
+*
+* Elle existe pour une question qu'aucun autre objet ne sait trancher : cette
+* entité vient-elle de l'APPLICATION, ou le framework l'a-t-il posée faute de
+* mieux ? Le registre d'entités, lui, ne retient pas qui a écrit. Or la réponse
+* décide d'un refus de démarrage : une entité de repli n'est dans AUCUNE chaîne
+* de migration, donc sa table n'existe nulle part hors développement.
+*/
+const fallbackEntities = /* @__PURE__ */ new Set();
+/** Clé de {@link fallbackEntities} — une entité vit par connecteur. */
+function fallbackKey(entityName, connector) {
+	return `${connector}:${entityName}`;
+}
+/**
+* Cette entité a-t-elle été posée par le repli du framework ?
+*
+* @param entityName - nom de l'entité (`"User"`…).
+* @param connector - connecteur porteur.
+* @returns `true` si le framework l'a enregistrée lui-même, faute d'entité d'app.
+*/
+function isFrameworkFallbackEntity(entityName, connector = FRAMEWORK_CONNECTOR) {
+	return fallbackEntities.has(fallbackKey(entityName, connector));
+}
+/**
+* Résout l'ORM `default` CONNECTÉ pour une fabrique de store — échec FRANC avec
+* la cause exacte (module absent / ordre de boot / dialecte) : principe « pas de
+* dégradation silencieuse ».
+*/
+function resolveConnectedOrm(store, dialect) {
+	let orm;
+	try {
+		orm = ormRegistry.get(FRAMEWORK_CONNECTOR);
+	} catch {
+		throw new Error(`${store} : ORM "${FRAMEWORK_CONNECTOR}" introuvable — charger @nodefony/drizzle AVANT @nodefony/security dans le manifeste "modules".`);
+	}
+	if (!(orm instanceof DrizzleOrm)) throw new Error(`${store} : l'ORM "${FRAMEWORK_CONNECTOR}" n'est pas un DrizzleOrm (connecteur homonyme d'un autre driver ?).`);
+	if (!orm.isConnected()) throw new Error(`${store} : ORM "${FRAMEWORK_CONNECTOR}" non connecté au montage du store (ordre de boot).`);
+	if (orm.dialect !== dialect) throw new Error(`${store} : ORM "${FRAMEWORK_CONNECTOR}" en "${orm.dialect}" mais le schéma framework a été déclaré en "${dialect}" (incohérence de config).`);
+	return orm;
+}
+/**
+* Déclare les entités framework portées sur `dialect` (connecteur `default`) et
+* enregistre leurs fabriques de stores dans les registres de `@nodefony/security`
+* et `@nodefony/framework`. Idempotent (guards) — rejouable sans effet.
+*
+* @param dialect - dialecte du connecteur `default` (config validée du module)
+* @returns bilan à logger (registered / appOwned / unported)
+*/
+function registerDrizzleFrameworkStores(dialect) {
+	const report = {
+		registered: [],
+		appOwned: [],
+		unported: []
+	};
+	fallbackEntities.clear();
+	const wire = (entityName, ported, registerEntity, registerFactory) => {
+		if (!ported.includes(dialect)) {
+			report.unported.push(entityName);
+			return;
+		}
+		if (entityRegistry.has(entityName, "default")) report.appOwned.push(entityName);
+		else {
+			registerEntity();
+			report.registered.push(entityName);
+			fallbackEntities.add(fallbackKey(entityName, FRAMEWORK_CONNECTOR));
+		}
+		registerFactory();
+	};
+	wire(SESSION_ENTITY_NAME, SESSION_PORTED, () => registerSessionEntity(SESSION_CONNECTOR, dialect), () => {});
+	wire("User", USER_PORTED, () => registerUserEntity(FRAMEWORK_CONNECTOR, dialect), () => {});
+	wire(TOKEN_ENTITY_NAMES.records, TOKEN_PORTED, () => registerTokenEntities(FRAMEWORK_CONNECTOR, dialect), () => {
+		if (getTokenStoreFactory("drizzle")) return;
+		registerTokenStore("drizzle", (ctx) => {
+			const orm = resolveConnectedOrm(`tokenStore "drizzle"`, dialect);
+			const days = ctx?.config?.tokenStore?.retentionRevokedDays;
+			return DrizzleTokenStore.from(orm, void 0, typeof days === "number" ? days * 864e5 : void 0);
+		});
+	});
+	wire(AUDIT_ENTITY_NAMES.events, AUDIT_PORTED, () => registerAuditEntities(FRAMEWORK_CONNECTOR, dialect), () => {
+		if (getAuditStoreFactory("drizzle")) return;
+		registerAuditStore("drizzle", (ctx) => {
+			const orm = resolveConnectedOrm(`audit.store "drizzle"`, dialect);
+			const days = ctx?.config?.audit?.retentionDays;
+			return DrizzleAuditStore.from(orm, void 0, typeof days === "number" ? days * 864e5 : void 0);
+		});
+	});
+	wire(WEBAUTHN_CREDENTIAL_ENTITY, WEBAUTHN_PORTED, () => registerWebAuthnCredentialEntity(FRAMEWORK_CONNECTOR, dialect), () => {
+		if (getWebAuthnStoreFactory("drizzle")) return;
+		registerWebAuthnStore("drizzle", () => DrizzleWebAuthnCredentialStore.from(resolveConnectedOrm(`passkeys.store "drizzle"`, dialect)));
+	});
+	wire(TOTP_SECRET_ENTITY, TOTP_PORTED, () => registerTotpSecretEntity(FRAMEWORK_CONNECTOR, dialect), () => {
+		if (getTotpStoreFactory("drizzle")) return;
+		registerTotpStore("drizzle", () => DrizzleTotpSecretStore.from(resolveConnectedOrm(`totp.store "drizzle"`, dialect)));
+	});
+	wire(WEBHOOK_ENDPOINT_ENTITY, WEBHOOK_PORTED, () => registerWebhookEndpointEntity(FRAMEWORK_CONNECTOR, dialect), () => {
+		if (getWebhookStoreFactory("drizzle")) return;
+		registerWebhookStore("drizzle", () => DrizzleWebhookStore.from(resolveConnectedOrm(`webhooks.store "drizzle"`, dialect)));
+	});
+	wire(IDEMPOTENCY_ENTITY_NAME, IDEMPOTENCY_PORTED, () => registerIdempotencyEntities(FRAMEWORK_CONNECTOR, dialect), () => {
+		if (getIdempotencyStoreFactory("drizzle")) return;
+		registerIdempotencyStore("drizzle", () => {
+			const resolveDb = () => {
+				let orm;
+				try {
+					orm = ormRegistry.get(FRAMEWORK_CONNECTOR);
+				} catch {
+					return null;
+				}
+				if (!(orm instanceof DrizzleOrm) || !orm.isConnected()) return null;
+				return orm.getNativeConnection();
+			};
+			return new DrizzleIdempotencyStore(resolveDb, void 0, void 0, void 0, createIdempotencyTable(dialect), () => {
+				try {
+					const orm = ormRegistry.get(FRAMEWORK_CONNECTOR);
+					return orm instanceof DrizzleOrm ? orm.location : void 0;
+				} catch {
+					return;
+				}
+			});
+		});
+	});
+	if (report.appOwned.includes("User")) assertAppUserEntityHonoursContract(dialect);
+	return report;
+}
+/**
+* Confronte l'entité `User` déclarée par l'application au contrat de colonnes.
+*
+* Appelé au moment où l'auto-register CONSTATE que l'application possède son
+* entité — donc au démarrage, avant qu'un seul lecteur n'ait tenté quoi que ce
+* soit. Le message vient de {@link assertUserContract} : une règle, un texte,
+* partagés avec l'adaptateur document.
+*
+* Le silence en cas de schéma illisible est délibéré : une entité dont la table
+* ne se laisse pas inspecter (driver tiers, forme inattendue, table déclarée
+* dans la grammaire d'un AUTRE dialecte — {@link userTableColumns} lève alors)
+* ne prouve PAS qu'une colonne manque. Refuser sur cette base transformerait un
+* contrôle en panne de démarrage pour une application parfaitement correcte —
+* et un refus faux apprend surtout à passer outre les refus.
+*
+* @param dialect - dialecte du connecteur framework, qui décide de la grammaire
+*   de lecture de la table.
+* @throws Error si une colonne du contrat manque à l'entité de l'application.
+*/
+function assertAppUserEntityHonoursContract(dialect) {
+	let present;
+	try {
+		const entity = entityRegistry.get("User", FRAMEWORK_CONNECTOR);
+		const columns = userTableColumns(entity.schema, dialect);
+		if (columns.size === 0) return;
+		present = columns.keys();
+	} catch {
+		return;
+	}
+	assertUserContract(present, `L'entité « User » de cette application (connecteur « ${FRAMEWORK_CONNECTOR} », ${dialect})`);
+}
+//#endregion
+export { FRAMEWORK_CONNECTOR, isFrameworkFallbackEntity, registerDrizzleFrameworkStores };

package/dist/nodefony/service/DrizzleService.js

@@ -0,0 +1,282 @@
+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 { describeDivergence } from "../src/migrator/divergence.js";
+import { DrizzleOrm } from "../src/orm-core/DrizzleOrm.js";
+import "../src/orm-core/index.js";
+import { dataLoss, renderDestructive, scanDestructive, summarizeDestructive } from "../src/migrator/destructive.js";
+import { BootConfigurationError, Service } from "nodefony";
+import { queryFlowMonitor, resolveOrmFlowEnabled } from "@nodefony/orm-core";
+import fs from "node:fs";
+import path from "node:path";
+//#region nodefony/service/DrizzleService.ts
+const serviceName = "drizzle";
+/**
+* Période de re-vérification du schéma quand la mise en service est retenue.
+*
+* C'est ce minuteur, et lui seul, qui donne au processus sa propriété la plus
+* précieuse : **il redevient disponible TOUT SEUL** dès que les migrations sont
+* appliquées par ailleurs — aucun redéploiement, aucune intervention. Sans lui,
+* un exemplaire retenu le resterait jusqu'à ce qu'on pense à le relancer.
+*
+* Quinze secondes : assez court pour qu'un déploiement ne perde pas de temps,
+* assez long pour être invisible (une requête sur une table minuscule). Le
+* minuteur n'existe QUE lorsque le schéma n'est pas dérivé du code — en
+* développement, il n'est jamais créé.
+*/
+const READINESS_POLL_MS = 15e3;
+/**
+* Ce que chaque mode veut dire, en clair, dans le journal de démarrage.
+*
+* Une ligne de journal qui dit `ddl: none` n'apprend rien à qui n'a pas lu la
+* documentation — et personne ne la lit AVANT l'incident. La phrase, elle,
+* suffit.
+*/
+const DDL_EXPLAINED = {
+	auto: "(dérivé du code au démarrage — développement ; les colonnes manquantes qui acceptent le vide sont ajoutées)",
+	migrate: "(migrations appliquées au démarrage, sous verrou — un seul exemplaire assumé)",
+	none: "(personne ne touche au schéma ici — un travail externe lance « nodefony orm:migrate »)"
+};
+/** Nom du contributeur de disponibilité, tel qu'il apparaît au diagnostic. */
+function readinessName(connector) {
+	return `drizzle:schema:${connector}`;
+}
+/** URL de connexion sans credentials — un log de boot ne porte jamais de secret. */
+function redactUrl(url) {
+	if (!url) return "no url";
+	try {
+		const parsed = new URL(url);
+		if (parsed.password) parsed.password = "***";
+		return parsed.toString();
+	} catch {
+		return "invalid url";
+	}
+}
+/**
+* Service bootable du module `@nodefony/drizzle`.
+*
+* Au boot du kernel (`onBoot`), instancie un {@link DrizzleOrm} (adapter
+* orm-core) **par connecteur** déclaré dans la config et le connecte ; chaque
+* ORM s'auto-enregistre dans le `ormRegistry` (accessible ensuite via DI ou
+* `OrmRegistry.get(name)`). Ferme proprement les connexions à `onTerminate`.
+*
+* C'est le point d'entrée « ORM par défaut » de l'app : il rend Drizzle utilisable
+* sans logique métier — les entités (`@entity`) ciblant un connecteur sont
+* compilées à la connexion (aucune au départ = base connectée mais vide).
+*/
+var DrizzleService = class extends Service {
+	module;
+	/** ORM connectés, indexés par nom de connecteur. */
+	#orms = /* @__PURE__ */ new Map();
+	/**
+	* Minuteurs de re-vérification du schéma, par connecteur.
+	*
+	* `null` tant que personne n'en a besoin — c'est le cas de TOUT le
+	* développement, où le schéma est dérivé du code : aucun objet alloué, aucun
+	* minuteur armé, aucune requête périodique. Ils ne naissent que pour les
+	* connecteurs dont le schéma appartient aux migrations.
+	*/
+	#watchers = null;
+	constructor(module) {
+		super(serviceName, module.container, module.notificationsCenter, module.options ?? {});
+		this.module = module;
+		this.module.hookKernel("onBoot", async () => {
+			queryFlowMonitor.setEnabled(resolveOrmFlowEnabled(this.kernel));
+			await this.connectAll().catch((e) => {
+				this.log(e, "ERROR");
+				throw e;
+			});
+		});
+		this.kernel?.once("onTerminate", async () => {
+			this.#stopWatchers();
+			await this.disconnectAll().catch(() => {});
+		});
+	}
+	/** Config validée (Zod) exposée par le Module (`this.module.config`). */
+	#config() {
+		return this.module.config;
+	}
+	/** Connecte tous les connecteurs déclarés en config (validée Zod). */
+	async connectAll() {
+		const connectors = this.#config()?.connectors ?? {};
+		for (const [name, cfg] of Object.entries(connectors)) await this.#connectOne(name, cfg);
+	}
+	/**
+	* Chemin SQLite par défaut d'un connecteur, résolu AU BOOT (kernel présent —
+	* jamais au top-level d'un import) : `<app>/var/databases/nodefony-<x>.db`.
+	*
+	* Sous `kernel.varDir` (= `<app>/var`) = la base COMMUNE des données runtime
+	* persistées (stores fichier + bases SQLite, lot 1 « varDir ») → un seul
+	* répertoire à sauvegarder/gitignorer, et « où sont mes données » a une réponse
+	* unique. Fallback `<root>/var` si le kernel n'a pas encore matérialisé `varDir`.
+	*/
+	#defaultFilename(name) {
+		return defaultConnectorFilename(this.kernel, name);
+	}
+	/** Connecte un connecteur (crée le dossier de la base SQLite si nécessaire). */
+	async #connectOne(name, cfg) {
+		const dialect = cfg.dialect ?? "sqlite";
+		const ddl = resolveDdlMode(cfg.ddl, readMigrationEnv(this.kernel));
+		let filename;
+		if (dialect === "sqlite") {
+			filename = cfg.filename ?? this.#defaultFilename(name);
+			if (filename !== ":memory:") fs.mkdirSync(path.dirname(filename), { recursive: true });
+		}
+		const orm = new DrizzleOrm(name, {
+			dialect,
+			filename,
+			url: cfg.url,
+			deriveSchema: ddl === "auto",
+			migrationStatus: async () => {
+				const { migrationStatusFor } = await import("../src/migrator/status.js");
+				const result = await migrationStatusFor(name, this.#config(), this.kernel);
+				return result.ok ? result.report : result.failure;
+			},
+			migrationPlan: async () => {
+				const { migrationPlanFor } = await import("../src/migrator/status.js");
+				const result = await migrationPlanFor(name, this.#config(), this.kernel);
+				return result.ok ? result.plan : result.failure;
+			},
+			applyMigrations: async () => {
+				const { applyMigrationsFor } = await import("../src/migrator/status.js");
+				const result = await applyMigrationsFor(name, this.#config(), this.kernel);
+				return result.ok ? result.run : result.failure;
+			}
+		});
+		const target = dialect === "sqlite" ? filename : redactUrl(cfg.url);
+		try {
+			await orm.connect();
+		} catch (e) {
+			const cause = e instanceof Error ? e.message : String(e);
+			throw new BootConfigurationError(`Drizzle : le connecteur "${name}" (${dialect}: ${target}) n'a pas pu se connecter — corriger la configuration (infra déclarée NF_DATABASE_URL/connectors, base démarrée ?, entités portées sur ce dialecte ?) ou la retirer. Cause : ${cause}`, { cause: e });
+		}
+		this.#orms.set(name, orm);
+		this.log(`Drizzle « ${name} » connecté (${dialect}: ${target}) — schéma : ${ddl} ${DDL_EXPLAINED[ddl]}`, "INFO");
+		await this.#applySchemaPolicy(name, ddl, cfg, dialect, filename);
+	}
+	/**
+	* Fait ce que le mode de schéma demande, et l'ÉNONCE.
+	*
+	* - `auto` : le schéma vient d'être dérivé du code, il n'y a rien de plus à
+	*   faire et rien à surveiller ;
+	* - `migrate` : les migrations sont appliquées ici, sous verrou ;
+	* - `none` : personne ne touche au schéma, on se contente de constater.
+	*
+	* Dans les deux derniers cas, l'état est publié à la sonde de disponibilité
+	* puis re-vérifié périodiquement.
+	*
+	* **Aucune de ces situations ne tue le processus.** Un schéma en retard est un
+	* état EXTÉRIEUR au processus : le redémarrer ne répare rien, et un
+	* redéploiement forcé coûterait plus cher que d'attendre. Le processus reste
+	* donc vivant, refuse le trafic, dit pourquoi — et repart tout seul.
+	*/
+	async #applySchemaPolicy(name, ddl, cfg, dialect, filename) {
+		if (ddl === "auto") return;
+		const kernel = this.kernel;
+		const config = this.#config();
+		const check = resolveCheckMode(config.migrations?.check, readMigrationEnv(kernel));
+		const target = {
+			dialect,
+			filename,
+			url: cfg.url
+		};
+		const sources = await defaultMigrationSources(appMigrationsDir(kernel, config.migrations?.dir ?? "migrations"), { framework: config.frameworkEntities !== false });
+		const migrator = new DrizzleMigrator({
+			connector: name,
+			...target,
+			sources,
+			lockTimeoutMs: config.migrations?.lockTimeoutMs
+		});
+		if (ddl === "migrate") try {
+			const prevu = await migrator.status();
+			const losses = dataLoss(scanDestructive(prevu.pending));
+			if (losses.length > 0) {
+				this.log(`${summarizeDestructive(losses, name)}\n  Le démarrage N'APPLIQUE PAS ces migrations : un exemplaire qui redémarre ne supprime jamais de données de lui-même.\n` + renderDestructive(losses, true) + `  À faire, une fois la décision prise : nodefony orm:migrate --connector ${name} --allow-destructive`, "CRITIC");
+				await this.#publishReadiness(name, migrator, ddl, check);
+				this.#watch(name, migrator, ddl, check);
+				return;
+			}
+			const run = await migrator.migrate();
+			if (run.applied.length > 0) this.log(`Drizzle « ${name} » : ${run.applied.length} migration(s) appliquée(s) au démarrage — ` + run.applied.map((a) => `${a.source}/${a.tag}`).join(", "), "INFO");
+		} catch (e) {
+			this.log(`Drizzle « ${name} » : les migrations n'ont pas pu être appliquées au démarrage — ${e.message}\n  Le processus reste vivant mais NE reçoit PAS de trafic. Il redeviendra disponible seul dès que le schéma sera à jour.\n  Diagnostic : nodefony orm:migrate:status --connector ${name} --json`, "CRITIC");
+		}
+		await this.#publishReadiness(name, migrator, ddl, check);
+		this.#watch(name, migrator, ddl, check);
+	}
+	/**
+	* Calcule l'état du schéma et le publie à la sonde de disponibilité.
+	*
+	* Le verdict est **déjà calculé** quand la sonde le lit : `/readyz` ne fait
+	* qu'une comparaison d'entier, sans `await` ni allocation. C'est ce qui la
+	* rend insensible à une base qui tombe — une sonde qui interrogerait la base
+	* tomberait avec elle, et l'orchestrateur conclurait que le processus est mort
+	* alors que c'est la base qui l'est.
+	*
+	* ⚠️ Elle ne touche JAMAIS `/livez`. Un schéma en retard n'est pas un
+	* processus malade : le tuer et le relancer ne changerait rien, et ferait
+	* boucler l'orchestrateur sur des redémarrages inutiles.
+	*/
+	async #publishReadiness(name, migrator, ddl, check) {
+		if (check === "off") return;
+		const kernel = this.kernel;
+		if (!kernel) return;
+		try {
+			const plan = await migrator.status();
+			const mode = this.#config().migrations?.divergence ?? "report";
+			const report = buildReport(plan, {
+				ddl,
+				divergence: mode === "off" ? null : await describeDivergence(plan),
+				divergenceMode: mode,
+				canReset: resetAllowed(readMigrationEnv(kernel))
+			});
+			const enAvance = isAheadOnly(plan);
+			const ok = report.exitCode === 0 || enAvance;
+			kernel.setReadiness(readinessName(name), ok, report.summary, check === "fail");
+			if (enAvance) this.log(`Drizzle « ${name} » : la base porte ${plan.missing.length} migration(s) que ce code ne connaît pas — elle est EN AVANCE. C'est attendu pendant un déploiement progressif ou après un retour arrière ; rien à appliquer, le processus peut servir.`, "INFO");
+			else if (!ok) this.log(`Drizzle « ${name} » : ${report.summary}\n  ${meaningOf(report.verdict)}\n` + (check === "fail" ? "  → le trafic est RETENU (/readyz répond 503) jusqu'à ce que ce soit réglé ; /livez reste vert, ce processus n'est pas malade.\n" : `  → le trafic passe quand même (migrations.check: "warn").\n`) + report.nextActions.map((a) => `  À faire : ${a.command}`).join("\n"), check === "fail" ? "CRITIC" : "WARNING");
+			else if (check === "fail") this.log(`Drizzle « ${name} » : schéma à jour — le processus peut servir.`, "INFO");
+		} catch (e) {
+			const cause = e.message;
+			if (check === "fail") kernel.setReadiness(readinessName(name), false, `état du schéma inconnu : ${cause}`);
+			this.log(`Drizzle « ${name} » : impossible de lire l'état du schéma — ${cause}\n  Ce n'est pas un schéma en retard : la base n'a pas répondu. Nouvelle tentative dans ${Math.round(READINESS_POLL_MS / 1e3)} s.\n  Diagnostic : nodefony orm:migrate:status --connector ${name} --json`, "CRITIC");
+		}
+	}
+	/**
+	* Arme la re-vérification périodique — le mécanisme qui rend le processus
+	* capable de redevenir disponible sans qu'on y touche.
+	*/
+	#watch(name, migrator, ddl, check) {
+		if (check === "off") return;
+		if (this.#watchers === null) this.#watchers = /* @__PURE__ */ new Map();
+		const timer = setInterval(() => {
+			this.#publishReadiness(name, migrator, ddl, check).catch(() => void 0);
+		}, READINESS_POLL_MS);
+		timer.unref();
+		this.#watchers.set(name, timer);
+	}
+	/** Éteint toutes les surveillances et libère le registre. */
+	#stopWatchers() {
+		if (this.#watchers === null) return;
+		const kernel = this.kernel;
+		for (const [name, timer] of this.#watchers) {
+			clearInterval(timer);
+			kernel?.clearReadiness(readinessName(name));
+		}
+		this.#watchers.clear();
+		this.#watchers = null;
+	}
+	/** Ferme toutes les connexions. */
+	async disconnectAll() {
+		for (const orm of this.#orms.values()) await orm.disconnect();
+		this.#orms.clear();
+	}
+	/** Retourne l'ORM Drizzle d'un connecteur (défaut : `"default"`). */
+	getOrm(name = "default") {
+		return this.#orms.get(name);
+	}
+};
+//#endregion
+export { DrizzleService as default };