---
title: "Référence d'API — @nodefony/mongoose"
source: docs/api/mongoose.md
url: https://nodefony.github.io/nodefony-core/docs/api/mongoose/
---


[Documentation](../../) › [Référence d'API](../) › `@nodefony/mongoose`

> Générée depuis les déclarations de types publiées de `@nodefony/mongoose` **10.0.0-beta.5** : exactement ce que reçoit une application qui l'installe. Cette page n'existe dans aucun dépôt — pour la corriger, on corrige le TSDoc du code.

## `@nodefony/mongoose`

`import { … } from "@nodefony/mongoose"` — 65 symboles.

### Classes (14)

#### `MongooseAuditStore`

```ts
class MongooseAuditStore implements IAuditStore
```

Journal d'audit **Mongoose** (NoSQL) — implémentation documentaire d' `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`.

- `constructor(resolveModel: () => LooseModel | null, now?: () => number, retentionMs?: number)`
- `get 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.
- `static from(orm: MongooseOrm, now?: () => number, retentionMs?: number): MongooseAuditStore` — Construit le store depuis un `MongooseOrm`.
- `append(event: IAuditEvent): Promise<void>` — Ajoute un événement (immuable, jamais modifié ensuite).
- `listPage(query: IAuditListQuery): Promise<IPage<IAuditEvent>>` — Lit **une page** d'événements filtrés, du plus récent au plus ancien — l'implémentation ne matérialise jamais plus que `limit` événements.
- `gc(now?: number): Promise<number>` — Purge les événements au-delà de la fenêtre de rétention.

#### `MongooseIdempotencyStore`

```ts
class MongooseIdempotencyStore implements IIdempotencyStore
```

Store d'idempotence **Mongoose** (NoSQL) — implémentation documentaire 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. Pendant documentaire de `DrizzleIdempotencyStore`.

- `constructor(resolveModel: () => LooseModel | null, now?: () => number, leaseMs?: number, ttlMs?: number, connector?: string)`
- `get 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.
- `static from(orm: MongooseOrm, now?: () => number, leaseMs?: number, ttlMs?: number): MongooseIdempotencyStore` — Construit le store depuis un `MongooseOrm`.
- `get size(): number` — 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, …
- `begin(key: string, fingerprint: string): Promise<IdempotencyOutcome>` — Réserve **atomiquement** la clé et renvoie le verdict à suivre.
- `complete(key: string, response: IdempotentResponse): Promise<void>` — Mémorise la réponse d'une clé *in-flight* (TTL) → rejeux futurs = `replayed`.
- `abort(key: string): Promise<void>` — Libère une clé *in-flight* dont l'exécution a échoué : rien n'est mémorisé (un échec doit pouvoir être réessayé).
- `gc(now?: number): Promise<number>` — 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).
- `listPage(query: IIdempotencyListQuery): Promise<IPage<IIdempotencyKeyEntry>>` — {@inheritDoc IIdempotencyStore.listPage}

#### `MongooseOrm`

```ts
class MongooseOrm extends Orm
```

Adapter Mongoose **branché sur `@nodefony/orm-core`** (P5.4).

- `get liveness(): "events" | "assumed"` — Mongoose traduit les signaux de topologie du driver MongoDB (SDAM) : il SAIT qu'un serveur est tombé, même sans le moindre trafic — d'où `"events"`.
- `constructor(name: string, uri: string, options?: ConnectOptions, container?: Container)`
- `protected onConnect(): Promise<void>` — Établit la connexion native du driver (compilation des entités, pool...).
- `get pendingIndexAudit(): Promise<IIndexAudit[]> | null` — Constat d'index de la connexion courante, ou `null` hors connexion.
- `verifyIndexes(): Promise<IIndexAudit[]>` — Constate l'écart entre les index DÉCLARÉS par les schémas et ceux que la base porte réellement, et journalise tout manque en `CRITIC`.
- `disconnect(): Promise<void>` — Ferme la connexion et libère le pool.
- `getRepository<T = unknown>(name: string): IRepository<T>` — Repository typé d'une entité enregistrée.
- `transaction<R>(work: (tx: ITransaction) => Promise<R>): Promise<R>` — Exécute un travail transactionnel (commit si résolu, rollback si rejeté).
- `getNativeConnection<C = unknown>(): C` — Expose la connexion native du driver (trappe SQL/commandes brutes).
- `ping(): Promise<void>` — Ping bas-coût : commande `{ ping: 1 }` sur la base native (`admin().command`) — round-trip réel vers MongoDB pour le diagnostic du data plane.
- `probe(): Promise<IOrmProbe>` — Sonde Mongo (best-effort) : connexions du serveur (`serverStatus`) → pool.
- `describeEntity(name: string): IColumnInfo[]` — Colonnes normalisées d'une entité depuis les `paths` du schéma Mongoose — alimente le graphe canonique / ERD / contexte IA.
- `describeConnection(): IConnectionInfo` — Décrit la connexion : driver `mongodb` + cible (hôte:port/base, **sans credentials**) + version de la lib `mongoose`.
- `safeTarget(): string` — Cible affichable de l'URI, **sans credentials** : `hôte:port/base`.

#### `MongooseRepository`

```ts
class MongooseRepository<T = unknown> implements IRepository<T>
```

