@nodefony/drizzle 10.0.0-alpha.1

package/dist/types/nodefony/entity/auditEventEntity.d.ts

@@ -0,0 +1,56 @@
+import type { SQLiteTable } from "drizzle-orm/sqlite-core";
+import type { IEntity } from "@nodefony/orm-core";
+import type { AuditCategory, AuditOutcome, IAuditEventFlags } from "@nodefony/security";
+import type { SqlDialect } from "../interfaces/IDrizzleConfig.js";
+/** Factory de la table du journal (mémoïsée — une instance par dialecte). */
+export declare const createAuditEventTable: import("./colKit.js").FrameworkTableFactory;
+/**
+ * Variante SQLite de la table (dialecte par défaut) — export conservé pour
+ * l'usage direct/banc-test.
+ */
+export declare const auditEventTable: SQLiteTable;
+/**
+ * Forme plate d'une ligne du journal d'audit. Miroir d'`IAuditEvent` avec les
+ * champs optionnels rendus explicitement `| null` (colonnes NULLABLE SQL). Le
+ * store mappe `null` ↔ `undefined` aux frontières.
+ */
+export interface AuditEventRow {
+    id: string;
+    ts: number;
+    category: AuditCategory;
+    action: string;
+    outcome: AuditOutcome;
+    actor: string | null;
+    resource: string | null;
+    reason: string | null;
+    ip: string | null;
+    userAgent: string | null;
+    requestId: string | null;
+    flags: IAuditEventFlags | null;
+    metadata: Record<string, unknown> | null;
+}
+/** Noms logiques des entités du store (clés de lookup `getRepository`). */
+export declare const AUDIT_ENTITY_NAMES: {
+    readonly events: "audit_event";
+};
+/**
+ * Construit les descripteurs d'entités du journal d'audit 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 registerAuditEntities}).
+ *
+ * @param orm - clé de l'ORM cible dans le `ormRegistry`.
+ * @param dialect - dialecte SQL du connecteur (sélectionne la variante de table).
+ * @returns le descripteur {@link IEntity} du journal d'audit.
+ */
+export declare function createAuditEntities(connector: string, dialect?: SqlDialect): IEntity[];
+/**
+ * Enregistre les entités du journal d'audit dans le `entityRegistry` pour un ORM
+ * donné. À appeler **avant** `orm.connect()` (l'adapter 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`).
+ */
+export declare function registerAuditEntities(connector: string, dialect?: SqlDialect): void;

package/dist/types/nodefony/entity/colKit.d.ts

