@nodefony/mongoose 10.0.0-alpha.7 → 10.0.0-alpha.9

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

@@ -0,0 +1,76 @@
+import type { SchemaDefinition } from "mongoose";
+import type { IEntity } from "@nodefony/orm-core";
+import type { AuditCategory, AuditOutcome, IAuditEventFlags } from "@nodefony/security";
+/**
+ * Schéma Mongoose du **journal d'audit** `@nodefony/security` — pendant
+ * documentaire de la table Drizzle `audit_event`, implémentation NoSQL d'
+ * `IAuditStore` (append-only, tamper-evident).
+ *
+ * ⚠️ **`_id` = clé naturelle (String), PAS un ObjectId auto** : l'`id` d'un
+ * événement est posé par l'`AuditService` (corrélation + curseur de pagination)
+ * → on force `_id: String`, l'id EST la clé primaire. Même convention que
+ * `webhookEndpointEntity` et `tokenEntity`.
+ *
+ * ⚠️ **Horodatage = `Number` (epoch ms), `timestamps:false`** : `IAuditEvent.ts`
+ * porte un `number` (`Date.now()`), pas une `Date` — et c'est ce champ qui porte
+ * l'ordre du journal.
+ *
+ * **Index** — mêmes axes que la variante SQL, et pour la même raison (filtrage
+ * de la console d'audit) ; perf de lecture seule, jamais de sémantique.
+ *
+ * L'ORDRE TOTAL du store (`ts DESC, _id DESC`) est porté par un index
+ * COMPOSITE déclaré sur l'entité (`indexes`, cf `createAuditEntities`) : un
+ * `SchemaDefinition` plat n'exprime que des index par champ, et sans lui la
+ * requête du journal parcourait toute la collection puis triait en mémoire
+ * (plan `COLLSCAN` + `SORT`, mesuré). C'est lui qui garantit, au coût d'un
+ * parcours d'index, qu'aucun événement ne se répète ni ne se perd d'une page à
+ * l'autre — `audit-store.test.ts` en lit le plan d'exécution.
+ */
+export declare const auditEventSchema: SchemaDefinition;
+/**
+ * Forme **plate** d'une ligne du journal renvoyée par le repository Mongoose —
+ * `id` = virtuel (= `_id` = l'id d'événement). Miroir d'`IAuditEvent` avec les
+ * champs optionnels rendus explicitement `| null` (le document Mongo les porte
+ * à `null`, jamais absents). `MongooseAuditStore` mappe `Row ↔ IAuditEvent`.
+ */
+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. `"nodefony"`) :
+ * le schéma est statique mais sa liaison à un ORM dépend de la config → pas
+ * d'`@entity` figé. Pas de dialecte (NoSQL) : le schéma est portable par
+ * construction. À enregistrer **avant** `orm.connect()` (modèle compilé au connect).
+ *
+ * `module: "security"` → la collection est regroupée sous @nodefony/security dans
+ * l'ERD Studio (l'audit est une feature security, hébergée par l'ORM).
+ *
+ * @param connector - clé de l'ORM cible dans le `ormRegistry`.
+ * @returns les descripteurs {@link IEntity} du journal d'audit.
+ */
+export declare function createAuditEntities(connector: string): IEntity[];
+/**
+ * Enregistre les entités du journal d'audit dans le `entityRegistry` pour un ORM
+ * donné. À appeler **avant** `orm.connect()` (le modèle est compilé au connect).
+ *
+ * @param connector - nom de la connexion cible (clé du registre).
+ */
+export declare function registerAuditEntities(connector: string): void;

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

