@nodefony/drizzle 10.0.0-alpha.1

package/dist/types/nodefony/registerStores.d.ts

@@ -0,0 +1,52 @@
+import type { SqlDialect } from "./config/config.js";
+/**
+ * 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).
+ */
+export declare const FRAMEWORK_CONNECTOR = "default";
+/** Bilan de l'auto-enregistrement (loggé par le module — jamais silencieux). */
+export interface IFrameworkStoresReport {
+    /** Entités déclarées par l'auto-register (tables créées au connect). */
+    registered: string[];
+    /** Entités déjà enregistrées par l'app (customisation respectée). */
+    appOwned: string[];
+    /** Entités non portées sur le dialecte configuré (stores indisponibles). */
+    unported: string[];
+}
+/**
+ * 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.
+ */
+export declare function isFrameworkFallbackEntity(entityName: string, connector?: string): boolean;
+/**
+ * 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)
+ */
+export declare function registerDrizzleFrameworkStores(dialect: SqlDialect): IFrameworkStoresReport;

package/dist/types/nodefony/service/DrizzleService.d.ts

@@ -0,0 +1,27 @@
+import { Service } from "nodefony";
+import type { Module } from "nodefony";
+import { DrizzleOrm } from "../src/orm-core/index.js";
+/**
+ * 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).
+ */
+declare class DrizzleService extends Service {
+    #private;
+    module: Module;
+    constructor(module: Module);
+    /** Connecte tous les connecteurs déclarés en config (validée Zod). */
+    connectAll(): Promise<void>;
+    /** Ferme toutes les connexions. */
+    disconnectAll(): Promise<void>;
+    /** Retourne l'ORM Drizzle d'un connecteur (défaut : `"default"`). */
+    getOrm(name?: string): DrizzleOrm | undefined;
+}
+export default DrizzleService;

package/dist/types/nodefony/src/DrizzleAuditStore.d.ts

@@ -0,0 +1,65 @@
+import type { IPage } from "nodefony";
+import type { IAuditEvent, IAuditListQuery, IAuditStore } from "@nodefony/security";
+import { type DrizzleDb, type DrizzleTable } from "./orm-core/DrizzleRepository.js";
+import type { DrizzleOrm } from "./orm-core/DrizzleOrm.js";
+/**
+ * Journal d'audit **Drizzle** (driver `better-sqlite3` en test, Postgres/MySQL en
+ * prod) — implémentation SQL d'{@link IAuditStore} (append-only, tamper-evident)
+ * pour la **rétention longue** et le **partage cross-pod**, là où le store mémoire
+ * par défaut reste affine à un pod et volatile.
+ *
+ * **Append-only** : `append` est la seule écriture (INSERT) ; aucune mutation ni
+ * suppression ciblée d'un événement — seul {@link DrizzleAuditStore.gc} (rétention)
+ * retire des lignes. L'immuabilité EST la garantie d'audit.
+ *
+ * **Pagination curseur EXACTE (`listPage`)** — via le query builder Drizzle
+ * (dialect-agnostique), l'ordre total est `(ts DESC, id DESC)` : `ts` porte l'ordre
+ * chronologique, `id` casse les collisions à la milliseconde (rafales de login). Le
+ * curseur transporte **les deux** (`<ts>:<id>`) et se compare en **composite**
+ * `(ts, id) < (cursorTs, cursorId)` — non exprimable en critère `IRepository`
+ * AND-only, d'où la trappe native (ADR-0003, comme `DrizzleIdempotencyStore`). Une
+ * ligne de garde (`limit + 1`) détermine `hasNext` sans page vide parasite.
+ *
+ * **Résolution LAZY + dégradation gracieuse** (calqué sur les stores frères) : le
+ * handle Drizzle est résolu à CHAQUE appel, pas capturé à la construction — l'ordre
+ * de boot n'est pas garanti (l'app câble à `onKernelBoot`, l'ORM peut n'être pas
+ * encore connecté) et l'ORM se déconnecte au shutdown avant le drain des serveurs.
+ * Si le handle est `null` : `append` est un no-op **best-effort** (l'audit ne
+ * bloque ni ne fait échouer le flux métier — un événement au boot/shutdown est
+ * perdu plutôt que de crasher un login), `listPage` rend une page vide et `gc` rend 0.
+ *
+ * Horloge injectable (`now`) pour des tests déterministes.
+ */
+export declare class DrizzleAuditStore implements IAuditStore {
+    #private;
+    /**
+     * @param resolveDb - résolveur **lazy** du handle Drizzle (`null` = ORM non
+     *   connecté → dégradation gracieuse).
+     * @param now - horloge (epoch ms) injectable pour des tests déterministes.
+     * @param retentionMs - fenêtre de rétention (ms) avant purge par `gc`.
+     * @param table - variante de table à utiliser (dialecte). Défaut = SQLite.
+     * @param location - emplacement physique de la base (fichier SQLite) pour Studio
+     *   ({@link DrizzleOrm.location}) ; `undefined` pour un backend réseau/`:memory:`.
+     */
+    constructor(resolveDb: () => DrizzleDb | null, now?: () => number, retentionMs?: number, table?: DrizzleTable, location?: string);
+    /**
+     * Emplacement physique de la base (fichier SQLite) pour l'écran Studio « Stores »
+     * — lu par `readStoreLocation`. `undefined` = backend réseau ou `:memory:`.
+     */
+    get location(): string | undefined;
+    /**
+     * Construit le store depuis un {@link DrizzleOrm}. Le handle est résolu **lazy**
+     * (gardé par `isConnected()` → `null` tant que l'ORM n'est pas/plus connecté).
+     * L'entité (`registerAuditEntities`) doit avoir été enregistrée **avant**
+     * `orm.connect()` (la table est créée au connect) — sur la **variante de table
+     * du dialecte de l'ORM** (S3 multi-dialecte).
+     *
+     * @param orm - ORM Drizzle hébergeant la table `audit_event`.
+     * @param now - horloge injectable (tests).
+     * @param retentionMs - fenêtre de rétention (ms).
+     */
+    static from(orm: DrizzleOrm, now?: () => number, retentionMs?: number): DrizzleAuditStore;
+    append(event: IAuditEvent): Promise<void>;
+    listPage(query: IAuditListQuery): Promise<IPage<IAuditEvent>>;
+    gc(now?: number): Promise<number>;
+}