@@ -0,0 +1,130 @@
+import type { SQLiteTable } from "drizzle-orm/sqlite-core";
+import type { PgTable } from "drizzle-orm/pg-core";
+import type { MySqlTable } from "drizzle-orm/mysql-core";
+import type { SqlDialect } from "../interfaces/IDrizzleConfig.js";
+/**
+ * colKit — kit de colonnes partagé des **entités framework** (chantier
+ * portabilité multi-dialecte, garde-fou G1 du comparatif ORM
+ * mémoire IA `core-dev/audits/orm-comparatif-froid-2026-07.md`).
+ *
+ * **Pourquoi** : Drizzle est schema-as-code *par dialecte* (`sqliteTable` ≠
+ * `pgTable`, builders de colonnes distincts). Sans kit, chaque entité duplique
+ * sa déclaration par dialecte (×2 aujourd'hui, ×3 avec mysql) — vécu sur
+ * `idempotencyEntity` (2 tables parallèles). Le colKit inverse le rapport :
+ * **une spec logique par entité**, le kit produit la table du dialecte demandé.
+ * Ajouter mysql (S4) = étendre CE fichier, pas les 8 entités.
+ *
+ * **Règles portées par construction** :
+ * - mêmes **NOMS** de colonnes sur tous les dialectes → stores/repositories
+ *   dialect-agnostiques (l'invariant central du chantier) ;
+ * - divergences de TYPE assumées ici et nulle part ailleurs : epoch ms =
+ *   `integer` SQLite (64-bit) / `bigint mode:"number"` PG+MySQL (`integer` PG
+ *   32-bit déborde) ; JSON = `text mode:"json"` SQLite / `jsonb` PG / `json`
+ *   MySQL ; booléen = `integer mode:"boolean"` SQLite / `boolean` PG+MySQL ;
+ *   date JS (`dateMs`, exposée `Date`) = `integer mode:"timestamp_ms"` SQLite /
+ *   `timestamptz(3)` PG / `datetime(3)` MySQL (pas `timestamp` : borne 2038) ;
+ *   texte = `text` partout SAUF MySQL où une colonne PK/UNIQUE/indexée devient
+ *   `varchar(512)` (InnoDB ne peut pas indexer TEXT sans longueur de préfixe ;
+ *   512 × 4 bytes utf8mb4 = 2048 < 3072, la limite d'index DYNAMIC, et couvre
+ *   la clé d'idempotence ~330 chars max) ;
+ * - **entier 64 bits (`int64`) dès qu'une valeur peut croître sans borne
+ *   connue** : `int` est un entier 32 bits signé sur les trois dialectes
+ *   (2 147 483 647), et un compteur qui le dépasse ne rend pas une erreur
+ *   lisible — il tronque ou refuse l'écriture, des années après la mise en
+ *   production. `int` reste réservé aux valeurs bornées par le domaine (un
+ *   nombre de chiffres, un code de statut HTTP) ;
+ * - **valeurs énumérées bornées en base (`enum`) et non seulement dans le
+ *   type** — la contrainte `CHECK` est émise dans le `CREATE TABLE` (DDL
+ *   dérivé ET drizzle-kit), donc un écrivain qui contournerait la frontière
+ *   typée est refusé par le serveur ;
+ * - défauts en **`$defaultFn`/`$onUpdateFn` (JS-level) uniquement** — le DDL
+ *   dérivé (`getTableConfig` → `DrizzleOrm.#buildCreateTable`) n'émet PAS les
+ *   `DEFAULT` SQL (gotcha `userTable`). Les `index` déclarés, eux, SONT émis
+ *   (`DrizzleOrm.#buildCreateIndexes`, `CREATE INDEX IF NOT EXISTS`) — les clés
+ *   étrangères restent le domaine de drizzle-kit (migrations prod).
+ *
+ * **Interne au module** (décision audit) : pas d'export dans `index.ts` — les
+ * entités de l'app choisissent LEUR dialecte et écrivent leurs tables Drizzle
+ * natives ; exposer le kit serait une sur-promesse d'API à maintenir.
+ */
+/** Types logiques couverts par les entités framework (étendre ici si besoin). */
+export type FrameworkColKind = "text" | "json" | "bool" | "epochMs" | "int" | "int64" | "dateMs" | "enum";
+/** Modificateurs communs à toutes les colonnes, quel que soit le type logique. */
+interface IFrameworkColMods {
+    primaryKey?: boolean;
+    notNull?: boolean;
+    unique?: boolean;
+    /** Défaut JS-level (`$defaultFn`) — JAMAIS de `DEFAULT` SQL (cf. doc du kit). */
+    defaultFn?: () => unknown;
+    /** Régénéré à chaque UPDATE (`$onUpdateFn`) — pendant SQL d'`updatedAt`. */
+    onUpdateFn?: () => unknown;
+}
+/** Colonne scalaire — le type logique suffit à la décrire. */
+interface IFrameworkScalarColSpec extends IFrameworkColMods {
+    /** Type logique — traduit vers le type natif du dialecte. */
+    kind: Exclude<FrameworkColKind, "enum">;
+}
+/**
+ * Colonne à valeurs énumérées — stockée en texte, **bornée par un `CHECK`**
+ * émis dans le `CREATE TABLE` (DDL dérivé dev/test ET drizzle-kit en prod).
+ *
+ * ⚠️ **Un `CHECK` se grave à vie** : une fois la migration `0000` publiée, y
+ * ajouter une valeur impose une migration correctrice visible chez chaque
+ * utilisateur. Ne l'employer que sur un ensemble **fermé par construction** —
+ * les états d'un automate dont l'élargissement serait de toute façon une
+ * rupture de contrat (ex. `if`/`done` du protocole d'idempotence). Un
+ * **catalogue** appelé à s'étendre (algorithme de hachage, catégorie d'audit,
+ * type de sujet) reste un `text` : son union vit sur le type `Row`, où elle ne
+ * coûte rien à faire évoluer.
+ */
+interface IFrameworkEnumColSpec extends IFrameworkColMods {
+    kind: "enum";
+    /** Valeurs admises — au moins une, gravées dans la contrainte `CHECK`. */
+    values: readonly [string, ...string[]];
+}
+/** Spécification logique d'une colonne d'entité framework. */
+export type IFrameworkColSpec = IFrameworkScalarColSpec | IFrameworkEnumColSpec;
+/** Index déclaratif — émis par le DDL dérivé (dev) et par drizzle-kit (prod). */
+export interface IFrameworkIndexSpec {
+    name: string;
+    /** Noms de colonnes de la spec (validés au build — fail-loud). */
+    on: readonly string[];
+    unique?: boolean;
+}
+/** Spécification logique complète d'une table d'entité framework. */
+export interface IFrameworkTableSpec {
+    name: string;
+    columns: Record<string, IFrameworkColSpec>;
+    indexes?: readonly IFrameworkIndexSpec[];
+}
+/**
+ * Construit la table Drizzle d'une spec logique pour un dialecte donné —
+ * **LE point unique** où « dialecte » se traduit en schéma (garde-fou G1 :
+ * ajouter un dialecte = une branche ICI + les types du switch de colonnes).
+ *
+ * @param dialect - dialecte SQL cible.
+ * @param spec - spec logique de la table.
+ * @returns la table Drizzle du dialecte.
+ */
+export declare function buildFrameworkTable(dialect: "sqlite", spec: IFrameworkTableSpec): SQLiteTable;
+export declare function buildFrameworkTable(dialect: "postgres", spec: IFrameworkTableSpec): PgTable;
+export declare function buildFrameworkTable(dialect: "mysql", spec: IFrameworkTableSpec): MySqlTable;
+export declare function buildFrameworkTable(dialect: SqlDialect, spec: IFrameworkTableSpec): SQLiteTable | PgTable | MySqlTable;
+/** Factory mémoïsée d'une entité framework — overloads par dialecte littéral. */
+export interface FrameworkTableFactory {
+    (dialect: "sqlite"): SQLiteTable;
+    (dialect: "postgres"): PgTable;
+    (dialect: "mysql"): MySqlTable;
+    (dialect?: SqlDialect): SQLiteTable | PgTable | MySqlTable;
+}
+/**
+ * Fabrique la factory `createXTable(dialect)` d'une entité framework : une
+ * table par dialecte, construite au premier usage puis **mémoïsée** (une seule
+ * instance par dialecte — le DDL, le registre d'entités et les stores voient
+ * le même objet table).
+ *
+ * @param spec - spec logique de la table.
+ * @returns factory mémoïsée (défaut `sqlite`).
+ */
+export declare function createFrameworkTableFactory(spec: IFrameworkTableSpec): FrameworkTableFactory;
+export {};