@@ -0,0 +1,75 @@
+import type { SchemaDefinition } from "mongoose";
+import type { IEntity } from "@nodefony/orm-core";
+import type { IdempotentResponse } from "nodefony";
+/**
+ * Schéma Mongoose du **store d'idempotence** — pendant documentaire de la table
+ * Drizzle `idempotency_key`, implémentation NoSQL d'`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 MongoDB plutôt que Redis** : un cluster qui possède déjà une base
+ * Mongo mais pas de Redis obtient la dédup cross-pod sans nouvelle infra — le
+ * même argument qui fonde la variante SQL.
+ *
+ * ⚠️ **`_id` = la clé d'idempotence (String)** : c'est la contrainte d'unicité de
+ * la clé primaire qui porte la **réservation atomique** de `begin`
+ * (`findOneAndUpdate(… , {upsert:true})` → `E11000` pour le perdant). Faire
+ * porter l'unicité par un index secondaire serait un faux ami : Mongoose
+ * construit ses index en tâche de fond, donc la contrainte n'existerait pas
+ * pendant la fenêtre de construction, et deux `begin` concurrents renverraient
+ * tous deux `fresh` — exactement le double-effet que ce store existe pour
+ * empêcher. Sur `_id`, la contrainte existe dès le premier document.
+ *
+ * Le champ `key` est **dupliqué** à côté de `_id` : c'est lui que le vocabulaire
+ * public filtre (`q` = préfixe de clé) et que `listPage` rend. Les deux sont
+ * écrits ensemble, jamais séparément.
+ *
+ * ⚠️ **PAS de TTL index natif** (≠ `expireAfterSeconds`) : l'échéance d'une
+ * entrée n'est pas une durée fixe depuis sa création — c'est d'abord un **bail**
+ * *in-flight* (`now + lease`), puis une **rétention** (`now + ttl`) posée à la
+ * complétion. Un TTL index effacerait selon une règle qui ignore cette bascule.
+ * `expiresAt` est donc un `Number` (epoch ms) indexé, purgé par le `gc()`
+ * applicatif — même contrepartie que la variante SQL.
+ *
+ * `state` : `if` = réservation *in-flight* ; `done` = réponse mémorisée
+ * (rejouée en `replayed`). `response` = la réponse mémorisée, `null` tant
+ * qu'*in-flight* ; elle ne sort JAMAIS par `listPage` (anti-IDOR sur le cache).
+ */
+export declare const idempotencyKeySchema: SchemaDefinition;
+/**
+ * Forme plate d'une ligne du store d'idempotence telle que rendue par le
+ * repository Mongoose. Identique aux champs de {@link idempotencyKeySchema}
+ * → 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. `"nodefony"`) :
+ * le schéma est statique mais sa liaison à un ORM dépend de la config → pas
+ * d'`@entity` figé. À enregistrer **avant** `orm.connect()` (le modèle est
+ * compilé au connect).
+ *
+ * `module: "framework"` → la collection est regroupée sous @nodefony/framework
+ * dans l'ERD Studio (l'idempotence est une feature framework — data plane admin
+ * + `@Idempotent` — simplement hébergée par l'ORM).
+ *
+ * @param connector - clé de l'ORM cible dans le `ormRegistry`.
+ * @returns les descripteurs {@link IEntity} du store d'idempotence.
+ */
+export declare function createIdempotencyEntities(connector: string): IEntity[];
+/**
+ * Enregistre l'entité du store d'idempotence dans le `entityRegistry` pour un
+ * ORM donné. À appeler **avant** `orm.connect()`.
+ *
+ * @param connector - nom de la connexion cible (clé du registre).
+ */
+export declare function registerIdempotencyEntities(connector: string): void;

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

