@nodefony/drizzle 10.0.0-alpha.1

package/dist/nodefony/entity/totpSecretEntity.js

@@ -0,0 +1,98 @@
+import { createFrameworkTableFactory } from "./colKit.js";
+import { entityRegistry } from "@nodefony/orm-core";
+/**
+* Factory de la table de secrets TOTP pour un dialecte donné (mémoïsée — une
+* instance par dialecte). **Les trois dialectes sont portés** (`TOTP_PORTED =
+* ALL_DIALECTS`, `registerStores.ts:92`) : sqlite, postgres et mysql.
+*/
+const createTotpSecretTable = createFrameworkTableFactory({
+	name: "totp_secret",
+	columns: {
+		/** Propriétaire du secret (clé naturelle — un seul secret par utilisateur). */
+		userId: {
+			kind: "text",
+			primaryKey: true
+		},
+		/** Secret partagé `K` **chiffré** (blob opaque `iv.tag.ciphertext` base64url). */
+		secretEnc: {
+			kind: "text",
+			notNull: true
+		},
+		/** Fonction HMAC du code (`SHA1`|`SHA256`|`SHA512`). */
+		algorithm: {
+			kind: "text",
+			notNull: true
+		},
+		/** Nombre de chiffres du code. */
+		digits: {
+			kind: "int",
+			notNull: true
+		},
+		/** Période d'un code en secondes. */
+		period: {
+			kind: "int",
+			notNull: true
+		},
+		/** Condensats `sha256` des codes de récupération non encore consommés. */
+		recoveryCodes: {
+			kind: "json",
+			notNull: true,
+			defaultFn: () => []
+		},
+		/** Confirmation de l'enrôlement (epoch ms) ou `null` (anti-lock-out). */
+		confirmedAt: { kind: "epochMs" },
+		/**
+		* Dernière tranche `T` validée (RFC 6238 §5.2, anti-rejeu) ou `null`.
+		*
+		* `int64` : `T = floor(epochSeconds / period)`, et `period` n'a pas de
+		* borne basse (schéma Zod : `positive()`). À `period` = 1 la tranche vaut
+		* l'horodatage Unix lui-même, qui dépasse l'entier 32 bits signé en 2038 —
+		* l'anti-rejeu cesserait alors de retenir, en silence.
+		*/
+		lastUsedStep: { kind: "int64" },
+		/** Création (epoch ms). */
+		createdAt: {
+			kind: "epochMs",
+			notNull: true
+		},
+		/** Dernier usage réussi (epoch ms) ou `null`. */
+		lastUsedAt: { kind: "epochMs" }
+	}
+});
+/**
+* Variante SQLite de la table de secrets TOTP (dialecte par défaut) — export
+* conservé pour l'usage direct/banc-test.
+*/
+const totpSecretTable = createTotpSecretTable("sqlite");
+/** Nom logique de l'entité (clé de lookup `getRepository`). */
+const TOTP_SECRET_ENTITY = "totp_secret";
+/**
+* Construit le descripteur d'entité du store de secrets TOTP pour un ORM nommé.
+* Le `connector` est **dynamique** (nom du connecteur de l'app) et la variante de table
+* suit le dialecte du connecteur (auto-register `registerStores.ts`). À enregistrer
+* **avant** `orm.connect()`. `module: "security"` → regroupé sous @nodefony/security
+* dans l'ERD Studio.
+*
+* @param orm - clé de l'ORM cible dans le `ormRegistry`.
+* @param dialect - dialecte SQL du connecteur (sélectionne la variante de table).
+*/
+function createTotpSecretEntity(connector, dialect = "sqlite") {
+	return {
+		connector,
+		name: TOTP_SECRET_ENTITY,
+		module: "security",
+		schema: createTotpSecretTable(dialect)
+	};
+}
+/**
+* Enregistre l'entité du store de secrets TOTP dans le `entityRegistry` pour un ORM
+* donné. À appeler **avant** `orm.connect()` (l'adapter crée la table au connect).
+*
+* @param connector - nom de la connexion cible (clé du registre).
+* @param dialect - dialecte SQL du connecteur (variante de table — défaut `sqlite`).
+*/
+function registerTotpSecretEntity(connector, dialect = "sqlite") {
+	entityRegistry.register(createTotpSecretEntity(connector, dialect));
+}
+//#endregion
+export { TOTP_SECRET_ENTITY, createTotpSecretEntity, createTotpSecretTable, registerTotpSecretEntity, totpSecretTable };