package/dist/types/nodefony/src/DrizzleIdempotencyStore.d.ts

@@ -0,0 +1,129 @@
+import type { IIdempotencyKeyEntry, IIdempotencyListQuery, IIdempotencyStore, IdempotencyOutcome, IdempotentResponse, IPage } from "nodefony";
+import { type DrizzleDb, type DrizzleTable } from "./orm-core/DrizzleRepository.js";
+import type { DrizzleOrm } from "./orm-core/DrizzleOrm.js";
+/**
+ * Store d'idempotence **Drizzle** (driver `better-sqlite3` en test, Postgres/MySQL
+ * en prod) — implémentation SQL d'{@link IIdempotencyStore} (contrat au CORE) pour
+ * dédoublonner les mutations rejouées PARTAGÉ cross-pod, là où le store mémoire par
+ * défaut reste affine à un pod.
+ *
+ * **Pourquoi SQL plutôt que Redis** : un cluster qui possède déjà une base
+ * (Postgres) mais pas de Redis obtient la dédup cross-pod sans nouvelle infra.
+ *
+ * **Réservation atomique (`begin`)** — clé de voûte. Un `INSERT … ON CONFLICT(key)
+ * DO UPDATE SET … WHERE expiresAt < now RETURNING` = l'équivalent SQL du `SET … NX
+ * PX` Redis, en **une seule instruction atomique** côté serveur :
+ *  - clé absente → l'`INSERT` passe → 1 ligne retournée → `fresh` ;
+ *  - clé présente mais **morte** (bail/rétention expirés) → le `DO UPDATE … WHERE
+ *    expirée` la **vole** atomiquement → 1 ligne retournée → `fresh` ;
+ *  - clé présente et **vivante** → le `WHERE` du `DO UPDATE` échoue → 0 ligne
+ *    retournée → on lit l'état (`in-flight` / `replayed` / `mismatch`).
+ *
+ * Cette atomicité au niveau de l'INSTRUCTION est ce qui rend la dédup correcte
+ * sous concurrence inter-pods (deux `begin` simultanés sur deux pods : un seul
+ * gagne la réservation). Le store ne renvoie JAMAIS `fresh` sur le chemin de
+ * contention → anti double-effet garanti (l'invariant capital d'un store
+ * d'idempotence).
+ *
+ * **Pas de TTL natif** (≠ Redis `PX`) → un {@link DrizzleIdempotencyStore.gc}
+ * applicatif purge les entrées expirées. À mutualiser avec la maintenance du store
+ * de session (chantier « GC moderne »).
+ *
+ * **Empreinte préservée à la complétion** : `complete()` ne touche pas la colonne
+ * `fingerprint` (UPDATE ciblé) → un rejeu de la clé avec un AUTRE payload après
+ * complétion est toujours détecté (`mismatch` 422, draft §2.7).
+ *
+ * ⚠️ **SQLite = banc de test de la sémantique** : un fichier SQLite est
+ * mono-machine (lock d'écriture) → aucun intérêt multi-pod. La cible RÉELLE est
+ * **Postgres/MySQL** (changement de driver). La preuve cross-pod réelle passe par
+ * un e2e Postgres (≠ test SQLite, qui valide la sémantique séquentielle).
+ *
+ * **Résolution LAZY + dégradation gracieuse** (calqué sur `RedisIdempotencyStore`,
+ * le frère idempotence) : le store ne capture PAS le handle Drizzle à la
+ * construction mais le résout à CHAQUE appel — l'ordre de boot n'est pas garanti
+ * (le framework résout ce store à `onKernelBoot`, quand l'ORM peut ne pas être
+ * encore connecté), et l'ORM se déconnecte au shutdown avant le drain des
+ * serveurs (cf le gotcha `SessionStorage`). Si le handle est `null` (ORM non
+ * connecté), `begin` renvoie `fresh` (la mutation s'exécute SANS dédup) et
+ * `complete`/`abort`/`gc` sont des no-op — l'idempotence est temporairement
+ * inactive plutôt que de crasher une mutation en vol. Trade-off identique à Redis
+ * (un rejeu pendant la fenêtre peut ré-exécuter) ; en pratique la base
+ * d'idempotence = la base applicative → « connectée » est vrai sur tout le service.
+ *
+ * **Câblage** : la classe reste PURE (`import type` du contrat core), mais le
+ * module drizzle s'enregistre LUI-MÊME au boot — `registerStores.ts:311-316` pose
+ * l'entité (`registerIdempotencyEntities`) puis la fabrique
+ * (`registerIdempotencyStore("drizzle", …)`, registre `@nodefony/framework`), sans
+ * rien demander à l'application. Celle-ci choisit seulement le store à employer
+ * (`idempotency.store`). L'enregistrement est idempotent : une fabrique déjà
+ * posée n'est pas écrasée, donc une app peut fournir la sienne avant le boot.
+ */
+export declare class DrizzleIdempotencyStore implements IIdempotencyStore {
+    #private;
+    /**
+     * @param resolveDb - résolveur **lazy** du handle Drizzle (`null` = ORM non
+     *   connecté → dégradation gracieuse). Lazy car l'ordre de boot/shutdown n'est
+     *   pas garanti à la construction.
+     * @param now - horloge (epoch ms) injectable pour des tests déterministes.
+     * @param leaseMs - bail d'une entrée *in-flight* (ms).
+     * @param ttlMs - rétention d'une réponse mémorisée (ms).
+     * @param table - variante de table à utiliser (dialecte). Défaut = variante
+     *   SQLite ; `from()` injecte la variante du dialecte de l'ORM.
+     * @param resolveLocation - résolveur **lazy** de l'emplacement physique de la
+     *   base ({@link DrizzleOrm.location}) pour Studio. Lazy (comme `resolveDb`) car
+     *   le store est fabriqué AVANT le connect de l'ORM → l'emplacement n'est lisible
+     *   qu'une fois l'ORM enregistré (lu au `onReady`, pas à la construction).
+     */
+    constructor(resolveDb: () => DrizzleDb | null, now?: () => number, leaseMs?: number, ttlMs?: number, table?: DrizzleTable, resolveLocation?: () => string | undefined);
+    /**
+     * Emplacement physique de la base (fichier SQLite) pour l'écran Studio « Stores »
+     * — lu par `readStoreLocation`. Résolu **lazy** (l'ORM n'existe pas à la
+     * construction) : `undefined` tant que l'ORM n'est pas enregistré, en `:memory:`,
+     * ou sur un backend réseau (pg/mysql → voir l'infra déclarée).
+     */
+    get location(): string | undefined;
+    /**
+     * Construit le store depuis un {@link DrizzleOrm}. Le handle est résolu **lazy**
+     * (gardé par `isConnected()` → `null` tant que l'ORM n'est pas/plus connecté).
+     * L'entité (`registerIdempotencyEntities`) doit avoir été enregistrée **avant**
+     * `orm.connect()` (la table est créée au connect).
+     *
+     * @param orm - ORM Drizzle hébergeant la table `idempotency_key` (dialecte
+     *   sélectionne la variante de table — `orm.dialect`).
+     * @param now - horloge injectable (tests).
+     * @param leaseMs - bail *in-flight* (ms).
+     * @param ttlMs - rétention d'une réponse mémorisée (ms).
+     */
+    static from(orm: DrizzleOrm, now?: () => number, leaseMs?: number, ttlMs?: number): DrizzleIdempotencyStore;
+    /**
+     * Approximation **per-pod, best-effort** : compteur local des réservations
+     * faites par CE pod (incrémenté au `fresh`, décrémenté au `complete`/`abort`),
+     * non décrémenté si le bail expire sans complétion, et désaligné cross-pod. La
+     * vérité cluster passe par un `COUNT(*)`, jamais ce getter (sync). Borné à ≥ 0.
+     */
+    get size(): number;
+    begin(key: string, fingerprint: string): Promise<IdempotencyOutcome>;
+    complete(key: string, response: IdempotentResponse): Promise<void>;
+    abort(key: string): Promise<void>;
+    /**
+     * Purge les entrées mortes (`expiresAt <= now`) — supplée l'absence de TTL natif
+     * SQL (≠ Redis `PX`). À déclencher périodiquement (timer de maintenance, à
+     * mutualiser avec le GC du store de session).
+     *
+     * @param now - horloge de purge (défaut : horloge injectée).
+     * @returns le nombre d'entrées supprimées.
+     */
+    gc(now?: number): Promise<number>;
+    /**
+     * {@inheritDoc IIdempotencyStore.listPage}
+     *
+     * Query builder dialect-agnostique (comme `gc`) : `LIMIT/OFFSET` + `COUNT`
+     * filtré. On ne SELECTe QUE les colonnes exposées — la réponse mémorisée
+     * (`response`) ne quitte jamais la base par ce chemin, quelle que soit la
+     * taille de la page.
+     *
+     * Les entrées expirées sont exclues (`expiresAt > now`) : le GC applicatif
+     * passe plus tard, mais une clé échue n'est déjà plus opposable.
+     */
+    listPage(query: IIdempotencyListQuery): Promise<IPage<IIdempotencyKeyEntry>>;
+}