@@ -0,0 +1,75 @@
+import type { SchemaDefinition } from "mongoose";
+import type { IEntity } from "@nodefony/orm-core";
+/**
+ * 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";
+/**
+ * Schéma Mongoose du **store de secrets TOTP** `@nodefony/security` (2FA) —
+ * pendant documentaire de la table Drizzle `totp_secret`, implémentation NoSQL
+ * d'`ITotpSecretStore`.
+ *
+ * ⚠️ **`_id` = `userId` (String)** : le modèle est **1 secret / utilisateur**, donc
+ * la clé naturelle EST l'utilisateur — `save` devient un upsert par `_id`, et
+ * l'unicité est portée par la clé primaire elle-même (aucun index à construire
+ * en tâche de fond, donc aucune fenêtre où la contrainte n'existerait pas).
+ *
+ * Le champ `userId` est **dupliqué** à côté de `_id` : c'est lui que le
+ * vocabulaire public trie et filtre (`q` = préfixe d'`userId`), et un document
+ * Mongo n'expose pas `_id` sous un autre nom. Les deux sont écrits ensemble par
+ * le store, jamais séparément.
+ *
+ * ⚠️ **`secretEnc` = secret déjà CHIFFRÉ** (AES-256-GCM par le service détenteur
+ * de la clé) : le store ne voit que des octets opaques, jamais le secret `K` en
+ * clair. Il ne sort JAMAIS par `listPage` (cf `ITotpEnrollmentSummary`).
+ *
+ * ⚠️ **Horodatages = `Number` (epoch ms), `timestamps:false`** — sauf
+ * `lastUsedStep`, qui est une **tranche `T`** RFC 6238 (`floor(epochSeconds /
+ * period)`), pas un horodatage.
+ *
+ * `recoveryCodes` = tableau de condensats `sha256` des codes NON consommés ; le
+ * store les réécrit en bloc (jamais de mutation partielle in-place).
+ */
+export declare const totpSecretSchema: SchemaDefinition;
+/**
+ * Forme **plate** d'une ligne de secret renvoyée par le repository Mongoose.
+ * Structure identique à `ITotpSecret` (tout `| null` déjà présent côté contrat)
+ * → mapping quasi-identité dans `MongooseTotpSecretStore`.
+ */
+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, ex. `"nodefony"`) :
+ * le schéma est statique mais sa liaison à un ORM dépend de la config → pas
+ * d'`@entity` figé. À enregistrer **avant** `orm.connect()` (le modèle est
+ * compilé au connect). `module: "security"` → regroupé sous @nodefony/security
+ * dans l'ERD Studio.
+ *
+ * @param connector - clé de l'ORM cible dans le `ormRegistry`.
+ */
+export declare function createTotpSecretEntity(connector: string): IEntity;
+/**
+ * Enregistre l'entité du store de secrets TOTP dans le `entityRegistry` pour un
+ * ORM donné. À appeler **avant** `orm.connect()`.
+ *
+ * @param connector - nom de la connexion cible (clé du registre).
+ */
+export declare function registerTotpSecretEntity(connector: string): void;
+export {};

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

@@ -7,9 +7,12 @@
  * modèles sont compilés à la connexion). Pas de dialecte (NoSQL) : les schémas
  * sont portables par construction.
  *
- * Couverture PARTIELLE assumée : session (auto via `@entity`), tokens, webauthn,
- * webhooks. PAS d'implémentation mongoose pour l'audit ni l'idempotence — les
- * sélectionner sur mongoose échoue franc (« store inconnu »), jamais en silence.
+ * Couverture : session (auto via `@entity`), utilisateurs, tokens, webauthn,
+ * webhooks, audit, TOTP et idempotence — soit **la totalité des briques
+ * durables**. C'est la propriété que Mongo doit tenir : une application doit
+ * pouvoir tourner SANS aucun backend SQL, et un backend durable est un chemin
+ * complet ou n'en est pas un. Une brique qui manquerait se sélectionnerait en
+ * échec franc (« store inconnu »), jamais en silence.
  *
  * Mêmes garde-fous que Drizzle : entité `has`-guarded (l'app garde la main),
  * fabrique `get`-guarded (premier-arrivé-premier-servi).

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

@@ -0,0 +1,70 @@
+import type { IPage } from "nodefony";
+import type { IAuditEvent, IAuditListQuery, IAuditStore } from "@nodefony/security";
+import type { Model } from "mongoose";
+import type { MongooseOrm } from "./orm-core/index.js";
+/** Modèle Mongoose à document libre (boundary — comme `MongooseRepository`). */
+type LooseModel = Model<Record<string, unknown>>;
+/**
+ * Journal d'audit **Mongoose** (NoSQL) — implémentation documentaire 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. Pendant documentaire de `DrizzleAuditStore`.
+ *
+ * **Append-only** : `append` est la seule écriture ; aucune mutation ni
+ * suppression ciblée d'un événement — seul {@link MongooseAuditStore.gc}
+ * (rétention) retire des documents. L'immuabilité EST la garantie d'audit.
+ *
+ * **Pagination curseur EXACTE (`listPage`)** — l'ordre total est `(ts DESC, _id
+ * DESC)` : `ts` porte l'ordre chronologique, `_id` (= l'id d'événement) casse
+ * les collisions à la milliseconde (rafales de login). Le curseur transporte
+ * **les deux** (`<ts>:<id>`) et se compare en **composite** — en Mongo, un `$or`
+ * de deux clauses, qui sort du `Criteria` AND-only d'`IRepository`, d'où la
+ * query native (même trappe que le frère SQL). Une ligne de garde (`limit + 1`)
+ * détermine `hasNext` sans page vide parasite.
+ *
+ * ⚠️ **Le tri se fait sur `_id`, jamais sur un champ `id`** : au repos un
+ * document Mongo n'a PAS de champ `id` (c'est un virtuel de lecture), et Mongo
+ * ne se plaint pas d'un tri sur un champ absent — il rend un ordre arbitraire.
+ * Un ordre total qui n'ordonne rien casserait le curseur en silence.
+ *
+ * **Résolution LAZY + dégradation gracieuse** (calqué sur le frère SQL) : le
+ * modèle est résolu à CHAQUE appel, pas capturé à la construction — l'ORM se
+ * déconnecte au shutdown avant le drain des serveurs, et un `connect()` rejoué
+ * recrée la connexion. Si l'ORM n'est pas connecté : `append` est un no-op
+ * **best-effort** (l'audit ne bloque ni ne fait échouer le flux métier — un
+ * événement au 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 MongooseAuditStore implements IAuditStore {
+    #private;
+    /**
+     * @param resolveModel - résolveur **lazy** du modèle Mongoose (`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`.
+     */
+    constructor(resolveModel: () => LooseModel | null, now?: () => number, retentionMs?: number);
+    /**
+     * Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+     * registre des stores : la console rattache la brique à SON connecteur au
+     * lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+     */
+    get connector(): string | undefined;
+    /**
+     * Construit le store depuis un {@link MongooseOrm}. Le modèle 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()` (le modèle est compilé au connect).
+     *
+     * @param orm - ORM Mongoose hébergeant la collection `audit_event`.
+     * @param now - horloge injectable (tests).
+     * @param retentionMs - fenêtre de rétention (ms).
+     */
+    static from(orm: MongooseOrm, now?: () => number, retentionMs?: number): MongooseAuditStore;
+    append(event: IAuditEvent): Promise<void>;
+    listPage(query: IAuditListQuery): Promise<IPage<IAuditEvent>>;
+    gc(now?: number): Promise<number>;
+}
+export {};

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