package/dist/nodefony/entity/userTable.js

@@ -0,0 +1,141 @@
+import { createFrameworkTableFactory } from "./colKit.js";
+import { entityRegistry } from "@nodefony/orm-core";
+import { USER_COLUMNS, USER_TABLE_NAME } from "@nodefony/user";
+import { getTableConfig } from "drizzle-orm/sqlite-core";
+import { getTableConfig as getTableConfig$1 } from "drizzle-orm/pg-core";
+import { getTableConfig as getTableConfig$2 } from "drizzle-orm/mysql-core";
+import { randomUUID } from "node:crypto";
+//#region nodefony/entity/userTable.ts
+/**
+* Traduction d'un type LOGIQUE du contrat utilisateur vers le type du colKit.
+*
+* C'est le seul endroit du module SQL qui connaisse ce vocabulaire : le contrat
+* dit ce que la donnée EST, le colKit dit comment chaque dialecte la range.
+*/
+const KIND_BY_TYPE = {
+	uuid: "text",
+	string: "text",
+	"string[]": "json",
+	boolean: "bool",
+	object: "json",
+	"object[]": "json",
+	date: "dateMs"
+};
+/**
+* Construit la spec colKit d'une colonne du contrat utilisateur.
+*
+* Les trois origines ne se déclarent pas pareil en SQL : la clé primaire reçoit
+* l'UUID applicatif, un horodatage reçoit l'heure courante (et se régénère si le
+* contrat le dit), une colonne ordinaire reçoit son défaut déclaré.
+*
+* ⚠️ Les défauts restent **JS-level** (`$defaultFn`) : le DDL dérivé n'émet pas
+* de `DEFAULT` SQL (règle du colKit). Une valeur absente à l'insertion est donc
+* comblée par le pilote, pas par le serveur.
+*/
+function toColSpec(column) {
+	const kind = KIND_BY_TYPE[column.type];
+	switch (column.origin) {
+		case "identity": return {
+			kind,
+			primaryKey: true,
+			defaultFn: () => randomUUID()
+		};
+		case "audit": return {
+			kind,
+			notNull: true,
+			defaultFn: () => /* @__PURE__ */ new Date(),
+			...column.refreshedOnWrite ? { onUpdateFn: () => /* @__PURE__ */ new Date() } : {}
+		};
+		case "column": return {
+			kind,
+			...column.nullable ? {} : { notNull: true },
+			...column.unique ? { unique: true } : {},
+			...column.makeDefault ? { defaultFn: column.makeDefault } : {}
+		};
+	}
+}
+/**
+* Entité de l'utilisateur Nodefony (schema-as-code) — implémentation SQL
+* **par défaut** du contrat `@nodefony/user`, **dérivée** de `USER_COLUMNS` et
+* déclinée par le `colKit` : une spec logique, la table du dialecte du
+* connecteur.
+*
+* Rien n'est recopié : les noms, les types logiques, les défauts et les
+* contraintes viennent du contrat. Ce fichier ne décide que de la traduction
+* vers SQL — ce qui est exactement ce qu'un adaptateur doit savoir, et rien de
+* plus. Une colonne ajoutée au contrat apparaît donc ici sans qu'on y touche,
+* et `tests/unit/userContractParity.test.ts` refuse le contraire.
+*
+* Les horodatages sont des colonnes EXPLICITES (kind `dateMs`, exposé `Date`) —
+* à la différence de Mongoose, qui les gère au niveau du schéma.
+*/
+const USER_TABLE_SPEC = {
+	name: USER_TABLE_NAME,
+	columns: Object.fromEntries(USER_COLUMNS.map((column) => [column.name, toColSpec(column)]))
+};
+/**
+* Factory de la table `User` pour un dialecte donné (mémoïsée — une instance
+* par dialecte). Les trois dialectes sont portés (`sqlite` par défaut).
+*/
+const createUserTable = createFrameworkTableFactory(USER_TABLE_SPEC);
+/**
+* Variante SQLite de la table `User` (dialecte par défaut) — export conservé
+* pour l'usage direct/banc-test (ex. module mediasoup).
+*/
+const userTable = createUserTable("sqlite");
+/**
+* Construit le descripteur d'entité `User` Drizzle pour un ORM nommé.
+*
+* Le `connector` est **dynamique** (nom du connecteur de l'app, ex. `"default"`) et la
+* variante de table suit le dialecte du connecteur (auto-register
+* `registerStores.ts` à `onKernelRegister`). À enregistrer dans `entityRegistry`
+* **avant** `orm.connect()` (cf {@link registerUserEntity}).
+*
+* @param orm - clé de l'ORM cible dans le `ormRegistry`.
+* @param dialect - dialecte SQL du connecteur (sélectionne la variante de table).
+* @returns descripteur {@link IEntity} (`name: "User"`).
+*/
+function createUserEntity(connector, dialect = "sqlite") {
+	return {
+		connector,
+		name: "User",
+		module: "user",
+		schema: createUserTable(dialect)
+	};
+}
+/**
+* Enregistre l'entité `User` Drizzle dans le `entityRegistry` pour un ORM donné.
+* À appeler **avant** `orm.connect()` (l'adapter compile/crée les tables au connect).
+*
+* @param connector - nom de la connexion cible (clé du registre).
+* @param dialect - dialecte SQL du connecteur (variante de table — défaut `sqlite`).
+*/
+function registerUserEntity(connector, dialect = "sqlite") {
+	entityRegistry.register(createUserEntity(connector, dialect));
+}
+/**
+* Colonnes d'une table Drizzle, lues dans la GRAMMAIRE de son dialecte.
+*
+* L'extraction n'a rien d'anodin : `getTableConfig` n'est pas la même fonction
+* selon le dialecte, et la mauvaise appliquée à une table LÈVE un
+* `TypeError: Cannot convert undefined or null to object` — mesuré sur les six
+* croisements, aucun ne rend un objet vide ni un résultat partiel. La
+* conséquence est la même dans les deux lectures qu'on pourrait en faire : un
+* appelant qui ne route pas par dialecte n'obtient RIEN d'exploitable. D'où un
+* seul point de lecture, partagé par le contrôle de démarrage et par le banc de
+* parité — et un dialecte qui doit suivre l'entité jusqu'ici.
+*
+* @param table - la table Drizzle, telle que l'entité la rend (`schema`).
+* @param dialect - dialecte du connecteur qui la porte.
+* @returns les colonnes indexées par nom SQL.
+*/
+function userTableColumns(table, dialect) {
+	const columns = dialect === "postgres" ? getTableConfig$1(table).columns : dialect === "mysql" ? getTableConfig$2(table).columns : getTableConfig(table).columns;
+	return new Map(columns.map((column) => [column.name, {
+		notNull: column.notNull,
+		isUnique: column.isUnique ?? false,
+		primary: column.primary
+	}]));
+}
+//#endregion
+export { createUserEntity, createUserTable, registerUserEntity, userTable, userTableColumns };