package/dist/types/nodefony/entity/idempotencyEntity.d.ts

@@ -0,0 +1,52 @@
+import type { SQLiteTable } from "drizzle-orm/sqlite-core";
+import type { IEntity } from "@nodefony/orm-core";
+import type { SqlDialect } from "../interfaces/IDrizzleConfig.js";
+import type { FrameworkTableFactory } from "./colKit.js";
+import type { IdempotentResponse } from "nodefony";
+/**
+ * Factory de la table d'idempotence pour un dialecte donné — **premier maillon du
+ * chantier portabilité multi-dialecte** (un schéma logique → la table Drizzle du
+ * bon dialecte), migrée du switch manuel 2 tables vers le colKit (S4 : la
+ * variante mysql sort du kit). Le `DrizzleOrm` l'appelle selon `connector.dialect`.
+ */
+export declare const createIdempotencyTable: FrameworkTableFactory;
+/**
+ * Variante SQLite mémoïsée (dialecte par défaut) — export statique de compat
+ * (bancs, typage du store {@link DrizzleIdempotencyStore}).
+ */
+export declare const idempotencyKeyTable: SQLiteTable;
+/**
+ * Forme plate d'une ligne du store d'idempotence (telle que renvoyée par le
+ * repository / `SELECT`). Identique aux colonnes de {@link idempotencyKeyTable}
+ * → zéro mapping store ↔ entité.
+ */
+export interface IdempotencyKeyRow {
+    key: string;
+    fingerprint: string;
+    state: "if" | "done";
+    response: IdempotentResponse | null;
+    expiresAt: number;
+}
+/** Nom logique de l'entité (clé de lookup `getRepository` / `entityRegistry`). */
+export declare const IDEMPOTENCY_ENTITY_NAME: "idempotency_key";
+/**
+ * Construit le descripteur d'entité du store d'idempotence pour un ORM nommé.
+ *
+ * Le `connector` est **dynamique** (nom du connecteur de l'app, ex. `"default"`) : la
+ * table est statique mais sa liaison à un ORM dépend de la config → on ne peut
+ * pas la figer via `@entity`. À enregistrer dans `entityRegistry` **avant**
+ * `orm.connect()` (cf {@link registerIdempotencyEntities}).
+ *
+ * @param orm - clé de l'ORM cible dans le `ormRegistry`.
+ * @param dialect - dialecte SQL du connecteur (sélectionne la variante de table).
+ * @returns le descripteur {@link IEntity} de la table d'idempotence.
+ */
+export declare function createIdempotencyEntities(connector: string, dialect?: SqlDialect): IEntity[];
+/**
+ * Enregistre l'entité du store d'idempotence 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`).
+ */
+export declare function registerIdempotencyEntities(connector: string, dialect?: SqlDialect): void;