package/dist/types/nodefony/src/DrizzleTokenStore.d.ts

@@ -0,0 +1,146 @@
+import type { IRepository } from "@nodefony/orm-core";
+import type { IPage } from "nodefony";
+import type { IAccessTokenRecord, ITokenListQuery, ITokenStore, ITokenUsage, TokenRevokeReason } from "@nodefony/security";
+import type { DrizzleOrm } from "./orm-core/DrizzleOrm.js";
+import { type DeniedJtiRow, type SubjectRevocationRow } from "../entity/tokenEntity.js";
+/**
+ * Store de jetons **Drizzle** (driver `better-sqlite3`) — implémentation SQL
+ * d'{@link ITokenStore} au-dessus de trois repositories `@nodefony/orm-core`
+ * (`access_token`, `denied_jti`, `subject_revocation`).
+ *
+ * **Approche B** (validée 2026-06-14) : l'ORM ne connaît `@nodefony/security`
+ * qu'en `import type` → 0 dépendance runtime. C'est l'application qui enregistre
+ * la fabrique (`registerTokenStore("drizzle", ({ container }) =>
+ * DrizzleTokenStore.from(container.get("…orm…")))`) et les entités
+ * (`registerTokenEntities(orm)` avant `orm.connect()`).
+ *
+ * **100 % portable** (aucun SQL natif) — toutes les opérations passent par le
+ * contrat `IRepository`, donc le code se transpose tel quel aux autres drivers.
+ * Les écritures conditionnelles portent leur condition dans le `WHERE` plutôt
+ * que dans un `if` JS après lecture (`{ revokedAt: { $null: true } }`) : chacune
+ * est une instruction unique, donc atomique — un `findOne` suivi d'un `update`
+ * laisse deux appels concurrents agir sur un état déjà périmé.
+ *
+ * Horloge injectable (`now`) pour des tests déterministes.
+ */
+export declare class DrizzleTokenStore implements ITokenStore {
+    #private;
+    /**
+     * {@inheritDoc ITokenStore.sortableFields}
+     *
+     * Le moteur SQL trie sur n'importe laquelle de ces colonnes : capacité pleine.
+     */
+    readonly sortableFields: readonly ["createdAt", "name", "subjectId", "id"];
+    /**
+     * @param records - repository de la table `access_token` (PAT + refresh).
+     * @param denied - repository de la denylist `denied_jti`.
+     * @param revocations - repository des seuils `subject_revocation`.
+     * @param now - horloge (epoch ms) injectable pour les tests.
+     * @param retentionRevokedMs - rétention d'un PAT révoqué sans `exp` avant purge.
+     * @param location - emplacement physique de la base (fichier SQLite) pour Studio
+     *   ({@link DrizzleOrm.location}) ; `undefined` pour un backend réseau/`:memory:`.
+     */
+    constructor(records: IRepository<IAccessTokenRecord>, denied: IRepository<DeniedJtiRow>, revocations: IRepository<SubjectRevocationRow>, now?: () => number, retentionRevokedMs?: number, location?: string);
+    /**
+     * Emplacement physique de la base (fichier SQLite) pour l'écran Studio « Stores »
+     * — lu par `readStoreLocation`. `undefined` = backend réseau ou `:memory:`.
+     */
+    get location(): string | undefined;
+    /**
+     * Construit le store depuis un {@link DrizzleOrm} connecté. Les entités
+     * (`registerTokenEntities`) doivent avoir été enregistrées **avant**
+     * `orm.connect()`.
+     *
+     * @param orm - ORM Drizzle connecté hébergeant les tables du store.
+     * @param now - horloge injectable (tests).
+     * @param retentionRevokedMs - rétention des PAT révoqués sans `exp`.
+     */
+    static from(orm: DrizzleOrm, now?: () => number, retentionRevokedMs?: number): DrizzleTokenStore;
+    /**
+     * Insère ou remplace un record (PAT / refresh) — 1 requête, `upsert` atomique
+     * sur la PK `id` plutôt qu'un `findOne` d'existence + `create`/`updateOne`
+     * (2 round-trips). `put` pose le record COMPLET (`createdAt` inclus) → tout
+     * hors `id` est ré-appliqué en cas de conflit ; pas de champ insert-only.
+     *
+     * ⚠️ **Limite `ON CONFLICT`, propre à cette table** : `access_token` porte
+     * DEUX contraintes uniques (`id` PK + `secretHash`), or un upsert n'arbitre
+     * qu'UN index. Deux INSERT **concurrents** d'un record **absent** partageant
+     * le même `secretHash` feraient donc lever le perdant (PG : `23505` sur
+     * `access_token_secretHash_unique`) — l'arbitre `id` ne couvre pas la seconde
+     * unique. Ce n'est pas atteignable : les trois appelants (`tokenService`
+     * émission + rotation, `apiKeys`) posent un `id` **généré** (`randomUUID` /
+     * `#randomId`), donc jamais deux `put` du même id neuf ; le seul `put`
+     * concurrent d'un même id porte sur une ligne **existante** (rotation
+     * rejouée), qui tombe sur le chemin DO UPDATE et passe. Une entité à deux
+     * uniques dont les DEUX seraient réellement disputées demanderait un autre
+     * remède (réservation en deux instructions, cf `reserveIdempotencyKeyMysql`).
+     *
+     * @param record - le record complet à persister.
+     */
+    put(record: IAccessTokenRecord): Promise<void>;
+    findById(id: string): Promise<IAccessTokenRecord | null>;
+    findByHash(secretHash: string): Promise<IAccessTokenRecord | null>;
+    findBySubject(subjectId: string): Promise<IAccessTokenRecord[]>;
+    /** Tous les jetons (PAT + refresh) — vue d'administration cross-porteur. */
+    listAll(): Promise<IAccessTokenRecord[]>;
+    /**
+     * {@inheritDoc ITokenStore.listPage}
+     *
+     * Portable à 100 % : le helper `paginate()` d'orm-core (LIMIT/OFFSET + COUNT
+     * optionnel) sur un `Criteria` simple — ne matérialise qu'une page. Le tri
+     * demandé descend dans le `ORDER BY` (jamais de tri après découpe : la 2ᵉ page
+     * doit continuer la 1ʳᵉ) ; à défaut, l'ordre contractuel `createdAt DESC, id
+     * DESC` rend l'offset déterministe. Les noms de colonnes SQL sont ceux du
+     * vocabulaire public — aucune traduction n'est nécessaire ici.
+     */
+    listPage(query: ITokenListQuery): Promise<IPage<IAccessTokenRecord>>;
+    /** {@inheritDoc ITokenStore.countTokens} */
+    countTokens(query: ITokenListQuery): Promise<number>;
+    markUsed(id: string, usage: ITokenUsage): Promise<void>;
+    /**
+     * Révoque un jeton — **idempotent** : la 1ʳᵉ date/raison de révocation est
+     * conservée (l'audit ne se réécrit pas).
+     *
+     * Le « pas encore révoqué » vit dans le `WHERE` (`revokedAt IS NULL`), pas
+     * dans un `if` JS après lecture : une seule instruction, donc deux révocations
+     * concurrentes ne peuvent plus se recouvrir (la seconde n'affecte 0 ligne au
+     * lieu d'écraser la date de la première).
+     *
+     * @param id - identifiant du jeton.
+     * @param reason - motif de révocation, posé seulement à la 1ʳᵉ.
+     */
+    revoke(id: string, reason: TokenRevokeReason): Promise<void>;
+    /**
+     * Coupe toute une famille de refresh (détection de rejeu, RFC 9700) — les
+     * membres déjà révoqués (ex. `rotated`) gardent leur raison d'origine.
+     *
+     * Un seul `UPDATE … WHERE family = ? AND revokedAt IS NULL` : atomique, et
+     * N+1 requêtes (1 SELECT + 1 UPDATE par membre actif) tombent à 1.
+     *
+     * @param family - famille de refresh à couper.
+     * @param reason - motif appliqué aux membres encore actifs.
+     */
+    revokeFamily(family: string, reason: TokenRevokeReason): Promise<void>;
+    denyJti(jti: string, expiresAt: number): Promise<void>;
+    isJtiDenied(jti: string): Promise<boolean>;
+    /**
+     * Pose le seuil de révocation en masse d'un porteur (« déconnecte-moi de
+     * partout ») : tout jeton émis avant `invalidBefore` est mort.
+     *
+     * **Monotone — le seuil ne recule JAMAIS**, y compris sous deux logouts
+     * simultanés : la comparaison vit dans la valeur écrite (`$max`), pas dans un
+     * `if` JS après lecture. Une lecture suivie d'une écriture laisserait les deux
+     * appels voir le même état et écrire tous les deux — c'est le dernier qui
+     * resterait, même porteur d'un seuil plus ANCIEN, et les jetons que le logout
+     * le plus récent venait d'invalider repasseraient sous le seuil : **des jetons
+     * révoqués redeviendraient valides**. Une instruction unique sur les 4
+     * backends (`MAX()` sqlite, `GREATEST()` pg/mysql, `$max` Mongo) — un `WHERE`
+     * sur le `DO UPDATE` n'existe pas en MySQL.
+     *
+     * @param subjectId - porteur visé.
+     * @param invalidBefore - seuil (epoch ms) ; ignoré s'il est antérieur au seuil courant.
+     */
+    revokeAllForSubject(subjectId: string, invalidBefore: number): Promise<void>;
+    getInvalidBefore(subjectId: string): Promise<number | null>;
+    gc(now?: number): Promise<number>;
+}