package/dist/nodefony/entity/webAuthnCredentialEntity.js

@@ -0,0 +1,114 @@
+import { createFrameworkTableFactory } from "./colKit.js";
+import { entityRegistry } from "@nodefony/orm-core";
+/**
+* Factory de la table de credentials pour un dialecte donné (mémoïsée — une
+* instance par dialecte). `sqlite` (défaut) et `postgres` sont portés ;
+* `mysql` jette (S4).
+*/
+const createWebAuthnCredentialTable = createFrameworkTableFactory({
+	name: "webauthn_credential",
+	columns: {
+		/** Identifiant du credential (base64url) — clé fournie par l'authenticator. */
+		id: {
+			kind: "text",
+			primaryKey: true
+		},
+		/** Propriétaire (sub / userHandle applicatif). */
+		userId: {
+			kind: "text",
+			notNull: true
+		},
+		/** Clé publique COSE encodée base64url. */
+		publicKey: {
+			kind: "text",
+			notNull: true
+		},
+		/**
+		* Compteur de signatures (anti-clone, §6.1.1).
+		*
+		* `int64` et non `int` : WebAuthn définit ce compteur comme un **uint32**
+		* (jusqu'à 4 294 967 295), qui déborde l'entier 32 bits SIGNÉ des trois
+		* dialectes. Un authenticator réel n'y arrivera pas, mais la valeur est
+		* fournie par le périphérique et rien ne la borne côté serveur.
+		*/
+		signCount: {
+			kind: "int64",
+			notNull: true
+		},
+		/** Transports annoncés (`usb`|`nfc`|`ble`|`internal`|`hybrid`). */
+		transports: {
+			kind: "json",
+			notNull: true,
+			defaultFn: () => []
+		},
+		/** BE flag (Backup Eligibility) — fixé à l'enregistrement. */
+		backupEligible: {
+			kind: "bool",
+			notNull: true
+		},
+		/** BS flag (Backup State) — peut évoluer. */
+		backupState: {
+			kind: "bool",
+			notNull: true
+		},
+		/** UV réalisée au moins une fois (base du step-up MFA). */
+		uvInitialized: {
+			kind: "bool",
+			notNull: true
+		},
+		/** Surnom choisi par l'utilisateur ; `null` = aucun. */
+		nickname: { kind: "text" },
+		/** Création (epoch ms). */
+		createdAt: {
+			kind: "epochMs",
+			notNull: true
+		},
+		/** Dernière authentification réussie (epoch ms) ou `null`. */
+		lastUsedAt: { kind: "epochMs" }
+	},
+	indexes: [{
+		name: "webauthn_credential_userId_idx",
+		on: ["userId"]
+	}]
+});
+/**
+* Variante SQLite de la table de credentials (dialecte par défaut) — export
+* conservé pour l'usage direct/banc-test.
+*/
+const webAuthnCredentialTable = createWebAuthnCredentialTable("sqlite");
+/** Nom logique de l'entité (clé de lookup `getRepository`). */
+const WEBAUTHN_CREDENTIAL_ENTITY = "webauthn_credential";
+/**
+* Construit le descripteur d'entité du store de credentials pour un ORM nommé.
+*
+* Le `connector` est **dynamique** (nom du connecteur de l'app, ex. `"default"`) et la
+* variante de table suit le dialecte du connecteur (auto-register
+* `registerStores.ts` à `onKernelRegister`). À enregistrer **avant**
+* `orm.connect()` (cf {@link registerWebAuthnCredentialEntity}).
+*
+* `module: "security"` → la table est regroupée sous @nodefony/security dans l'ERD
+* Studio (le store est une feature security, hébergée par l'ORM de l'app).
+*
+* @param orm - clé de l'ORM cible dans le `ormRegistry`.
+* @param dialect - dialecte SQL du connecteur (sélectionne la variante de table).
+*/
+function createWebAuthnCredentialEntity(connector, dialect = "sqlite") {
+	return {
+		connector,
+		name: WEBAUTHN_CREDENTIAL_ENTITY,
+		module: "security",
+		schema: createWebAuthnCredentialTable(dialect)
+	};
+}
+/**
+* Enregistre l'entité du store de credentials dans le `entityRegistry` pour un
+* ORM donné. À appeler **avant** `orm.connect()` (l'adapter crée la table au connect).
+*
+* @param connector - nom de la connexion cible (clé du registre).
+* @param dialect - dialecte SQL du connecteur (variante de table — défaut `sqlite`).
+*/
+function registerWebAuthnCredentialEntity(connector, dialect = "sqlite") {
+	entityRegistry.register(createWebAuthnCredentialEntity(connector, dialect));
+}
+//#endregion
+export { WEBAUTHN_CREDENTIAL_ENTITY, createWebAuthnCredentialEntity, createWebAuthnCredentialTable, registerWebAuthnCredentialEntity, webAuthnCredentialTable };