package/dist/types/nodefony/entity/sessionEntity.d.ts

@@ -0,0 +1,50 @@
+import type { SQLiteTable } from "drizzle-orm/sqlite-core";
+import type { IEntity } from "@nodefony/orm-core";
+import type { SqlDialect } from "../interfaces/IDrizzleConfig.js";
+/** ORM cible du stockage de session (connecteur par défaut du module). */
+export declare const SESSION_CONNECTOR = "default";
+/** Nom logique de l'entité (clé de lookup `getRepository` / `entityRegistry`). */
+export declare const SESSION_ENTITY_NAME = "session";
+/**
+ * Factory de la table de session pour un dialecte donné (mémoïsée — une
+ * instance par dialecte). `sqlite` (défaut) et `postgres` sont portés ;
+ * `mysql` jette (S4).
+ */
+export declare const createSessionTable: import("./colKit.js").FrameworkTableFactory;
+/**
+ * Variante SQLite de la table de session (dialecte par défaut) — export
+ * conservé pour l'usage direct/banc-test.
+ */
+export declare const sessionTable: SQLiteTable;
+/** Forme plate d'une ligne de session telle que renvoyée par le repository. */
+export interface SessionRow {
+    session_id: string;
+    Attributes: unknown;
+    flashBag: unknown;
+    metaBag: unknown;
+    user: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * Construit le descripteur d'entité session 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 → l'enregistrement est fait
+ * par `registerStores.ts` à `onKernelRegister` (plus de décorateur `@entity`
+ * figé au chargement du fichier, qui imposait la variante sqlite quel que soit
+ * le dialecte configuré). À enregistrer **avant** `orm.connect()`.
+ *
+ * @param orm - clé de l'ORM cible dans le `ormRegistry`.
+ * @param dialect - dialecte SQL du connecteur (sélectionne la variante de table).
+ * @returns le descripteur {@link IEntity} de la table de session.
+ */
+export declare function createSessionEntity(connector: string, dialect?: SqlDialect): IEntity[];
+/**
+ * Enregistre l'entité session 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`).
+ */
+export declare function registerSessionEntity(connector: string, dialect?: SqlDialect): void;

package/dist/types/nodefony/entity/tokenEntity.d.ts

@@ -0,0 +1,53 @@
+import type { SQLiteTable } from "drizzle-orm/sqlite-core";
+import type { IEntity } from "@nodefony/orm-core";
+import type { SqlDialect } from "../interfaces/IDrizzleConfig.js";
+/** Factory de la table des records (mémoïsée — une instance par dialecte). */
+export declare const createAccessTokenTable: import("./colKit.js").FrameworkTableFactory;
+/** Factory de la denylist `jti` (mémoïsée — une instance par dialecte). */
+export declare const createDeniedJtiTable: import("./colKit.js").FrameworkTableFactory;
+/** Factory des seuils de révocation (mémoïsée — une instance par dialecte). */
+export declare const createSubjectRevocationTable: import("./colKit.js").FrameworkTableFactory;
+/**
+ * Variantes SQLite des trois tables (dialecte par défaut) — exports conservés
+ * pour l'usage direct/banc-test.
+ */
+export declare const accessTokenTable: SQLiteTable;
+export declare const deniedJtiTable: SQLiteTable;
+export declare const subjectRevocationTable: SQLiteTable;
+/** Forme plate d'une ligne de la denylist `jti`. */
+export interface DeniedJtiRow {
+    jti: string;
+    expiresAt: number;
+}
+/** Forme plate d'une ligne de révocation par porteur. */
+export interface SubjectRevocationRow {
+    subjectId: string;
+    invalidBefore: number;
+}
+/** Noms logiques des entités du store (clés de lookup `getRepository`). */
+export declare const TOKEN_ENTITY_NAMES: {
+    readonly records: "access_token";
+    readonly denied: "denied_jti";
+    readonly revocations: "subject_revocation";
+};
+/**
+ * Construit les descripteurs d'entités du store de jetons 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 registerTokenEntities}).
+ *
+ * @param orm - clé de l'ORM cible dans le `ormRegistry`.
+ * @param dialect - dialecte SQL du connecteur (sélectionne la variante des tables).
+ * @returns les trois descripteurs {@link IEntity} (records / denylist / seuils).
+ */
+export declare function createTokenEntities(connector: string, dialect?: SqlDialect): IEntity[];
+/**
+ * Enregistre les entités du store de jetons dans le `entityRegistry` pour un ORM
+ * donné. À appeler **avant** `orm.connect()` (l'adapter crée les tables au connect).
+ *
+ * @param connector - nom de la connexion cible (clé du registre).
+ * @param dialect - dialecte SQL du connecteur (variante des tables — défaut `sqlite`).
+ */
+export declare function registerTokenEntities(connector: string, dialect?: SqlDialect): void;

package/dist/types/nodefony/entity/totpSecretEntity.d.ts

@@ -0,0 +1,61 @@
+import type { SQLiteTable } from "drizzle-orm/sqlite-core";
+import type { IEntity } from "@nodefony/orm-core";
+import type { SqlDialect } from "../interfaces/IDrizzleConfig.js";
+/**
+ * Algorithme HMAC du code TOTP (RFC 6238) — union littérale (miroir du
+ * `TotpAlgorithm` de `@nodefony/security`, non ré-exporté à la racine). Écrite en
+ * clair plutôt que dérivée d'`ITotpSecret["algorithm"]` : sinon le `.d.ts` généré
+ * référencerait un chemin interne du package security (non portable, TS2883).
+ */
+type TotpAlgorithm = "SHA1" | "SHA256" | "SHA512";
+/**
+ * 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.
+ */
+export declare const createTotpSecretTable: import("./colKit.js").FrameworkTableFactory;
+/**
+ * Variante SQLite de la table de secrets TOTP (dialecte par défaut) — export
+ * conservé pour l'usage direct/banc-test.
+ */
+export declare const totpSecretTable: SQLiteTable;
+/**
+ * Forme **plate** d'une ligne de secret renvoyée par le repository ORM. Structure
+ * identique à `ITotpSecret` (tout `| null` déjà présent côté contrat) → mapping
+ * quasi-identité dans `DrizzleTotpSecretStore` (≠ `webAuthnCredentialEntity` qui a
+ * un `nickname?` à normaliser).
+ */
+export interface TotpSecretRow {
+    userId: string;
+    secretEnc: string;
+    algorithm: TotpAlgorithm;
+    digits: number;
+    period: number;
+    recoveryCodes: string[];
+    confirmedAt: number | null;
+    lastUsedStep: number | null;
+    createdAt: number;
+    lastUsedAt: number | null;
+}
+/** Nom logique de l'entité (clé de lookup `getRepository`). */
+export declare 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).
+ */
+export declare function createTotpSecretEntity(connector: string, dialect?: SqlDialect): IEntity;
+/**
+ * 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`).
+ */
+export declare function registerTotpSecretEntity(connector: string, dialect?: SqlDialect): void;
+export {};