@@ -0,0 +1,121 @@
+import type { IIdempotencyKeyEntry, IIdempotencyListQuery, IIdempotencyStore, IdempotencyOutcome, IdempotentResponse, IPage } from "nodefony";
+import type { Model } from "mongoose";
+import type { MongooseOrm } from "./orm-core/index.js";
+/** Modèle Mongoose à document libre (boundary — comme `MongooseRepository`). */
+type LooseModel = Model<Record<string, unknown>>;
+/**
+ * Store d'idempotence **Mongoose** (NoSQL) — implémentation documentaire 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. Pendant documentaire de `DrizzleIdempotencyStore`.
+ *
+ * **Pourquoi MongoDB plutôt que Redis** : un cluster qui possède déjà une base
+ * Mongo mais pas de Redis obtient la dédup cross-pod sans nouvelle infra — le
+ * même argument qui fonde la variante SQL.
+ *
+ * **Réservation atomique (`begin`)** — clé de voûte. Un `findOneAndUpdate`
+ * filtré sur l'entrée MORTE, en `upsert`, est l'équivalent Mongo du `SET … NX
+ * PX` Redis et du `INSERT … ON CONFLICT … WHERE expiré` SQL, en **une seule
+ * instruction atomique** côté serveur :
+ *  - clé absente → le filtre ne matche rien → l'`upsert` insère → `fresh` ;
+ *  - clé présente mais **morte** (bail/rétention expirés) → le filtre matche →
+ *    l'update la **vole** atomiquement → `fresh` ;
+ *  - clé présente et **vivante** → le filtre ne matche pas → l'`upsert` tente
+ *    d'insérer → violation d'unicité sur `_id` (`E11000`) → on lit l'état
+ *    (`in-flight` / `replayed` / `mismatch`).
+ *
+ * C'est la **clé primaire** qui porte cette unicité, jamais un index secondaire :
+ * Mongoose construit ses index en tâche de fond, donc la contrainte n'existerait
+ * pas pendant la fenêtre de construction, et deux `begin` concurrents
+ * renverraient tous deux `fresh` — exactement le double-effet que ce store
+ * existe pour empêcher.
+ *
+ * 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`, et un index TTL Mongo ignorerait la
+ * bascule bail → rétention) → un {@link MongooseIdempotencyStore.gc} applicatif
+ * purge les entrées expirées, comme la variante SQL.
+ *
+ * **Empreinte préservée à la complétion** : `complete()` ne touche pas le champ
+ * `fingerprint` → un rejeu de la clé avec un AUTRE payload après complétion est
+ * toujours détecté (`mismatch` 422, draft §2.7).
+ *
+ * **Résolution LAZY + dégradation gracieuse** (calqué sur le frère SQL) : le
+ * modèle est résolu à CHAQUE appel, jamais capturé à la construction — le
+ * framework fabrique ce store à `onKernelBoot`, AVANT le connect de l'ORM
+ * (`onBoot`), et l'ORM se déconnecte au shutdown avant le drain des serveurs. Si
+ * l'ORM n'est pas 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.
+ */
+export declare class MongooseIdempotencyStore implements IIdempotencyStore {
+    #private;
+    /**
+     * @param resolveModel - résolveur **lazy** du modèle Mongoose (`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 connector - connecteur ORM qui porte la collection, publié au registre des stores.
+     */
+    constructor(resolveModel: () => LooseModel | null, now?: () => number, leaseMs?: number, ttlMs?: number, connector?: string);
+    /**
+     * Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+     * registre des stores : la console rattache la brique à SON connecteur au
+     * lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+     */
+    get connector(): string | undefined;
+    /**
+     * Construit le store depuis un {@link MongooseOrm}. Le modèle 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()` (le modèle est compilé au connect).
+     *
+     * @param orm - ORM Mongoose hébergeant la collection `idempotency_key`.
+     * @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: MongooseOrm, now?: () => number, leaseMs?: number, ttlMs?: number): MongooseIdempotencyStore;
+    /**
+     * 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 `countDocuments`, 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
+     * exploitable ici (cf le schéma : l'échéance bascule du bail à la rétention).
+     * À déclencher périodiquement (le framework arme un `GcScheduler` au boot
+     * quand cette méthode existe).
+     *
+     * @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 native projetée : on ne lit QUE les champs exposés — la réponse
+     * mémorisée (`response`) ne quitte jamais la base par ce chemin, quelle que
+     * soit la taille de la page (anti-IDOR sur le cache).
+     *
+     * 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.
+     *
+     * ⚠️ **Le préfixe `q` est ÉCHAPPÉ**, donc littéral. Une chaîne saisie dans une
+     * console n'est pas une expression régulière : laisser passer les
+     * métacaractères ouvrirait un balayage de collection arbitraire — et pire, une
+     * catastrophe de retour sur trace. L'écart avec le frère SQL (où `%` et `_`
+     * restent des jokers) est assumé dans ce sens : ici le contrat — « `q` =
+     * préfixe » — est tenu au pied de la lettre.
+     */
+    listPage(query: IIdempotencyListQuery): Promise<IPage<IIdempotencyKeyEntry>>;
+}
+export {};

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

