@nodefony/mongoose 10.0.0-alpha.8 → 10.0.0-alpha.9

package/dist/nodefony/src/MongooseTotpSecretStore.js

@@ -0,0 +1,151 @@
+import { TOTP_SECRET_ENTITY } from "../entity/totpSecretEntity.js";
+import { assertPageQuery } from "nodefony";
+import { paginate, searchCriteria } from "@nodefony/orm-core";
+//#region nodefony/src/MongooseTotpSecretStore.ts
+/**
+* Store de secrets TOTP **Mongoose** (NoSQL) — implémentation documentaire d'
+* {@link ITotpSecretStore} au-dessus d'un unique repository `@nodefony/orm-core`
+* (`totp_secret`). Pendant documentaire de `DrizzleTotpSecretStore` : là où
+* `MemoryTotpSecretStore` est volatile, ce store survit au redémarrage et se
+* partage entre pods.
+*
+* **Modèle 1 secret / utilisateur** (clé = `userId`, portée par `_id`) → `save`
+* est un upsert par clé primaire.
+*
+* **Approche B** : `@nodefony/security` n'est connu qu'en `import type` (0 dép
+* runtime).  L'entité (`registerTotpSecretEntity`) doit être enregistrée
+* **avant** `orm.connect()` (le modèle est compilé au connect).
+*
+* **100 % portable** (aucune query native) — toutes les opérations passent par
+* le contrat `IRepository`, comme son frère SQL : l'`userId` est cherché sous
+* `id` (le contrat traduit `{ id }` → `{ _id }`), et le listing par `paginate()`.
+*
+* **`secretEnc` opaque** : le store persiste le secret DÉJÀ chiffré (AES-256-GCM
+* côté service) — il ne déchiffre jamais, ne voit que des octets. Il ne sort
+* JAMAIS par `listPage` (cf {@link ITotpEnrollmentSummary}).
+*/
+var MongooseTotpSecretStore = class MongooseTotpSecretStore {
+	#repo;
+	/**
+	* @param repo - repository de la collection `totp_secret`.
+	*/
+	constructor(repo) {
+		this.#repo = repo;
+	}
+	/** Connecteur ORM qui porte ce store — posé par {@link MongooseTotpSecretStore.from}. */
+	#connector;
+	/**
+	* Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+	* registre des stores : la console rattache la brique à SON connecteur au
+	* lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+	*/
+	get connector() {
+		return this.#connector;
+	}
+	/**
+	* Construit le store depuis un {@link MongooseOrm} connecté. L'entité
+	* (`registerTotpSecretEntity`) doit avoir été enregistrée **avant**
+	* `orm.connect()`.
+	*
+	* @param orm - ORM Mongoose connecté hébergeant la collection du store.
+	*/
+	static from(orm) {
+		const store = new MongooseTotpSecretStore(orm.getRepository(TOTP_SECRET_ENTITY));
+		store.#connector = orm.name;
+		return store;
+	}
+	/** Row plate → secret du contrat (recoveryCodes copié = mutable indépendant). */
+	#toSecret(row) {
+		return {
+			userId: row.userId,
+			secretEnc: row.secretEnc,
+			algorithm: row.algorithm,
+			digits: row.digits,
+			period: row.period,
+			recoveryCodes: [...row.recoveryCodes],
+			confirmedAt: row.confirmedAt,
+			lastUsedStep: row.lastUsedStep,
+			createdAt: row.createdAt,
+			lastUsedAt: row.lastUsedAt
+		};
+	}
+	async findByUser(userId) {
+		const row = await this.#repo.findOne({ id: userId });
+		return row ? this.#toSecret(row) : null;
+	}
+	async save(secret) {
+		await this.#repo.upsert({ id: secret.userId }, {
+			userId: secret.userId,
+			secretEnc: secret.secretEnc,
+			algorithm: secret.algorithm,
+			digits: secret.digits,
+			period: secret.period,
+			recoveryCodes: [...secret.recoveryCodes],
+			confirmedAt: secret.confirmedAt,
+			lastUsedStep: secret.lastUsedStep,
+			createdAt: secret.createdAt,
+			lastUsedAt: secret.lastUsedAt
+		});
+	}
+	async update(userId, patch) {
+		const set = {};
+		if (patch.confirmedAt !== void 0) set.confirmedAt = patch.confirmedAt;
+		if (patch.recoveryCodes !== void 0) set.recoveryCodes = [...patch.recoveryCodes];
+		if (patch.lastUsedStep !== void 0) set.lastUsedStep = patch.lastUsedStep;
+		if (patch.lastUsedAt !== void 0) set.lastUsedAt = patch.lastUsedAt;
+		if (Object.keys(set).length === 0) return;
+		await this.#repo.updateOne({ id: userId }, set);
+	}
+	async delete(userId) {
+		await this.#repo.delete({ id: userId });
+	}
+	/**
+	* Critère portable des filtres du listing. `confirmed` s'exprime en `$null`
+	* sur `confirmedAt` (pas de champ booléen dérivé à maintenir), `q` en `$like`
+	* **ancré à gauche** (`préfixe%`) — traduit en `$regex` ancré par le
+	* repository, donc servable par un index.
+	*/
+	#listCriteria(query) {
+		const criteria = {};
+		if (query.confirmed !== void 0) criteria.confirmedAt = { $null: !query.confirmed };
+		Object.assign(criteria, searchCriteria(query.q, ["userId"]) ?? {});
+		return criteria;
+	}
+	/**
+	* {@inheritDoc ITotpSecretStore.listPage}
+	*
+	* 100 % portable : le helper `paginate()` d'orm-core (limite/décalage + total
+	* optionnel) sur un critère simple. La projection en vue d'enrôlement retire
+	* `secretEnc` et les condensats — ils ne franchissent jamais la frontière du
+	* store, quel que soit l'appelant.
+	*/
+	async listPage(query) {
+		assertPageQuery(query, "offset");
+		const page = await paginate(this.#repo, {
+			criteria: this.#listCriteria(query),
+			limit: query.limit,
+			offset: query.offset,
+			withTotal: query.withTotal,
+			order: [["createdAt", "DESC"], ["userId", "ASC"]]
+		});
+		return {
+			...page,
+			items: page.items.map((row) => ({
+				userId: row.userId,
+				algorithm: row.algorithm,
+				digits: row.digits,
+				period: row.period,
+				confirmedAt: row.confirmedAt,
+				createdAt: row.createdAt,
+				lastUsedAt: row.lastUsedAt,
+				recoveryCodesLeft: row.recoveryCodes.length
+			}))
+		};
+	}
+	/** {@inheritDoc ITotpSecretStore.countEnrollments} */
+	countEnrollments(query) {
+		return this.#repo.count(this.#listCriteria(query));
+	}
+};
+//#endregion
+export { MongooseTotpSecretStore };