package/dist/types/nodefony/entity/userTable.d.ts

@@ -0,0 +1,65 @@
+import type { SQLiteTable } from "drizzle-orm/sqlite-core";
+import type { IEntity } from "@nodefony/orm-core";
+import type { SqlDialect } from "../interfaces/IDrizzleConfig.js";
+/**
+ * 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).
+ */
+export declare const createUserTable: import("./colKit.js").FrameworkTableFactory;
+/**
+ * Variante SQLite de la table `User` (dialecte par défaut) — export conservé
+ * pour l'usage direct/banc-test (ex. module mediasoup).
+ */
+export declare const userTable: SQLiteTable;
+/**
+ * Forme plate d'une ligne `User` renvoyée par le repository de base — le contrat
+ * `IUserRow` de `@nodefony/user`, ré-exporté sous son nom historique.
+ */
+export type { IUserRow as UserRow } from "@nodefony/user";
+/**
+ * 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"`).
+ */
+export declare function createUserEntity(connector: string, dialect?: SqlDialect): IEntity;
+/**
+ * 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`).
+ */
+export declare function registerUserEntity(connector: string, dialect?: SqlDialect): void;
+/** Ce qu'une colonne SQL dit d'elle-même, quel que soit le dialecte. */
+export interface IUserColumnView {
+    /** La colonne refuse-t-elle `NULL` ? */
+    readonly notNull: boolean;
+    /** Porte-t-elle une contrainte d'unicité de colonne ? */
+    readonly isUnique: boolean;
+    /** Est-elle la clé primaire ? */
+    readonly primary: boolean;
+}
+/**
+ * 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.
+ */
+export declare function userTableColumns(table: unknown, dialect: SqlDialect): Map<string, IUserColumnView>;

