@nodefony/mongoose 10.0.0-alpha.1

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

@@ -0,0 +1,61 @@
+import type { SchemaDefinition } from "mongoose";
+import type { IEntity } from "@nodefony/orm-core";
+/**
+ * Schéma Mongoose du **store de credentials WebAuthn** `@nodefony/security`
+ * (pendant documentaire de la table Drizzle) — implémentation NoSQL d'
+ * `IWebAuthnCredentialStore` (passkeys).
+ *
+ * ⚠️ **`_id` = clé naturelle (String), PAS un ObjectId auto** : le contrat
+ * `IRepository` traduit le critère `{ id }` en `{ _id }` (cf `MongooseRepository`).
+ * Comme l'`id` d'un credential est un **identifiant base64url fourni par
+ * l'authenticator** (pas généré par Mongo), on force `_id: String` → le
+ * credentialId EST la clé primaire. Le virtuel `id` (activé par `MongooseOrm`,
+ * `toObject:{virtuals:true}`) renvoie `String(_id)` = le credentialId.
+ *
+ * ⚠️ **Horodatages = `Number` (epoch ms), `timestamps:false`** : `IWebAuthnCredential`
+ * porte des `number` (`Date.now()`) et l'appelant fournit `createdAt`.
+ *
+ * Le store ne lit/écrit JAMAIS `IWebAuthnCredential` directement : il traduit via
+ * {@link WebAuthnCredentialRow} (forme plate, `nickname: string | null`) — le
+ * contrat porte un `nickname?` optionnel et des champs `readonly`, que la
+ * frontière de persistance normalise.
+ */
+export declare const webAuthnCredentialSchema: SchemaDefinition;
+/**
+ * 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`).
+ */
+export interface WebAuthnCredentialRow {
+    id: string;
+    userId: string;
+    publicKey: string;
+    signCount: number;
+    transports: string[];
+    backupEligible: boolean;
+    backupState: boolean;
+    uvInitialized: boolean;
+    nickname: string | null;
+    createdAt: number;
+    lastUsedAt: number | null;
+}
+/** Nom logique de l'entité (clé de lookup `getRepository`). */
+export declare const WEBAUTHN_CREDENTIAL_ENTITY = "webauthn_credential";
+/**
+ * Construit le descripteur d'entité du store de credentials pour un ORM nommé.
+ *
+ * Le `connector` est **dynamique** (nom du connecteur de l'app, ex. `"nodefony"`) : le
+ * schéma est statique mais sa liaison à un ORM dépend de la config → pas d'`@entity`
+ * figé (parité `createTokenEntities`). `timestamps:false`. À enregistrer **avant**
+ * `orm.connect()`.
+ *
+ * @param orm - clé de l'ORM cible dans le `ormRegistry`.
+ */
+export declare function createWebAuthnCredentialEntity(connector: string): IEntity;
+/**
+ * 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).
+ *
+ * @param connector - nom de la connexion cible (clé du registre).
+ */
+export declare function registerWebAuthnCredentialEntity(connector: string): void;

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