@@ -37,6 +37,12 @@ export declare class MongooseTokenStore implements ITokenStore {
      * @param retentionRevokedMs - rétention d'un PAT révoqué sans `exp` avant purge.
      */
     constructor(records: IRepository<IAccessTokenRecord>, denied: IRepository<DeniedJtiRow>, revocations: IRepository<SubjectRevocationRow>, now?: () => number, retentionRevokedMs?: number);
+    /**
+     * Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+     * registre des stores : la console rattache la brique à SON connecteur au
+     * lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+     */
+    get connector(): string | undefined;
     /**
      * Construit le store depuis un {@link MongooseOrm} connecté. Les entités
      * (`registerTokenEntities`) doivent avoir été enregistrées **avant** `connect()`.
@@ -69,7 +75,8 @@ export declare class MongooseTokenStore implements ITokenStore {
      * {@inheritDoc ITokenStore.listPage}
      *
      * `paginate()` d'orm-core (skip/limit + countDocuments) sur un filtre portable ;
-     * les `id` sont re-normalisés (`_id` → `id`) comme dans {@link listAll}.
+     * les documents sont convertis en records (`_id` → `id`, sans `__v`) comme dans
+     * {@link listAll}.
      *
      * Le tri demandé est **traduit** avant de descendre : au repos, le jeton n'a
      * pas de champ `id` (le `jti` EST le `_id`), et Mongo ne se plaint pas d'un tri

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

@@ -0,0 +1,63 @@
+import { type IRepository } from "@nodefony/orm-core";
+import type { IPage } from "nodefony";
+import type { ITotpEnrollmentSummary, ITotpListQuery, ITotpSecret, ITotpSecretStore, TotpSecretUpdate } from "@nodefony/security";
+import type { MongooseOrm } from "./orm-core/index.js";
+import { type TotpSecretRow } from "../entity/totpSecretEntity.js";
+/**
+ * Store de secrets TOTP **Mongoose** (NoSQL) — implémentation documentaire d'
+ * {@link ITotpSecretStore} au-dessus d'un unique repository `@nodefony/orm-core`
+ * (`totp_secret`). Pendant documentaire de `DrizzleTotpSecretStore` : là où
+ * `MemoryTotpSecretStore` est volatile, ce store survit au redémarrage et se
+ * partage entre pods.
+ *
+ * **Modèle 1 secret / utilisateur** (clé = `userId`, portée par `_id`) → `save`
+ * est un upsert par clé primaire.
+ *
+ * **Approche B** : `@nodefony/security` n'est connu qu'en `import type` (0 dép
+ * runtime).  L'entité (`registerTotpSecretEntity`) doit être enregistrée
+ * **avant** `orm.connect()` (le modèle est compilé au connect).
+ *
+ * **100 % portable** (aucune query native) — toutes les opérations passent par
+ * le contrat `IRepository`, comme son frère SQL : l'`userId` est cherché sous
+ * `id` (le contrat traduit `{ id }` → `{ _id }`), et le listing par `paginate()`.
+ *
+ * **`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. Il ne sort
+ * JAMAIS par `listPage` (cf {@link ITotpEnrollmentSummary}).
+ */
+export declare class MongooseTotpSecretStore implements ITotpSecretStore {
+    #private;
+    /**
+     * @param repo - repository de la collection `totp_secret`.
+     */
+    constructor(repo: IRepository<TotpSecretRow>);
+    /**
+     * Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+     * registre des stores : la console rattache la brique à SON connecteur au
+     * lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+     */
+    get connector(): string | undefined;
+    /**
+     * Construit le store depuis un {@link MongooseOrm} connecté. L'entité
+     * (`registerTotpSecretEntity`) doit avoir été enregistrée **avant**
+     * `orm.connect()`.
+     *
+     * @param orm - ORM Mongoose connecté hébergeant la collection du store.
+     */
+    static from(orm: MongooseOrm): MongooseTotpSecretStore;
+    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 (limite/décalage + total
+     * 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/MongooseWebAuthnCredentialStore.d.ts

@@ -24,6 +24,12 @@ export declare class MongooseWebAuthnCredentialStore implements IWebAuthnCredent
     #private;
     /** @param repo - repository de la collection `webauthn_credential`. */
     constructor(repo: IRepository<WebAuthnCredentialRow>);
+    /**
+     * Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+     * registre des stores : la console rattache la brique à SON connecteur au
+     * lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+     */
+    get connector(): string | undefined;
     /**
      * Construit le store depuis un {@link MongooseOrm} connecté. L'entité
      * (`registerWebAuthnCredentialEntity`) doit avoir été enregistrée **avant**

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

@@ -40,6 +40,12 @@ export declare class MongooseWebhookStore implements IWebhookStore {
      *   `null` = `listPage` refuse plutôt que de tout charger en silence.
      */
     constructor(repo: IRepository<WebhookEndpointRow>, model?: LooseModel | null);
+    /**
+     * Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+     * registre des stores : la console rattache la brique à SON connecteur au
+     * lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+     */
+    get connector(): string | undefined;
     /**
      * Construit le store depuis un {@link MongooseOrm} connecté. L'entité
      * (`registerWebhookEndpointEntity`) doit avoir été enregistrée **avant**

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

@@ -21,6 +21,12 @@ declare class SessionStorage implements ISessionStorage {
      */
     readonly sortableFields: readonly ["updatedAt", "createdAt", "user", "id"];
     constructor(manager: SessionsService);
+    /**
+     * Connecteur ORM qui porte les sessions — lu par `readStoreConnector` pour le
+     * registre des stores. `undefined` tant que l'ORM de ce connecteur n'est pas
+     * enregistré : on ne publie pas un rattachement que rien ne porte.
+     */
+    get connector(): string | undefined;
     read(id: string): Promise<ISerializedSession>;
     start(id: string): Promise<ISerializedSession>;
     write(id: string, data: ISerializedSession): Promise<ISerializedSession>;

package/dist/types/nodefony/src/orm-core/MongooseOrm.d.ts

@@ -1,3 +1,4 @@
+import type { Container } from "nodefony";
 import type { ConnectOptions } from "mongoose";
 import { Orm } from "@nodefony/orm-core";
 import type { IColumnInfo, IConnectionInfo, IOrmProbe, IRepository, ITransaction } from "@nodefony/orm-core";
@@ -51,8 +52,11 @@ export declare class MongooseOrm extends Orm {
      * @param name - clé unique de l'ORM dans le `ormRegistry`.
      * @param uri - URI de connexion MongoDB (replica set requis pour les tx).
      * @param options - options de connexion Mongoose (auth, pool, timeouts).
+     * @param container - container du service qui construit l'ORM : il porte le
+     *   `syslog` du kernel. Sans lui, la perte et la reprise de connexion
+     *   s'écrivent dans un journal que rien ne relie à la sortie du serveur.
      */
-    constructor(name: string, uri: string, options?: ConnectOptions);
+    constructor(name: string, uri: string, options?: ConnectOptions, container?: Container);
     protected onConnect(): Promise<void>;
     /** Constat d'index de la connexion courante, ou `null` hors connexion. */
     get pendingIndexAudit(): Promise<IIndexAudit[]> | null;
@@ -109,8 +113,11 @@ export declare class MongooseOrm extends Orm {
     probe(): Promise<IOrmProbe>;
     /**
      * Colonnes normalisées d'une entité depuis les `paths` du schéma Mongoose —
-     * alimente le graphe canonique / ERD / contexte IA. Pas de PK SQL : `_id` est
-     * la clé primaire implicite de tout document.
+     * alimente le graphe canonique / ERD / contexte IA. Rendues dans le
+     * vocabulaire du CONTRAT, pas du moteur : la clé primaire `_id` s'y nomme
+     * `id` (comme dans les critères et les lignes lues), et la clé de version
+     * interne `__v` n'y figure pas — un graphe qui changerait de noms selon
+     * l'adaptateur ne décrirait plus la même application.
      *
      * @param name - nom logique de l'entité.
      * @returns colonnes (`[]` si l'entité n'est pas connue de cet ORM).

package/dist/types/nodefony/src/orm-core/MongooseRepository.d.ts

@@ -2,6 +2,25 @@ import type { ClientSession, Model } from "mongoose";
 import type { Criteria, UpdateData, IRepository, ITransaction, RepositoryReadOptions } from "@nodefony/orm-core";
 /** Modèle Mongoose à document libre (boundary — typé finement côté repo). */
 type LooseModel = Model<Record<string, unknown>>;
+/**
+ * Champ d'une AUTRE entité qui référence celle d'un repository — une entrée de
+ * l'index inverse que {@link MongooseOrm} bâtit au `connect()`.
+ *
+ * MongoDB ne tient aucune clé étrangère : c'est cette table qui porte, à la
+ * suppression d'un parent, la politique que le SQL généré confie à la base.
+ */
+export interface IMongooseReferrer {
+    /** Modèle de l'entité qui porte la référence. */
+    readonly model: LooseModel;
+    /** Chemin du champ `ObjectId` qui désigne le parent. */
+    readonly path: string;
+    /**
+     * Référence obligatoire → la suppression du parent est REFUSÉE (`restrict`) ;
+     * facultative → le champ est remis à `null` (`set null`). Même règle que le
+     * SQL généré, qui déduit l'effacement de la nullabilité de la colonne.
+     */
+    readonly required: boolean;
+}
 /**
  * Repository portable (contrat {@link IRepository}) au-dessus d'un modèle Mongoose.
  *
@@ -21,8 +40,10 @@ export declare class MongooseRepository<T = unknown> implements IRepository<T> {
      * @param model - modèle Mongoose compilé.
      * @param connector - nom de la connexion (clé du registre) — défaut `"nodefony"`.
      * @param session - session transactionnelle à laquelle lier les ops (ou `null`).
+     * @param referrers - champs d'autres entités qui référencent celle-ci (index
+     *   inverse de {@link MongooseOrm}) ; `null` quand aucune ne la vise.
      */
-    constructor(model: LooseModel, connector?: string, session?: ClientSession | null);
+    constructor(model: LooseModel, connector?: string, session?: ClientSession | null, referrers?: readonly IMongooseReferrer[] | null);
     find(criteria?: Criteria<T>, options?: RepositoryReadOptions): Promise<T[]>;
     findOne(criteria: Criteria<T>, options?: RepositoryReadOptions): Promise<T | null>;
     create(data: Partial<T>): Promise<T>;