package/dist/types/nodefony/entity/webAuthnCredentialEntity.d.ts

@@ -0,0 +1,57 @@
+import type { SQLiteTable } from "drizzle-orm/sqlite-core";
+import type { IEntity } from "@nodefony/orm-core";
+import type { SqlDialect } from "../interfaces/IDrizzleConfig.js";
+/**
+ * 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).
+ */
+export declare const createWebAuthnCredentialTable: import("./colKit.js").FrameworkTableFactory;
+/**
+ * Variante SQLite de la table de credentials (dialecte par défaut) — export
+ * conservé pour l'usage direct/banc-test.
+ */
+export declare const webAuthnCredentialTable: SQLiteTable;
+/**
+ * Forme **plate** d'une ligne de credentials renvoyée par le repository ORM —
+ * `nickname: string | null` (≠ `nickname?: string` du contrat) et `transports`
+ * mutable. `DrizzleWebAuthnCredentialStore` mappe `Row ↔ IWebAuthnCredential`.
+ */
+export interface WebAuthnCredentialRow {
+    id: string;
+    userId: string;
+    publicKey: string;
+    signCount: number;
+    transports: string[];
+    backupEligible: boolean;
+    backupState: boolean;
+    uvInitialized: boolean;
+    nickname: string | null;
+    createdAt: number;
+    lastUsedAt: number | null;
+}
+/** Nom logique de l'entité (clé de lookup `getRepository`). */
+export declare 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).
+ */
+export declare function createWebAuthnCredentialEntity(connector: string, dialect?: SqlDialect): IEntity;
+/**
+ * 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`).
+ */
+export declare function registerWebAuthnCredentialEntity(connector: string, dialect?: SqlDialect): void;