@@ -0,0 +1,62 @@
+import type { SchemaDefinition } from "mongoose";
+import type { IEntity } from "@nodefony/orm-core";
+/**
+ * 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).
+ *
+ * ⚠️ **`_id` = clé naturelle (String), PAS un ObjectId auto** : l'`id` d'un
+ * endpoint est un identifiant `wh_<random>` **fourni** (pas généré par Mongo) →
+ * on force `_id: String` → l'id EST la clé primaire. Le contrat `IRepository`
+ * traduit le critère `{ id }` en `{ _id }` ; le virtuel `id` (activé par
+ * `MongooseOrm`, `toObject:{virtuals:true}`) renvoie `String(_id)` = l'id.
+ *
+ * ⚠️ **Horodatages = `Number` (epoch ms), `timestamps:false`** : `IWebhookEndpoint`
+ * porte des `number` (`Date.now()`) et l'appelant fournit `createdAt`/`updatedAt`.
+ *
+ * `events` = tableau de strings ; `metadata` = objet libre (`Object`/Mixed, idem
+ * `tokenEntity.metadata`). Le store réécrit ces champs en bloc (pas de mutation
+ * partielle in-place) → pas de souci de change-tracking Mixed.
+ */
+export declare const webhookEndpointSchema: SchemaDefinition;
+/**
+ * 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`.
+ */
+export interface WebhookEndpointRow {
+    id: string;
+    url: string;
+    secretEnc: string;
+    events: string[];
+    enabled: boolean;
+    description: string | null;
+    tenantId: string | null;
+    createdBy: string | null;
+    createdAt: number;
+    updatedAt: number;
+    lastDeliveryAt: number | null;
+    lastDeliveryStatus: number | null;
+    lastDeliveryError: string | null;
+    failureCount: number;
+    metadata: Record<string, unknown>;
+}
+/** Nom logique de l'entité (clé de lookup `getRepository`). */
+export declare const WEBHOOK_ENDPOINT_ENTITY = "webhook_endpoint";
+/**
+ * Construit le descripteur d'entité du store webhook pour un ORM nommé.
+ *
+ * Le `connector` est **dynamique** (nom du connecteur de l'app, ex. `"nodefony"`) : le
+ * schéma est statique mais sa liaison à un ORM dépend de la config → pas
+ * d'`@entity` figé. `timestamps:false`. À enregistrer **avant** `orm.connect()`.
+ *
+ * @param orm - clé de l'ORM cible dans le `ormRegistry`.
+ */
+export declare function createWebhookEndpointEntity(connector: string): IEntity;
+/**
+ * Enregistre l'entité du store webhook 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 registerWebhookEndpointEntity(connector: string): void;

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

@@ -0,0 +1,17 @@
+import type { z } from "zod";
+import type { mongooseConfigSchema } from "../config/config.js";
+/**
+ * Configuration normalisée et gelée de `@nodefony/mongoose` (sortie du builder
+ * {@link defineMongooseConfig}, consommée par le `MongooseService`).
+ *
+ * Type **dérivé du schéma Zod** — NE PAS redéclarer les champs à la main (ils
+ * divergeraient silencieusement de la source de vérité `config/config.ts`).
+ */
+export type IMongooseConfig = z.infer<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()`).
+ */
+export type IMongooseConfigInput = z.input<typeof mongooseConfigSchema>;
+/** Définition d'une connexion Mongoose nommée (sous-objet de `connectors`). */
+export type IMongooseConnectorConfig = IMongooseConfig["connectors"][string];

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

@@ -0,0 +1 @@
+export type { IMongooseConfig, IMongooseConfigInput, IMongooseConnectorConfig, } from "./IMongooseConfig.js";

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

@@ -0,0 +1,37 @@
+/**
+ * AUTO-ENREGISTREMENT des backends framework portés par Mongoose — « charger le
+ * module = ses backends deviennent sélectionnables par simple nom » (convention-
+ * frère : `registerDrizzleFrameworkStores` de `@nodefony/drizzle`).
+ *
+ * Appelé par `Mongoose.onKernelRegister` (AVANT le connect de `onBoot` — les
+ * 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.
+ *
+ * Mêmes garde-fous que Drizzle : entité `has`-guarded (l'app garde la main),
+ * fabrique `get`-guarded (premier-arrivé-premier-servi).
+ */
+/**
+ * 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).
+ */
+export declare const FRAMEWORK_CONNECTOR = "nodefony";
+/** Bilan de l'auto-enregistrement (loggé par le module — jamais silencieux). */
+export interface IFrameworkStoresReport {
+    /** Entités déclarées par l'auto-register (modèles compilés au connect). */
+    registered: string[];
+    /** Entités déjà enregistrées par l'app (customisation respectée). */
+    appOwned: string[];
+}
+/**
+ * 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.
+ *
+ * @returns bilan à logger (registered / appOwned)
+ */
+export declare function registerMongooseFrameworkStores(): IFrameworkStoresReport;

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

@@ -0,0 +1,48 @@
+import type { ConnectOptions } from "mongoose";
+import { Service } from "nodefony";
+import type { Module } from "nodefony";
+import { MongooseOrm } from "../src/orm-core/MongooseOrm.js";
+import type { IMongooseConnectorConfig } from "../interfaces/IMongooseConfig.js";
+/**
+ * Service bootable du module `@nodefony/mongoose` (driver NoSQL).
+ *
+ * Au boot du kernel (`onBoot`), instancie un {@link MongooseOrm} (adapter
+ * orm-core) **par connecteur** déclaré dans la config et le connecte ; chaque
+ * ORM s'auto-enregistre dans le `ormRegistry`. Ferme proprement les connexions
+ * à `onTerminate`.
+ *
+ * Refonte de l'ancien `Mongoose extends Orm` (core legacy) : ce service ne
+ * dérive plus de la base ORM du core — il **orchestre** des adapters orm-core
+ * autonomes, exactement comme `DrizzleService`. Le core ne connaît plus l'ORM.
+ */
+declare class MongooseService extends Service {
+    #private;
+    module: Module;
+    constructor(module: Module);
+    /** Connecte tous les connecteurs déclarés en config (validée Zod). */
+    connectAll(): Promise<void>;
+    /** Assemble l'URI de connexion à partir de la config (`uri` ou composants). */
+    static buildUri(cfg: IMongooseConnectorConfig): string;
+    /**
+     * Options de connexion Mongoose d'un connecteur.
+     *
+     * `options` reste un fourre-tout transmis tel quel — Mongoose valide ses
+     * propres `ConnectOptions`, les re-modéliser en Zod serait une duplication
+     * qui dériverait. `autoIndex` fait exception, et une seule : il décide si les
+     * contraintes d'unicité sont construites au démarrage, ce qui mérite un champ
+     * typé, décrit, et visible dans la configuration d'un connecteur.
+     *
+     * Il **prime** donc sur une clé homonyme écrite dans `options` : entre deux
+     * canaux, celui qui est déclaré gagne — la même règle que les délais de
+     * connexion, où un choix explicite l'emporte sur un défaut.
+     *
+     * @param cfg - configuration validée du connecteur.
+     * @returns les options à passer à la connexion, ou `undefined` s'il n'y en a aucune.
+     */
+    static buildConnectOptions(cfg: IMongooseConnectorConfig): ConnectOptions | undefined;
+    /** Ferme toutes les connexions. */
+    disconnectAll(): Promise<void>;
+    /** Retourne l'ORM Mongoose d'un connecteur (défaut : `"nodefony"`). */
+    getOrm(name?: string): MongooseOrm | undefined;
+}
+export default MongooseService;

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

@@ -0,0 +1,126 @@
+import type { IRepository } from "@nodefony/orm-core";
+import type { IPage } from "nodefony";
+import type { IAccessTokenRecord, ITokenListQuery, ITokenStore, ITokenUsage, TokenRevokeReason } from "@nodefony/security";
+import type { MongooseOrm } from "./orm-core/index.js";
+import { type DeniedJtiRow, type SubjectRevocationRow } from "../entity/tokenEntity.js";
+/**
+ * Store de jetons **Mongoose** (NoSQL) — implémentation d'{@link ITokenStore} au
+ * dessus de trois repositories `@nodefony/orm-core` (`access_token`, `denied_jti`,
+ * `subject_revocation`). Pendant documentaire de `DrizzleTokenStore`.
+ *
+ * **Approche B** : `@nodefony/security` n'est connu qu'en `import type` (0 dép
+ * runtime). C'est l'application qui enregistre la fabrique (`registerTokenStore`)
+ * et les entités (`registerTokenEntities(orm)` avant `orm.connect()`).
+ *
+ * **Spécificité Mongo** : la clé naturelle (`jti` / `subjectId`) est portée par
+ * `_id` (cf {@link tokenEntity}). Le contrat traduit `{ id }` → `{ _id }`, donc
+ * les lookups passent par le champ `id` ; les **écritures** posent explicitement
+ * `_id` (Mongo ne génère pas notre jti). Les reads sont normalisés (`id` ← `_id`)
+ * pour ne pas dépendre du virtuel. Le reste est identique au store Drizzle : `gc`
+ * via `$lte` (le type bracketing Mongo exclut les `null`), idempotence de `revoke`
+ * par read-then-write.
+ */
+export declare class MongooseTokenStore implements ITokenStore {
+    #private;
+    /**
+     * {@inheritDoc ITokenStore.sortableFields}
+     *
+     * Capacité pleine : le vocabulaire public entier est trié par Mongo, `id`
+     * compris — traduit en `_id` au moment de la requête.
+     */
+    readonly sortableFields: readonly ["createdAt", "name", "subjectId", "id"];
+    /**
+     * @param records - repository de `access_token` (PAT + refresh).
+     * @param denied - repository de la denylist `denied_jti`.
+     * @param revocations - repository des seuils `subject_revocation`.
+     * @param now - horloge (epoch ms) injectable pour les tests.
+     * @param retentionRevokedMs - rétention d'un PAT révoqué sans `exp` avant purge.
+     */
+    constructor(records: IRepository<IAccessTokenRecord>, denied: IRepository<DeniedJtiRow>, revocations: IRepository<SubjectRevocationRow>, now?: () => number, retentionRevokedMs?: number);
+    /**
+     * Construit le store depuis un {@link MongooseOrm} connecté. Les entités
+     * (`registerTokenEntities`) doivent avoir été enregistrées **avant** `connect()`.
+     *
+     * @param orm - ORM Mongoose connecté hébergeant les collections du store.
+     * @param now - horloge injectable (tests).
+     * @param retentionRevokedMs - rétention des PAT révoqués sans `exp`.
+     */
+    static from(orm: MongooseOrm, now?: () => number, retentionRevokedMs?: number): MongooseTokenStore;
+    /**
+     * 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 id lire « absent » et
+     * insérer tous les deux → E11000 pour le perdant). `put` pose le record
+     * COMPLET → tout hors `id` est ré-appliqué au conflit.
+     *
+     * `id` en critère suffit à poser `_id` : Mongo ajoute les égalités du filtre
+     * au document inséré (cf `MongooseRepository.upsert`), plus besoin du `_id`
+     * explicite. Parité stricte avec l'adapter Drizzle.
+     *
+     * @param record - le record complet à persister.
+     */
+    put(record: IAccessTokenRecord): Promise<void>;
+    findById(id: string): Promise<IAccessTokenRecord | null>;
+    findByHash(secretHash: string): Promise<IAccessTokenRecord | null>;
+    findBySubject(subjectId: string): Promise<IAccessTokenRecord[]>;
+    /** Tous les jetons (PAT + refresh) — vue d'administration cross-porteur. */
+    listAll(): Promise<IAccessTokenRecord[]>;
+    /**
+     * {@inheritDoc ITokenStore.listPage}
+     *
+     * `paginate()` d'orm-core (skip/limit + countDocuments) sur un filtre portable ;
+     * les `id` sont re-normalisés (`_id` → `id`) 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
+     * sur un champ absent — il rend un ordre arbitraire. Sans traduction, un
+     * `?order=id` serait donc inerte ici et correct partout ailleurs.
+     */
+    listPage(query: ITokenListQuery): Promise<IPage<IAccessTokenRecord>>;
+    /** {@inheritDoc ITokenStore.countTokens} */
+    countTokens(query: ITokenListQuery): Promise<number>;
+    markUsed(id: string, usage: ITokenUsage): Promise<void>;
+    /**
+     * Révoque un jeton — **idempotent** : la 1ʳᵉ date/raison est conservée.
+     *
+     * Le « pas encore révoqué » est dans le filtre (`revokedAt: { $null: true }`),
+     * pas dans un `if` JS après lecture : une seule instruction, donc deux
+     * révocations concurrentes ne se recouvrent plus (la 2ᵉ ne matche rien au lieu
+     * d'écraser la date/raison de la 1ʳᵉ). Parité stricte avec l'adapter Drizzle.
+     *
+     * @param id - identifiant du jeton.
+     * @param reason - motif, posé seulement à la 1ʳᵉ révocation.
+     */
+    revoke(id: string, reason: TokenRevokeReason): Promise<void>;
+    /**
+     * Coupe toute une famille de refresh (détection de rejeu, RFC 9700) — les
+     * membres déjà révoqués gardent leur raison d'origine.
+     *
+     * Un seul `updateMany` filtré : atomique, et N+1 requêtes (1 find + 1 update
+     * par membre actif) tombent à 1.
+     *
+     * @param family - famille de refresh à couper.
+     * @param reason - motif appliqué aux membres encore actifs.
+     */
+    revokeFamily(family: string, reason: TokenRevokeReason): Promise<void>;
+    denyJti(jti: string, expiresAt: number): Promise<void>;
+    isJtiDenied(jti: string): Promise<boolean>;
+    /**
+     * Pose le seuil de révocation en masse d'un porteur (« déconnecte-moi de
+     * partout ») : tout jeton émis avant `invalidBefore` est mort.
+     *
+     * **Monotone — le seuil ne recule JAMAIS**, y compris sous deux logouts
+     * simultanés : la comparaison vit dans la valeur écrite (`$max`, natif Mongo),
+     * pas dans un `if` JS après lecture. Une lecture suivie d'une écriture
+     * laisserait les deux appels voir le même état et écrire tous les deux — c'est
+     * le dernier qui resterait, même porteur d'un seuil plus ANCIEN, et **des
+     * jetons révoqués redeviendraient valides**. Parité stricte avec l'adapter
+     * Drizzle (`GREATEST`/`MAX` SQL).
+     *
+     * @param subjectId - porteur visé.
+     * @param invalidBefore - seuil (epoch ms) ; ignoré s'il est antérieur au seuil courant.
+     */
+    revokeAllForSubject(subjectId: string, invalidBefore: number): Promise<void>;
+    getInvalidBefore(subjectId: string): Promise<number | null>;
+    gc(now?: number): Promise<number>;
+}

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

@@ -0,0 +1,82 @@
+import type { ClientSession, Model } from "mongoose";
+import type { IPasswordAuthenticatedUser, IUserListQuery, IUserRepository } from "@nodefony/user";
+import type { IPage } from "nodefony";
+import type { Criteria, IRepository, ITransaction, RepositoryReadOptions } from "@nodefony/orm-core";
+import type { MongooseOrm } from "./orm-core/MongooseOrm.js";
+import type { UserRow } from "../entity/userEntity.js";
+/** Modèle Mongoose à document libre (boundary — comme `MongooseRepository`). */
+type LooseModel = Model<Record<string, unknown>>;
+/**
+ * Adapter Mongoose du contrat {@link IUserRepository} — persistance NoSQL de
+ * l'utilisateur (P5.8), pendant documentaire de `DrizzleUserRepository` (P5.9).
+ *
+ * Décore le repository portable (`IRepository<UserRow>` de {@link MongooseOrm}) de
+ * deux responsabilités propres à l'utilisateur :
+ * - **mapping document ↔ `BaseUser`** : les consommateurs reçoivent le comportement
+ *   (`hasRole`/`isActive`/`isLocked`), pas un document nu ;
+ * - **finders métier** : `findByIdentifier` (lookup unique) et
+ *   `findBySocialProvider` (scan du tableau `socialProviders` via `$elemMatch` —
+ *   équivalent Mongo du `json_each` SQL de Drizzle, pattern Shadow User OAuth).
+ *
+ * Le credential (`password`) transite par cette frontière — attendu : le repository
+ * **est** la frontière de persistance du hash (cf `IUserRepository`).
+ */
+export declare class MongooseUserRepository implements IUserRepository {
+    #private;
+    /**
+     * Même vocabulaire public que les autres repositories — ici le tri part
+     * dans la requête, où il ne coûte qu'un index.
+     */
+    readonly sortableFields: readonly ["identifier", "enabled", "createdAt", "updatedAt", "id"];
+    /**
+     * @param base - repository portable sur l'entité `User` (CRUD + criteria).
+     * @param model - modèle Mongoose natif `User` (pour le scan `$elemMatch`).
+     * @param session - session transactionnelle liée aux ops natives, ou `null`.
+     */
+    constructor(base: IRepository<UserRow>, model: LooseModel, session?: ClientSession | null);
+    /**
+     * Construit le repository utilisateur depuis un {@link MongooseOrm} connecté.
+     * L'entité `User` doit avoir été enregistrée (cf `registerUserEntity`) **avant**
+     * `orm.connect()` (le modèle est compilé au connect).
+     *
+     * @param orm - ORM Mongoose connecté.
+     * @returns le repository utilisateur prêt à l'emploi.
+     */
+    static from(orm: MongooseOrm): MongooseUserRepository;
+    find(criteria?: Criteria<IPasswordAuthenticatedUser>, options?: RepositoryReadOptions): Promise<IPasswordAuthenticatedUser[]>;
+    findOne(criteria: Criteria<IPasswordAuthenticatedUser>, options?: RepositoryReadOptions): Promise<IPasswordAuthenticatedUser | null>;
+    create(data: Partial<IPasswordAuthenticatedUser>): Promise<IPasswordAuthenticatedUser>;
+    updateOne(criteria: Criteria<IPasswordAuthenticatedUser>, data: Partial<IPasswordAuthenticatedUser>): Promise<IPasswordAuthenticatedUser | null>;
+    upsert(criteria: Criteria<IPasswordAuthenticatedUser>, update: Partial<IPasswordAuthenticatedUser>, insertOnly?: Partial<IPasswordAuthenticatedUser>): Promise<IPasswordAuthenticatedUser>;
+    createMany(data: Partial<IPasswordAuthenticatedUser>[]): Promise<IPasswordAuthenticatedUser[]>;
+    exists(criteria: Criteria<IPasswordAuthenticatedUser>): Promise<boolean>;
+    deleteOne(criteria: Criteria<IPasswordAuthenticatedUser>): Promise<boolean>;
+    findOneAndDelete(criteria: Criteria<IPasswordAuthenticatedUser>): Promise<IPasswordAuthenticatedUser | null>;
+    increment(criteria: Criteria<IPasswordAuthenticatedUser>, changes: Partial<Record<keyof IPasswordAuthenticatedUser, number>>): Promise<IPasswordAuthenticatedUser | null>;
+    updateMany(criteria: Criteria<IPasswordAuthenticatedUser>, data: Partial<IPasswordAuthenticatedUser>): Promise<number>;
+    delete(criteria: Criteria<IPasswordAuthenticatedUser>): Promise<number>;
+    count(criteria?: Criteria<IPasswordAuthenticatedUser>): Promise<number>;
+    countDistinct(field: keyof IPasswordAuthenticatedUser & string, criteria?: Criteria<IPasswordAuthenticatedUser>): Promise<number>;
+    withTransaction(tx: ITransaction): IUserRepository;
+    findByIdentifier(identifier: string): Promise<IPasswordAuthenticatedUser | null>;
+    /**
+     * Recherche par compte externe lié — scanne le tableau `socialProviders` via
+     * `$elemMatch` (1 requête, équivalent Mongo du `json_each` Drizzle). `null` si
+     * aucun lien. Liée à la session transactionnelle courante le cas échéant.
+     */
+    findBySocialProvider(provider: string, providerId: string): Promise<IPasswordAuthenticatedUser | null>;
+    /**
+     * {@inheritDoc IUserRepository.listPage}
+     *
+     * Query native Mongo : `find(filter).sort().skip().limit(limit + 1)` — le store
+     * ne renvoie qu'une page (jamais de matérialisation complète). `roles: role` =
+     * containment de tableau natif, `$regex/i` = sous-chaîne insensible casse.
+     * `_id` en tiebreaker de tri (pagination offset déterministe).
+     */
+    listPage(query: IUserListQuery): Promise<IPage<IPasswordAuthenticatedUser>>;
+    /** {@inheritDoc IUserRepository.countActiveAdmins} */
+    /** {@inheritDoc IUserRepository.countUsers} */
+    countUsers(query: IUserListQuery): Promise<number>;
+    countActiveAdmins(adminRole: string): Promise<number>;
+}
+export {};

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

@@ -0,0 +1,52 @@
+import { type IRepository } from "@nodefony/orm-core";
+import type { IPage } from "nodefony";
+import type { IWebAuthnCredential, IWebAuthnCredentialStore, IWebAuthnCredentialSummary, IWebAuthnListQuery, WebAuthnAuthUpdate } from "@nodefony/security";
+import type { MongooseOrm } from "./orm-core/index.js";
+import { type WebAuthnCredentialRow } from "../entity/webAuthnCredentialEntity.js";
+/**
+ * Store de credentials WebAuthn **Mongoose** (NoSQL) — implémentation d'
+ * {@link IWebAuthnCredentialStore} au-dessus d'un unique repository
+ * `@nodefony/orm-core` (`webauthn_credential`). Pendant documentaire de
+ * `DrizzleWebAuthnCredentialStore`.
+ *
+ * **Approche B** : `@nodefony/security` n'est connu qu'en `import type` (0 dép
+ * runtime). C'est l'application qui enregistre la fabrique
+ * (`registerWebAuthnStore("mongoose", …)`) et l'entité
+ * (`registerWebAuthnCredentialEntity(orm)` avant `orm.connect()`).
+ *
+ * **Spécificité Mongo** : la clé naturelle (credentialId) est portée par `_id`
+ * (cf {@link webAuthnCredentialSchema}). Le contrat traduit `{ id }` → `{ _id }`,
+ * donc les lookups passent par le champ `id` ; les **écritures** posent
+ * explicitement `_id` (Mongo ne génère pas notre credentialId). Le mapping
+ * `Row ↔ IWebAuthnCredential` normalise `nickname` (`null` → omis).
+ */
+export declare class MongooseWebAuthnCredentialStore implements IWebAuthnCredentialStore {
+    #private;
+    /** @param repo - repository de la collection `webauthn_credential`. */
+    constructor(repo: IRepository<WebAuthnCredentialRow>);
+    /**
+     * Construit le store depuis un {@link MongooseOrm} connecté. L'entité
+     * (`registerWebAuthnCredentialEntity`) doit avoir été enregistrée **avant**
+     * `connect()`.
+     *
+     * @param orm - ORM Mongoose connecté hébergeant la collection du store.
+     */
+    static from(orm: MongooseOrm): MongooseWebAuthnCredentialStore;
+    findById(credentialId: string): Promise<IWebAuthnCredential | null>;
+    findByUser(userId: string): Promise<IWebAuthnCredential[]>;
+    /** `countDocuments` natif — jamais un `find().length` (le plafond ne charge rien). */
+    countByUser(userId: string): Promise<number>;
+    save(credential: IWebAuthnCredential): Promise<void>;
+    update(credentialId: string, patch: WebAuthnAuthUpdate): Promise<void>;
+    delete(credentialId: string): Promise<void>;
+    /**
+     * {@inheritDoc IWebAuthnCredentialStore.listPage}
+     *
+     * Même helper `paginate()` que l'adapter SQL (`skip`/`limit` + `countDocuments`).
+     * La projection retire `publicKey` — elle ne franchit jamais la frontière du store.
+     * ⚠️ L'identité vient de `_id` (`#idOf`), pas du champ `id` de la row.
+     */
+    listPage(query: IWebAuthnListQuery): Promise<IPage<IWebAuthnCredentialSummary>>;
+    /** {@inheritDoc IWebAuthnCredentialStore.countCredentials} */
+    countCredentials(query: IWebAuthnListQuery): Promise<number>;
+}

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