package/dist/types/nodefony/src/DrizzleTotpSecretStore.d.ts

@@ -0,0 +1,60 @@
+import { type IRepository } from "@nodefony/orm-core";
+import type { IPage } from "nodefony";
+import type { ITotpEnrollmentSummary, ITotpListQuery, ITotpSecret, ITotpSecretStore, TotpSecretUpdate } from "@nodefony/security";
+import type { DrizzleOrm } from "./orm-core/DrizzleOrm.js";
+import { type TotpSecretRow } from "../entity/totpSecretEntity.js";
+/**
+ * Store de secrets TOTP **Drizzle** (driver `better-sqlite3`) — implémentation SQL
+ * d'{@link ITotpSecretStore} au-dessus d'un unique repository `@nodefony/orm-core`
+ * (`totp_secret`). Comble le gap « 2FA persistant sans fichier » : là où
+ * `MemoryTotpSecretStore` est volatile, ce store survit au redémarrage et se
+ * partage entre pods (base durable).
+ *
+ * **Modèle 1 secret / utilisateur** (clé = `userId`) → `save` est un upsert par PK.
+ *
+ * **Approche B** : l'ORM ne connaît `@nodefony/security` qu'en `import type` → 0
+ * dépendance runtime. L'entité (`registerTotpSecretEntity(orm)`) doit être
+ * enregistrée **avant** `orm.connect()`.
+ *
+ * **100 % portable** (aucun SQL natif) — toutes les opérations passent par le
+ * contrat `IRepository`, donc le code se transpose tel quel aux autres drivers.
+ *
+ * **`secretEnc` opaque** : le store persiste le secret DÉJÀ chiffré (AES-256-GCM
+ * côté service) — il ne déchiffre jamais, ne voit que des octets.
+ */
+export declare class DrizzleTotpSecretStore implements ITotpSecretStore {
+    #private;
+    /**
+     * @param repo - repository de la table `totp_secret`.
+     * @param location - emplacement physique de la base (fichier SQLite) pour Studio
+     *   ({@link DrizzleOrm.location}) ; `undefined` pour un backend réseau/`:memory:`.
+     */
+    constructor(repo: IRepository<TotpSecretRow>, location?: string);
+    /**
+     * Emplacement physique de la base (fichier SQLite) pour l'écran Studio « Stores »
+     * — lu par `readStoreLocation`. `undefined` = backend réseau ou `:memory:`.
+     */
+    get location(): string | undefined;
+    /**
+     * Construit le store depuis un {@link DrizzleOrm} connecté. L'entité
+     * (`registerTotpSecretEntity`) doit avoir été enregistrée **avant** `orm.connect()`.
+     *
+     * @param orm - ORM Drizzle connecté hébergeant la table du store.
+     */
+    static from(orm: DrizzleOrm): DrizzleTotpSecretStore;
+    findByUser(userId: string): Promise<ITotpSecret | null>;
+    save(secret: ITotpSecret): Promise<void>;
+    update(userId: string, patch: TotpSecretUpdate): Promise<void>;
+    delete(userId: string): Promise<void>;
+    /**
+     * {@inheritDoc ITotpSecretStore.listPage}
+     *
+     * 100 % portable : le helper `paginate()` d'orm-core (LIMIT/OFFSET + COUNT
+     * optionnel) sur un critère simple. La projection en vue d'enrôlement retire
+     * `secretEnc` et les condensats — ils ne franchissent jamais la frontière du
+     * store, quel que soit l'appelant.
+     */
+    listPage(query: ITotpListQuery): Promise<IPage<ITotpEnrollmentSummary>>;
+    /** {@inheritDoc ITotpSecretStore.countEnrollments} */
+    countEnrollments(query: ITotpListQuery): Promise<number>;
+}