package/dist/types/nodefony/entity/webhookEndpointEntity.d.ts

@@ -0,0 +1,58 @@
+import type { SQLiteTable } from "drizzle-orm/sqlite-core";
+import type { IEntity } from "@nodefony/orm-core";
+import type { SqlDialect } from "../interfaces/IDrizzleConfig.js";
+/** Factory de la table des endpoints (mémoïsée — une instance par dialecte). */
+export declare const createWebhookEndpointTable: import("./colKit.js").FrameworkTableFactory;
+/**
+ * Variante SQLite de la table (dialecte par défaut) — export conservé pour
+ * l'usage direct/banc-test.
+ */
+export declare const webhookEndpointTable: SQLiteTable;
+/**
+ * Forme **plate** d'une ligne d'endpoint renvoyée par le repository ORM —
+ * `events` mutable (le contrat porte `readonly string[]`). Tous les autres
+ * champs sont identiques à `IWebhookEndpoint` (déjà « plat tout `| null` »).
+ * `DrizzleWebhookStore` mappe `Row ↔ IWebhookEndpoint`.
+ */
+export interface WebhookEndpointRow {
+    id: string;
+    url: string;
+    secretEnc: string;
+    events: string[];
+    enabled: boolean;
+    description: string | null;
+    tenantId: string | null;
+    createdBy: string | null;
+    createdAt: number;
+    updatedAt: number;
+    lastDeliveryAt: number | null;
+    lastDeliveryStatus: number | null;
+    lastDeliveryError: string | null;
+    failureCount: number;
+    metadata: Record<string, unknown>;
+}
+/** Nom logique de l'entité (clé de lookup `getRepository`). */
+export declare 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).
+ */
+export declare function createWebhookEndpointEntity(connector: string, dialect?: SqlDialect): IEntity;
+/**
+ * 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`).
+ */
+export declare function registerWebhookEndpointEntity(connector: string, dialect?: SqlDialect): void;

package/dist/types/nodefony/interfaces/IDrizzleConfig.d.ts

@@ -0,0 +1,17 @@
+import type { z } from "zod";
+import type { drizzleConfigSchema } from "../config/config.js";
+export type { SqlDialect } from "../config/config.js";
+/**
+ * Configuration normalisée et gelée de `@nodefony/drizzle` (sortie du builder
+ * {@link defineDrizzleConfig}, consommée par le `DrizzleService`).
+ *
+ * Type **dérivé du schéma Zod** — NE PAS redéclarer les champs à la main.
+ */
+export type IDrizzleConfig = z.infer<typeof drizzleConfigSchema>;
+/**
+ * Entrée du builder `defineDrizzleConfig` — tous les champs portant un défaut
+ * sont optionnels (l'app ne fournit que ce qu'elle surcharge dans `use()`).
+ */
+export type IDrizzleConfigInput = z.input<typeof drizzleConfigSchema>;
+/** Définition d'une connexion Drizzle nommée (sous-objet de `connectors`). */
+export type IDrizzleConnectorConfig = IDrizzleConfig["connectors"][string];

package/dist/types/nodefony/interfaces/index.d.ts

@@ -0,0 +1 @@
+export type { IDrizzleConfig, IDrizzleConfigInput, IDrizzleConnectorConfig, } from "./IDrizzleConfig.js";

package/dist/types/nodefony/migrations-schema/mysql.d.ts

