@nodefony/mongoose 10.0.0-alpha.9 → 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";
@@ -63,10 +63,10 @@ let Mongoose = class Mongoose extends Module {
 	* propre avec messages clairs si la config est invalide (convention Zod).
 	*/
 	async onKernelRegister() {
-		const validated = defineMongooseConfig(this.options ?? {});
+		const validated = defineMongooseConfig(this.options);
 		this.options = validated;
 		registerUserStore("mongoose");
-		if (validated.frameworkEntities !== false) {
+		if (validated.frameworkEntities) {
 			const report = registerMongooseFrameworkStores();
 			if (report.appOwned.length) this.log(`schéma framework : entités déjà enregistrées par l'app [${report.appOwned.join(", ")}] — auto-register respecte l'app`, "DEBUG");
 			if (report.registered.length) this.log(`schéma framework déclaré sur "${FRAMEWORK_CONNECTOR}" : [${report.registered.join(", ")}]`, "DEBUG");
@@ -85,7 +85,7 @@ let Mongoose = class Mongoose extends Module {
 		wireOrmAdminPlane(this.kernel);
 		registerErrorAdapter("mongoose", {
 			isError: (e) => e instanceof mongoose.Error,
-			errorToString: (e) => String(e?.message ?? e)
+			errorToString: (e) => e instanceof Error ? e.message : String(e)
 		});
 		return this;
 	}

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/config/defineModuleConfig.js

@@ -18,10 +18,11 @@ import { z } from "zod";
 function applyEnvOverrides(config) {
 	const env = process.env;
 	const database = resolveInfra(env).database;
-	const uri = env.MONGODB_URI ?? (database && database.family === "mongo" ? database.url : void 0);
+	const uri = env.MONGODB_URI ?? (database?.family === "mongo" ? database.url : void 0);
 	if (uri) {
-		const target = config.connectors.nodefony ? "nodefony" : Object.keys(config.connectors)[0];
-		if (target && config.connectors[target]) config.connectors[target].uri = uri;
+		const target = Object.hasOwn(config.connectors, "nodefony") ? "nodefony" : Object.keys(config.connectors).at(0);
+		const connector = target === void 0 ? void 0 : config.connectors[target];
+		if (connector !== void 0) connector.uri = uri;
 	}
 	if (env.NF_MONGODB_DEBUG === "1" || env.NF_MONGODB_DEBUG === "true") config.debug = true;
 	return config;

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/registerStores.js

@@ -83,7 +83,7 @@ function registerMongooseFrameworkStores() {
 		if (getTokenStoreFactory("mongoose")) return;
 		registerTokenStore("mongoose", (ctx) => {
 			const orm = resolveConnectedOrm(`tokenStore "mongoose"`);
-			const days = ctx?.config?.tokenStore?.retentionRevokedDays;
+			const days = ctx.config.tokenStore.retentionRevokedDays;
 			return MongooseTokenStore.from(orm, void 0, typeof days === "number" ? days * 864e5 : void 0);
 		});
 	});
@@ -99,7 +99,7 @@ function registerMongooseFrameworkStores() {
 		if (getAuditStoreFactory("mongoose")) return;
 		registerAuditStore("mongoose", (ctx) => {
 			const orm = resolveConnectedOrm(`audit.store "mongoose"`);
-			const days = ctx?.config?.audit?.retentionDays;
+			const days = ctx.config.audit.retentionDays;
 			return MongooseAuditStore.from(orm, void 0, typeof days === "number" ? days * 864e5 : void 0);
 		});
 	});

package/dist/nodefony/service/MongooseService.js

@@ -21,7 +21,7 @@ var MongooseService = class MongooseService extends Service {
 	/** ORM connectés, indexés par nom de connecteur. */
 	#orms = /* @__PURE__ */ new Map();
 	constructor(module) {
-		super(serviceName, module.container, module.notificationsCenter, module.options ?? {});
+		super(serviceName, module.container, module.notificationsCenter, module.options);
 		this.module = module;
 		this.module.hookKernel("onBoot", async () => {
 			queryFlowMonitor.setEnabled(resolveOrmFlowEnabled(this.kernel));
@@ -34,7 +34,14 @@ var MongooseService = class MongooseService extends Service {
 			await this.disconnectAll().catch(() => {});
 		});
 	}
-	/** Config validée (Zod) exposée par le Module (`this.module.config`). */
+	/**
+	* Config du module telle que le service la TROUVE.
+	*
+	* Validée par Zod au boot du kernel ; mais le service se construit aussi hors
+	* kernel (bancs, usage direct) avec une config partielle, voire absente — et
+	* « config absente → rien à connecter » est un contrat couvert par
+	* `MongooseService.test.ts`. Le type le dit, donc chaque lecture garde.
+	*/
 	#config() {
 		return this.module.config;
 	}

package/dist/nodefony/src/MongooseAuditStore.js

@@ -1,3 +1,4 @@
+import { writeCount } from "./writeCount.js";
 import { AUDIT_ENTITY_NAMES } from "../entity/auditEventEntity.js";
 import { assertPageQuery } from "nodefony";
 //#region nodefony/src/MongooseAuditStore.ts
@@ -133,7 +134,7 @@ var MongooseAuditStore = class MongooseAuditStore {
 		const hasNext = docs.length > limit;
 		const rows = (hasNext ? docs.slice(0, limit) : docs).map((doc) => doc.toObject({ virtuals: true }));
 		const items = rows.map((row) => this.#toEvent(row));
-		const last = rows[rows.length - 1];
+		const last = rows.at(-1);
 		return {
 			items,
 			limit,
@@ -161,7 +162,8 @@ var MongooseAuditStore = class MongooseAuditStore {
 		const model = this.#resolveModel();
 		if (!model) return 0;
 		const threshold = now - this.#retentionMs;
-		return (await model.deleteMany({ ts: { $lt: threshold } }).exec()).deletedCount ?? 0;
+		const result = await model.deleteMany({ ts: { $lt: threshold } }).exec();
+		return writeCount(result.deletedCount);
 	}
 	/** Compose le filtre Mongo des critères AND ; `{}` si aucun (= tout). */
 	#buildFilter(filter) {

package/dist/nodefony/src/MongooseIdempotencyStore.js

@@ -1,3 +1,4 @@
+import { writeCount } from "./writeCount.js";
 import { IDEMPOTENCY_ENTITY_NAME } from "../entity/idempotencyEntity.js";
 import { assertPageQuery, escapeRegExp } from "nodefony";
 //#region nodefony/src/MongooseIdempotencyStore.ts
@@ -164,22 +165,24 @@ var MongooseIdempotencyStore = class MongooseIdempotencyStore {
 	async complete(key, response) {
 		const model = this.#resolveModel();
 		if (!model) return;
-		if (((await model.updateOne({
+		const result = await model.updateOne({
 			_id: key,
 			state: "if"
 		}, { $set: {
 			state: "done",
 			response,
 			expiresAt: this.#now() + this.#ttlMs
-		} }).exec()).modifiedCount ?? 0) > 0) this.#dec();
+		} }).exec();
+		if (writeCount(result.modifiedCount) > 0) this.#dec();
 	}
 	async abort(key) {
 		const model = this.#resolveModel();
 		if (!model) return;
-		if (((await model.deleteOne({
+		const result = await model.deleteOne({
 			_id: key,
 			state: "if"
-		}).exec()).deletedCount ?? 0) > 0) this.#dec();
+		}).exec();
+		if (writeCount(result.deletedCount) > 0) this.#dec();
 	}
 	/**
 	* Purge les entrées mortes (`expiresAt <= now`) — supplée l'absence de TTL
@@ -193,7 +196,8 @@ var MongooseIdempotencyStore = class MongooseIdempotencyStore {
 	async gc(now = this.#now()) {
 		const model = this.#resolveModel();
 		if (!model) return 0;
-		return (await model.deleteMany({ expiresAt: { $lte: now } }).exec()).deletedCount ?? 0;
+		const result = await model.deleteMany({ expiresAt: { $lte: now } }).exec();
+		return writeCount(result.deletedCount);
 	}
 	/**
 	* {@inheritDoc IIdempotencyStore.listPage}
@@ -242,7 +246,7 @@ var MongooseIdempotencyStore = class MongooseIdempotencyStore {
 			items: page.map((doc) => ({
 				key: doc._id,
 				state: doc.state === "if" ? "in-flight" : "done",
-				expiresAtMs: Number(doc.expiresAt),
+				expiresAtMs: doc.expiresAt,
 				hasResponse: doc.state !== "if"
 			})),
 			total,

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
@@ -167,7 +167,7 @@ var MongooseUserRepository = class MongooseUserRepository {
 		const offset = Math.max(0, Math.floor(query.offset ?? 0));
 		const filter = this.#listFilter(query);
 		const sort = toMongoSort(mongoOrder(query.order, this.sortableFields, USER_DEFAULT_ORDER));
-		if (sort._id === void 0) sort._id = 1;
+		if (!Object.hasOwn(sort, "_id")) sort._id = 1;
 		let cursor = this.#model.find(filter).sort(sort).skip(offset).limit(limit + 1);
 		if (this.#session) cursor = cursor.session(this.#session);
 		const docs = await cursor.exec();

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/MongooseOrm.js

@@ -107,7 +107,7 @@ var MongooseOrm = class MongooseOrm extends Orm {
 				switch (relation.type) {
 					case "one-to-many": {
 						const fk = relation.foreignKey ?? this.#foreignKey(entity.name);
-						if (!targetSchema.path(fk)) targetSchema.add({ [fk]: {
+						if (targetSchema.path(fk) === void 0) targetSchema.add({ [fk]: {
 							type: mongoose.Schema.Types.ObjectId,
 							ref: entity.name
 						} });
@@ -121,7 +121,7 @@ var MongooseOrm = class MongooseOrm extends Orm {
 					case "many-to-one":
 					case "one-to-one": {
 						const fk = relation.foreignKey ?? relation.field;
-						if (!sourceSchema.path(fk)) sourceSchema.add({ [fk]: {
+						if (sourceSchema.path(fk) === void 0) sourceSchema.add({ [fk]: {
 							type: mongoose.Schema.Types.ObjectId,
 							ref: relation.target
 						} });
@@ -191,7 +191,7 @@ var MongooseOrm = class MongooseOrm extends Orm {
 		for (const [name, model] of Object.entries(models)) {
 			const audit = {
 				entity: name,
-				collection: model.collection?.name ?? name,
+				collection: model.collection.name,
 				missing: [],
 				extra: []
 			};
@@ -279,7 +279,7 @@ var MongooseOrm = class MongooseOrm extends Orm {
 		const listeners = [
 			["disconnected", lost("mongoose: disconnected")],
 			["close", lost("mongoose: close")],
-			["error", ((e) => this.connectionLost(`mongoose: ${e?.message ?? String(e)}`))],
+			["error", (e) => this.connectionLost(`mongoose: ${e instanceof Error ? e.message : String(e)}`)],
 			["reconnected", () => this.connectionRestored()],
 			["connected", () => this.connectionRestored()]
 		];
@@ -332,7 +332,7 @@ var MongooseOrm = class MongooseOrm extends Orm {
 			model.schema.eachPath((fieldPath, type) => {
 				const ref = type.options?.ref;
 				if (fieldPath === "_id" || type.instance !== "ObjectId" || typeof ref !== "string" || models[ref] === void 0) return;
-				if (index === null) index = Object.create(null);
+				index ??= Object.create(null);
 				(index[ref] ??= []).push({
 					model,
 					path: fieldPath,
@@ -346,7 +346,7 @@ var MongooseOrm = class MongooseOrm extends Orm {
 	getRepository(name) {
 		const model = this.#models?.[name];
 		if (!model) throw new Error(`MongooseOrm "${this.name}": no entity model registered under "${name}".`);
-		if (this.#repositories === null) this.#repositories = Object.create(null);
+		this.#repositories ??= Object.create(null);
 		let repository = this.#repositories[name];
 		if (repository === void 0) {
 			repository = new MongooseRepository(model, this.name, null, this.#referrers?.[name] ?? null);
@@ -358,15 +358,11 @@ var MongooseOrm = class MongooseOrm extends Orm {
 		const connection = this.#connection;
 		if (!connection) throw new Error(`MongooseOrm "${this.name}": not connected.`);
 		const session = await connection.startSession();
-		let result;
 		try {
-			await session.withTransaction(async () => {
-				result = await work(new MongooseTransaction(session));
-			});
+			return await session.withTransaction(() => work(new MongooseTransaction(session)));
 		} finally {
 			await session.endSession();
 		}
-		return result;
 	}
 	getNativeConnection() {
 		if (!this.#connection) throw new Error(`MongooseOrm "${this.name}": not connected.`);

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

@@ -1,20 +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** :
@@ -48,6 +36,15 @@ var MongooseRepository = class MongooseRepository {
 		this.#referrers = referrers;
 	}
 	/**
+	* Options de session pour les méthodes dont le type refuse `session: null`
+	* (`updateMany`, `deleteMany`, `countDocuments`…) : la clé est ABSENTE hors
+	* transaction. Un objet neuf par appel, comme le littéral qu'il remplace —
+	* Mongoose peut enrichir l'objet d'options qu'il reçoit.
+	*/
+	#sessionOptions() {
+		return this.#session === null ? {} : { session: this.#session };
+	}
+	/**
 	* Tap dev-only : mesure la durée d'une opération et alimente **deux** sondes
 	* complémentaires (sans surcoût quand les deux sont inactives — flags lus avant
 	* toute allocation, prod = coût nul) :
@@ -135,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]] !== 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));
 	}
 	/**
@@ -155,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);
@@ -177,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);
 	}
@@ -188,21 +194,22 @@ 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);
 	}
 	async create(data) {
 		return this.#prof(() => this.#descr("create"), async () => {
-			const [doc] = await this.#model.create([data], { session: this.#session ?? void 0 });
+			const [doc] = await this.#model.create([data], { session: this.#session });
+			if (doc === void 0) throw new Error(`create: le pilote n'a rendu aucun document (${this.#model.modelName})`);
 			return this.#plain(doc);
 		}, () => 1);
 	}
 	async createMany(data) {
 		if (data.length === 0) return [];
 		return this.#prof(() => this.#descr("insertMany"), async () => {
-			return (await this.#model.insertMany(data, { session: this.#session ?? void 0 })).map((doc) => this.#plain(doc));
+			return (await this.#model.insertMany(data, { session: this.#session })).map((doc) => this.#plain(doc));
 		}, (rows) => rows.length);
 	}
 	async updateOne(criteria, data) {
@@ -210,7 +217,7 @@ var MongooseRepository = class MongooseRepository {
 		return this.#prof(() => this.#descr("findOneAndUpdate", filter), async () => {
 			const doc = await this.#model.findOneAndUpdate(filter, data, {
 				returnDocument: "after",
-				session: this.#session ?? void 0
+				session: this.#session
 			}).exec();
 			return doc ? this.#plain(doc) : null;
 		}, (doc) => doc ? 1 : 0);
@@ -224,9 +231,8 @@ var MongooseRepository = class MongooseRepository {
 			}, {
 				upsert: true,
 				returnDocument: "after",
-				session: this.#session ?? void 0
+				session: this.#session
 			}).exec();
-			if (!doc) throw new Error("MongooseRepository.upsert: aucun document retourné");
 			return this.#plain(doc);
 		}, () => 1);
 	}
@@ -260,7 +266,8 @@ var MongooseRepository = class MongooseRepository {
 	async updateMany(criteria, data) {
 		const filter = this.#filter(criteria);
 		return this.#prof(() => this.#descr("updateMany", filter), async () => {
-			return (await this.#model.updateMany(filter, data, { session: this.#session ?? void 0 })).modifiedCount ?? 0;
+			const res = await this.#model.updateMany(filter, data, this.#sessionOptions());
+			return writeCount(res.modifiedCount);
 		}, (n) => n);
 	}
 	async increment(criteria, changes) {
@@ -268,7 +275,7 @@ var MongooseRepository = class MongooseRepository {
 		return this.#prof(() => this.#descr("findOneAndUpdate", filter), async () => {
 			const doc = await this.#model.findOneAndUpdate(filter, { $inc: changes }, {
 				returnDocument: "after",
-				session: this.#session ?? void 0
+				session: this.#session
 			}).exec();
 			return doc ? this.#plain(doc) : null;
 		}, (doc) => doc ? 1 : 0);
@@ -281,7 +288,8 @@ var MongooseRepository = class MongooseRepository {
 			filter = { _id: { $in: ids } };
 		}
 		const removed = await this.#prof(() => this.#descr("deleteMany", filter), async () => {
-			return (await this.#model.deleteMany(filter, { session: this.#session ?? void 0 })).deletedCount ?? 0;
+			const res = await this.#model.deleteMany(filter, this.#sessionOptions());
+			return writeCount(res.deletedCount);
 		}, (n) => n);
 		if (ids !== null && removed > 0) await this.#releaseOptional(ids);
 		return removed;
@@ -294,7 +302,8 @@ var MongooseRepository = class MongooseRepository {
 			filter = { _id: ids[0] };
 		}
 		const removed = await this.#prof(() => this.#descr("deleteOne", filter), async () => {
-			return ((await this.#model.deleteOne(filter, { session: this.#session ?? void 0 })).deletedCount ?? 0) > 0;
+			const res = await this.#model.deleteOne(filter, this.#sessionOptions());
+			return writeCount(res.deletedCount) > 0;
 		}, (ok) => ok ? 1 : 0);
 		if (ids !== null && removed) await this.#releaseOptional(ids);
 		return removed;
@@ -307,7 +316,7 @@ var MongooseRepository = class MongooseRepository {
 			filter = { _id: ids[0] };
 		}
 		const doc = await this.#prof(() => this.#descr("findOneAndDelete", filter), async () => {
-			const found = await this.#model.findOneAndDelete(filter, { session: this.#session ?? void 0 }).exec();
+			const found = await this.#model.findOneAndDelete(filter, { session: this.#session }).exec();
 			return found ? this.#plain(found) : null;
 		}, (d) => d ? 1 : 0);
 		if (ids !== null && doc !== null) await this.#releaseOptional(ids);
@@ -337,7 +346,7 @@ var MongooseRepository = class MongooseRepository {
 	async #referencedTargets(filter, single) {
 		const referrers = this.#referrers;
 		if (referrers === null) return null;
-		const session = this.#session ?? void 0;
+		const session = this.#session;
 		const query = this.#model.find(filter, { _id: 1 }, { session }).lean();
 		if (single) query.limit(1);
 		const docs = await query.exec();
@@ -360,15 +369,14 @@ var MongooseRepository = class MongooseRepository {
 	* @param ids - `_id` des documents supprimés.
 	*/
 	async #releaseOptional(ids) {
-		const session = this.#session ?? void 0;
 		for (const referrer of this.#referrers ?? []) {
 			if (referrer.required) continue;
-			await referrer.model.updateMany({ [referrer.path]: { $in: ids } }, { $set: { [referrer.path]: null } }, { session });
+			await referrer.model.updateMany({ [referrer.path]: { $in: ids } }, { $set: { [referrer.path]: null } }, this.#sessionOptions());
 		}
 	}
 	async count(criteria) {
 		const filter = this.#filter(criteria);
-		return this.#prof(() => this.#descr("countDocuments", filter), () => this.#model.countDocuments(filter, { session: this.#session ?? void 0 }));
+		return this.#prof(() => this.#descr("countDocuments", filter), () => this.#model.countDocuments(filter, this.#sessionOptions()));
 	}
 	/**
 	* `COUNT(DISTINCT …)` en agrégation — `$group` puis `$count`, donc la

package/dist/nodefony/src/writeCount.js

@@ -0,0 +1,17 @@
+//#region nodefony/src/writeCount.ts
+/**
+* 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.
+*/
+function writeCount(count) {
+	return count ?? 0;
+}
+//#endregion
+export { writeCount };

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

@@ -28,7 +28,7 @@ declare class MongooseService extends Service {
      */
     connectAll(connect?: boolean): Promise<void>;
     /** Assemble l'URI de connexion à partir de la config (`uri` ou composants). */
-    static buildUri(cfg: IMongooseConnectorConfig): string;
+    static buildUri(cfg: Partial<IMongooseConnectorConfig>): string;
     /**
      * Options de connexion Mongoose d'un connecteur.
      *
@@ -45,7 +45,7 @@ declare class MongooseService extends Service {
      * @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;
+    static buildConnectOptions(cfg: Partial<IMongooseConnectorConfig>): ConnectOptions | undefined;
     /** Ferme toutes les connexions. */
     disconnectAll(): Promise<void>;
     /** Retourne l'ORM Mongoose d'un connecteur (défaut : `"nodefony"`). */

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/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;

package/docs/configuration.md

@@ -267,7 +267,7 @@ ainsi qu'une application lit une base métier et écrit dans une base d'archives
 L'adresse se donne de deux façons, jamais les deux à la fois utilement :
 
 - **En pièces détachées** — `host`, `port`, `dbname` : lisible, adapté au développement. Le service
-  les assemble en `mongodb://hôte:port/base` (`MongooseService.buildUri()` (`MongooseService.ts:102`)).
+  les assemble en `mongodb://hôte:port/base` (`MongooseService.buildUri()` (`MongooseService.ts:117`)).
 - **En une URI** — `uri` (`config.ts:41`) : la seule forme capable d'exprimer un replica set, un
   `mongodb+srv`, des options de requête. **Dès qu'`uri` est présent, les trois autres champs ne sont
   plus lus du tout.**
@@ -295,7 +295,7 @@ publique** de ton application : le changer déplace des entités.
 ### `options` — ce que Mongoose sait faire et Nodefony ne re-décrit pas
 
 `options` (`config.ts:86`) est transmis tel quel au driver
-(`MongooseService.#connectOne()` (`MongooseService.ts:141`)). On y met tout ce qui touche au
+(`MongooseService.#connectOne()` (`MongooseService.ts:156`)). On y met tout ce qui touche au
 **transport** plutôt qu'à l'adresse : taille du pool, délais, TLS, identifiants séparés.
 
 ```typescript
@@ -320,7 +320,7 @@ description des options du driver.
 
 ### `debug` — voir passer les requêtes
 
-`debug` (`config.ts:100`) active la trace intégrée de Mongoose (`connectAll()` (`MongooseService.ts:81`)).
+`debug` (`config.ts:100`) active la trace intégrée de Mongoose (`connectAll()` (`MongooseService.ts:104`)).
 Chaque opération part sur la sortie standard, avec sa collection, son filtre et ses champs.
 
 C'est un **réglage de processus, pas de connecteur** : il vaut pour toutes les connexions à la fois.
@@ -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
@@ -395,7 +397,7 @@ Trois précisions qui évitent les mauvaises surprises :
 ### L'override générique du framework
 
 Toute clé de config d'un module se surcharge par `NF__<MODULE>__<CHEMIN>`, le double tiret bas
-séparant les niveaux (`parseNfEnvOverrides()` (`envOverride.ts:80`)). Le segment de module est le nom
+séparant les niveaux (`parseNfEnvOverrides()` (`envOverride.ts:92`)). Le segment de module est le nom
 court : `MONGOOSE`.
 
 ```bash
@@ -405,7 +407,7 @@ NF__MONGOOSE__CONNECTORS__NODEFONY__DBNAME=recette    # champ imbriqué
 NF__MONGOOSE__CONNECTORS__NODEFONY__PORT=27018        # coercé en nombre
 ```
 
-Ces overrides sont posés **avant** la validation Zod (`Kernel.applyEnvConfigOverrides()` (`Kernel.ts:1807`)) :
+Ces overrides sont posés **avant** la validation Zod (`Kernel.applyEnvConfigOverrides()` (`Kernel.ts:1895`)) :
 une valeur aberrante est donc rejetée comme si tu l'avais écrite dans ton fichier. C'est voulu — un
 réglage d'environnement invalide doit casser aussi fort qu'un réglage de code.
 
@@ -436,7 +438,7 @@ De la plus faible à la plus forte priorité :
 
 1. **Les défauts du schéma** — `localhost:27017/nodefony`, `debug: false`, `frameworkEntities: true`.
 2. **Ta config d'app** — `use("@nodefony/mongoose", { … })`, fusionnée en profondeur sous les défauts
-   (`Kernel.loadModulesFromManifest()` (`Kernel.ts:1656`)).
+   (`Kernel.loadModulesFromManifest()` (`Kernel.ts:1714`)).
 3. **Un override venu d'un autre module** — la clé `module-mongoose` dans la config d'un module tiers.
 4. **`NF__MONGOOSE__…`** — l'override générique d'environnement.
 5. **La validation Zod** — types, bornes, défauts des champs restés absents.
@@ -549,9 +551,9 @@ use("@nodefony/mongoose", {
 ```
 
 Les deux connexions s'ouvrent en série au démarrage, dans l'ordre de déclaration
-(`connectAll()` (`MongooseService.ts:81`)), et se ferment toutes à l'arrêt
-(`disconnectAll()` (`MongooseService.ts:195`)). Un service peut demander l'une ou l'autre par son nom
-(`getOrm()` (`MongooseService.ts:203`)), mais l'usage courant reste le registre d'ORM.
+(`connectAll()` (`MongooseService.ts:104`)), et se ferment toutes à l'arrêt
+(`disconnectAll()` (`MongooseService.ts:210`)). Un service peut demander l'une ou l'autre par son nom
+(`getOrm()` (`MongooseService.ts:218`)), mais l'usage courant reste le registre d'ORM.
 
 ## 🔐 Le secret de connexion
 
@@ -568,7 +570,7 @@ données d'un coup. La règle est donc sans nuance.
 - **Les identifiants passés par `options`** (`user`, `pass`) suivent la même règle : ils viennent de
   l'environnement, pas du fichier. Le framework rédige d'ailleurs la valeur de tout override
   d'environnement dont le chemin ressemble à un secret, avant de le journaliser
-  (`pathLooksSecret()` (`envOverride.ts:375`)).
+  (`pathLooksSecret()` (`envOverride.ts:417`)).
 
 > [!TIP]
 > Vérifie ta redaction en une commande : démarre l'application et lis la ligne de connexion. Elle doit
@@ -653,7 +655,7 @@ Un port hors bornes, un type erroné, un champ vide : le démarrage s'arrête av
 le champ**, pas une pile d'appels.
 
 ```
-[@nodefony/mongoose] Invalid config: connectors.x.port: Too small: expected number to be >=1
+[@nodefony/mongoose] configuration invalide — connectors.x.port : Too small: expected number to be >=1
 ```
 
 Le message est assemblé à partir des remontées de validation, chemin de champ compris
@@ -665,24 +667,21 @@ coûteux à diagnostiquer qu'un serveur qui refuse de démarrer.
 
 Le cas courant : la config est parfaite, mais Mongo n'est pas joignable — conteneur pas encore prêt,
 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:3130`)) :
+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
 
@@ -697,7 +696,7 @@ vaut mieux qu'une erreur 500 et un rejet non capturé. À l'inverse, une entité
 La configuration ne se contente pas d'être validée : elle se **montre**.
 
 - Le module publie son schéma en JSON Schema (`Mongoose.configSchema()` (`mongoose/index.ts:55`) →
-  `mongooseConfigJsonSchema()` (`defineModuleConfig.ts:72`)). C'est ce qui permet à Studio d'afficher
+  `mongooseConfigJsonSchema()` (`defineModuleConfig.ts:78`)). C'est ce qui permet à Studio d'afficher
   chaque clé avec son type, son défaut et son texte d'aide — sans qu'une seule ligne de description
   soit recopiée quelque part.
 - L'écran `/nodefony/config` montre la configuration **effective** après toutes les couches, et la
@@ -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
@@ -492,8 +492,8 @@ global de Mongoose : c'est ce qui permet à plusieurs bases — voire plusieurs
 le même processus.
 
 Le service orchestre ce cycle de bout en bout : il ouvre une connexion par connecteur déclaré au
-démarrage (`MongooseService.connectAll()` (`MongooseService.ts:89`)) et referme tout à l'arrêt
-(`MongooseService.disconnectAll()` (`MongooseService.ts:195`)). Le module se déclare **non critique**
+démarrage (`MongooseService.connectAll()` (`MongooseService.ts:104`)) et referme tout à l'arrêt
+(`MongooseService.disconnectAll()` (`MongooseService.ts:210`)). Le module se déclare **non critique**
 (`Mongoose.critical` (`mongoose/index.ts:48`)) : une base injoignable ne tue pas le processus —
 l'application monte quand même, l'échec est journalisé, et c'est l'orchestrateur qui relèvera Mongo.
 
@@ -508,7 +508,7 @@ l'application monte quand même, l'échec est journalisé, et c'est l'orchestrat
 
 `repo.find({ views: { $gte: 10 } }, { limit: 20 })` traverse quatre étapes :
 
-1. **Traduction du critère** (`MongooseRepository.#filter()` (`MongooseRepository.ts:244`)) : chaque
+1. **Traduction du critère** (`MongooseRepository.#filter()` (`MongooseRepository.ts:256`)) : chaque
    champ est résolu (`id` devient `_id`), chaque opérateur portable est converti.
 2. **Validation du champ** (`MongooseRepository.#resolveField()` (`MongooseRepository.ts:222`)) : un
    champ absent du schéma lève `UnknownCriteriaField` — plutôt que de renvoyer zéro résultat sans
@@ -539,11 +539,12 @@ drivers. Les signatures exactes vivent dans le graphe généré
 | `delete` / `deleteOne` | supprimer | `deleteMany` / `deleteOne` |
 | `findOneAndDelete` | supprimer **et** récupérer le document | `findOneAndDelete` |
 | `count` / `exists` | compter / tester l'existence | `countDocuments` / `exists` |
+| `countDistinct` | compter les valeurs distinctes et non nulles d'un champ | agrégation `$match` → `$group` → `$count` |
 | `withTransaction` | rejouer les mêmes opérations dans une transaction | ajoute la `session` à chaque opération |
 
 Les écritures qui « lisent puis écrivent » sont **atomiques par construction**
-(`MongooseRepository.upsert()` (`MongooseRepository.ts:405`),
-`MongooseRepository.increment()` (`MongooseRepository.ts:491`)) : un seul aller-retour, la
+(`MongooseRepository.upsert()` (`MongooseRepository.ts:422`),
+`MongooseRepository.increment()` (`MongooseRepository.ts:507`)) : un seul aller-retour, la
 comparaison est faite par le serveur. Ce n'est pas une optimisation cosmétique — c'est ce qui évite
 que deux requêtes simultanées lisent le même état et s'écrasent mutuellement.
 
@@ -569,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
@@ -657,13 +658,16 @@ contrat est importé en `import type` (effacé à la compilation), et c'est le d
 auprès du module consommateur. Le module met en place tout ce câblage à son enregistrement, avant que
 la connexion ne s'ouvre.
 
-| Store        | Contrat                    | Comment le choisir                  | Collections                                        |
-| ------------ | -------------------------- | ----------------------------------- | -------------------------------------------------- |
-| Sessions     | `ISessionStorage` (http)   | `session: { store: "mongoose" }`    | `session`                                          |
-| Utilisateurs | `IUserRepository` (user)   | via `provisionUsers` de ton app     | `User`                                             |
-| Jetons       | `ITokenStore` (security)   | `tokenStore: { store: "mongoose" }` | `access_token`, `denied_jti`, `subject_revocation` |
-| Passkeys     | `IWebAuthnCredentialStore` | `passkeys: { store: "mongoose" }`   | `webauthn_credential`                              |
-| Webhooks     | `IWebhookStore`            | `webhooks: { store: "mongoose" }`   | `webhook_endpoint`                                 |
+| Store        | Contrat                       | Comment le choisir                               | Collections                                        |
+| ------------ | ----------------------------- | ------------------------------------------------ | -------------------------------------------------- |
+| Sessions     | `ISessionStorage` (http)      | `session: { store: "mongoose" }`                 | `session`                                          |
+| Utilisateurs | `IUserRepository` (user)      | via `provisionUsers` de ton app                  | `User`                                             |
+| Jetons       | `ITokenStore` (security)      | `tokenStore: { store: "mongoose" }`              | `access_token`, `denied_jti`, `subject_revocation` |
+| Passkeys     | `IWebAuthnCredentialStore`    | `passkeys: { store: "mongoose" }`                | `webauthn_credential`                              |
+| Webhooks     | `IWebhookStore`               | `webhooks: { store: "mongoose" }`                | `webhook_endpoint`                                 |
+| 2FA (TOTP)   | `ITotpSecretStore` (security) | `totp: { store: "mongoose" }`                    | `totp_secret`                                      |
+| Audit        | `IAuditStore` (security)      | `audit: { store: "mongoose" }`                   | `audit_event`                                      |
+| Idempotence  | `IIdempotencyStore` (cœur)    | `idempotency: { store: "mongoose" }` (framework) | `idempotency_key`                                  |
 
 L'auto-enregistrement peut être coupé (`frameworkEntities: false` (`config.ts:102`)) : le module
 devient alors un pur driver de données, sans schéma framework.
@@ -676,7 +680,7 @@ devient alors un pur driver de données, sans schéma framework.
 
 Trois comportements valent d'être connus :
 
-- **Purge à deux bornes** — `idleTimeoutS` et `absoluteTimeoutS` (`SessionStorage.gc()` (`SessionStorage.ts:32`)) :
+- **Purge à deux bornes** — `idleTimeoutS` et `absoluteTimeoutS` (`SessionStorage.gc()` (`SessionStorage.ts:163`)) :
   l'inactivité (depuis la dernière activité) et l'âge absolu (depuis la création, **jamais prolongé** —
   la ré-authentification finit par être imposée, conformément aux recommandations NIST/OWASP).
 - **Prolongation sans réécriture** (`SessionStorage.touch()` (`SessionStorage.ts:195`)) : rafraîchir
@@ -695,15 +699,15 @@ vaut mieux qu'une erreur 500 et un rejet non capturé.
 `MongooseUserRepository` rend des objets `BaseUser` (avec leur comportement : rôles, actif, verrouillé),
 pas des documents nus. Deux recherches lui sont propres :
 
-- **par compte social lié** (`MongooseUserRepository.findBySocialProvider()` (`MongooseUserRepository.ts:264`)) :
+- **par compte social lié** (`MongooseUserRepository.findBySocialProvider()` (`MongooseUserRepository.ts:238`)) :
   un `$elemMatch` sur un tableau libre de fournisseurs — le pendant Mongo du parcours JSON en SQL.
   C'est ce qui porte le motif « Shadow User » d'OAuth (un compte créé à la volée au premier login social),
   **sans colonne par fournisseur** : ajouter GitHub demain n'est pas une migration.
-- **listing paginé** (`MongooseUserRepository.listPage()` (`MongooseUserRepository.ts:299`)) : requête
+- **listing paginé** (`MongooseUserRepository.listPage()` (`MongooseUserRepository.ts:281`)) : requête
   native bornée (`skip`/`limit + 1`), tri sur liste blanche, `_id` en départage. Une page est une page,
   jamais la collection entière rapatriée en mémoire.
 
-Le comptage des administrateurs actifs (`MongooseUserRepository.countActiveAdmins()` (`MongooseUserRepository.ts:354`))
+Le comptage des administrateurs actifs (`MongooseUserRepository.countActiveAdmins()` (`MongooseUserRepository.ts:328`))
 compte côté serveur — c'est le garde-fou qui empêche de supprimer le dernier administrateur.
 
 ### Jetons
@@ -719,7 +723,7 @@ Deux invariants de sécurité sont tenus **par la requête**, pas par du code Ja
   déconnexions simultanées pourraient reposer un seuil **plus ancien** — et des jetons révoqués
   redeviendraient valides. Ici, c'est structurellement impossible.
 
-La purge, bornée par `retentionRevokedMs` (`MongooseTokenStore.gc()` (`MongooseTokenStore.ts:350`)), s'appuie sur une particularité utile
+La purge, bornée par `retentionRevokedMs` (`MongooseTokenStore.gc()` (`MongooseTokenStore.ts:356`)), s'appuie sur une particularité utile
 de Mongo : une comparaison numérique **ignore** les documents dont le champ est `null`. Les jetons sans
 expiration ne sont donc jamais balayés par erreur ; ils partent par une règle de rétention distincte.
 
@@ -748,7 +752,7 @@ serait pire qu'une erreur.
 
 ## 🗃 Ce qui est stocké
 
-Les cinq schémas portés par le module. Les collections sont créées à la volée par MongoDB — il n'y a
+Les schémas portés par le module — dix collections. Les collections sont créées à la volée par MongoDB — il n'y a
 ni migration ni DDL à jouer, ce qui est l'un des vrais conforts du modèle documentaire.
 
 > ⚠️ **Le revers de ce confort : ce qui n'est pas déclaré est JETÉ, sans un mot.** Mongoose valide en
@@ -763,15 +767,18 @@ ni migration ni DDL à jouer, ce qui est l'un des vrais conforts du modèle docu
 > partagé (`USER_COLUMNS`), et le module en dérive un schéma Mongoose. Un champ métier que tu ajoutes
 > à ton utilisateur suit le même chemin — déclaré, donc écrit ; oublié, donc perdu en silence.
 
-| Collection            | Clé primaire (`_id`)         | Contenu                                                            | Horodatages        |
-| --------------------- | ---------------------------- | ------------------------------------------------------------------ | ------------------ |
-| `session`             | `ObjectId` (auto)            | identifiant de session, contenu, messages flash, méta, utilisateur | nombres (ms)       |
-| `User`                | `ObjectId` (auto)            | identifiant, mot de passe haché, rôles, comptes sociaux, méta      | gérés par Mongoose |
-| `access_token`        | le `jti` (texte)             | type, porteur, périmètres, empreinte du secret, révocation         | nombres (ms)       |
-| `denied_jti`          | le `jti` (texte)             | expiration                                                         | nombres (ms)       |
-| `subject_revocation`  | le porteur (texte)           | seuil `invalidBefore`                                              | nombres (ms)       |
-| `webauthn_credential` | l'identifiant du credential  | clé publique, compteur, transports, état de sauvegarde             | nombres (ms)       |
-| `webhook_endpoint`    | l'identifiant `wh_…` (texte) | URL, secret chiffré, événements, état des livraisons               | nombres (ms)       |
+| Collection            | Clé primaire (`_id`)                   | Contenu                                                                              | Horodatages        |
+| --------------------- | -------------------------------------- | ------------------------------------------------------------------------------------ | ------------------ |
+| `session`             | `ObjectId` (auto)                      | identifiant de session, contenu, messages flash, méta, utilisateur                   | nombres (ms)       |
+| `User`                | `ObjectId` (auto)                      | identifiant, mot de passe haché, rôles, comptes sociaux, méta                        | gérés par Mongoose |
+| `access_token`        | le `jti` (texte)                       | type, porteur, périmètres, empreinte du secret, révocation                           | nombres (ms)       |
+| `denied_jti`          | le `jti` (texte)                       | expiration                                                                           | nombres (ms)       |
+| `subject_revocation`  | le porteur (texte)                     | seuil `invalidBefore`                                                                | nombres (ms)       |
+| `webauthn_credential` | l'identifiant du credential            | clé publique, compteur, transports, état de sauvegarde                               | nombres (ms)       |
+| `webhook_endpoint`    | l'identifiant `wh_…` (texte)           | URL, secret chiffré, événements, état des livraisons                                 | nombres (ms)       |
+| `totp_secret`         | l'identifiant de l'utilisateur (texte) | secret chiffré, algorithme, chiffres, période, codes de secours, dernier pas utilisé | nombres (ms)       |
+| `audit_event`         | l'identifiant d'événement (texte)      | catégorie, action, issue, acteur, ressource, raison, IP, requête                     | nombre (`ts`, ms)  |
+| `idempotency_key`     | la clé d'idempotence (texte)           | empreinte de la requête, état, réponse rejouée                                       | expiration (ms)    |
 
 Deux choix structurants s'y lisent :
 
@@ -867,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                                |
@@ -901,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-alpha.9",
+  "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-alpha.9",
-    "@nodefony/http": "^10.0.0-alpha.9",
-    "@nodefony/orm-core": "^10.0.0-alpha.9",
-    "@nodefony/security": "^10.0.0-alpha.9",
-    "@nodefony/user": "^10.0.0-alpha.9",
-    "@types/node": "26.6.2",
+    "@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-alpha.9",
-    "vitest": "5.0.1"
+    "nodefony": "^10.0.0-beta.2",
+    "vitest": "5.0.3"
   },
   "peerDependencies": {
-    "@nodefony/framework": "^10.0.0-alpha.9",
-    "@nodefony/http": "^10.0.0-alpha.9",
-    "@nodefony/orm-core": "^10.0.0-alpha.9",
-    "@nodefony/security": "^10.0.0-alpha.9",
-    "@nodefony/user": "^10.0.0-alpha.9",
-    "nodefony": "^10.0.0-alpha.9"
+    "@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",