@nodefony/mongoose 10.0.0-alpha.8 → 10.0.0-beta.1

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

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

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

@@ -0,0 +1,121 @@
+import type { IIdempotencyKeyEntry, IIdempotencyListQuery, IIdempotencyStore, IdempotencyOutcome, IdempotentResponse, IPage } from "nodefony";
+import type { Model } from "mongoose";
+import type { MongooseOrm } from "./orm-core/index.js";
+/** Modèle Mongoose à document libre (boundary — comme `MongooseRepository`). */
+type LooseModel = Model<Record<string, unknown>>;
+/**
+ * Store d'idempotence **Mongoose** (NoSQL) — implémentation documentaire d'
+ * {@link IIdempotencyStore} (contrat au CORE) pour dédoublonner les mutations
+ * rejouées PARTAGÉ cross-pod, là où le store mémoire par défaut reste affine à
+ * un pod. Pendant documentaire de `DrizzleIdempotencyStore`.
+ *
+ * **Pourquoi MongoDB plutôt que Redis** : un cluster qui possède déjà une base
+ * Mongo mais pas de Redis obtient la dédup cross-pod sans nouvelle infra — le
+ * même argument qui fonde la variante SQL.
+ *
+ * **Réservation atomique (`begin`)** — clé de voûte. Un `findOneAndUpdate`
+ * filtré sur l'entrée MORTE, en `upsert`, est l'équivalent Mongo du `SET … NX
+ * PX` Redis et du `INSERT … ON CONFLICT … WHERE expiré` SQL, en **une seule
+ * instruction atomique** côté serveur :
+ *  - clé absente → le filtre ne matche rien → l'`upsert` insère → `fresh` ;
+ *  - clé présente mais **morte** (bail/rétention expirés) → le filtre matche →
+ *    l'update la **vole** atomiquement → `fresh` ;
+ *  - clé présente et **vivante** → le filtre ne matche pas → l'`upsert` tente
+ *    d'insérer → violation d'unicité sur `_id` (`E11000`) → on lit l'état
+ *    (`in-flight` / `replayed` / `mismatch`).
+ *
+ * C'est la **clé primaire** qui porte cette unicité, jamais un index secondaire :
+ * Mongoose construit ses index en tâche de fond, donc la contrainte n'existerait
+ * pas pendant la fenêtre de construction, et deux `begin` concurrents
+ * renverraient tous deux `fresh` — exactement le double-effet que ce store
+ * existe pour empêcher.
+ *
+ * Le store ne renvoie JAMAIS `fresh` sur le chemin de contention → anti
+ * double-effet garanti (l'invariant capital d'un store d'idempotence).
+ *
+ * **Pas de TTL natif** (≠ Redis `PX`, et un index TTL Mongo ignorerait la
+ * bascule bail → rétention) → un {@link MongooseIdempotencyStore.gc} applicatif
+ * purge les entrées expirées, comme la variante SQL.
+ *
+ * **Empreinte préservée à la complétion** : `complete()` ne touche pas le champ
+ * `fingerprint` → un rejeu de la clé avec un AUTRE payload après complétion est
+ * toujours détecté (`mismatch` 422, draft §2.7).
+ *
+ * **Résolution LAZY + dégradation gracieuse** (calqué sur le frère SQL) : le
+ * modèle est résolu à CHAQUE appel, jamais capturé à la construction — le
+ * framework fabrique ce store à `onKernelBoot`, AVANT le connect de l'ORM
+ * (`onBoot`), et l'ORM se déconnecte au shutdown avant le drain des serveurs. Si
+ * l'ORM n'est pas connecté, `begin` renvoie `fresh` (la mutation s'exécute SANS
+ * dédup) et `complete`/`abort`/`gc` sont des no-op — l'idempotence est
+ * temporairement inactive plutôt que de crasher une mutation en vol.
+ */
+export declare class MongooseIdempotencyStore implements IIdempotencyStore {
+    #private;
+    /**
+     * @param resolveModel - résolveur **lazy** du modèle Mongoose (`null` = ORM non
+     *   connecté → dégradation gracieuse). Lazy car l'ordre de boot/shutdown n'est
+     *   pas garanti à la construction.
+     * @param now - horloge (epoch ms) injectable pour des tests déterministes.
+     * @param leaseMs - bail d'une entrée *in-flight* (ms).
+     * @param ttlMs - rétention d'une réponse mémorisée (ms).
+     * @param connector - connecteur ORM qui porte la collection, publié au registre des stores.
+     */
+    constructor(resolveModel: () => LooseModel | null, now?: () => number, leaseMs?: number, ttlMs?: number, connector?: string);
+    /**
+     * Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+     * registre des stores : la console rattache la brique à SON connecteur au
+     * lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+     */
+    get connector(): string | undefined;
+    /**
+     * Construit le store depuis un {@link MongooseOrm}. Le modèle est résolu
+     * **lazy** (gardé par `isConnected()` → `null` tant que l'ORM n'est pas/plus
+     * connecté). L'entité (`registerIdempotencyEntities`) doit avoir été
+     * enregistrée **avant** `orm.connect()` (le modèle est compilé au connect).
+     *
+     * @param orm - ORM Mongoose hébergeant la collection `idempotency_key`.
+     * @param now - horloge injectable (tests).
+     * @param leaseMs - bail *in-flight* (ms).
+     * @param ttlMs - rétention d'une réponse mémorisée (ms).
+     */
+    static from(orm: MongooseOrm, now?: () => number, leaseMs?: number, ttlMs?: number): MongooseIdempotencyStore;
+    /**
+     * Approximation **per-pod, best-effort** : compteur local des réservations
+     * faites par CE pod (incrémenté au `fresh`, décrémenté au `complete`/`abort`),
+     * non décrémenté si le bail expire sans complétion, et désaligné cross-pod. La
+     * vérité cluster passe par un `countDocuments`, jamais ce getter (sync). Borné à ≥ 0.
+     */
+    get size(): number;
+    begin(key: string, fingerprint: string): Promise<IdempotencyOutcome>;
+    complete(key: string, response: IdempotentResponse): Promise<void>;
+    abort(key: string): Promise<void>;
+    /**
+     * Purge les entrées mortes (`expiresAt <= now`) — supplée l'absence de TTL
+     * exploitable ici (cf le schéma : l'échéance bascule du bail à la rétention).
+     * À déclencher périodiquement (le framework arme un `GcScheduler` au boot
+     * quand cette méthode existe).
+     *
+     * @param now - horloge de purge (défaut : horloge injectée).
+     * @returns le nombre d'entrées supprimées.
+     */
+    gc(now?: number): Promise<number>;
+    /**
+     * {@inheritDoc IIdempotencyStore.listPage}
+     *
+     * Query native projetée : on ne lit QUE les champs exposés — la réponse
+     * mémorisée (`response`) ne quitte jamais la base par ce chemin, quelle que
+     * soit la taille de la page (anti-IDOR sur le cache).
+     *
+     * Les entrées expirées sont exclues (`expiresAt > now`) : le GC applicatif
+     * passe plus tard, mais une clé échue n'est déjà plus opposable.
+     *
+     * ⚠️ **Le préfixe `q` est ÉCHAPPÉ**, donc littéral. Une chaîne saisie dans une
+     * console n'est pas une expression régulière : laisser passer les
+     * métacaractères ouvrirait un balayage de collection arbitraire — et pire, une
+     * catastrophe de retour sur trace. L'écart avec le frère SQL (où `%` et `_`
+     * restent des jokers) est assumé dans ce sens : ici le contrat — « `q` =
+     * préfixe » — est tenu au pied de la lettre.
+     */
+    listPage(query: IIdempotencyListQuery): Promise<IPage<IIdempotencyKeyEntry>>;
+}
+export {};

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

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

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