package/dist/nodefony/entity/webhookEndpointEntity.js

@@ -0,0 +1,106 @@
+import { createFrameworkTableFactory } from "./colKit.js";
+import { entityRegistry } from "@nodefony/orm-core";
+/** Factory de la table des endpoints (mémoïsée — une instance par dialecte). */
+const createWebhookEndpointTable = createFrameworkTableFactory({
+	name: "webhook_endpoint",
+	columns: {
+		/** Identifiant public stable (`wh_<random>`). */
+		id: {
+			kind: "text",
+			primaryKey: true
+		},
+		/** URL de destination (validée anti-SSRF à l'enregistrement). */
+		url: {
+			kind: "text",
+			notNull: true
+		},
+		/** Secret de signature **chiffré** au repos (blob `gcm1.…`). Jamais en clair. */
+		secretEnc: {
+			kind: "text",
+			notNull: true
+		},
+		/** Actions d'audit souscrites (`"*"` = toutes). */
+		events: {
+			kind: "json",
+			notNull: true,
+			defaultFn: () => []
+		},
+		/** Endpoint actif ? (désactivé = aucune livraison). */
+		enabled: {
+			kind: "bool",
+			notNull: true
+		},
+		/** Libellé humain optionnel (console admin) ; `null` = aucun. */
+		description: { kind: "text" },
+		/** Slot multi-tenant (réservé P17) — `null` = global. */
+		tenantId: { kind: "text" },
+		/** Identité de l'admin créateur (soft ref, traçabilité) ; `null` = inconnu. */
+		createdBy: { kind: "text" },
+		createdAt: {
+			kind: "epochMs",
+			notNull: true
+		},
+		updatedAt: {
+			kind: "epochMs",
+			notNull: true
+		},
+		/** Dernière tentative de livraison (epoch ms) ou `null`. */
+		lastDeliveryAt: { kind: "epochMs" },
+		/** Code HTTP de la dernière livraison, ou `null`. */
+		lastDeliveryStatus: { kind: "int" },
+		/** Message d'erreur de la dernière livraison, ou `null`. */
+		lastDeliveryError: { kind: "text" },
+		/** Échecs consécutifs (auto-désactivation au-delà d'un seuil). */
+		failureCount: {
+			kind: "int",
+			notNull: true
+		},
+		/** Métadonnées extensibles (jamais de secret). */
+		metadata: {
+			kind: "json",
+			notNull: true,
+			defaultFn: () => ({})
+		}
+	}
+});
+/**
+* Variante SQLite de la table (dialecte par défaut) — export conservé pour
+* l'usage direct/banc-test.
+*/
+const webhookEndpointTable = createWebhookEndpointTable("sqlite");
+/** Nom logique de l'entité (clé de lookup `getRepository`). */
+const WEBHOOK_ENDPOINT_ENTITY = "webhook_endpoint";
+/**
+* Construit le descripteur d'entité du store webhook pour un ORM nommé.
+*
+* Le `connector` est **dynamique** (nom du connecteur de l'app, ex. `"default"`) et la
+* variante de table suit le dialecte du connecteur (auto-register
+* `registerStores.ts` à `onKernelRegister`). À enregistrer **avant**
+* `orm.connect()`.
+*
+* `module: "security"` → la table est regroupée sous @nodefony/security dans
+* l'ERD Studio (le store est une feature security, hébergée par l'ORM de l'app).
+*
+* @param orm - clé de l'ORM cible dans le `ormRegistry`.
+* @param dialect - dialecte SQL du connecteur (sélectionne la variante de table).
+*/
+function createWebhookEndpointEntity(connector, dialect = "sqlite") {
+	return {
+		connector,
+		name: WEBHOOK_ENDPOINT_ENTITY,
+		module: "security",
+		schema: createWebhookEndpointTable(dialect)
+	};
+}
+/**
+* Enregistre l'entité du store webhook dans le `entityRegistry` pour un ORM
+* donné. À appeler **avant** `orm.connect()` (l'adapter crée la table au connect).
+*
+* @param connector - nom de la connexion cible (clé du registre).
+* @param dialect - dialecte SQL du connecteur (variante de table — défaut `sqlite`).
+*/
+function registerWebhookEndpointEntity(connector, dialect = "sqlite") {
+	entityRegistry.register(createWebhookEndpointEntity(connector, dialect));
+}
+//#endregion
+export { WEBHOOK_ENDPOINT_ENTITY, createWebhookEndpointEntity, createWebhookEndpointTable, registerWebhookEndpointEntity, webhookEndpointTable };