Repository portable (contrat `IRepository`) au-dessus d'un modèle Mongoose.

- `constructor(model: LooseModel, connector?: string, session?: ClientSession | null, referrers?: readonly IMongooseReferrer[] | null)`
- `find(criteria?: Criteria<T>, options?: RepositoryReadOptions): Promise<T[]>` — Retourne toutes les entités correspondant au critère (toutes si omis).
- `findOne(criteria: Criteria<T>, options?: RepositoryReadOptions): Promise<T | null>` — Retourne la première entité correspondant au critère, ou `null`.
- `create(data: Partial<T>): Promise<T>` — Persiste une nouvelle entité et retourne sa version persistée (id généré, valeurs par défaut).
- `createMany(data: Partial<T>[]): Promise<T[]>` — Insère **plusieurs** entités en **une seule** requête (`INSERT … VALUES (…),(…)` SQL / `insertMany` Mongo) et retourne leurs versions persistées (ids générés, défauts appliqués), dans l'ordre.
- `updateOne(criteria: Criteria<T>, data: Partial<T>): Promise<T | null>` — Met à jour **au plus une** entité correspondant au critère, de façon **atomique**, et retourne sa version persistée (ou `null` si aucune ne correspond).
- `upsert(criteria: Criteria<T>, update: UpdateData<T>, insertOnly?: Partial<T>): Promise<T>` — Insère **ou** met à jour atomiquement l'entité identifiée par `criteria` (clé unique), en **une seule** requête (`INSERT … ON CONFLICT DO UPDATE … RETURNING` SQL / `findOneAndUpdate({ upsert })` Mongo …
- `updateMany(criteria: Criteria<T>, data: Partial<T>): Promise<number>` — Met à jour **toutes** les entités correspondant au critère et retourne le **nombre** de lignes modifiées (parité de signature avec `IRepository.delete`).
- `increment(criteria: Criteria<T>, changes: Partial<Record<keyof T, number>>): Promise<T | null>` — Incrémente **atomiquement** des champs numériques d'**au plus une** entité (`SET f = f + ?` SQL / `$inc` Mongo), sans read-modify-write (donc sans race) — pour les compteurs (stats, usage/tokens, rate …
- `delete(criteria: Criteria<T>): Promise<number>` — Supprime les entités correspondant au critère.
- `deleteOne(criteria: Criteria<T>): Promise<boolean>` — Supprime **au plus une** entité de façon **atomique** (symétrique d'`IRepository.updateOne` ; `DELETE … LIMIT 1` SQL / `deleteOne` Mongo).
- `findOneAndDelete(criteria: Criteria<T>): Promise<T | null>` — Supprime **au plus une** entité et **retourne** sa valeur supprimée (ou `null`), de façon atomique (`DELETE … RETURNING` SQL / `findOneAndDelete` Mongo) — claim-and-remove (file de jobs, outbox, pop a …
- `count(criteria?: Criteria<T>): Promise<number>` — Compte les entités correspondant au critère (toutes si omis).
- `countDistinct(field: keyof T & string, criteria?: Criteria<T>): Promise<number>` — `COUNT(DISTINCT …)` en agrégation — `$group` puis `$count`, donc la déduplication reste dans le serveur.
- `exists(criteria: Criteria<T>): Promise<boolean>` — Indique si **au moins une** entité correspond au critère, sans rapatrier la ligne (`SELECT 1 … LIMIT 1` SQL / `exists` Mongo).
- `withTransaction(tx: ITransaction): IRepository<T>` — Retourne une **vue de ce repository liée à une transaction** : toutes ses opérations s'exécutent dans `tx` (commit/rollback gérés par `IOrm.transaction()`).

#### `MongooseService`

```ts
class MongooseService extends Service
```

Service bootable du module `@nodefony/mongoose` (driver NoSQL).

- `module: Module`
- `constructor(module: Module)`
- `connectAll(connect?: boolean): Promise<void>` — Connecte tous les connecteurs déclarés en config (validée Zod).
- `static buildUri(cfg: Partial<IMongooseConnectorConfig>): string` — Assemble l'URI de connexion à partir de la config (`uri` ou composants).
- `static buildConnectOptions(cfg: Partial<IMongooseConnectorConfig>): ConnectOptions` — Options de connexion Mongoose d'un connecteur.
- `disconnectAll(): Promise<void>` — Ferme toutes les connexions.
- `getOrm(name?: string): MongooseOrm` — Retourne l'ORM Mongoose d'un connecteur (défaut : `"nodefony"`).

#### `MongooseTokenStore`

```ts
class MongooseTokenStore implements ITokenStore
```

Store de jetons **Mongoose** (NoSQL) — implémentation d'`ITokenStore` au dessus de trois repositories `@nodefony/orm-core` (`access_token`, `denied_jti`, `subject_revocation`). Pendant documentaire de `DrizzleTokenStore`.

- `readonly sortableFields: readonly [ "createdAt", "name", "subjectId", "id" ]` — {@inheritDoc ITokenStore.sortableFields}
- `constructor(records: IRepository<IAccessTokenRecord>, denied: IRepository<DeniedJtiRow>, revocations: IRepository<SubjectRevocationRow>, now?: () => number, retentionRevokedMs?: number)`
- `get 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.
- `static from(orm: MongooseOrm, now?: () => number, retentionRevokedMs?: number): MongooseTokenStore` — Construit le store depuis un `MongooseOrm` connecté.
- `put(record: IAccessTokenRecord): Promise<void>` — Insère ou remplace un record (PAT / refresh) — 1 round-trip, `upsert` atomique sur la PK plutôt qu'un `findOne` d'existence + `create`/`updateOne` (dont l'`await` laisse deux put concurrents du même i …
- `findById(id: string): Promise<IAccessTokenRecord | null>` — Recherche par identifiant (`jti`/id public).
- `findByHash(secretHash: string): Promise<IAccessTokenRecord | null>` — Recherche par hash de secret présenté.
- `findBySubject(subjectId: string): Promise<IAccessTokenRecord[]>` — Tous les jetons d'un porteur (console « mes jetons », révocation ciblée).
- `listAll(): Promise<IAccessTokenRecord[]>` — Tous les jetons (PAT + refresh) — vue d'administration cross-porteur.
- `listPage(query: ITokenListQuery): Promise<IPage<IAccessTokenRecord>>` — {@inheritDoc ITokenStore.listPage}
- `countTokens(query: ITokenListQuery): Promise<number>` — {@inheritDoc ITokenStore.countTokens}
- `markUsed(id: string, usage: ITokenUsage): Promise<void>` — Met à jour `lastUsedAt`/IP/UA (no-op si l'id est inconnu).
- `revoke(id: string, reason: TokenRevokeReason): Promise<void>` — Révoque un jeton — **idempotent** : la 1ʳᵉ date/raison est conservée.
- `revokeFamily(family: string, reason: TokenRevokeReason): Promise<void>` — Coupe toute une famille de refresh (détection de rejeu, RFC 9700) — les membres déjà révoqués gardent leur raison d'origine.
- `denyJti(jti: string, expiresAt: number): Promise<void>` — Inscrit un `jti` d'access sur la denylist jusqu'à `expiresAt` (epoch ms) — révocation immédiate avant l'`exp` du JWT.
- `isJtiDenied(jti: string): Promise<boolean>` — `true` si le `jti` est denylisté et non encore expiré.
- `revokeAllForSubject(subjectId: string, invalidBefore: number): Promise<void>` — Pose le seuil de révocation en masse d'un porteur (« déconnecte-moi de partout ») : tout jeton émis avant `invalidBefore` est mort.
- `getInvalidBefore(subjectId: string): Promise<number | null>` — Seuil `invalidBefore` d'un porteur (epoch ms) ou `null` si aucun.
- `gc(now?: number): Promise<number>` — Purge les entrées devenues inutiles : denylist `jti` expirée, records arrivés à `exp`, PAT révoqués sans expiration au-delà de la fenêtre de rétention.

#### `MongooseTotpSecretStore`

```ts
class MongooseTotpSecretStore implements ITotpSecretStore
```

Store de secrets TOTP **Mongoose** (NoSQL) — implémentation documentaire d' `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.

- `constructor(repo: IRepository<TotpSecretRow>)`
- `get 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.
- `static from(orm: MongooseOrm): MongooseTotpSecretStore` — Construit le store depuis un `MongooseOrm` connecté.
- `findByUser(userId: string): Promise<ITotpSecret | null>` — Secret TOTP de l'utilisateur, ou `null` si non enrôlé.
- `save(secret: ITotpSecret): Promise<void>` — Crée ou remplace le secret de l'utilisateur (upsert — ré-enrôlement).
- `update(userId: string, patch: TotpSecretUpdate): Promise<void>` — Applique un patch partiel (confirmation, anti-rejeu, consommation de codes).
- `delete(userId: string): Promise<void>` — Supprime le secret de l'utilisateur (désactivation du 2FA).
- `listPage(query: ITotpListQuery): Promise<IPage<ITotpEnrollmentSummary>>` — {@inheritDoc ITotpSecretStore.listPage}
- `countEnrollments(query: ITotpListQuery): Promise<number>` — {@inheritDoc ITotpSecretStore.countEnrollments}

#### `MongooseTransaction`

```ts
class MongooseTransaction implements ITransaction
```

Adapte une `ClientSession` MongoDB au contrat portable `ITransaction`.

- `constructor(session: ClientSession)`
- `isDone(): boolean` — Indique si la transaction est déjà terminée (commit ou rollback).
- `commit(): Promise<void>` — Valide la transaction (no-op si déjà terminée — idempotent, parité avec `DrizzleTransaction`).
- `rollback(): Promise<void>` — Annule la transaction (no-op si déjà terminée — idempotent).
- `savepoint(_name: string): Promise<void>` — Refusé : MongoDB n'a pas de savepoints.
- `rollbackTo(_name: string): Promise<void>` — Refusé : MongoDB n'a pas de savepoints.
- `getNative<C = unknown>(): C` — Expose la `ClientSession` native (trappe bas niveau).

#### `MongooseUserRepository`

```ts
class MongooseUserRepository implements IUserRepository
```

Adapter Mongoose du contrat `IUserRepository` — persistance NoSQL de l'utilisateur (P5.8), pendant documentaire de `DrizzleUserRepository` (P5.9).

- `readonly sortableFields: readonly [ "identifier", "enabled", "createdAt", "updatedAt", "id" ]` — Même vocabulaire public que les autres repositories — ici le tri part dans la requête, où il ne coûte qu'un index.
- `constructor(base: IRepository<UserRow>, model: LooseModel, session?: ClientSession | null)`
- `static from(orm: MongooseOrm): MongooseUserRepository` — Construit le repository utilisateur depuis un `MongooseOrm` connecté.
- `find(criteria?: Criteria<IPasswordAuthenticatedUser>, options?: RepositoryReadOptions): Promise<IPasswordAuthenticatedUser[]>` — Retourne toutes les entités correspondant au critère (toutes si omis).
- `findOne(criteria: Criteria<IPasswordAuthenticatedUser>, options?: RepositoryReadOptions): Promise<IPasswordAuthenticatedUser | null>` — Retourne la première entité correspondant au critère, ou `null`.
- `create(data: Partial<IPasswordAuthenticatedUser>): Promise<IPasswordAuthenticatedUser>` — Persiste une nouvelle entité et retourne sa version persistée (id généré, valeurs par défaut).
- `updateOne(criteria: Criteria<IPasswordAuthenticatedUser>, data: Partial<IPasswordAuthenticatedUser>): Promise<IPasswordAuthenticatedUser | null>` — Met à jour **au plus une** entité correspondant au critère, de façon **atomique**, et retourne sa version persistée (ou `null` si aucune ne correspond).
- `upsert(criteria: Criteria<IPasswordAuthenticatedUser>, update: Partial<IPasswordAuthenticatedUser>, insertOnly?: Partial<IPasswordAuthenticatedUser>): Promise<IPasswordAuthenticatedUser>` — Insère **ou** met à jour atomiquement l'entité identifiée par `criteria` (clé unique), en **une seule** requête (`INSERT … ON CONFLICT DO UPDATE … RETURNING` SQL / `findOneAndUpdate({ upsert })` Mongo …
- `createMany(data: Partial<IPasswordAuthenticatedUser>[]): Promise<IPasswordAuthenticatedUser[]>` — Insère **plusieurs** entités en **une seule** requête (`INSERT … VALUES (…),(…)` SQL / `insertMany` Mongo) et retourne leurs versions persistées (ids générés, défauts appliqués), dans l'ordre.
- `exists(criteria: Criteria<IPasswordAuthenticatedUser>): Promise<boolean>` — Indique si **au moins une** entité correspond au critère, sans rapatrier la ligne (`SELECT 1 … LIMIT 1` SQL / `exists` Mongo).
- `deleteOne(criteria: Criteria<IPasswordAuthenticatedUser>): Promise<boolean>` — Supprime **au plus une** entité de façon **atomique** (symétrique d'`IRepository.updateOne` ; `DELETE … LIMIT 1` SQL / `deleteOne` Mongo).
- `findOneAndDelete(criteria: Criteria<IPasswordAuthenticatedUser>): Promise<IPasswordAuthenticatedUser | null>` — Supprime **au plus une** entité et **retourne** sa valeur supprimée (ou `null`), de façon atomique (`DELETE … RETURNING` SQL / `findOneAndDelete` Mongo) — claim-and-remove (file de jobs, outbox, pop a …
- `increment(criteria: Criteria<IPasswordAuthenticatedUser>, changes: Partial<Record<keyof IPasswordAuthenticatedUser, number>>): Promise<IPasswordAuthenticatedUser | null>` — Incrémente **atomiquement** des champs numériques d'**au plus une** entité (`SET f = f + ?` SQL / `$inc` Mongo), sans read-modify-write (donc sans race) — pour les compteurs (stats, usage/tokens, rate …
- `updateMany(criteria: Criteria<IPasswordAuthenticatedUser>, data: Partial<IPasswordAuthenticatedUser>): Promise<number>` — Met à jour **toutes** les entités correspondant au critère et retourne le **nombre** de lignes modifiées (parité de signature avec `IRepository.delete`).
- `delete(criteria: Criteria<IPasswordAuthenticatedUser>): Promise<number>` — Supprime les entités correspondant au critère.
- `count(criteria?: Criteria<IPasswordAuthenticatedUser>): Promise<number>` — Compte les entités correspondant au critère (toutes si omis).
- `countDistinct(field: keyof IPasswordAuthenticatedUser, criteria?: Criteria<IPasswordAuthenticatedUser>): Promise<number>` — Compte les **valeurs distinctes** d'un champ parmi les entités qui correspondent au critère (`COUNT(DISTINCT col)` SQL / agrégation Mongo).
- `withTransaction(tx: ITransaction): IUserRepository` — Retourne une **vue de ce repository liée à une transaction** : toutes ses opérations s'exécutent dans `tx` (commit/rollback gérés par `IOrm.transaction()`).
- `findByIdentifier(identifier: string): Promise<IPasswordAuthenticatedUser | null>` — Retrouve un utilisateur par son identifiant fonctionnel (email, login...).
- `findBySocialProvider(provider: string, providerId: string): Promise<IPasswordAuthenticatedUser | null>` — Recherche par compte externe lié — scanne le tableau `socialProviders` via `$elemMatch` (1 requête, équivalent Mongo du `json_each` Drizzle).
- `listPage(query: IUserListQuery): Promise<IPage<IPasswordAuthenticatedUser>>` — {@inheritDoc IUserRepository.listPage}
- `countUsers(query: IUserListQuery): Promise<number>` — {@inheritDoc IUserRepository.countUsers}
- `countActiveAdmins(adminRole: string): Promise<number>` — Compte les administrateurs **actifs** (`isActive()` **et** porteurs de `adminRole`) — garde-fou anti-lockout, calculé **au store** (SQL `COUNT` avec containment de rôle), jamais en chargeant tous les …

#### `MongooseWebAuthnCredentialStore`

```ts
class MongooseWebAuthnCredentialStore implements IWebAuthnCredentialStore
```

Store de credentials WebAuthn **Mongoose** (NoSQL) — implémentation d' `IWebAuthnCredentialStore` au-dessus d'un unique repository `@nodefony/orm-core` (`webauthn_credential`). Pendant documentaire de `DrizzleWebAuthnCredentialStore`.

- `constructor(repo: IRepository<WebAuthnCredentialRow>)`
- `get 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.
- `static from(orm: MongooseOrm): MongooseWebAuthnCredentialStore` — Construit le store depuis un `MongooseOrm` connecté.
- `findById(credentialId: string): Promise<IWebAuthnCredential | null>` — Credential par son id (base64url), ou `null` — résolution à l'authentification.
- `findByUser(userId: string): Promise<IWebAuthnCredential[]>` — Tous les credentials d'un utilisateur — pour `allowCredentials` (authentification ciblée) et l'UX « mes appareils ».
- `countByUser(userId: string): Promise<number>` — `countDocuments` natif — jamais un `find().length` (le plafond ne charge rien).
- `save(credential: IWebAuthnCredential): Promise<void>` — Persiste un nouveau credential (fin de la cérémonie d'enregistrement).
- `update(credentialId: string, patch: WebAuthnAuthUpdate): Promise<void>` — Met à jour l'état post-authentification (compteur, sauvegarde, UV, usage).
- `delete(credentialId: string): Promise<void>` — Révoque un credential (l'utilisateur retire un appareil).
- `listPage(query: IWebAuthnListQuery): Promise<IPage<IWebAuthnCredentialSummary>>` — {@inheritDoc IWebAuthnCredentialStore.listPage}
- `countCredentials(query: IWebAuthnListQuery): Promise<number>` — {@inheritDoc IWebAuthnCredentialStore.countCredentials}

#### `MongooseWebhookStore`

```ts
class MongooseWebhookStore implements IWebhookStore
```

Store d'endpoints webhook **Mongoose** (NoSQL) — implémentation d' `IWebhookStore` au-dessus d'un unique repository `@nodefony/orm-core` (`webhook_endpoint`). Pendant documentaire de `DrizzleWebhookStore` ; registre DURABLE des endpoints (survit au redémarrage, ≠ `MemoryWebhookStore`).

- `readonly sortableFields: readonly [ "createdAt", "updatedAt", "url", "enabled", "failureCount", "id" ]` — {@inheritDoc IWebhookStore.sortableFields}
- `constructor(repo: IRepository<WebhookEndpointRow>, model?: LooseModel | null)`
- `get 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.
- `static from(orm: MongooseOrm): MongooseWebhookStore` — Construit le store depuis un `MongooseOrm` connecté.
- `save(endpoint: IWebhookEndpoint): Promise<void>` — Insère un nouvel endpoint.
- `findById(id: string): Promise<IWebhookEndpoint | null>` — Charge un endpoint par id, ou `null`.
- `update(id: string, patch: WebhookEndpointUpdate): Promise<void>` — Applique un patch partiel (champs mutables) ; no-op si id absent.
- `delete(id: string): Promise<void>` — Supprime un endpoint ; no-op si id absent.
- `listAll(): Promise<IWebhookEndpoint[]>` — **Tous** les endpoints — réservé au **snapshot du dispatcher** (le service garde en mémoire la table complète des abonnements pour router un événement sans I/O, et la recharge au boot puis après chaqu …
- `listPage(query: IWebhookListQuery): Promise<IPage<IWebhookEndpoint>>` — {@inheritDoc IWebhookStore.listPage}
- `countEndpoints(query: IWebhookListQuery): Promise<number>` — {@inheritDoc IWebhookStore.countEndpoints}

#### `SessionEntity`

```ts
class SessionEntity
```

Entité session enregistrée dans le `entityRegistry` pour le connecteur `nodefony` — `MongooseOrm` compile le modèle à la connexion (au boot).

#### `SessionStorage`

```ts
class SessionStorage implements ISessionStorage
```

Stockage de session **Mongoose** (driver NoSQL), branché sur `@nodefony/orm-core`.

- `manager: SessionsService`
- `idleTimeoutS: number`
- `absoluteTimeoutS: number`
- `readonly sortableFields: readonly [ "updatedAt", "createdAt", "user", "id" ]` — Même vocabulaire public que les autres backends — le tri part dans le `sort()` Mongo, où il ne coûte qu'un index.
- `constructor(manager: SessionsService)`
- `get connector(): string` — Connecteur ORM qui porte les sessions — lu par `readStoreConnector` pour le registre des stores.
- `read(id: string): Promise<ISerializedSession>`
- `start(id: string): Promise<ISerializedSession>`
- `write(id: string, data: ISerializedSession): Promise<ISerializedSession>`
- `open(): Promise<number>`
- `close(): boolean`
- `destroy(id: string): Promise<boolean>`
- `gc(idleSeconds?: number, absoluteSeconds?: number): Promise<void>` — Purge les sessions expirées sur les **deux bornes** NIST/OWASP : idle (inactivité depuis `updatedAt`) ET absolute (âge depuis `createdAt`, jamais prolongé).
- `touch(id: string): Promise<void>` — Prolonge l'idle d'une session (timeout glissant) : `updateOne updatedAt = now` sur `session_id` — SANS réécrire le blob (touch NIST/OWASP).
- `listAll(filter?: ISessionListFilter): Promise<ISessionRecord[]>` — Énumération admin (capacité optionnelle d'`ISessionStorage`) — `find` projeté, filtrable par `user`.
- `listPage(query: ISessionListQuery): Promise<IPage<ISessionRecord>>` — Pagination **native** `skip/limit` + `countDocuments` (helper `paginate` orm-core) : une page = une requête bornée, quel que soit le volume en base.
- `countSessions(query?: Partial<ISessionListQuery>): Promise<number>` — `countDocuments` natif filtré — aucun document matérialisé.
- `countDistinctUsers(query?: Partial<ISessionListQuery>): Promise<number>` — Utilisateurs distincts, agrégés côté serveur.

#### `default`

```ts
class Mongoose extends Module<IMongooseConfig>
```

- `static critical: boolean` — Module **optionnel** (driver NoSQL externe, opt-in) : un échec de son boot (Mongo injoignable) ne tue jamais le process — le store de session dégrade gracieusement (`#repo()` → null).
- `constructor(kernel: Kernel)`
- `configSchema(): unknown` — JSON Schema de la config mongoose → data plane admin (config riche Studio).
- `onKernelRegister(): Promise<this>` — Valide la config (défauts + `module.options` + surcharge env) au boot via `buildMongooseConfig`, et l'expose au container sous `mongooseConfig` pour que le `MongooseService` la consomme sans redupliqu …
- `onKernelBoot(): Promise<this>` — Monte le data plane ORM (`/nodefony/orm/api/*` + providers santé/flux) via `wireOrmAdminPlane` — branchement GLOBAL et idempotent factorisé en orm-core (C5), identique à Drizzle.

### Fonctions (17)

#### `createAuditEntities`

```ts
function createAuditEntities(connector: string): IEntity[]
```

Construit les descripteurs d'entités du journal d'audit pour un ORM nommé.

#### `createIdempotencyEntities`

```ts
function createIdempotencyEntities(connector: string): IEntity[]
```

Construit le descripteur d'entité du store d'idempotence pour un ORM nommé.

#### `createTokenEntities`

```ts
function createTokenEntities(connector: string): IEntity[]
```

Construit les descripteurs d'entités du store de jetons pour un ORM nommé.

#### `createTotpSecretEntity`

```ts
function createTotpSecretEntity(connector: string): IEntity
```

Construit le descripteur d'entité du store de secrets TOTP pour un ORM nommé.

#### `createUserEntity`

```ts
function createUserEntity(connector: string): IEntity
```

Construit le descripteur d'entité `User` Mongoose pour un ORM nommé.

#### `createWebAuthnCredentialEntity`

```ts
function createWebAuthnCredentialEntity(connector: string): IEntity
```

Construit le descripteur d'entité du store de credentials pour un ORM nommé.

#### `createWebhookEndpointEntity`

```ts
function createWebhookEndpointEntity(connector: string): IEntity
```

Construit le descripteur d'entité du store webhook pour un ORM nommé.

#### `defineMongooseConfig`

```ts
function defineMongooseConfig(config?: IMongooseConfigInput): IMongooseConfig
```

Builder type-safe de la configuration de `@nodefony/mongoose`.

#### `mongooseConfigJsonSchema`

```ts
function mongooseConfigJsonSchema(): unknown
```

JSON Schema introspectable de la config Mongoose — destiné au formulaire d'édition Studio (futur) et à la documentation générée.

#### `registerAuditEntities`

```ts
function registerAuditEntities(connector: string): void
```

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).

#### `registerIdempotencyEntities`

```ts
function registerIdempotencyEntities(connector: string): void
```

Enregistre l'entité du store d'idempotence dans le `entityRegistry` pour un ORM donné. À appeler **avant** `orm.connect()`.

#### `registerMongooseFrameworkStores`

```ts
function registerMongooseFrameworkStores(): IFrameworkStoresReport
```

Déclare les entités framework Mongoose (connecteur `nodefony`) et enregistre leurs fabriques de stores dans les registres de `@nodefony/security`. Idempotent (guards) — rejouable sans effet.

#### `registerTokenEntities`

```ts
function registerTokenEntities(connector: string): void
```

Enregistre les entités du store de jetons dans le `entityRegistry` pour un ORM donné. À appeler **avant** `orm.connect()` (le modèle est compilé au connect).

#### `registerTotpSecretEntity`

```ts
function registerTotpSecretEntity(connector: string): void
```

Enregistre l'entité du store de secrets TOTP dans le `entityRegistry` pour un ORM donné. À appeler **avant** `orm.connect()`.

#### `registerUserEntity`

```ts
function registerUserEntity(connector: string): void
```

Enregistre l'entité `User` Mongoose dans le `entityRegistry` pour un ORM donné. À appeler **avant** `orm.connect()` (le modèle est compilé au connect).

#### `registerWebAuthnCredentialEntity`

```ts
function registerWebAuthnCredentialEntity(connector: string): void
```

Enregistre l'entité du store de credentials dans le `entityRegistry` pour un ORM donné. À appeler **avant** `orm.connect()` (le modèle est compilé au connect).

#### `registerWebhookEndpointEntity`

```ts
function registerWebhookEndpointEntity(connector: string): void
```

Enregistre l'entité du store webhook dans le `entityRegistry` pour un ORM donné. À appeler **avant** `orm.connect()` (le modèle est compilé au connect).

### Constantes (19)

#### `AUDIT_ENTITY_NAMES`

```ts
const AUDIT_ENTITY_NAMES: { readonly events: "audit_event"; }
```

Noms logiques des entités du store (clés de lookup `getRepository`).

#### `FRAMEWORK_CONNECTOR`

```ts
const FRAMEWORK_CONNECTOR = "nodefony"
```

Connecteur conventionnel qui héberge le schéma framework (`"nodefony"` pour Mongoose, ≠ `"default"` de Drizzle — isole les entités homonymes dans le `entityRegistry` process-wide si les deux ORM cohabitent).

#### `IDEMPOTENCY_ENTITY_NAME`

```ts
const IDEMPOTENCY_ENTITY_NAME: "idempotency_key"
```

Nom logique de l'entité (clé de lookup `getRepository` / `entityRegistry`).

#### `SESSION_CONNECTOR`

```ts
const SESSION_CONNECTOR = "nodefony"
```

ORM cible du stockage de session (connecteur par défaut du module).

#### `TOKEN_ENTITY_NAMES`

```ts
const TOKEN_ENTITY_NAMES: { readonly records: "access_token"; readonly denied: "denied_jti"; readonly revocations: "subject_revocation"; }
```

Noms logiques des entités du store (clés de lookup `getRepository`).

#### `TOTP_SECRET_ENTITY`

```ts
const TOTP_SECRET_ENTITY = "totp_secret"
```

Nom logique de l'entité (clé de lookup `getRepository`).

#### `WEBAUTHN_CREDENTIAL_ENTITY`

```ts
const WEBAUTHN_CREDENTIAL_ENTITY = "webauthn_credential"
```

Nom logique de l'entité (clé de lookup `getRepository`).

#### `WEBHOOK_ENDPOINT_ENTITY`

```ts
const WEBHOOK_ENDPOINT_ENTITY = "webhook_endpoint"
```

Nom logique de l'entité (clé de lookup `getRepository`).

#### `accessTokenSchema`

```ts
const accessTokenSchema: SchemaDefinition
```

Schémas Mongoose du **store de jetons** `@nodefony/security` (pendant documentaire des tables Drizzle) — implémentation NoSQL d'`ITokenStore` (PAT, refresh, denylist `jti`, seuil de révocation en masse).

#### `auditEventSchema`

```ts
const auditEventSchema: SchemaDefinition
```

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).

#### `deniedJtiSchema`

```ts
const deniedJtiSchema: SchemaDefinition
```

Denylist des access tokens (`jti` = `_id`) révoqués avant leur `exp`.

#### `idempotencyKeySchema`

```ts
const idempotencyKeySchema: SchemaDefinition
```

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.

#### `mongooseConfigSchema`

```ts
const mongooseConfigSchema: z.ZodObject<{ debug: z.ZodDefault<z.ZodBoolean>; connectors: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{ uri: z.ZodOptional<z.ZodString>; host: z.ZodDefault<z.ZodString>; port: z.ZodDefault<z.ZodNumber>; dbname: z.ZodDefault<z.ZodString>; autoIndex: z.ZodOptional<z.ZodBoolean>; options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>; }, z.core.$strict>>>; …
```

#### `sessionSchema`

```ts
const schema: SchemaDefinition
```

Schéma Mongoose de stockage des sessions (compilé par `MongooseOrm` au boot).

#### `subjectRevocationSchema`

```ts
const subjectRevocationSchema: SchemaDefinition
```

Seuil de révocation en masse par porteur (`subjectId` = `_id`).

#### `totpSecretSchema`

```ts
const totpSecretSchema: SchemaDefinition
```

Schéma Mongoose du **store de secrets TOTP** `@nodefony/security` (2FA) — pendant documentaire de la table Drizzle `totp_secret`, implémentation NoSQL d'`ITotpSecretStore`.

#### `userSchema`

```ts
const userSchema: SchemaDefinition
```

Schéma Mongoose de l'utilisateur Nodefony — implémentation NoSQL du contrat `@nodefony/user`, **dérivée** de `USER_COLUMNS` (pendant documentaire de `userTable`).

#### `webAuthnCredentialSchema`

```ts
const webAuthnCredentialSchema: SchemaDefinition
```

Schéma Mongoose du **store de credentials WebAuthn** `@nodefony/security` (pendant documentaire de la table Drizzle) — implémentation NoSQL d' `IWebAuthnCredentialStore` (passkeys).

#### `webhookEndpointSchema`

```ts
const webhookEndpointSchema: SchemaDefinition
```

Schéma Mongoose du **store d'endpoints webhook** `@nodefony/security` (P6.13, pendant documentaire de la table Drizzle) — implémentation NoSQL d' `IWebhookStore` (registre durable des destinations notifiées).

### Interfaces (11)

#### `AuditEventRow`

```ts
interface AuditEventRow
```

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`.

- `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`

#### `DeniedJtiRow`

```ts
interface DeniedJtiRow
```

Forme plate d'une ligne de denylist (`id` = virtuel = jti).

- `id: string`
- `expiresAt: number`

#### `IFrameworkStoresReport`

```ts
interface IFrameworkStoresReport
```

Bilan de l'auto-enregistrement (loggé par le module — jamais silencieux).

- `registered: string[]` — Entités déclarées par l'auto-register (modèles compilés au connect).
- `appOwned: string[]` — Entités déjà enregistrées par l'app (customisation respectée).

#### `IIndexAudit`

```ts
interface IIndexAudit
```

Verdict d'index d'une entité — l'écart entre ce que le schéma DÉCLARE et ce que la base PORTE réellement.

- `entity: string` — Nom de l'entité (clé du `entityRegistry`).
- `collection: string` — Collection MongoDB sous-jacente.
- `missing: string[]` — Index déclarés au schéma et ABSENTS de la base — la vraie alerte.
- `extra: string[]` — Index présents en base et non déclarés — informatif, jamais supprimé.
- `error?: string` — Motif d'un échec de construction, quand la base l'a refusée.

#### `IdempotencyKeyRow`

```ts
interface IdempotencyKeyRow
```

Forme plate d'une ligne du store d'idempotence telle que rendue par le repository Mongoose. Identique aux champs de `idempotencyKeySchema` → zéro mapping store ↔ entité.

- `key: string`
- `fingerprint: string`
- `state: "if" | "done"`
- `response: IdempotentResponse | null`
- `expiresAt: number`

#### `SessionRow`

```ts
interface SessionRow
```

Forme plate d'une ligne de session telle que renvoyée par le repository.

- `session_id: string`
- `Attributes: unknown`
- `flashBag: unknown`
- `metaBag: unknown`
- `user: string | null`
- `createdAt: number`
- `updatedAt: number`

#### `SubjectRevocationRow`

```ts
interface SubjectRevocationRow
```

Forme plate d'une ligne de révocation par porteur (`id` = virtuel = subjectId).

- `id: string`
- `invalidBefore: number`

#### `TotpSecretRow`

```ts
interface TotpSecretRow
```

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`.

- `userId: string`
- `secretEnc: string`
- `algorithm: TotpAlgorithm`
- `digits: number`
- `period: number`
- `recoveryCodes: string[]`
- `confirmedAt: number | null`
- `lastUsedStep: number | null`
- `createdAt: number`
- `lastUsedAt: number | null`

#### `UserRow`

```ts
interface IUserRow
```

Forme plate d'un utilisateur tel qu'un dépôt le rend, avant reconstruction en `BaseUser` — pendant TypeScript de `USER_COLUMNS`.

- `id: string`
- `identifier: string`
- `password: string | null`
- `roles: string[]`
- `enabled: boolean`
- `locked: boolean`
- `currentRole: string | null`
- `socialProviders: ISocialProvider[]`
- `metadata: Record<string, unknown>`
- `credentialsVersion: number | null`
- `createdAt: Date`
- `updatedAt: Date`

#### `WebAuthnCredentialRow`

```ts
interface WebAuthnCredentialRow
```

Forme **plate** d'une ligne de credentials renvoyée par le repository Mongoose — `id` = virtuel (= `_id` = credentialId), `nickname: string | null`. Le store mappe `Row ↔ IWebAuthnCredential` (`nickname?` omis si `null`).

- `id: string`
- `userId: string`
- `publicKey: string`
- `signCount: number`
- `transports: string[]`
- `backupEligible: boolean`
- `backupState: boolean`
- `uvInitialized: boolean`
- `nickname: string | null`
- `createdAt: number`
- `lastUsedAt: number | null`

#### `WebhookEndpointRow`

```ts
interface WebhookEndpointRow
```

Forme **plate** d'une ligne d'endpoint renvoyée par le repository Mongoose — `id` = virtuel (= `_id` = l'id `wh_…`), `events` mutable (le contrat porte `readonly string[]`). `MongooseWebhookStore` mappe `Row ↔ IWebhookEndpoint`.

- `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>`

### Types (3)

#### `IMongooseConfig`

```ts
type IMongooseConfig = z.infer<typeof mongooseConfigSchema>
```

Configuration normalisée et gelée de `@nodefony/mongoose` (sortie du builder `defineMongooseConfig`, consommée par le `MongooseService`).

#### `IMongooseConfigInput`

```ts
type IMongooseConfigInput = z.input<typeof mongooseConfigSchema>
```

Entrée du builder `defineMongooseConfig` — tous les champs portant un défaut sont optionnels (l'app ne fournit que ce qu'elle surcharge dans `use()`).

#### `IMongooseConnectorConfig`

```ts
type IMongooseConnectorConfig = IMongooseConfig["connectors"][string]
```

Définition d'une connexion Mongoose nommée (sous-objet de `connectors`).

### Bibliothèques réexportées (1)

#### `mongoose`

La bibliothèque `mongoose`, réexportée telle quelle : sa documentation est la sienne.

---

[← Toutes les références d'API](../)