@@ -0,0 +1,63 @@
+import { type IRepository } from "@nodefony/orm-core";
+import type { IPage } from "nodefony";
+import type { ITotpEnrollmentSummary, ITotpListQuery, ITotpSecret, ITotpSecretStore, TotpSecretUpdate } from "@nodefony/security";
+import type { MongooseOrm } from "./orm-core/index.js";
+import { type TotpSecretRow } from "../entity/totpSecretEntity.js";
+/**
+ * Store de secrets TOTP **Mongoose** (NoSQL) — implémentation documentaire d'
+ * {@link ITotpSecretStore} au-dessus d'un unique repository `@nodefony/orm-core`
+ * (`totp_secret`). Pendant documentaire de `DrizzleTotpSecretStore` : là où
+ * `MemoryTotpSecretStore` est volatile, ce store survit au redémarrage et se
+ * partage entre pods.
+ *
+ * **Modèle 1 secret / utilisateur** (clé = `userId`, portée par `_id`) → `save`
+ * est un upsert par clé primaire.
+ *
+ * **Approche B** : `@nodefony/security` n'est connu qu'en `import type` (0 dép
+ * runtime).  L'entité (`registerTotpSecretEntity`) doit être enregistrée
+ * **avant** `orm.connect()` (le modèle est compilé au connect).
+ *
+ * **100 % portable** (aucune query native) — toutes les opérations passent par
+ * le contrat `IRepository`, comme son frère SQL : l'`userId` est cherché sous
+ * `id` (le contrat traduit `{ id }` → `{ _id }`), et le listing par `paginate()`.
+ *
+ * **`secretEnc` opaque** : le store persiste le secret DÉJÀ chiffré (AES-256-GCM
+ * côté service) — il ne déchiffre jamais, ne voit que des octets. Il ne sort
+ * JAMAIS par `listPage` (cf {@link ITotpEnrollmentSummary}).
+ */
+export declare class MongooseTotpSecretStore implements ITotpSecretStore {
+    #private;
+    /**
+     * @param repo - repository de la collection `totp_secret`.
+     */
+    constructor(repo: IRepository<TotpSecretRow>);
+    /**
+     * Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+     * registre des stores : la console rattache la brique à SON connecteur au
+     * lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+     */
+    get connector(): string | undefined;
+    /**
+     * Construit le store depuis un {@link MongooseOrm} connecté. L'entité
+     * (`registerTotpSecretEntity`) doit avoir été enregistrée **avant**
+     * `orm.connect()`.
+     *
+     * @param orm - ORM Mongoose connecté hébergeant la collection du store.
+     */
+    static from(orm: MongooseOrm): MongooseTotpSecretStore;
+    findByUser(userId: string): Promise<ITotpSecret | null>;
+    save(secret: ITotpSecret): Promise<void>;
+    update(userId: string, patch: TotpSecretUpdate): Promise<void>;
+    delete(userId: string): Promise<void>;
+    /**
+     * {@inheritDoc ITotpSecretStore.listPage}
+     *
+     * 100 % portable : le helper `paginate()` d'orm-core (limite/décalage + total
+     * optionnel) sur un critère simple. La projection en vue d'enrôlement retire
+     * `secretEnc` et les condensats — ils ne franchissent jamais la frontière du
+     * store, quel que soit l'appelant.
+     */
+    listPage(query: ITotpListQuery): Promise<IPage<ITotpEnrollmentSummary>>;
+    /** {@inheritDoc ITotpSecretStore.countEnrollments} */
+    countEnrollments(query: ITotpListQuery): Promise<number>;
+}

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