package/dist/nodefony/interfaces/IDrizzleConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/index.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/migrations-schema/mysql.js

@@ -0,0 +1,48 @@
+import { createAccessTokenTable, createDeniedJtiTable, createSubjectRevocationTable } from "../entity/tokenEntity.js";
+import { createAuditEventTable } from "../entity/auditEventEntity.js";
+import { createWebAuthnCredentialTable } from "../entity/webAuthnCredentialEntity.js";
+import { createTotpSecretTable } from "../entity/totpSecretEntity.js";
+import { createWebhookEndpointTable } from "../entity/webhookEndpointEntity.js";
+import { createIdempotencyTable } from "../entity/idempotencyEntity.js";
+import { createSessionTable } from "../entity/sessionEntity.js";
+//#region nodefony/migrations-schema/mysql.ts
+/**
+* Schéma **matérialisé** des tables du framework pour le dialecte `mysql` — la
+* seule entrée que `drizzle-kit` sait lire pour produire les migrations.
+*
+* ⚠️ **Trois contraintes de forme, mesurées, qu'une « factorisation » casserait
+* en silence** :
+*
+* 1. **Un fichier PAR dialecte.** Le dialecte est figé dans la configuration de
+*    `drizzle-kit`, pas passé en argument : il ne peut pas y avoir de fichier
+*    unique paramétré.
+* 2. **Des ré-exports PLATS.** `drizzle-kit` ne collecte que les tables exportées
+*    directement ; une table nichée dans un objet exporté est **ignorée sans un
+*    mot** (vérifié : un fichier exportant une table plate et une table nichée
+*    rend « 1 tables »). Regrouper ces dix constantes dans un objet ferait donc
+*    une migration VIDE, verte.
+* 3. **Rien d'autre que ces exports.** Toute constante supplémentaire de type
+*    table entrerait dans la migration.
+*
+* ⚠️ **`User` n'y figure pas, et c'est une décision.** L'identité est du DOMAINE :
+* la table appartient à l'APPLICATION, qui y ajoute ses champs et en porte les
+* migrations. La livrer ici la rendrait « table du framework » — donc exclue du
+* diff que l'application génère, en silence.
+*
+* Les trois fichiers sont volontairement identiques au dialecte près : ils ne
+* portent aucune décision, seulement l'application des fabriques du `colKit`.
+* La source de vérité reste la spécification de chaque entité — c'est elle qu'on
+* modifie, jamais ce fichier, et le contrôle de dérive le vérifie.
+*/
+const DIALECT = "mysql";
+const accessToken = createAccessTokenTable(DIALECT);
+const deniedJti = createDeniedJtiTable(DIALECT);
+const subjectRevocation = createSubjectRevocationTable(DIALECT);
+const session = createSessionTable(DIALECT);
+const idempotencyKey = createIdempotencyTable(DIALECT);
+const auditEvent = createAuditEventTable(DIALECT);
+const totpSecret = createTotpSecretTable(DIALECT);
+const webAuthnCredential = createWebAuthnCredentialTable(DIALECT);
+const webhookEndpoint = createWebhookEndpointTable(DIALECT);
+//#endregion
+export { accessToken, auditEvent, deniedJti, idempotencyKey, session, subjectRevocation, totpSecret, webAuthnCredential, webhookEndpoint };