@@ -0,0 +1,72 @@
+import type { IRepository } from "@nodefony/orm-core";
+import type { IPage } from "nodefony";
+import type { IWebhookEndpoint, IWebhookListQuery, IWebhookStore, WebhookEndpointUpdate } 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>>;
+import { type WebhookEndpointRow } from "../entity/webhookEndpointEntity.js";
+/**
+ * Store d'endpoints webhook **Mongoose** (NoSQL) — implémentation d'
+ * {@link 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`).
+ *
+ * **Approche B** : `@nodefony/security` n'est connu qu'en `import type` (0 dép
+ * runtime). C'est l'application qui enregistre la fabrique
+ * (`registerWebhookStore("mongoose", …)`) et l'entité
+ * (`registerWebhookEndpointEntity(orm)` avant `orm.connect()`).
+ *
+ * **Spécificité Mongo** : la clé naturelle (`wh_<random>`) est portée par `_id`
+ * (cf {@link webhookEndpointSchema}). Le contrat traduit `{ id }` → `{ _id }`,
+ * donc les lookups passent par `id` ; les **écritures** posent explicitement
+ * `_id` (Mongo ne génère pas notre id). Mapping `Row ↔ IWebhookEndpoint` :
+ * `IWebhookEndpoint` est déjà « plat tout `| null` », seuls les champs JSON
+ * `events`/`metadata` sont copiés défensivement.
+ */
+export declare class MongooseWebhookStore implements IWebhookStore {
+    #private;
+    /**
+     * {@inheritDoc IWebhookStore.sortableFields}
+     *
+     * Capacité pleine : le vocabulaire public entier est trié par Mongo, `id`
+     * compris — traduit en `_id` au moment de la requête.
+     */
+    readonly sortableFields: readonly ["createdAt", "updatedAt", "url", "enabled", "failureCount", "id"];
+    /**
+     * @param repo - repository de la collection `webhook_endpoint`.
+     * @param model - modèle Mongoose natif, requis par le seul listing paginé
+     *   (recherche `q` = `$or` sur deux champs, hors `Criteria` AND-only).
+     *   `null` = `listPage` refuse plutôt que de tout charger en silence.
+     */
+    constructor(repo: IRepository<WebhookEndpointRow>, model?: LooseModel | null);
+    /**
+     * Construit le store depuis un {@link MongooseOrm} connecté. L'entité
+     * (`registerWebhookEndpointEntity`) doit avoir été enregistrée **avant**
+     * `connect()`.
+     *
+     * @param orm - ORM Mongoose connecté hébergeant la collection du store.
+     */
+    static from(orm: MongooseOrm): MongooseWebhookStore;
+    save(endpoint: IWebhookEndpoint): Promise<void>;
+    findById(id: string): Promise<IWebhookEndpoint | null>;
+    update(id: string, patch: WebhookEndpointUpdate): Promise<void>;
+    delete(id: string): Promise<void>;
+    listAll(): Promise<IWebhookEndpoint[]>;
+    /**
+     * {@inheritDoc IWebhookStore.listPage}
+     *
+     * Query native : `find(filter).sort(…).skip().limit(limit+1)` — une page,
+     * jamais la collection. Le `limit + 1` donne `hasNext` sans compter.
+     *
+     * Le tri demandé est **traduit** avant de descendre : au repos, l'endpoint n'a
+     * pas de champ `id` (l'identifiant EST le `_id`), et Mongo ne se plaint pas
+     * d'un tri sur un champ absent — il rend un ordre arbitraire. Sans traduction,
+     * un `?order=id` serait donc inerte ici et correct partout ailleurs. À défaut
+     * d'`order`, l'ordre par défaut `createdAt DESC, _id ASC` reste déterministe.
+     */
+    listPage(query: IWebhookListQuery): Promise<IPage<IWebhookEndpoint>>;
+    /** {@inheritDoc IWebhookStore.countEndpoints} */
+    countEndpoints(query: IWebhookListQuery): Promise<number>;
+}
+export {};

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