@@ -56,7 +56,7 @@ export declare class MongooseUserRepository implements IUserRepository {
     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>;
+    countDistinct(field: keyof IPasswordAuthenticatedUser, criteria?: Criteria<IPasswordAuthenticatedUser>): Promise<number>;
     withTransaction(tx: ITransaction): IUserRepository;
     findByIdentifier(identifier: string): Promise<IPasswordAuthenticatedUser | null>;
     /**

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

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

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

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

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

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

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

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

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

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

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

@@ -8,8 +8,8 @@ import type { ITransaction } from "@nodefony/orm-core";
  * MongoDB **exigent un replica set** (un standalone ne les supporte pas).
  *
  * MongoDB n'a **pas de savepoints** : {@link MongooseTransaction.savepoint} /
- * {@link MongooseTransaction.rollbackTo} sont des no-op documentés (limite du
- * driver, prévue par le contrat).
+ * {@link MongooseTransaction.rollbackTo} les REFUSENT (`SavepointNotSupportedError`).
+ * Un no-op laissait croire un rollback partiel qui n'annulait rien.
  */
 export declare class MongooseTransaction implements ITransaction {
     #private;
@@ -28,9 +28,17 @@ export declare class MongooseTransaction implements ITransaction {
     commit(): Promise<void>;
     /** Annule la transaction (no-op si déjà terminée — idempotent). */
     rollback(): Promise<void>;
-    /** No-op : MongoDB ne gère pas les savepoints. */
+    /**
+     * Refusé : MongoDB n'a pas de savepoints.
+     *
+     * @throws SavepointNotSupportedError toujours.
+     */
     savepoint(_name: string): Promise<void>;
-    /** No-op : MongoDB ne gère pas les savepoints. */
+    /**
+     * Refusé : MongoDB n'a pas de savepoints.
+     *
+     * @throws SavepointNotSupportedError toujours.
+     */
     rollbackTo(_name: string): Promise<void>;
     /** Expose la `ClientSession` native (trappe bas niveau). */
     getNative<C = unknown>(): C;

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

@@ -0,0 +1,12 @@
+/**
+ * Compte rendu par une écriture MongoDB (`deletedCount`, `modifiedCount`), 0 s'il manque.
+ *
+ * Le pilote le type `number`, mais le recopie de la réponse du serveur
+ * (`res.n`) : une écriture NON acquittée (`w: 0`) n'en reçoit aucune, et le
+ * compte arrive `undefined`. Sans ce repli, un `gc()` rendrait `undefined` et
+ * un `> 0` conclurait « rien écrit » pour une raison qui n'est pas la bonne.
+ *
+ * @param count - le compte tel que le pilote le rend.
+ * @returns le compte, ou 0 quand le serveur n'en a rendu aucun.
+ */
+export declare function writeCount(count: number | undefined): number;