package/dist/types/nodefony/src/DrizzleUserRepository.d.ts

@@ -0,0 +1,67 @@
+import type { Criteria, IRepository, ITransaction, RepositoryReadOptions } from "@nodefony/orm-core";
+import type { IPasswordAuthenticatedUser, IUserListQuery, IUserRepository } from "@nodefony/user";
+import type { IPage } from "nodefony";
+import type { DrizzleDb } from "./orm-core/DrizzleRepository.js";
+import type { DrizzleOrm } from "./orm-core/DrizzleOrm.js";
+import type { SqlDialect } from "../interfaces/IDrizzleConfig.js";
+import type { UserRow } from "../entity/userTable.js";
+export declare class DrizzleUserRepository implements IUserRepository {
+    #private;
+    /**
+     * Même vocabulaire public que les autres repositories — ici le tri part
+     * dans la requête, où il ne coûte qu'un index.
+     */
+    readonly sortableFields: readonly ["identifier", "enabled", "createdAt", "updatedAt", "id"];
+    /**
+     * @param base - repository portable sur la table `User` (CRUD + criteria).
+     * @param db - handle Drizzle (racine ou transaction) pour les requêtes JSON brutes.
+     * @param dialect - dialecte SQL du connecteur (route les requêtes du queryKit).
+     */
+    constructor(base: IRepository<UserRow>, db: DrizzleDb, dialect?: SqlDialect);
+    /**
+     * Construit le repository utilisateur depuis un {@link DrizzleOrm} connecté.
+     * L'entité `User` doit avoir été enregistrée (cf `registerUserEntity`) avant
+     * `orm.connect()` — sur la variante de table du dialecte de l'ORM.
+     *
+     * @param orm - ORM Drizzle connecté.
+     * @returns le repository utilisateur prêt à l'emploi.
+     */
+    static from(orm: DrizzleOrm): DrizzleUserRepository;
+    find(criteria?: Criteria<IPasswordAuthenticatedUser>, options?: RepositoryReadOptions): Promise<IPasswordAuthenticatedUser[]>;
+    findOne(criteria: Criteria<IPasswordAuthenticatedUser>, options?: RepositoryReadOptions): Promise<IPasswordAuthenticatedUser | null>;
+    create(data: Partial<IPasswordAuthenticatedUser>): Promise<IPasswordAuthenticatedUser>;
+    updateOne(criteria: Criteria<IPasswordAuthenticatedUser>, data: Partial<IPasswordAuthenticatedUser>): Promise<IPasswordAuthenticatedUser | null>;
+    upsert(criteria: Criteria<IPasswordAuthenticatedUser>, update: Partial<IPasswordAuthenticatedUser>, insertOnly?: Partial<IPasswordAuthenticatedUser>): Promise<IPasswordAuthenticatedUser>;
+    createMany(data: Partial<IPasswordAuthenticatedUser>[]): Promise<IPasswordAuthenticatedUser[]>;
+    exists(criteria: Criteria<IPasswordAuthenticatedUser>): Promise<boolean>;
+    deleteOne(criteria: Criteria<IPasswordAuthenticatedUser>): Promise<boolean>;
+    findOneAndDelete(criteria: Criteria<IPasswordAuthenticatedUser>): Promise<IPasswordAuthenticatedUser | null>;
+    increment(criteria: Criteria<IPasswordAuthenticatedUser>, changes: Partial<Record<keyof IPasswordAuthenticatedUser, number>>): Promise<IPasswordAuthenticatedUser | null>;
+    updateMany(criteria: Criteria<IPasswordAuthenticatedUser>, data: Partial<IPasswordAuthenticatedUser>): Promise<number>;
+    delete(criteria: Criteria<IPasswordAuthenticatedUser>): Promise<number>;
+    count(criteria?: Criteria<IPasswordAuthenticatedUser>): Promise<number>;
+    countDistinct(field: keyof IPasswordAuthenticatedUser & string, criteria?: Criteria<IPasswordAuthenticatedUser>): Promise<number>;
+    withTransaction(tx: ITransaction): IUserRepository;
+    findByIdentifier(identifier: string): Promise<IPasswordAuthenticatedUser | null>;
+    /**
+     * Recherche par compte externe lié — cherche dans le JSON `socialProviders`
+     * via le queryKit (forme native du dialecte : `json_each` SQLite / `@>`
+     * jsonb PG, 1 requête), récupère l'`id`, puis recharge par le chemin typé
+     * (parsing JSON/booléens cohérent). `null` si aucun lien.
+     */
+    findBySocialProvider(provider: string, providerId: string): Promise<IPasswordAuthenticatedUser | null>;
+    /**
+     * {@inheritDoc IUserRepository.listPage}
+     *
+     * SQL natif (queryKit, routé par dialecte) → **uniquement les `id`** de la page
+     * (containment de rôle + `LIKE` insensible casse non exprimables par le query
+     * builder portable), puis rechargement des lignes complètes par le chemin typé
+     * (`find({ id: $in })`, parsing JSON/booléens cohérent), **ré-ordonnées** selon
+     * le tri SQL. Jamais plus d'une page matérialisée.
+     */
+    listPage(query: IUserListQuery): Promise<IPage<IPasswordAuthenticatedUser>>;
+    /** {@inheritDoc IUserRepository.countUsers} */
+    countUsers(query: IUserListQuery): Promise<number>;
+    /** {@inheritDoc IUserRepository.countActiveAdmins} */
+    countActiveAdmins(adminRole: string): Promise<number>;
+}