@@ -0,0 +1,63 @@
+import { SessionsService } from "@nodefony/http";
+import type { ISessionStorage, ISerializedSession, ISessionRecord, ISessionListFilter, ISessionListQuery } from "@nodefony/http";
+import type { IPage } from "nodefony";
+/**
+ * Stockage de session **Mongoose** (driver NoSQL), branché sur `@nodefony/orm-core`.
+ *
+ * Implémente le contrat {@link ISessionStorage} consommé par le `SessionsService`
+ * de `@nodefony/http` — store de session portable. Persiste via le repository
+ * orm-core de l'entité `session` (connecteur `nodefony`, modèle compilé au boot
+ * par `MongooseOrm`). Logique **identique** au store Drizzle (timestamps en ms,
+ * GC via l'opérateur riche portable `$lt`) — la portabilité du contrat orm-core.
+ */
+declare class SessionStorage implements ISessionStorage {
+    #private;
+    manager: SessionsService;
+    idleTimeoutS: number;
+    absoluteTimeoutS: number;
+    /**
+     * Même vocabulaire public que les autres backends — le tri part dans le
+     * `sort()` Mongo, où il ne coûte qu'un index.
+     */
+    readonly sortableFields: readonly ["updatedAt", "createdAt", "user", "id"];
+    constructor(manager: SessionsService);
+    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>;
+    /**
+     * Prolonge l'idle d'une session (timeout glissant) : `updateOne updatedAt = now`
+     * sur `session_id` — SANS réécrire le blob (touch NIST/OWASP). N'affecte pas
+     * `createdAt` (= borne absolute). ORM déconnecté → no-op ; ligne absente →
+     * no-op silencieux. Parité avec le store Drizzle.
+     */
+    touch(id: string): Promise<void>;
+    /**
+     * Énumération admin (capacité optionnelle d'`ISessionStorage`) — `find` projeté,
+     * filtrable par `user`. **Redaction par construction** : seuls `user`/`metaBag`/
+     * timestamps sortent de la base ; `Attributes`/`flashBag` (potentiellement
+     * sensibles) restent en base. ORM déconnecté → `[]`. Strictement identique au
+     * store Drizzle (parité du contrat orm-core).
+     */
+    listAll(filter?: ISessionListFilter): Promise<ISessionRecord[]>;
+    /**
+     * Pagination **native** `skip/limit` + `countDocuments` (helper `paginate`
+     * orm-core) : une page = une requête bornée, quel que soit le volume en base.
+     * Ordre `updatedAt` DESC départagé par `session_id` — déterministe à horodatage
+     * égal. ORM déconnecté → page vide. Parité stricte avec le store Drizzle.
+     */
+    listPage(query: ISessionListQuery): Promise<IPage<ISessionRecord>>;
+    /** `countDocuments` natif filtré — aucun document matérialisé. Déconnecté → 0. */
+    countSessions(query?: Partial<ISessionListQuery>): Promise<number>;
+    /**
+     * Utilisateurs distincts, agrégés côté serveur. Les sessions anonymes portent
+     * un `user` nul ou absent : l'agrégation les écarte, elles ne comptent donc
+     * pas pour un utilisateur. Déconnecté → 0 (même dégradation que
+     * {@link countSessions}).
+     */
+    countDistinctUsers(query?: Partial<ISessionListQuery>): Promise<number>;
+}
+export default SessionStorage;