package/dist/nodefony/migrations-schema/postgres.js

@@ -0,0 +1,48 @@
+import { createAccessTokenTable, createDeniedJtiTable, createSubjectRevocationTable } from "../entity/tokenEntity.js";
+import { createAuditEventTable } from "../entity/auditEventEntity.js";
+import { createWebAuthnCredentialTable } from "../entity/webAuthnCredentialEntity.js";
+import { createTotpSecretTable } from "../entity/totpSecretEntity.js";
+import { createWebhookEndpointTable } from "../entity/webhookEndpointEntity.js";
+import { createIdempotencyTable } from "../entity/idempotencyEntity.js";
+import { createSessionTable } from "../entity/sessionEntity.js";
+//#region nodefony/migrations-schema/postgres.ts
+/**
+* Schéma **matérialisé** des tables du framework pour le dialecte `postgres` — la
+* seule entrée que `drizzle-kit` sait lire pour produire les migrations.
+*
+* ⚠️ **Trois contraintes de forme, mesurées, qu'une « factorisation » casserait
+* en silence** :
+*
+* 1. **Un fichier PAR dialecte.** Le dialecte est figé dans la configuration de
+*    `drizzle-kit`, pas passé en argument : il ne peut pas y avoir de fichier
+*    unique paramétré.
+* 2. **Des ré-exports PLATS.** `drizzle-kit` ne collecte que les tables exportées
+*    directement ; une table nichée dans un objet exporté est **ignorée sans un
+*    mot** (vérifié : un fichier exportant une table plate et une table nichée
+*    rend « 1 tables »). Regrouper ces dix constantes dans un objet ferait donc
+*    une migration VIDE, verte.
+* 3. **Rien d'autre que ces exports.** Toute constante supplémentaire de type
+*    table entrerait dans la migration.
+*
+* ⚠️ **`User` n'y figure pas, et c'est une décision.** L'identité est du DOMAINE :
+* la table appartient à l'APPLICATION, qui y ajoute ses champs et en porte les
+* migrations. La livrer ici la rendrait « table du framework » — donc exclue du
+* diff que l'application génère, en silence.
+*
+* Les trois fichiers sont volontairement identiques au dialecte près : ils ne
+* portent aucune décision, seulement l'application des fabriques du `colKit`.
+* La source de vérité reste la spécification de chaque entité — c'est elle qu'on
+* modifie, jamais ce fichier, et le contrôle de dérive le vérifie.
+*/
+const DIALECT = "postgres";
+const accessToken = createAccessTokenTable(DIALECT);
+const deniedJti = createDeniedJtiTable(DIALECT);
+const subjectRevocation = createSubjectRevocationTable(DIALECT);
+const session = createSessionTable(DIALECT);
+const idempotencyKey = createIdempotencyTable(DIALECT);
+const auditEvent = createAuditEventTable(DIALECT);
+const totpSecret = createTotpSecretTable(DIALECT);
+const webAuthnCredential = createWebAuthnCredentialTable(DIALECT);
+const webhookEndpoint = createWebhookEndpointTable(DIALECT);
+//#endregion
+export { accessToken, auditEvent, deniedJti, idempotencyKey, session, subjectRevocation, totpSecret, webAuthnCredential, webhookEndpoint };

