@nodefony/mongoose 10.0.0-beta.1 → 10.0.0-beta.2

package/README.md

@@ -55,18 +55,19 @@ durables sont portées, aucune ne retombe sur un autre backend. C'est la propri
 de choisir sa base — un backend durable est un chemin complet, ou il oblige à en rapatrier un
 second pour une seule brique.
 
-| Brique       | Ce qu'elle range                          | Comment l'activer                                           |
-| ------------ | ----------------------------------------- | ----------------------------------------------------------- |
-| Session      | sessions HTTP                             | `use("@nodefony/http", { session: { store: "mongoose" } })` |
-| Utilisateurs | l'annuaire                                | `NF_USER_STORE=mongoose`                                    |
-| Jetons       | rafraîchissement, clés d'API, révocations | `tokenStore: { store: "mongoose" }`                         |
-| Passkeys     | credentials WebAuthn                      | `passkeys: { store: "mongoose" }`                           |
-| TOTP         | secrets du second facteur                 | `totp: { store: "mongoose" }`                               |
-| Audit        | journal de sécurité append-only           | `audit: { store: "mongoose" }`                              |
-| Webhooks     | endpoints notifiés                        | `webhooks: { store: "mongoose" }`                           |
-| Idempotence  | dédoublonnage des mutations rejouées      | `NF_IDEMPOTENCY_STORE=mongoose`                             |
-
-Les quatre dernières colonnes de configuration vivent sous `use("@nodefony/security", …)`.
+| Brique       | Ce qu'elle range                          | Comment l'activer                                                    |
+| ------------ | ----------------------------------------- | -------------------------------------------------------------------- |
+| Session      | sessions HTTP                             | `use("@nodefony/http", { session: { store: "mongoose" } })`          |
+| Utilisateurs | l'annuaire                                | `provisionUsers` → `MongooseUserRepository.from(orm)`                |
+| Jetons       | rafraîchissement, clés d'API, révocations | `tokenStore: { store: "mongoose" }`                                  |
+| Passkeys     | credentials WebAuthn                      | `passkeys: { store: "mongoose" }`                                    |
+| TOTP         | secrets du second facteur                 | `totp: { store: "mongoose" }`                                        |
+| Audit        | journal de sécurité append-only           | `audit: { store: "mongoose" }`                                       |
+| Webhooks     | endpoints notifiés                        | `webhooks: { store: "mongoose" }`                                    |
+| Idempotence  | dédoublonnage des mutations rejouées      | `use("@nodefony/framework", { idempotency: { store: "mongoose" } })` |
+
+Les configurations des jetons, passkeys, TOTP, audit et webhooks vivent sous
+`use("@nodefony/security", …)`.
 **Rien d'autre à écrire** : charger le module suffit à rendre ces backends sélectionnables, et
 `store: "auto"` (le défaut) les choisit tout seul dès qu'une infra Mongo est déclarée
 (`NF_DATABASE_URL=mongodb://…`).

package/dist/_virtual/{_@oxc-project_runtime@0.151.0 → _@oxc-project_runtime@0.152.0}/helpers/esm/decorate.js

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorate.js
+//#region \0@oxc-project+runtime@0.152.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);

package/dist/_virtual/{_@oxc-project_runtime@0.151.0 → _@oxc-project_runtime@0.152.0}/helpers/esm/decorateMetadata.js

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorateMetadata.js
+//#region \0@oxc-project+runtime@0.152.0/helpers/esm/decorateMetadata.js
 function __decorateMetadata(k, v) {
 	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }

package/dist/index.js

@@ -19,8 +19,8 @@ import { MongooseAuditStore } from "./nodefony/src/MongooseAuditStore.js";
 import { MongooseTotpSecretStore } from "./nodefony/src/MongooseTotpSecretStore.js";
 import { MongooseIdempotencyStore } from "./nodefony/src/MongooseIdempotencyStore.js";
 import { FRAMEWORK_CONNECTOR, registerMongooseFrameworkStores } from "./nodefony/registerStores.js";
