Référence d'API — @nodefony/mongoose

stable

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#

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#

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#

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#

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#

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#

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#

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#

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#

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#

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#

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#

class SessionEntity

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

SessionStorage#

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#

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#

function createAuditEntities(connector: string): IEntity[]

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

createIdempotencyEntities#

function createIdempotencyEntities(connector: string): IEntity[]

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

createTokenEntities#

function createTokenEntities(connector: string): IEntity[]

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

createTotpSecretEntity#

function createTotpSecretEntity(connector: string): IEntity

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

createUserEntity#

function createUserEntity(connector: string): IEntity

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

createWebAuthnCredentialEntity#

function createWebAuthnCredentialEntity(connector: string): IEntity

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

createWebhookEndpointEntity#

function createWebhookEndpointEntity(connector: string): IEntity

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

defineMongooseConfig#

function defineMongooseConfig(config?: IMongooseConfigInput): IMongooseConfig

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

mongooseConfigJsonSchema#

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#

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#

function registerIdempotencyEntities(connector: string): void

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

registerMongooseFrameworkStores#

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#

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#

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#

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#

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#

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#

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

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

FRAMEWORK_CONNECTOR#

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#

const IDEMPOTENCY_ENTITY_NAME: "idempotency_key"

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

SESSION_CONNECTOR#

const SESSION_CONNECTOR = "nodefony"

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

TOKEN_ENTITY_NAMES#

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#

const TOTP_SECRET_ENTITY = "totp_secret"

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

WEBAUTHN_CREDENTIAL_ENTITY#

const WEBAUTHN_CREDENTIAL_ENTITY = "webauthn_credential"

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

WEBHOOK_ENDPOINT_ENTITY#

const WEBHOOK_ENDPOINT_ENTITY = "webhook_endpoint"

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

accessTokenSchema#

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#

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#

const deniedJtiSchema: SchemaDefinition

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

idempotencyKeySchema#

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#

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#

const schema: SchemaDefinition

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

subjectRevocationSchema#

const subjectRevocationSchema: SchemaDefinition

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

totpSecretSchema#

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#

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#

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#

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#

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#

interface DeniedJtiRow

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

• id: string
• expiresAt: number

IFrameworkStoresReport#

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#

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#

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#

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#

interface SubjectRevocationRow

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

• id: string
• invalidBefore: number

TotpSecretRow#

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#

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#

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#

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#

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#

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#

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