@@ -0,0 +1,9 @@
+export declare const accessToken: import("drizzle-orm/mysql-core").MySqlTable<import("drizzle-orm/mysql-core").TableConfig>;
+export declare const deniedJti: import("drizzle-orm/mysql-core").MySqlTable<import("drizzle-orm/mysql-core").TableConfig>;
+export declare const subjectRevocation: import("drizzle-orm/mysql-core").MySqlTable<import("drizzle-orm/mysql-core").TableConfig>;
+export declare const session: import("drizzle-orm/mysql-core").MySqlTable<import("drizzle-orm/mysql-core").TableConfig>;
+export declare const idempotencyKey: import("drizzle-orm/mysql-core").MySqlTable<import("drizzle-orm/mysql-core").TableConfig>;
+export declare const auditEvent: import("drizzle-orm/mysql-core").MySqlTable<import("drizzle-orm/mysql-core").TableConfig>;
+export declare const totpSecret: import("drizzle-orm/mysql-core").MySqlTable<import("drizzle-orm/mysql-core").TableConfig>;
+export declare const webAuthnCredential: import("drizzle-orm/mysql-core").MySqlTable<import("drizzle-orm/mysql-core").TableConfig>;
+export declare const webhookEndpoint: import("drizzle-orm/mysql-core").MySqlTable<import("drizzle-orm/mysql-core").TableConfig>;

package/dist/types/nodefony/migrations-schema/postgres.d.ts

@@ -0,0 +1,9 @@
+export declare const accessToken: import("drizzle-orm/pg-core").PgTable<import("drizzle-orm/pg-core").TableConfig>;
+export declare const deniedJti: import("drizzle-orm/pg-core").PgTable<import("drizzle-orm/pg-core").TableConfig>;
+export declare const subjectRevocation: import("drizzle-orm/pg-core").PgTable<import("drizzle-orm/pg-core").TableConfig>;
+export declare const session: import("drizzle-orm/pg-core").PgTable<import("drizzle-orm/pg-core").TableConfig>;
+export declare const idempotencyKey: import("drizzle-orm/pg-core").PgTable<import("drizzle-orm/pg-core").TableConfig>;
+export declare const auditEvent: import("drizzle-orm/pg-core").PgTable<import("drizzle-orm/pg-core").TableConfig>;
+export declare const totpSecret: import("drizzle-orm/pg-core").PgTable<import("drizzle-orm/pg-core").TableConfig>;
+export declare const webAuthnCredential: import("drizzle-orm/pg-core").PgTable<import("drizzle-orm/pg-core").TableConfig>;
+export declare const webhookEndpoint: import("drizzle-orm/pg-core").PgTable<import("drizzle-orm/pg-core").TableConfig>;

package/dist/types/nodefony/migrations-schema/sqlite.d.ts

@@ -0,0 +1,9 @@
+export declare const accessToken: import("drizzle-orm/sqlite-core").SQLiteTable<import("drizzle-orm/sqlite-core").TableConfig>;
+export declare const deniedJti: import("drizzle-orm/sqlite-core").SQLiteTable<import("drizzle-orm/sqlite-core").TableConfig>;
+export declare const subjectRevocation: import("drizzle-orm/sqlite-core").SQLiteTable<import("drizzle-orm/sqlite-core").TableConfig>;
+export declare const session: import("drizzle-orm/sqlite-core").SQLiteTable<import("drizzle-orm/sqlite-core").TableConfig>;
+export declare const idempotencyKey: import("drizzle-orm/sqlite-core").SQLiteTable<import("drizzle-orm/sqlite-core").TableConfig>;
+export declare const auditEvent: import("drizzle-orm/sqlite-core").SQLiteTable<import("drizzle-orm/sqlite-core").TableConfig>;
+export declare const totpSecret: import("drizzle-orm/sqlite-core").SQLiteTable<import("drizzle-orm/sqlite-core").TableConfig>;
+export declare const webAuthnCredential: import("drizzle-orm/sqlite-core").SQLiteTable<import("drizzle-orm/sqlite-core").TableConfig>;
+export declare const webhookEndpoint: import("drizzle-orm/sqlite-core").SQLiteTable<import("drizzle-orm/sqlite-core").TableConfig>;