-import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/decorateMetadata.js";
-import __decorate from "./_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/decorate.js";
+import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateMetadata.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorate.js";
 import sessionEntity_default, { SESSION_CONNECTOR, sessionSchema as schema } from "./nodefony/entity/sessionEntity.js";
 import SessionStorage from "./nodefony/src/SessionStorage.js";
 import { MongooseUserRepository } from "./nodefony/src/MongooseUserRepository.js";

package/dist/nodefony/config/config.js

@@ -46,7 +46,7 @@ const connectorSchema = z.strictObject({
 const mongooseConfigSchema = z.strictObject({
 	debug: z.boolean().default(false).describe("Active la trace Mongoose des requêtes (`mongoose.set('debug')`). Défaut false. Mettre true en dev pour voir chaque opération. Surchargé par l'env `NF_MONGODB_DEBUG` (1/true). Reco prod : false."),
 	connectors: z.record(z.string(), connectorSchema).default(() => ({ nodefony: connectorSchema.parse({}) })).describe("Connexions indexées par nom (= clé dans le `ormRegistry`). Défaut : un connecteur `nodefony` sur `localhost:27017/nodefony`. Le nom `nodefony` (≠ `default` de Drizzle) évite toute collision d'entité dans le `entityRegistry` (process-wide) si les deux ORM cohabitent."),
-	frameworkEntities: z.boolean().default(true).describe("Déclare le schéma framework sur le connecteur `nodefony` (tokens, webauthn, webhooks — modèles compilés au connect) et rend les stores correspondants sélectionnables par nom (`mongoose`). Couverture partielle assumée : PAS d'audit ni d'idempotence mongoose. `false` = module data-only.")
+	frameworkEntities: z.boolean().default(true).describe("Déclare le schéma framework sur le connecteur `nodefony` (tokens, webauthn, totp, audit, webhooks, idempotence — modèles compilés au connect) et rend les stores correspondants sélectionnables par nom (`mongoose`). `false` = module data-only.")
 }).describe("Configuration de @nodefony/mongoose.");
 /**
 * Défauts du module, matérialisés depuis le schéma (source unique). Toujours

package/dist/nodefony/entity/sessionEntity.js

@@ -1,4 +1,4 @@
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/decorate.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorate.js";
 import { entity } from "@nodefony/orm-core";
 //#region nodefony/entity/sessionEntity.ts
 /** ORM cible du stockage de session (connecteur par défaut du module). */

package/dist/nodefony/src/MongooseTokenStore.js

@@ -1,5 +1,5 @@
-import { mongoOrder } from "./mongoOrder.js";
 import { TOKEN_ENTITY_NAMES } from "../entity/tokenEntity.js";
+import { mongoOrder } from "./mongoOrder.js";
 import { assertPageQuery } from "nodefony";
 import { paginate } from "@nodefony/orm-core";
 import { TOKEN_DEFAULT_ORDER, TOKEN_SORTABLE_FIELDS, tokenStatusCriteria } from "@nodefony/security";

package/dist/nodefony/src/MongooseUserRepository.js

@@ -1,5 +1,5 @@
-import { mongoOrder, toMongoSort } from "./mongoOrder.js";
 import { DOCUMENT_USER_COLUMNS } from "../entity/userEntity.js";
+import { mongoOrder, toMongoSort } from "./mongoOrder.js";
 import { assertPageQuery, escapeRegExp } from "nodefony";
 import { BaseUser, USER_DEFAULT_ORDER, USER_SORTABLE_FIELDS, assertUserContract, attachExtraColumns } from "@nodefony/user";
 //#region nodefony/src/MongooseUserRepository.ts

package/dist/nodefony/src/MongooseWebhookStore.js

@@ -1,5 +1,5 @@
-import { mongoOrder, toMongoSort } from "./mongoOrder.js";
 import { WEBHOOK_ENDPOINT_ENTITY } from "../entity/webhookEndpointEntity.js";
+import { mongoOrder, toMongoSort } from "./mongoOrder.js";
 import { assertPageQuery, escapeRegExp } from "nodefony";
 import { WEBHOOK_DEFAULT_ORDER, WEBHOOK_SORTABLE_FIELDS } from "@nodefony/security";
 //#region nodefony/src/MongooseWebhookStore.ts

package/dist/nodefony/src/orm-core/MongooseRepository.js

@@ -1,21 +1,8 @@
-import { MONGO_ORDER_ALIASES } from "../mongoOrder.js";
 import { writeCount } from "../writeCount.js";
 import { RequestContext, redactSecrets } from "nodefony";
 import { ReferencedEntityError, UnknownCriteriaField, assertOrderOption, isFieldOperators, isUpdateOperators, likePatternToRegExp, queryFlowMonitor } from "@nodefony/orm-core";
 //#region nodefony/src/orm-core/MongooseRepository.ts
 /**
-* Clé Mongo d'un champ de TRI — `id` public → `_id` au repos.
-*
-* Mongo ne se plaint pas d'un tri sur un champ absent : il rend les documents
-* dans un ordre arbitraire. `id` n'est qu'un virtuel de lecture ; sans cette
-* traduction, `order: [["id", "DESC"]]` — le départage du tri par défaut de
-* tout CRUD généré — serait silencieusement inerte ici et correct en SQL. Même
-* table que les stores Mongo ({@link MONGO_ORDER_ALIASES}).
-*/
-function sortKey(field) {
-	return MONGO_ORDER_ALIASES[field] ?? field;
-}
-/**
 * Repository portable (contrat {@link IRepository}) au-dessus d'un modèle Mongoose.
 *
 * Démontre la portabilité du contrat sur un **store documentaire hétérogène** :
@@ -145,14 +132,18 @@ var MongooseRepository = class MongooseRepository {
 	* donnait 0 résultat silencieux — et divergeait de Drizzle qui, lui, renvoyait
 	* tout). Échoue tôt et pareil sur les deux drivers.
 	*
-	* @param field - clé brute du critère.
+	* Sert AUSSI au tri : Mongo ne se plaint pas d'un `sort` sur un champ absent
+	* — il rend un ordre arbitraire, là où Drizzle refuse. `id` (virtuel de
+	* lecture) y devient `_id`, le départage du tri par défaut d'un CRUD généré.
+	*
+	* @param field - clé brute du critère ou du tri.
 	* @returns la clé Mongo résolue.
 	* @throws UnknownCriteriaField si le champ n'existe pas sur le schéma.
 	*/
 	#resolveField(field) {
 		const key = field === "id" ? "_id" : field;
 		const paths = this.#model.schema.paths;
-		if (key === "_id" || paths[key] !== void 0 || paths[key.split(".")[0] ?? key] !== void 0) return key;
+		if (key === "_id" || Object.hasOwn(paths, key) || Object.hasOwn(paths, key.split(".")[0] ?? key)) return key;
 		throw new UnknownCriteriaField(field, this.#model.modelName, Object.keys(paths));
 	}
 	/**
@@ -165,8 +156,13 @@ var MongooseRepository = class MongooseRepository {
 		for (const [field, value] of Object.entries(criteria)) {
 			if (field === "$or") {
 				if (!Array.isArray(value)) throw new TypeError(`MongooseRepository(${this.#model.modelName}): $or attend un tableau de critères.`);
-				const branches = value.map((branch) => this.#filter(branch)).filter((f) => Object.keys(f).length > 0);
-				if (branches.length > 0) out.$or = branches;
+				if (value.length === 0) {
+					out.$and = [{ _id: { $in: [] } }];
+					continue;
+				}
+				const branches = value.map((branch) => this.#filter(branch));
+				if (branches.some((f) => Object.keys(f).length === 0)) continue;
+				out.$or = branches;
 				continue;
 			}
 			const key = this.#resolveField(field);
@@ -187,7 +183,7 @@ var MongooseRepository = class MongooseRepository {
 			if (options?.relations?.length) query = query.populate(options.relations);
 			if (options?.offset !== void 0) query = query.skip(options.offset);
 			if (options?.limit !== void 0) query = query.limit(options.limit);
-			if (options?.order?.length) query = query.sort(Object.fromEntries(options.order.map(([field, dir]) => [sortKey(field), dir === "DESC" ? -1 : 1])));
+			if (options?.order?.length) query = query.sort(Object.fromEntries(options.order.map(([field, dir]) => [this.#resolveField(field), dir === "DESC" ? -1 : 1])));
 			return (await query.exec()).map((doc) => this.#plain(doc));
 		}, (docs) => docs.length);
 	}
@@ -198,7 +194,7 @@ var MongooseRepository = class MongooseRepository {
 			let query = this.#model.findOne(filter);
 			if (this.#session) query = query.session(this.#session);
 			if (options?.relations?.length) query = query.populate(options.relations);
-			if (options?.order?.length) query = query.sort(Object.fromEntries(options.order.map(([field, dir]) => [sortKey(field), dir === "DESC" ? -1 : 1])));
+			if (options?.order?.length) query = query.sort(Object.fromEntries(options.order.map(([field, dir]) => [this.#resolveField(field), dir === "DESC" ? -1 : 1])));
 			const doc = await query.exec();
 			return doc ? this.#plain(doc) : null;
 		}, (doc) => doc ? 1 : 0);

package/docs/configuration.md

@@ -334,10 +334,12 @@ C'est le champ le plus discret et le plus structurant (`frameworkEntities` (`con
 défaut `true`, le module fait deux choses de plus qu'ouvrir des connexions, dès son enregistrement et
 **avant** que la connexion ne s'ouvre (`Mongoose.onKernelRegister()` (`mongoose/index.ts:65`)) :
 
-1. il **déclare les entités du framework** sur le connecteur `nodefony` — jetons, passkeys, webhooks —
+1. il **déclare les entités du framework** sur le connecteur `nodefony` — jetons, passkeys, TOTP,
+   audit, webhooks, idempotence —
    pour que leurs modèles soient compilés au moment de la connexion ;
 2. il **enregistre les fabriques** correspondantes dans les registres de `@nodefony/security`, ce qui
-   rend le nom `"mongoose"` sélectionnable dans `tokenStore`, `passkeys`, `webhooks`
+   rend le nom `"mongoose"` sélectionnable dans `tokenStore`, `passkeys`, `totp`, `audit`, `webhooks`
+   et `idempotency`
    (`registerMongooseFrameworkStores()` (`registerStores.ts:126`)).
 
 Le passer à `false` transforme le module en **pur driver de données** : tes entités à toi, rien
@@ -667,22 +669,19 @@ Le cas courant : la config est parfaite, mais Mongo n'est pas joignable — cont
 réseau coupé, identifiants périmés. Le comportement **dépend de l'environnement**, arbitré par la
 politique de boot du cœur (`Kernel.isBootErrorFatal()` (`Kernel.ts:3221`)) :
 
-| Environnement       | Ce qui se passe                                                                        |
-| ------------------- | -------------------------------------------------------------------------------------- |
-| Développement, test | `WARNING`, l'échec est agrégé au bilan de démarrage, **le serveur démarre quand même** |
-| Production          | L'échec **interrompt le démarrage** : le processus sort en erreur                      |
+| Environnement                         | Ce qui se passe                                                                                                    |
+| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| Développement, test **et production** | `WARNING`, l'échec est agrégé au bilan de démarrage, **le serveur démarre quand même** (module `critical = false`) |
+| Toute configuration invalide          | Fatale partout : une `BootConfigurationError` ne se répare pas en attendant                                        |
 
-Ce n'est pas une inconséquence : en développement, tu veux ton serveur debout pour travailler sur le
-reste ; en production, un pod qui répond sans sa base est un piège — l'orchestrateur doit le voir
-tomber pour le relancer, et c'est le modèle cloud-native que le framework applique partout.
+Un pod qui démarre sans sa base n'est pas pour autant mis en service à l'aveugle : c'est la sonde de
+disponibilité (`/readyz`) qui dit à l'orchestrateur de ne pas lui envoyer de trafic.
 
 > [!IMPORTANT]
-> **Le module est déclaré non critique** (`Mongoose.critical` (`mongoose/index.ts:48`)), et cette
-> déclaration protège bien ses **hooks de module** — mais l'ouverture de la connexion, elle, est faite
-> par un écouteur `onBoot` posé par le service, qui ne porte pas cette étiquette
-> (`MongooseService.ts:41`). En production, une base injoignable interrompt donc
-> le démarrage. Si tu attends l'inverse — un serveur qui démarre sans sa base et se rattrape plus
-> tard — ne compte pas dessus : prévois une sonde de disponibilité côté orchestrateur.
+> **Le module est déclaré non critique** (`Mongoose.critical` (`mongoose/index.ts:48`)), et l'ouverture
+> de la connexion est posée par `module.hookKernel("onBoot", …)` (`MongooseService.ts:59`), donc
+> couverte par cette étiquette : même en production, une base injoignable n'interrompt pas le
+> démarrage. Prévois une sonde de disponibilité côté orchestrateur.
 
 ### Pendant l'arrêt du serveur
 
@@ -739,9 +738,8 @@ jamais figés ici.
   bancs) : l'assemblage d'URI, l'ouverture et la fermeture des connexions, puis tout le reste du
   module — contrat ORM, session, jetons, passkeys, webhooks, utilisateurs.
 
-Ce qui **n'est pas** couvert, dit franchement : la surcharge par l'infra déclarée
-(`NF_DATABASE_URL`/`DATABASE_URL`) n'a pas de test unitaire propre à ce module — seule la variable
-dédiée `MONGODB_URI` en a un. Il n'y a pas non plus de test de charge ni de mesure mémoire dédiés au
+La branche infra (`NF_DATABASE_URL` de famille mongo) et `MONGODB_URI` ont chacune un test unitaire
+(`tests/unit/config.test.ts`). Ce qui **n'est pas** couvert, dit franchement : il n'y a pas de test de charge ni de mesure mémoire dédiés au
 driver.
 
 > [!WARNING]
@@ -753,9 +751,9 @@ driver.
 > que la base était là : soit `NF_MONGO_TEST_URI` pointe un conteneur
 > (`docker run -p 27017:27017 mongo:7`), soit le serveur en mémoire a démarré.
 >
-> Le catalogue des variables d'infrastructure du dépôt est `vitest.gates.ts`, à la racine. Ce module
-> **n'y déclare pas de porte** : ses sauts sont donc silencieux, là où les suites SQL et Redis
-> annoncent en fin de course ce qu'elles n'ont pas joué.
+> Le catalogue des variables d'infrastructure du dépôt est `vitest.gates.ts`, à la racine. Ce module y
+> déclare sa porte `MONGO_GATE` : le rapporteur de fin de course nomme la cible Mongo non exercée, avec
+> la commande exacte pour la monter.
 
 Couverture : `npm run coverage` dans `@nodefony/mongoose`.
 

package/docs/index.md

@@ -30,8 +30,8 @@ coverageFiles: MongooseOrm.ts,MongooseRepository.ts,SessionStorage.ts,MongooseTo
 
 > Le module qui fait parler ton application à **MongoDB**. Il ouvre les connexions au démarrage,
 > compile tes schémas en modèles, et te rend des **repositories portables** : le même code métier
-> tourne sur Mongo ou sur SQL. Il fournit aussi cinq **briques du framework** prêtes à l'emploi sur
-> Mongo — sessions, utilisateurs, jetons, passkeys, webhooks. Ce qu'il ne porte pas, il le dit :
+> tourne sur Mongo ou sur SQL. Il fournit aussi huit **briques du framework** prêtes à l'emploi sur
+> Mongo — sessions, utilisateurs, jetons, passkeys, TOTP, audit, webhooks, idempotence. Ce qu'il ne porte pas, il le dit :
 > la couverture est **adaptée à la vocation de MongoDB**, jamais une course à la parité avec SQL.
 
 📍 [Documentation](../../../../../docs/index.md) › **MongoDB (Mongoose)**
@@ -139,7 +139,7 @@ flowchart TD
   ENT["Tes entités<br/>defineEntity + @entities"] --> MODEL
 
   SESS["session"] -.->|store: mongoose| MR
-  TOK["tokens · passkeys · webhooks"] -.->|store: mongoose| MR
+  TOK["tokens · passkeys · totp · audit · webhooks · idempotence"] -.->|store: mongoose| MR
   USR["users"] -.->|provisionUsers| MR
 ```
 
@@ -231,12 +231,12 @@ réellement chargés :
 | Ta situation                                            | Ce que `auto` choisit                                    |
 | ------------------------------------------------------- | -------------------------------------------------------- |
 | `NF_DATABASE_URL=mongodb://…` + module mongoose chargé  | `mongoose` — « infra database (mongodb) »                |
-| Idem, mais pour une brique que mongoose ne porte pas    | repli annoncé (`memory`), avec la **raison** dans le log |
+| Une brique que le backend d'infra ne porte pas          | repli annoncé (`memory`), avec la **raison** dans le log |
 | Aucune infra déclarée, mongoose chargé (et pas drizzle) | `mongoose` — backend local persistant                    |
 | `NF_REDIS_URL` déclaré, brique non durable (session…)   | `redis` d'abord (le cache passe avant la base)           |
 
 Rien n'est jamais dégradé en silence : la raison du choix est journalisée. Et si tu nommes
-**explicitement** un store qui n'existe pas (`audit: { store: "mongoose" }`), l'échec est franc —
+**explicitement** un store qui n'existe pas (`audit: { store: "mongo" }`), l'échec est franc —
 boot avorté en production, brique désactivée avec un log `CRITIC` en développement. Un store durable
 ne retombe **jamais** en mémoire sans le dire.
 
@@ -469,7 +469,7 @@ sequenceDiagram
 
   K->>M: onKernelRegister
   M->>M: valider la config (Zod) + geler
-  M->>M: déclarer les entités framework<br/>(tokens · passkeys · webhooks)
+  M->>M: déclarer les entités framework<br/>(tokens · passkeys · totp · audit · webhooks · idempotence)
   M->>M: déclarer "mongoose" comme backend utilisateur
   K->>M: onKernelBoot
   M->>M: monter le data plane ORM + l'adapter d'erreurs
@@ -570,8 +570,8 @@ await articles.find({ publishedAt: { $null: true } }); // jamais publié
 ```
 
 > [!WARNING]
-> Un critère ne combine **qu'une condition par champ** (c'est un ET de champs). Pour un `$or`, une
-> agrégation, une recherche plein texte ou un index composé : passe par
+> Un critère ne combine **qu'une condition par champ** (c'est un ET de champs ; la disjonction se
+> dit `$or: [...]`). Pour une agrégation, une recherche plein texte ou un index composé : passe par
 > [la trappe native](#la-trappe-native--quand-le-contrat-ne-suffit-plus). C'est prévu, pas subi.
 
 ### Relations — sans clé étrangère
@@ -874,10 +874,10 @@ Le module suit la règle de fond du framework : **ce qui n'est pas observé ne c
 | `ORM "nodefony" introuvable` au montage d'un store           | `@nodefony/security` chargé **avant** `@nodefony/mongoose`                    | Mettre le driver **avant** dans `modules` (`registerStores.ts:64`)                |
 | `no entity model registered under "X"`                       | Entité déclarée après la connexion (les modèles sont compilés au `connect`)   | Déclarer via `@entities` (phase `onRegister`), jamais à `onBoot`                  |
 | `UnknownCriteriaField` sur un champ pourtant présent en base | Le champ n'est pas dans le **schéma** déclaré                                 | L'ajouter au schéma, ou passer par la connexion native                            |
-| Un critère renvoie tout au lieu de filtrer                   | Deux conditions posées sur le **même champ** (le critère est un ET de champs) | Passer par une requête native (`$or`, agrégation)                                 |
+| Un critère renvoie tout au lieu de filtrer                   | Deux conditions posées sur le **même champ** (le critère est un ET de champs) | `$or: [...]`, ou une requête native (agrégation)                                  |
 | `many-to-many non portable`                                  | Refus explicite : pas de traduction unique en Mongo                           | Déclarer la relation via la connexion native                                      |
 | Les sessions disparaissent au redémarrage                    | `session.store` resté sur `memory`                                            | `session: { store: "mongoose" }`, ou déclarer `NF_DATABASE_URL` et laisser `auto` |
-| `audit store "mongoose" inconnu` — boot avorté en production | Brique **non portée** par Mongo, sélectionnée explicitement                   | Laisser `auto` (repli annoncé) ou choisir un backend qui la porte                 |
+| `audit store "xxx" inconnu` — boot avorté en production      | Nom de store inexistant, ou `frameworkEntities: false`                        | Corriger le nom, ou laisser `auto`                                                |
 | Les comptes ne survivent pas au redémarrage                  | `provisionUsers` toujours branché sur l'annuaire mémoire                      | Câbler `MongooseUserRepository.from(orm)` (`MongooseUserRepository.ts:89`)        |
 | Un champ écrit se relit `undefined`, sans aucune erreur      | Il n'est pas dans le **schéma** : Mongoose est strict et l'écarte en silence  | L'ajouter au schéma de l'entité — le type TypeScript seul ne suffit pas           |
 | Le premier `npm test` du module met une éternité             | Le serveur Mongo de test télécharge son binaire (une seule fois)              | Définir `NF_MONGO_TEST_URI` sur un conteneur Mongo                                |
@@ -908,9 +908,8 @@ couverts en amont, dans les modules qui possèdent les contrats.
 > bien là : soit `NF_MONGO_TEST_URI` pointe sur un conteneur (`docker run -p 27017:27017 mongo:7`), soit
 > le serveur en mémoire a démarré. Les bancs de transaction exigent en plus un **replica set**.
 >
-> Le catalogue des variables d'infrastructure du dépôt est `vitest.gates.ts`, à la racine. Ce module
-> n'y déclare pas encore sa porte : ses sauts sont donc **silencieux**, alors que les suites SQL et
-> Redis affichent en fin de course ce qu'elles n'ont pas joué.
+> Le catalogue des variables d'infrastructure du dépôt est `vitest.gates.ts`, à la racine. Ce module y
+> déclare sa porte `MONGO_GATE` : le rapporteur de fin de course nomme la cible Mongo non exercée.
 
 Couverture : `npm run coverage` dans `@nodefony/mongoose` (rapport lisible aussi dans Studio).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodefony/mongoose",
-  "version": "10.0.0-beta.1",
+  "version": "10.0.0-beta.2",
   "description": "Moteur MongoDB de Nodefony sur Mongoose : dépôts typés conformes au contrat orm-core",
   "nodefony": {
     "storeKind": "durable",
@@ -49,29 +49,29 @@
     "esm"
   ],
   "dependencies": {
-    "mongodb": "7.6.0",
-    "mongoose": "9.10.2",
+    "mongodb": "7.7.0",
+    "mongoose": "9.10.3",
     "tslib": "2.8.1",
     "zod": "^4.6.5"
   },
   "devDependencies": {
-    "@nodefony/framework": "^10.0.0-beta.1",
-    "@nodefony/http": "^10.0.0-beta.1",
-    "@nodefony/orm-core": "^10.0.0-beta.1",
-    "@nodefony/security": "^10.0.0-beta.1",
-    "@nodefony/user": "^10.0.0-beta.1",
+    "@nodefony/framework": "^10.0.0-beta.2",
+    "@nodefony/http": "^10.0.0-beta.2",
+    "@nodefony/orm-core": "^10.0.0-beta.2",
+    "@nodefony/security": "^10.0.0-beta.2",
+    "@nodefony/user": "^10.0.0-beta.2",
     "@types/node": "26.6.3",
     "mongodb-memory-server": "11.3.0",
-    "nodefony": "^10.0.0-beta.1",
-    "vitest": "5.0.2"
+    "nodefony": "^10.0.0-beta.2",
+    "vitest": "5.0.3"
   },
   "peerDependencies": {
-    "@nodefony/framework": "^10.0.0-beta.1",
-    "@nodefony/http": "^10.0.0-beta.1",
-    "@nodefony/orm-core": "^10.0.0-beta.1",
-    "@nodefony/security": "^10.0.0-beta.1",
-    "@nodefony/user": "^10.0.0-beta.1",
-    "nodefony": "^10.0.0-beta.1"
+    "@nodefony/framework": "^10.0.0-beta.2",
+    "@nodefony/http": "^10.0.0-beta.2",
+    "@nodefony/orm-core": "^10.0.0-beta.2",
+    "@nodefony/security": "^10.0.0-beta.2",
+    "@nodefony/user": "^10.0.0-beta.2",
+    "nodefony": "^10.0.0-beta.2"
   },
   "repository": {
     "type": "git",