package/dist/nodefony/migrations-schema/sqlite.js

@@ -0,0 +1,48 @@
+import { createAccessTokenTable, createDeniedJtiTable, createSubjectRevocationTable } from "../entity/tokenEntity.js";
+import { createAuditEventTable } from "../entity/auditEventEntity.js";
+import { createWebAuthnCredentialTable } from "../entity/webAuthnCredentialEntity.js";
+import { createTotpSecretTable } from "../entity/totpSecretEntity.js";
+import { createWebhookEndpointTable } from "../entity/webhookEndpointEntity.js";
+import { createIdempotencyTable } from "../entity/idempotencyEntity.js";
+import { createSessionTable } from "../entity/sessionEntity.js";
+//#region nodefony/migrations-schema/sqlite.ts
+/**
+* Schéma **matérialisé** des tables du framework pour le dialecte `sqlite` — la
+* seule entrée que `drizzle-kit` sait lire pour produire les migrations.
+*
+* ⚠️ **Trois contraintes de forme, mesurées, qu'une « factorisation » casserait
+* en silence** :
+*
+* 1. **Un fichier PAR dialecte.** Le dialecte est figé dans la configuration de
+*    `drizzle-kit`, pas passé en argument : il ne peut pas y avoir de fichier
+*    unique paramétré.
+* 2. **Des ré-exports PLATS.** `drizzle-kit` ne collecte que les tables exportées
+*    directement ; une table nichée dans un objet exporté est **ignorée sans un
+*    mot** (vérifié : un fichier exportant une table plate et une table nichée
+*    rend « 1 tables »). Regrouper ces dix constantes dans un objet ferait donc
+*    une migration VIDE, verte.
+* 3. **Rien d'autre que ces exports.** Toute constante supplémentaire de type
+*    table entrerait dans la migration.
+*
+* ⚠️ **`User` n'y figure pas, et c'est une décision.** L'identité est du DOMAINE :
+* la table appartient à l'APPLICATION, qui y ajoute ses champs et en porte les
+* migrations. La livrer ici la rendrait « table du framework » — donc exclue du
+* diff que l'application génère, en silence.
+*
+* Les trois fichiers sont volontairement identiques au dialecte près : ils ne
+* portent aucune décision, seulement l'application des fabriques du `colKit`.
+* La source de vérité reste la spécification de chaque entité — c'est elle qu'on
+* modifie, jamais ce fichier, et le contrôle de dérive le vérifie.
+*/
+const DIALECT = "sqlite";
+const accessToken = createAccessTokenTable(DIALECT);
+const deniedJti = createDeniedJtiTable(DIALECT);
+const subjectRevocation = createSubjectRevocationTable(DIALECT);
+const session = createSessionTable(DIALECT);
+const idempotencyKey = createIdempotencyTable(DIALECT);
+const auditEvent = createAuditEventTable(DIALECT);
+const totpSecret = createTotpSecretTable(DIALECT);
+const webAuthnCredential = createWebAuthnCredentialTable(DIALECT);
+const webhookEndpoint = createWebhookEndpointTable(DIALECT);
+//#endregion
+export { accessToken, auditEvent, deniedJti, idempotencyKey, session, subjectRevocation, totpSecret, webAuthnCredential, webhookEndpoint };