package/dist/nodefony/src/MongooseWebAuthnCredentialStore.js

@@ -25,6 +25,16 @@ var MongooseWebAuthnCredentialStore = class MongooseWebAuthnCredentialStore {
 	constructor(repo) {
 		this.#repo = repo;
 	}
+	/** Connecteur ORM qui porte ce store — posé par {@link MongooseWebAuthnCredentialStore.from}. */
+	#connector;
+	/**
+	* Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+	* registre des stores : la console rattache la brique à SON connecteur au
+	* lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+	*/
+	get connector() {
+		return this.#connector;
+	}
 	/**
 	* Construit le store depuis un {@link MongooseOrm} connecté. L'entité
 	* (`registerWebAuthnCredentialEntity`) doit avoir été enregistrée **avant**
@@ -33,7 +43,9 @@ var MongooseWebAuthnCredentialStore = class MongooseWebAuthnCredentialStore {
 	* @param orm - ORM Mongoose connecté hébergeant la collection du store.
 	*/
 	static from(orm) {
-		return new MongooseWebAuthnCredentialStore(orm.getRepository(WEBAUTHN_CREDENTIAL_ENTITY));
+		const store = new MongooseWebAuthnCredentialStore(orm.getRepository(WEBAUTHN_CREDENTIAL_ENTITY));
+		store.#connector = orm.name;
+		return store;
 	}
 	/** Identité réelle d'un credential : `_id` fait foi, le virtuel `id` en repli. */
 	#idOf(row) {

package/dist/nodefony/src/MongooseWebhookStore.js

@@ -1,5 +1,5 @@
-import { WEBHOOK_ENDPOINT_ENTITY } from "../entity/webhookEndpointEntity.js";
 import { mongoOrder, toMongoSort } from "./mongoOrder.js";
+import { WEBHOOK_ENDPOINT_ENTITY } from "../entity/webhookEndpointEntity.js";
 import { assertPageQuery, escapeRegExp } from "nodefony";
 import { WEBHOOK_DEFAULT_ORDER, WEBHOOK_SORTABLE_FIELDS } from "@nodefony/security";
 //#region nodefony/src/MongooseWebhookStore.ts
@@ -41,6 +41,16 @@ var MongooseWebhookStore = class MongooseWebhookStore {
 		this.#repo = repo;
 		this.#model = model;
 	}
+	/** Connecteur ORM qui porte ce store — posé par {@link MongooseWebhookStore.from}. */
+	#connector;
+	/**
+	* Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+	* registre des stores : la console rattache la brique à SON connecteur au
+	* lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+	*/
+	get connector() {
+		return this.#connector;
+	}
 	/**
 	* Construit le store depuis un {@link MongooseOrm} connecté. L'entité
 	* (`registerWebhookEndpointEntity`) doit avoir été enregistrée **avant**
@@ -50,7 +60,9 @@ var MongooseWebhookStore = class MongooseWebhookStore {
 	*/
 	static from(orm) {
 		const connection = orm.getNativeConnection();
-		return new MongooseWebhookStore(orm.getRepository(WEBHOOK_ENDPOINT_ENTITY), connection.model(WEBHOOK_ENDPOINT_ENTITY));
+		const store = new MongooseWebhookStore(orm.getRepository(WEBHOOK_ENDPOINT_ENTITY), connection.model(WEBHOOK_ENDPOINT_ENTITY));
+		store.#connector = orm.name;
+		return store;
 	}
 	/** Identité réelle d'un endpoint : `_id` fait foi, le virtuel `id` en repli. */
 	#idOf(row) {

package/dist/nodefony/src/SessionStorage.js

@@ -27,6 +27,14 @@ var SessionStorage = class SessionStorage {
 		this.absoluteTimeoutS = manager.options.absoluteTimeoutS;
 	}
 	/**
+	* Connecteur ORM qui porte les sessions — lu par `readStoreConnector` pour le
+	* registre des stores. `undefined` tant que l'ORM de ce connecteur n'est pas
+	* enregistré : on ne publie pas un rattachement que rien ne porte.
+	*/
+	get connector() {
+		return ormRegistry.has("nodefony") ? SESSION_CONNECTOR : void 0;
+	}
+	/**
 	* Repository de l'entité session, ou `null` si l'ORM n'est pas (ou plus)
 	* connecté.
 	*

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

@@ -56,9 +56,12 @@ var MongooseOrm = class MongooseOrm extends Orm {
 	* @param name - clé unique de l'ORM dans le `ormRegistry`.
 	* @param uri - URI de connexion MongoDB (replica set requis pour les tx).
 	* @param options - options de connexion Mongoose (auth, pool, timeouts).
+	* @param container - container du service qui construit l'ORM : il porte le
+	*   `syslog` du kernel. Sans lui, la perte et la reprise de connexion
+	*   s'écrivent dans un journal que rien ne relie à la sortie du serveur.
 	*/
-	constructor(name, uri, options) {
-		super(name);
+	constructor(name, uri, options, container) {
+		super(name, container);
 		this.#uri = uri;
 		this.#options = options;
 	}
@@ -83,11 +86,18 @@ var MongooseOrm = class MongooseOrm extends Orm {
 		this.#models = Object.create(null);
 		const entities = this.#ownEntities();
 		const schemas = /* @__PURE__ */ new Map();
-		for (const entity of entities) schemas.set(entity.name, new mongoose.Schema(entity.schema, {
-			toObject: { virtuals: true },
-			toJSON: { virtuals: true },
-			timestamps: entity.timestamps ?? false
-		}));
+		for (const entity of entities) {
+			const schema = new mongoose.Schema(entity.schema, {
+				toObject: { virtuals: true },
+				toJSON: { virtuals: true },
+				timestamps: entity.timestamps ?? false
+			});
+			for (const index of entity.indexes ?? []) schema.index({ ...index.fields }, {
+				...index.unique !== void 0 ? { unique: index.unique } : {},
+				...index.name !== void 0 ? { name: index.name } : {}
+			});
+			schemas.set(entity.name, schema);
+		}
 		for (const entity of entities) {
 			if (!entity.relations) continue;
 			const sourceSchema = schemas.get(entity.name);
@@ -126,6 +136,7 @@ var MongooseOrm = class MongooseOrm extends Orm {
 			this.#models[entity.name] = model;
 			entity.model = model;
 		}
+		this.#referrers = this.#indexReferrers(this.#models);
 		const audit = this.verifyIndexes();
 		this.#indexAudit = audit;
 		audit.catch(() => void 0);
@@ -294,15 +305,51 @@ var MongooseOrm = class MongooseOrm extends Orm {
 		this.#connection = null;
 		this.#models = null;
 		this.#repositories = null;
+		this.#referrers = null;
 		this.#indexAudit = null;
 	}
+	/**
+	* Index inverse des références : pour chaque entité visée, les champs des
+	* autres entités qui la désignent. `null` quand aucune référence n'existe.
+	*/
+	#referrers = null;
+	/**
+	* Bâtit l'index inverse des références à partir des schémas COMPILÉS.
+	*
+	* Tout champ `ObjectId` qui porte un `ref` vers une entité de cette connexion
+	* compte — qu'il vienne d'un schéma généré (`author: { type: ObjectId, ref }`)
+	* ou d'une relation déclarée (`relations`, que l'étape 2 traduit en champ).
+	* Un tableau de références n'y entre pas : son effacement (retirer l'élément)
+	* n'a pas d'équivalent dans la politique `restrict` / `set null` du SQL.
+	*
+	* @param models - modèles compilés de la connexion.
+	* @returns l'index, ou `null` si aucune entité n'en référence une autre.
+	*/
+	#indexReferrers(models) {
+		let index = null;
+		for (const model of Object.values(models)) {
+			const leading = new Set(model.schema.indexes().map(([fields]) => Object.keys(fields)[0]));
+			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[ref] ??= []).push({
+					model,
+					path: fieldPath,
+					required: type.isRequired === true
+				});
+				if (!leading.has(fieldPath)) this.log(`référence "${model.modelName}.${fieldPath}" → "${ref}" sans index : chaque suppression d'un "${ref}" parcourra toute la collection "${model.collection.collectionName}" — ajouter \`index: true\``, "WARNING");
+			});
+		}
+		return index;
+	}
 	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);
 		let repository = this.#repositories[name];
 		if (repository === void 0) {
-			repository = new MongooseRepository(model, this.name);
+			repository = new MongooseRepository(model, this.name, null, this.#referrers?.[name] ?? null);
 			this.#repositories[name] = repository;
 		}
 		return repository;
@@ -362,8 +409,11 @@ var MongooseOrm = class MongooseOrm extends Orm {
 	}
 	/**
 	* Colonnes normalisées d'une entité depuis les `paths` du schéma Mongoose —
-	* alimente le graphe canonique / ERD / contexte IA. Pas de PK SQL : `_id` est
-	* la clé primaire implicite de tout document.
+	* alimente le graphe canonique / ERD / contexte IA. Rendues dans le
+	* vocabulaire du CONTRAT, pas du moteur : la clé primaire `_id` s'y nomme
+	* `id` (comme dans les critères et les lignes lues), et la clé de version
+	* interne `__v` n'y figure pas — un graphe qui changerait de noms selon
+	* l'adaptateur ne décrirait plus la même application.
 	*
 	* @param name - nom logique de l'entité.
 	* @returns colonnes (`[]` si l'entité n'est pas connue de cet ORM).
@@ -372,8 +422,8 @@ var MongooseOrm = class MongooseOrm extends Orm {
 		const model = this.#models?.[name];
 		if (!model) return [];
 		const paths = model.schema.paths;
-		return Object.entries(paths).map(([field, schemaType]) => ({
-			name: field,
+		return Object.entries(paths).filter(([field]) => field !== "__v").map(([field, schemaType]) => ({
+			name: field === "_id" ? "id" : field,
 			type: schemaType.instance || "Mixed",
 			primaryKey: field === "_id",
 			nullable: field === "_id" ? false : schemaType.isRequired !== true,

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

@@ -1,7 +1,20 @@
+import { MONGO_ORDER_ALIASES } from "../mongoOrder.js";
 import { RequestContext, redactSecrets } from "nodefony";
-import { UnknownCriteriaField, assertOrderOption, isFieldOperators, isUpdateOperators, likePatternToRegExp, queryFlowMonitor } from "@nodefony/orm-core";
+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** :
@@ -19,15 +32,20 @@ var MongooseRepository = class MongooseRepository {
 	#session;
 	/** Connecteur ORM (clé du registre) — tag des métriques de flux. */
 	#connector;
+	/** Champs qui référencent cette entité — `null` si personne ne la vise (cas courant, coût nul). */
+	#referrers;
 	/**
 	* @param model - modèle Mongoose compilé.
 	* @param connector - nom de la connexion (clé du registre) — défaut `"nodefony"`.
 	* @param session - session transactionnelle à laquelle lier les ops (ou `null`).
+	* @param referrers - champs d'autres entités qui référencent celle-ci (index
+	*   inverse de {@link MongooseOrm}) ; `null` quand aucune ne la vise.
 	*/
-	constructor(model, connector = "nodefony", session = null) {
+	constructor(model, connector = "nodefony", session = null, referrers = null) {
 		this.#model = model;
 		this.#connector = connector;
 		this.#session = session;
+		this.#referrers = referrers;
 	}
 	/**
 	* Tap dev-only : mesure la durée d'une opération et alimente **deux** sondes
@@ -77,6 +95,13 @@ var MongooseRepository = class MongooseRepository {
 	* (`$eq`/`$ne`) — en Mongo `null` matche aussi le champ **absent**, ce qui est
 	* bien l'équivalent du `NULL` SQL (colonne sans valeur).
 	*
+	* `$ne`/`$nin` ne matchent JAMAIS l'absence de valeur, comme en SQL (où
+	* `col <> 'x'` est inconnu, donc faux, sur un NULL). Natifs, ils la
+	* matcheraient : `{ note: { $ne: "x" } }` ramenait sous MongoDB les documents
+	* sans note, que PostgreSQL écarte — la même requête rendait plus de lignes en
+	* production MongoDB, sans un mot. `null` est donc ajouté à l'ensemble exclu.
+	* Un `$nin` VIDE reste neutre (SQL : aucune exclusion, NULL compris).
+	*
 	* @throws Error si `$null` est combiné à `$eq`/`$ne` sur le même champ : les
 	*   deux viseraient la même clé Mongo et l'une écraserait l'autre **en
 	*   silence** (le contrat les déclare exclusifs — cf `FieldOperators.$null`).
@@ -90,6 +115,17 @@ var MongooseRepository = class MongooseRepository {
 			out[target] = null;
 		} else if ((key === "$eq" || key === "$ne") && key in out) throw new Error(`criteria: $null ne se combine pas avec ${key} sur le même champ (${this.#model.modelName})`);
 		else out[key] = value;
+		const ne = ops.$ne;
+		const nin = ops.$nin;
+		if (ne !== void 0 && ne !== null || nin !== void 0 && nin.length > 0) {
+			const excluded = [...nin ?? []];
+			if (ne !== void 0 && ne !== null) {
+				excluded.push(ne);
+				delete out.$ne;
+			}
+			excluded.push(null);
+			out.$nin = excluded;
+		}
 		return out;
 	}
 	/**
@@ -141,7 +177,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]) => [field, dir === "DESC" ? -1 : 1])));
+			if (options?.order?.length) query = query.sort(Object.fromEntries(options.order.map(([field, dir]) => [sortKey(field), dir === "DESC" ? -1 : 1])));
 			return (await query.exec()).map((doc) => this.#plain(doc));
 		}, (docs) => docs.length);
 	}
@@ -152,7 +188,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]) => [field, dir === "DESC" ? -1 : 1])));
+			if (options?.order?.length) query = query.sort(Object.fromEntries(options.order.map(([field, dir]) => [sortKey(field), dir === "DESC" ? -1 : 1])));
 			const doc = await query.exec();
 			return doc ? this.#plain(doc) : null;
 		}, (doc) => doc ? 1 : 0);
@@ -238,23 +274,97 @@ var MongooseRepository = class MongooseRepository {
 		}, (doc) => doc ? 1 : 0);
 	}
 	async delete(criteria) {
-		const filter = this.#filter(criteria);
-		return this.#prof(() => this.#descr("deleteMany", filter), async () => {
+		let filter = this.#filter(criteria);
+		const ids = await this.#referencedTargets(filter, false);
+		if (ids !== null) {
+			if (ids.length === 0) return 0;
+			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;
 		}, (n) => n);
+		if (ids !== null && removed > 0) await this.#releaseOptional(ids);
+		return removed;
 	}
 	async deleteOne(criteria) {
-		const filter = this.#filter(criteria);
-		return this.#prof(() => this.#descr("deleteOne", filter), async () => {
+		let filter = this.#filter(criteria);
+		const ids = await this.#referencedTargets(filter, true);
+		if (ids !== null) {
+			if (ids.length === 0) return false;
+			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;
 		}, (ok) => ok ? 1 : 0);
+		if (ids !== null && removed) await this.#releaseOptional(ids);
+		return removed;
 	}
 	async findOneAndDelete(criteria) {
-		const filter = this.#filter(criteria);
-		return this.#prof(() => this.#descr("findOneAndDelete", filter), async () => {
-			const doc = await this.#model.findOneAndDelete(filter, { session: this.#session ?? void 0 }).exec();
-			return doc ? this.#plain(doc) : null;
-		}, (doc) => doc ? 1 : 0);
+		let filter = this.#filter(criteria);
+		const ids = await this.#referencedTargets(filter, true);
+		if (ids !== null) {
+			if (ids.length === 0) return null;
+			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();
+			return found ? this.#plain(found) : null;
+		}, (d) => d ? 1 : 0);
+		if (ids !== null && doc !== null) await this.#releaseOptional(ids);
+		return doc;
+	}
+	/**
+	* Garde d'intégrité d'une suppression — le `restrict` que MongoDB ne tient pas.
+	*
+	* Rend `null` (et ne coûte rien) quand aucune entité ne référence celle-ci.
+	* Sinon, lit les `_id` que la suppression viserait, REFUSE si l'un d'eux est
+	* encore désigné par une référence obligatoire, et les rend : la suppression
+	* porte alors sur ces `_id` exacts, pas sur le filtre — ce qui a été contrôlé
+	* est ce qui part.
+	*
+	* ⚠️ Hors transaction, le contrôle et la suppression sont deux opérations : un
+	* enfant créé entre les deux n'est pas vu. Le SQL, lui, est atomique ; dans
+	* une transaction (`withTransaction`), les deux lisent la même session.
+	* ⚠️ Les `_id` visés sont tous chargés : une suppression en MASSE garde sa
+	* règle « un seul parent retenu bloque le lot », au prix d'une mémoire
+	* proportionnelle au lot. Le CRUD généré supprime par `id`, donc un à un.
+	*
+	* @param filter - filtre Mongo déjà traduit.
+	* @param single - vrai pour `deleteOne`/`findOneAndDelete` (un seul document).
+	* @returns les `_id` visés, ou `null` si l'entité n'est référencée par personne.
+	* @throws ReferencedEntityError si une référence obligatoire désigne l'un d'eux.
+	*/
+	async #referencedTargets(filter, single) {
+		const referrers = this.#referrers;
+		if (referrers === null) return null;
+		const session = this.#session ?? void 0;
+		const query = this.#model.find(filter, { _id: 1 }, { session }).lean();
+		if (single) query.limit(1);
+		const docs = await query.exec();
+		if (docs.length === 0) return [];
+		const ids = docs.map((d) => d._id);
+		for (const referrer of referrers) {
+			if (!referrer.required) continue;
+			if (await referrer.model.exists(referrer.model === this.#model ? {
+				[referrer.path]: { $in: ids },
+				_id: { $nin: ids }
+			} : { [referrer.path]: { $in: ids } }).session(session ?? null).exec() !== null) throw new ReferencedEntityError(this.#model.modelName, referrer.model.modelName, referrer.path);
+		}
+		return ids;
+	}
+	/**
+	* Remet à `null` les références FACULTATIVES aux documents supprimés — le
+	* `set null` du SQL généré : l'enfant survit à son parent, sans pointer dans
+	* le vide.
+	*
+	* @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 });
+		}
 	}
 	async count(criteria) {
 		const filter = this.#filter(criteria);
@@ -293,7 +403,7 @@ var MongooseRepository = class MongooseRepository {
 		});
 	}
 	withTransaction(tx) {
-		return new MongooseRepository(this.#model, this.#connector, tx.getNative());
+		return new MongooseRepository(this.#model, this.#connector, tx.getNative(), this.#referrers);
 	}
 };
 //#endregion

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

@@ -1,3 +1,4 @@
+import { SavepointNotSupportedError } from "@nodefony/orm-core";
 //#region nodefony/src/orm-core/MongooseTransaction.ts
 /**
 * Adapte une `ClientSession` MongoDB au contrat portable {@link ITransaction}.
@@ -7,8 +8,8 @@
 * MongoDB **exigent un replica set** (un standalone ne les supporte pas).
 *
 * MongoDB n'a **pas de savepoints** : {@link MongooseTransaction.savepoint} /
-* {@link MongooseTransaction.rollbackTo} sont des no-op documentés (limite du
-* driver, prévue par le contrat).
+* {@link MongooseTransaction.rollbackTo} les REFUSENT (`SavepointNotSupportedError`).
+* Un no-op laissait croire un rollback partiel qui n'annulait rien.
 */
 var MongooseTransaction = class {
 	#session;
@@ -40,10 +41,22 @@ var MongooseTransaction = class {
 		this.#done = true;
 		await this.#session.abortTransaction();
 	}
-	/** No-op : MongoDB ne gère pas les savepoints. */
-	async savepoint(_name) {}
-	/** No-op : MongoDB ne gère pas les savepoints. */
-	async rollbackTo(_name) {}
+	/**
+	* Refusé : MongoDB n'a pas de savepoints.
+	*
+	* @throws SavepointNotSupportedError toujours.
+	*/
+	async savepoint(_name) {
+		throw new SavepointNotSupportedError("mongodb", "savepoint");
+	}
+	/**
+	* Refusé : MongoDB n'a pas de savepoints.
+	*
+	* @throws SavepointNotSupportedError toujours.
+	*/
+	async rollbackTo(_name) {
+		throw new SavepointNotSupportedError("mongodb", "rollbackTo");
+	}
 	/** Expose la `ClientSession` native (trappe bas niveau). */
 	getNative() {
 		return this.#session;

package/dist/types/index.d.ts

@@ -70,5 +70,14 @@ export { MongooseWebAuthnCredentialStore } from "./nodefony/src/MongooseWebAuthn
 export { webhookEndpointSchema, createWebhookEndpointEntity, registerWebhookEndpointEntity, WEBHOOK_ENDPOINT_ENTITY, } from "./nodefony/entity/webhookEndpointEntity.js";
 export type { WebhookEndpointRow } from "./nodefony/entity/webhookEndpointEntity.js";
 export { MongooseWebhookStore } from "./nodefony/src/MongooseWebhookStore.js";
+export { auditEventSchema, createAuditEntities, registerAuditEntities, AUDIT_ENTITY_NAMES, } from "./nodefony/entity/auditEventEntity.js";
+export type { AuditEventRow } from "./nodefony/entity/auditEventEntity.js";
+export { MongooseAuditStore } from "./nodefony/src/MongooseAuditStore.js";
+export { totpSecretSchema, createTotpSecretEntity, registerTotpSecretEntity, TOTP_SECRET_ENTITY, } from "./nodefony/entity/totpSecretEntity.js";
+export type { TotpSecretRow } from "./nodefony/entity/totpSecretEntity.js";
+export { MongooseTotpSecretStore } from "./nodefony/src/MongooseTotpSecretStore.js";
+export { idempotencyKeySchema, createIdempotencyEntities, registerIdempotencyEntities, IDEMPOTENCY_ENTITY_NAME, } from "./nodefony/entity/idempotencyEntity.js";
+export type { IdempotencyKeyRow } from "./nodefony/entity/idempotencyEntity.js";
+export { MongooseIdempotencyStore } from "./nodefony/src/MongooseIdempotencyStore.js";
 export { registerMongooseFrameworkStores, FRAMEWORK_CONNECTOR, } from "./nodefony/registerStores.js";
 export type { IFrameworkStoresReport } from "./nodefony/registerStores.js";