package/dist/types/nodefony/src/DrizzleWebAuthnCredentialStore.d.ts

@@ -0,0 +1,62 @@
+import { type IRepository } from "@nodefony/orm-core";
+import type { IPage } from "nodefony";
+import type { IWebAuthnCredential, IWebAuthnCredentialStore, IWebAuthnCredentialSummary, IWebAuthnListQuery, WebAuthnAuthUpdate } from "@nodefony/security";
+import type { DrizzleOrm } from "./orm-core/DrizzleOrm.js";
+import { type WebAuthnCredentialRow } from "../entity/webAuthnCredentialEntity.js";
+/**
+ * Store de credentials WebAuthn **Drizzle** (driver `better-sqlite3`) —
+ * implémentation SQL d'{@link IWebAuthnCredentialStore} au-dessus d'un unique
+ * repository `@nodefony/orm-core` (`webauthn_credential`).
+ *
+ * **Approche B** : l'ORM ne connaît `@nodefony/security` qu'en `import type` → 0
+ * dépendance runtime. C'est l'application qui enregistre la fabrique
+ * (`registerWebAuthnStore("drizzle", …)`) et l'entité
+ * (`registerWebAuthnCredentialEntity(orm)` avant `orm.connect()`).
+ *
+ * **100 % portable** (aucun SQL natif) — toutes les opérations passent par le
+ * contrat `IRepository`, donc le code se transpose tel quel aux autres drivers.
+ *
+ * **Mapping Row ↔ contrat** : le repository renvoie une {@link WebAuthnCredentialRow}
+ * plate (`nickname: string | null`, `transports` mutable) ; le store la normalise
+ * en `IWebAuthnCredential` (`nickname?` omis si `null`). Le store de jetons n'a pas
+ * ce mapping car `IAccessTokenRecord` est déjà la forme repository (tout `| null`).
+ */
+export declare class DrizzleWebAuthnCredentialStore implements IWebAuthnCredentialStore {
+    #private;
+    /**
+     * @param repo - repository de la table `webauthn_credential`.
+     * @param location - emplacement physique de la base (fichier SQLite) pour Studio
+     *   ({@link DrizzleOrm.location}) ; `undefined` pour un backend réseau/`:memory:`.
+     */
+    constructor(repo: IRepository<WebAuthnCredentialRow>, location?: string);
+    /**
+     * Emplacement physique de la base (fichier SQLite) pour l'écran Studio « Stores »
+     * — lu par `readStoreLocation`. `undefined` = backend réseau ou `:memory:`.
+     */
+    get location(): string | undefined;
+    /**
+     * Construit le store depuis un {@link DrizzleOrm} connecté. L'entité
+     * (`registerWebAuthnCredentialEntity`) doit avoir été enregistrée **avant**
+     * `orm.connect()`.
+     *
+     * @param orm - ORM Drizzle connecté hébergeant la table du store.
+     */
+    static from(orm: DrizzleOrm): DrizzleWebAuthnCredentialStore;
+    findById(credentialId: string): Promise<IWebAuthnCredential | null>;
+    findByUser(userId: string): Promise<IWebAuthnCredential[]>;
+    /** `COUNT(*)` natif — jamais un `find().length` (le plafond ne charge rien). */
+    countByUser(userId: string): Promise<number>;
+    save(credential: IWebAuthnCredential): Promise<void>;
+    update(credentialId: string, patch: WebAuthnAuthUpdate): Promise<void>;
+    delete(credentialId: string): Promise<void>;
+    /**
+     * {@inheritDoc IWebAuthnCredentialStore.listPage}
+     *
+     * 100 % portable : le helper `paginate()` d'orm-core (LIMIT/OFFSET + COUNT
+     * optionnel). La projection en vue admin retire `publicKey` — elle ne franchit
+     * jamais la frontière du store, quel que soit l'appelant.
+     */
+    listPage(query: IWebAuthnListQuery): Promise<IPage<IWebAuthnCredentialSummary>>;
+    /** {@inheritDoc IWebAuthnCredentialStore.countCredentials} */
+    countCredentials(query: IWebAuthnListQuery): Promise<number>;
+}