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

package/README.md

@@ -48,6 +48,38 @@ Mongoose : `user`/`pass`/`maxPoolSize`/timeouts).
 La config est validée par **Zod** au boot (`config.ts` = source de vérité). Une config invalide
 plante proprement avec un message clair.
 
+## Les briques que ce module fournit au framework
+
+**Une application peut tourner entièrement sur MongoDB** : les huit briques de persistance
+durables sont portées, aucune ne retombe sur un autre backend. C'est la propriété à retenir avant
+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", …)`.
+**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://…`).
+
+Deux briques méritent un mot :
+
+- **Idempotence** — la dédup fonctionne **entre pods**, sans exiger Redis. La réservation est
+  atomique côté serveur : un `findOneAndUpdate` en `upsert`, filtré sur l'entrée expirée, dont le
+  perdant reçoit une violation d'unicité. C'est l'équivalent Mongo du `SET … NX PX` de Redis.
+  Comme la variante SQL, il n'y a pas de TTL natif : le framework arme une purge périodique.
+- **Audit** — le journal se lit par **curseur**, jamais par décalage : il reçoit des écritures
+  pendant qu'on le parcourt. Rétention purgée par `gc()` (365 jours par défaut).
+
 ## Stockage de session
 
 L'import du module enregistre automatiquement un `SessionStorage` sous le handler `"mongoose"`

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

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.150.0/helpers/esm/decorate.js
+//#region \0@oxc-project+runtime@0.151.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.150.0 → _@oxc-project_runtime@0.151.0}/helpers/esm/decorateMetadata.js

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.150.0/helpers/esm/decorateMetadata.js
+//#region \0@oxc-project+runtime@0.151.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

@@ -8,15 +8,21 @@ import "./nodefony/src/orm-core/index.js";
 import { TOKEN_ENTITY_NAMES, accessTokenSchema, createTokenEntities, deniedJtiSchema, registerTokenEntities, subjectRevocationSchema } from "./nodefony/entity/tokenEntity.js";
 import { WEBAUTHN_CREDENTIAL_ENTITY, createWebAuthnCredentialEntity, registerWebAuthnCredentialEntity, webAuthnCredentialSchema } from "./nodefony/entity/webAuthnCredentialEntity.js";
 import { WEBHOOK_ENDPOINT_ENTITY, createWebhookEndpointEntity, registerWebhookEndpointEntity, webhookEndpointSchema } from "./nodefony/entity/webhookEndpointEntity.js";
+import { AUDIT_ENTITY_NAMES, auditEventSchema, createAuditEntities, registerAuditEntities } from "./nodefony/entity/auditEventEntity.js";
+import { TOTP_SECRET_ENTITY, createTotpSecretEntity, registerTotpSecretEntity, totpSecretSchema } from "./nodefony/entity/totpSecretEntity.js";
+import { IDEMPOTENCY_ENTITY_NAME, createIdempotencyEntities, idempotencyKeySchema, registerIdempotencyEntities } from "./nodefony/entity/idempotencyEntity.js";
+import { createUserEntity, registerUserEntity, userSchema } from "./nodefony/entity/userEntity.js";
 import { MongooseTokenStore } from "./nodefony/src/MongooseTokenStore.js";
 import { MongooseWebAuthnCredentialStore } from "./nodefony/src/MongooseWebAuthnCredentialStore.js";
 import { MongooseWebhookStore } from "./nodefony/src/MongooseWebhookStore.js";
+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.150.0/helpers/esm/decorateMetadata.js";
-import __decorate from "./_virtual/_@oxc-project_runtime@0.150.0/helpers/esm/decorate.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 sessionEntity_default, { SESSION_CONNECTOR, sessionSchema as schema } from "./nodefony/entity/sessionEntity.js";
 import SessionStorage from "./nodefony/src/SessionStorage.js";
-import { createUserEntity, registerUserEntity, userSchema } from "./nodefony/entity/userEntity.js";
 import { MongooseUserRepository } from "./nodefony/src/MongooseUserRepository.js";
 import mongoose from "mongoose";
 import { Kernel, Module, registerErrorAdapter, services } from "nodefony";
@@ -87,4 +93,4 @@ let Mongoose = class Mongoose extends Module {
 Mongoose = __decorate([services([MongooseService]), __decorateMetadata("design:paramtypes", [typeof Kernel === "undefined" ? Object : Kernel])], Mongoose);
 var mongoose_default = Mongoose;
 //#endregion
-export { FRAMEWORK_CONNECTOR, MongooseOrm, MongooseRepository, MongooseService, MongooseTokenStore, MongooseTransaction, MongooseUserRepository, MongooseWebAuthnCredentialStore, MongooseWebhookStore, SESSION_CONNECTOR, sessionEntity_default as SessionEntity, SessionStorage, TOKEN_ENTITY_NAMES, WEBAUTHN_CREDENTIAL_ENTITY, WEBHOOK_ENDPOINT_ENTITY, accessTokenSchema, createTokenEntities, createUserEntity, createWebAuthnCredentialEntity, createWebhookEndpointEntity, mongoose_default as default, defineMongooseConfig, deniedJtiSchema, mongoose, mongooseConfigJsonSchema, mongooseConfigSchema, registerMongooseFrameworkStores, registerTokenEntities, registerUserEntity, registerWebAuthnCredentialEntity, registerWebhookEndpointEntity, schema as sessionSchema, subjectRevocationSchema, userSchema, webAuthnCredentialSchema, webhookEndpointSchema };
+export { AUDIT_ENTITY_NAMES, FRAMEWORK_CONNECTOR, IDEMPOTENCY_ENTITY_NAME, MongooseAuditStore, MongooseIdempotencyStore, MongooseOrm, MongooseRepository, MongooseService, MongooseTokenStore, MongooseTotpSecretStore, MongooseTransaction, MongooseUserRepository, MongooseWebAuthnCredentialStore, MongooseWebhookStore, SESSION_CONNECTOR, sessionEntity_default as SessionEntity, SessionStorage, TOKEN_ENTITY_NAMES, TOTP_SECRET_ENTITY, WEBAUTHN_CREDENTIAL_ENTITY, WEBHOOK_ENDPOINT_ENTITY, accessTokenSchema, auditEventSchema, createAuditEntities, createIdempotencyEntities, createTokenEntities, createTotpSecretEntity, createUserEntity, createWebAuthnCredentialEntity, createWebhookEndpointEntity, mongoose_default as default, defineMongooseConfig, deniedJtiSchema, idempotencyKeySchema, mongoose, mongooseConfigJsonSchema, mongooseConfigSchema, registerAuditEntities, registerIdempotencyEntities, registerMongooseFrameworkStores, registerTokenEntities, registerTotpSecretEntity, registerUserEntity, registerWebAuthnCredentialEntity, registerWebhookEndpointEntity, schema as sessionSchema, subjectRevocationSchema, totpSecretSchema, userSchema, webAuthnCredentialSchema, webhookEndpointSchema };

package/dist/nodefony/entity/auditEventEntity.js

@@ -0,0 +1,124 @@
+import { entityRegistry } from "@nodefony/orm-core";
+//#region nodefony/entity/auditEventEntity.ts
+/**
+* Schéma Mongoose du **journal d'audit** `@nodefony/security` — pendant
+* documentaire de la table Drizzle `audit_event`, implémentation NoSQL d'
+* `IAuditStore` (append-only, tamper-evident).
+*
+* ⚠️ **`_id` = clé naturelle (String), PAS un ObjectId auto** : l'`id` d'un
+* événement est posé par l'`AuditService` (corrélation + curseur de pagination)
+* → on force `_id: String`, l'id EST la clé primaire. Même convention que
+* `webhookEndpointEntity` et `tokenEntity`.
+*
+* ⚠️ **Horodatage = `Number` (epoch ms), `timestamps:false`** : `IAuditEvent.ts`
+* porte un `number` (`Date.now()`), pas une `Date` — et c'est ce champ qui porte
+* l'ordre du journal.
+*
+* **Index** — mêmes axes que la variante SQL, et pour la même raison (filtrage
+* de la console d'audit) ; perf de lecture seule, jamais de sémantique.
+*
+* L'ORDRE TOTAL du store (`ts DESC, _id DESC`) est porté par un index
+* COMPOSITE déclaré sur l'entité (`indexes`, cf `createAuditEntities`) : un
+* `SchemaDefinition` plat n'exprime que des index par champ, et sans lui la
+* requête du journal parcourait toute la collection puis triait en mémoire
+* (plan `COLLSCAN` + `SORT`, mesuré). C'est lui qui garantit, au coût d'un
+* parcours d'index, qu'aucun événement ne se répète ni ne se perd d'une page à
+* l'autre — `audit-store.test.ts` en lit le plan d'exécution.
+*/
+const auditEventSchema = {
+	_id: { type: String },
+	ts: {
+		type: Number,
+		required: true,
+		index: true
+	},
+	category: {
+		type: String,
+		required: true,
+		index: true
+	},
+	action: {
+		type: String,
+		required: true
+	},
+	outcome: {
+		type: String,
+		required: true
+	},
+	actor: {
+		type: String,
+		default: null,
+		index: true
+	},
+	resource: {
+		type: String,
+		default: null
+	},
+	reason: {
+		type: String,
+		default: null
+	},
+	ip: {
+		type: String,
+		default: null
+	},
+	userAgent: {
+		type: String,
+		default: null
+	},
+	requestId: {
+		type: String,
+		default: null,
+		index: true
+	},
+	flags: {
+		type: Object,
+		default: null
+	},
+	metadata: {
+		type: Object,
+		default: null
+	}
+};
+/** Noms logiques des entités du store (clés de lookup `getRepository`). */
+const AUDIT_ENTITY_NAMES = { events: "audit_event" };
+/**
+* Construit les descripteurs d'entités du journal d'audit pour un ORM nommé.
+*
+* Le `connector` est **dynamique** (nom du connecteur de l'app, ex. `"nodefony"`) :
+* le schéma est statique mais sa liaison à un ORM dépend de la config → pas
+* d'`@entity` figé. Pas de dialecte (NoSQL) : le schéma est portable par
+* construction. À enregistrer **avant** `orm.connect()` (modèle compilé au connect).
+*
+* `module: "security"` → la collection est regroupée sous @nodefony/security dans
+* l'ERD Studio (l'audit est une feature security, hébergée par l'ORM).
+*
+* @param connector - clé de l'ORM cible dans le `ormRegistry`.
+* @returns les descripteurs {@link IEntity} du journal d'audit.
+*/
+function createAuditEntities(connector) {
+	return [{
+		connector,
+		name: AUDIT_ENTITY_NAMES.events,
+		module: "security",
+		schema: auditEventSchema,
+		indexes: [{
+			fields: {
+				ts: -1,
+				_id: -1
+			},
+			name: "audit_ts_id_desc"
+		}]
+	}];
+}
+/**
+* Enregistre les entités du journal d'audit dans le `entityRegistry` pour un ORM
+* donné. À appeler **avant** `orm.connect()` (le modèle est compilé au connect).
+*
+* @param connector - nom de la connexion cible (clé du registre).
+*/
+function registerAuditEntities(connector) {
+	for (const entity of createAuditEntities(connector)) entityRegistry.register(entity);
+}
+//#endregion
+export { AUDIT_ENTITY_NAMES, auditEventSchema, createAuditEntities, registerAuditEntities };

package/dist/nodefony/entity/idempotencyEntity.js

@@ -0,0 +1,96 @@
+import { entityRegistry } from "@nodefony/orm-core";
+//#region nodefony/entity/idempotencyEntity.ts
+/**
+* Schéma Mongoose du **store d'idempotence** — pendant documentaire de la table
+* Drizzle `idempotency_key`, implémentation NoSQL d'`IIdempotencyStore` (contrat
+* au CORE) pour dédoublonner les mutations rejouées PARTAGÉ cross-pod, là où le
+* store mémoire par défaut reste affine à un pod.
+*
+* **Pourquoi MongoDB plutôt que Redis** : un cluster qui possède déjà une base
+* Mongo mais pas de Redis obtient la dédup cross-pod sans nouvelle infra — le
+* même argument qui fonde la variante SQL.
+*
+* ⚠️ **`_id` = la clé d'idempotence (String)** : c'est la contrainte d'unicité de
+* la clé primaire qui porte la **réservation atomique** de `begin`
+* (`findOneAndUpdate(… , {upsert:true})` → `E11000` pour le perdant). Faire
+* porter l'unicité par un index secondaire serait un faux ami : Mongoose
+* construit ses index en tâche de fond, donc la contrainte n'existerait pas
+* pendant la fenêtre de construction, et deux `begin` concurrents renverraient
+* tous deux `fresh` — exactement le double-effet que ce store existe pour
+* empêcher. Sur `_id`, la contrainte existe dès le premier document.
+*
+* Le champ `key` est **dupliqué** à côté de `_id` : c'est lui que le vocabulaire
+* public filtre (`q` = préfixe de clé) et que `listPage` rend. Les deux sont
+* écrits ensemble, jamais séparément.
+*
+* ⚠️ **PAS de TTL index natif** (≠ `expireAfterSeconds`) : l'échéance d'une
+* entrée n'est pas une durée fixe depuis sa création — c'est d'abord un **bail**
+* *in-flight* (`now + lease`), puis une **rétention** (`now + ttl`) posée à la
+* complétion. Un TTL index effacerait selon une règle qui ignore cette bascule.
+* `expiresAt` est donc un `Number` (epoch ms) indexé, purgé par le `gc()`
+* applicatif — même contrepartie que la variante SQL.
+*
+* `state` : `if` = réservation *in-flight* ; `done` = réponse mémorisée
+* (rejouée en `replayed`). `response` = la réponse mémorisée, `null` tant
+* qu'*in-flight* ; elle ne sort JAMAIS par `listPage` (anti-IDOR sur le cache).
+*/
+const idempotencyKeySchema = {
+	_id: { type: String },
+	key: {
+		type: String,
+		required: true
+	},
+	fingerprint: {
+		type: String,
+		required: true
+	},
+	state: {
+		type: String,
+		required: true
+	},
+	response: {
+		type: Object,
+		default: null
+	},
+	expiresAt: {
+		type: Number,
+		required: true,
+		index: true
+	}
+};
+/** Nom logique de l'entité (clé de lookup `getRepository` / `entityRegistry`). */
+const IDEMPOTENCY_ENTITY_NAME = "idempotency_key";
+/**
+* Construit le descripteur d'entité du store d'idempotence pour un ORM nommé.
+*
+* Le `connector` est **dynamique** (nom du connecteur de l'app, ex. `"nodefony"`) :
+* le schéma est statique mais sa liaison à un ORM dépend de la config → pas
+* d'`@entity` figé. À enregistrer **avant** `orm.connect()` (le modèle est
+* compilé au connect).
+*
+* `module: "framework"` → la collection est regroupée sous @nodefony/framework
+* dans l'ERD Studio (l'idempotence est une feature framework — data plane admin
+* + `@Idempotent` — simplement hébergée par l'ORM).
+*
+* @param connector - clé de l'ORM cible dans le `ormRegistry`.
+* @returns les descripteurs {@link IEntity} du store d'idempotence.
+*/
+function createIdempotencyEntities(connector) {
+	return [{
+		connector,
+		name: IDEMPOTENCY_ENTITY_NAME,
+		module: "framework",
+		schema: idempotencyKeySchema
+	}];
+}
+/**
+* Enregistre l'entité du store d'idempotence dans le `entityRegistry` pour un
+* ORM donné. À appeler **avant** `orm.connect()`.
+*
+* @param connector - nom de la connexion cible (clé du registre).
+*/
+function registerIdempotencyEntities(connector) {
+	for (const entity of createIdempotencyEntities(connector)) entityRegistry.register(entity);
+}
+//#endregion
+export { IDEMPOTENCY_ENTITY_NAME, createIdempotencyEntities, idempotencyKeySchema, registerIdempotencyEntities };

package/dist/nodefony/entity/sessionEntity.js

@@ -1,4 +1,4 @@
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.150.0/helpers/esm/decorate.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.151.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/entity/totpSecretEntity.js

@@ -0,0 +1,103 @@
+import { entityRegistry } from "@nodefony/orm-core";
+//#region nodefony/entity/totpSecretEntity.ts
+/**
+* Schéma Mongoose du **store de secrets TOTP** `@nodefony/security` (2FA) —
+* pendant documentaire de la table Drizzle `totp_secret`, implémentation NoSQL
+* d'`ITotpSecretStore`.
+*
+* ⚠️ **`_id` = `userId` (String)** : le modèle est **1 secret / utilisateur**, donc
+* la clé naturelle EST l'utilisateur — `save` devient un upsert par `_id`, et
+* l'unicité est portée par la clé primaire elle-même (aucun index à construire
+* en tâche de fond, donc aucune fenêtre où la contrainte n'existerait pas).
+*
+* Le champ `userId` est **dupliqué** à côté de `_id` : c'est lui que le
+* vocabulaire public trie et filtre (`q` = préfixe d'`userId`), et un document
+* Mongo n'expose pas `_id` sous un autre nom. Les deux sont écrits ensemble par
+* le store, jamais séparément.
+*
+* ⚠️ **`secretEnc` = secret déjà CHIFFRÉ** (AES-256-GCM par le service détenteur
+* de la clé) : le store ne voit que des octets opaques, jamais le secret `K` en
+* clair. Il ne sort JAMAIS par `listPage` (cf `ITotpEnrollmentSummary`).
+*
+* ⚠️ **Horodatages = `Number` (epoch ms), `timestamps:false`** — sauf
+* `lastUsedStep`, qui est une **tranche `T`** RFC 6238 (`floor(epochSeconds /
+* period)`), pas un horodatage.
+*
+* `recoveryCodes` = tableau de condensats `sha256` des codes NON consommés ; le
+* store les réécrit en bloc (jamais de mutation partielle in-place).
+*/
+const totpSecretSchema = {
+	_id: { type: String },
+	userId: {
+		type: String,
+		required: true
+	},
+	secretEnc: {
+		type: String,
+		required: true
+	},
+	algorithm: {
+		type: String,
+		required: true
+	},
+	digits: {
+		type: Number,
+		required: true
+	},
+	period: {
+		type: Number,
+		required: true
+	},
+	recoveryCodes: {
+		type: [String],
+		default: []
+	},
+	confirmedAt: {
+		type: Number,
+		default: null
+	},
+	lastUsedStep: {
+		type: Number,
+		default: null
+	},
+	createdAt: {
+		type: Number,
+		required: true
+	},
+	lastUsedAt: {
+		type: Number,
+		default: null
+	}
+};
+/** Nom logique de l'entité (clé de lookup `getRepository`). */
+const TOTP_SECRET_ENTITY = "totp_secret";
+/**
+* Construit le descripteur d'entité du store de secrets TOTP pour un ORM nommé.
+*
+* Le `connector` est **dynamique** (nom du connecteur de l'app, ex. `"nodefony"`) :
+* le schéma est statique mais sa liaison à un ORM dépend de la config → pas
+* d'`@entity` figé. À enregistrer **avant** `orm.connect()` (le modèle est
+* compilé au connect). `module: "security"` → regroupé sous @nodefony/security
+* dans l'ERD Studio.
+*
+* @param connector - clé de l'ORM cible dans le `ormRegistry`.
+*/
+function createTotpSecretEntity(connector) {
+	return {
+		connector,
+		name: TOTP_SECRET_ENTITY,
+		module: "security",
+		schema: totpSecretSchema
+	};
+}
+/**
+* Enregistre l'entité du store de secrets TOTP dans le `entityRegistry` pour un
+* ORM donné. À appeler **avant** `orm.connect()`.
+*
+* @param connector - nom de la connexion cible (clé du registre).
+*/
+function registerTotpSecretEntity(connector) {
+	entityRegistry.register(createTotpSecretEntity(connector));
+}
+//#endregion
+export { TOTP_SECRET_ENTITY, createTotpSecretEntity, registerTotpSecretEntity, totpSecretSchema };

package/dist/nodefony/registerStores.js

@@ -3,11 +3,19 @@ import "./src/orm-core/index.js";
 import { TOKEN_ENTITY_NAMES, registerTokenEntities } from "./entity/tokenEntity.js";
 import { WEBAUTHN_CREDENTIAL_ENTITY, registerWebAuthnCredentialEntity } from "./entity/webAuthnCredentialEntity.js";
 import { WEBHOOK_ENDPOINT_ENTITY, registerWebhookEndpointEntity } from "./entity/webhookEndpointEntity.js";
+import { AUDIT_ENTITY_NAMES, registerAuditEntities } from "./entity/auditEventEntity.js";
+import { TOTP_SECRET_ENTITY, registerTotpSecretEntity } from "./entity/totpSecretEntity.js";
+import { IDEMPOTENCY_ENTITY_NAME, registerIdempotencyEntities } from "./entity/idempotencyEntity.js";
+import { registerUserEntity } from "./entity/userEntity.js";
 import { MongooseTokenStore } from "./src/MongooseTokenStore.js";
 import { MongooseWebAuthnCredentialStore } from "./src/MongooseWebAuthnCredentialStore.js";
 import { MongooseWebhookStore } from "./src/MongooseWebhookStore.js";
+import { MongooseAuditStore } from "./src/MongooseAuditStore.js";
+import { MongooseTotpSecretStore } from "./src/MongooseTotpSecretStore.js";
+import { MongooseIdempotencyStore } from "./src/MongooseIdempotencyStore.js";
 import { entityRegistry, ormRegistry } from "@nodefony/orm-core";
-import { getTokenStoreFactory, getWebAuthnStoreFactory, getWebhookStoreFactory, registerTokenStore, registerWebAuthnStore, registerWebhookStore } from "@nodefony/security";
+import { getAuditStoreFactory, getTokenStoreFactory, getTotpStoreFactory, getWebAuthnStoreFactory, getWebhookStoreFactory, registerAuditStore, registerTokenStore, registerTotpStore, registerWebAuthnStore, registerWebhookStore } from "@nodefony/security";
+import { getIdempotencyStoreFactory, registerIdempotencyStore } from "@nodefony/framework";
 //#region nodefony/registerStores.ts
 /**
 * AUTO-ENREGISTREMENT des backends framework portés par Mongoose — « charger le
@@ -18,9 +26,12 @@ import { getTokenStoreFactory, getWebAuthnStoreFactory, getWebhookStoreFactory,
 * modèles sont compilés à la connexion). Pas de dialecte (NoSQL) : les schémas
 * sont portables par construction.
 *
-* Couverture PARTIELLE assumée : session (auto via `@entity`), tokens, webauthn,
-* webhooks. PAS d'implémentation mongoose pour l'audit ni l'idempotence — les
-* sélectionner sur mongoose échoue franc (« store inconnu »), jamais en silence.
+* Couverture : session (auto via `@entity`), utilisateurs, tokens, webauthn,
+* webhooks, audit, TOTP et idempotence — soit **la totalité des briques
+* durables**. C'est la propriété que Mongo doit tenir : une application doit
+* pouvoir tourner SANS aucun backend SQL, et un backend durable est un chemin
+* complet ou n'en est pas un. Une brique qui manquerait se sélectionnerait en
+* échec franc (« store inconnu »), jamais en silence.
 *
 * Mêmes garde-fous que Drizzle : entité `has`-guarded (l'app garde la main),
 * fabrique `get`-guarded (premier-arrivé-premier-servi).
@@ -67,6 +78,7 @@ function registerMongooseFrameworkStores() {
 		}
 		registerFactory();
 	};
+	wire("User", () => registerUserEntity(FRAMEWORK_CONNECTOR), () => {});
 	wire(TOKEN_ENTITY_NAMES.records, () => registerTokenEntities(FRAMEWORK_CONNECTOR), () => {
 		if (getTokenStoreFactory("mongoose")) return;
 		registerTokenStore("mongoose", (ctx) => {
@@ -83,6 +95,31 @@ function registerMongooseFrameworkStores() {
 		if (getWebhookStoreFactory("mongoose")) return;
 		registerWebhookStore("mongoose", () => MongooseWebhookStore.from(resolveConnectedOrm(`webhooks.store "mongoose"`)));
 	});
+	wire(AUDIT_ENTITY_NAMES.events, () => registerAuditEntities(FRAMEWORK_CONNECTOR), () => {
+		if (getAuditStoreFactory("mongoose")) return;
+		registerAuditStore("mongoose", (ctx) => {
+			const orm = resolveConnectedOrm(`audit.store "mongoose"`);
+			const days = ctx?.config?.audit?.retentionDays;
+			return MongooseAuditStore.from(orm, void 0, typeof days === "number" ? days * 864e5 : void 0);
+		});
+	});
+	wire(TOTP_SECRET_ENTITY, () => registerTotpSecretEntity(FRAMEWORK_CONNECTOR), () => {
+		if (getTotpStoreFactory("mongoose")) return;
+		registerTotpStore("mongoose", () => MongooseTotpSecretStore.from(resolveConnectedOrm(`totp.store "mongoose"`)));
+	});
+	wire(IDEMPOTENCY_ENTITY_NAME, () => registerIdempotencyEntities(FRAMEWORK_CONNECTOR), () => {
+		if (getIdempotencyStoreFactory("mongoose")) return;
+		registerIdempotencyStore("mongoose", () => new MongooseIdempotencyStore(() => {
+			let orm;
+			try {
+				orm = ormRegistry.get(FRAMEWORK_CONNECTOR);
+			} catch {
+				return null;
+			}
+			if (!(orm instanceof MongooseOrm) || !orm.isConnected()) return null;
+			return orm.getNativeConnection().model(IDEMPOTENCY_ENTITY_NAME);
+		}, void 0, void 0, void 0, FRAMEWORK_CONNECTOR));
+	});
 	return report;
 }
 //#endregion

package/dist/nodefony/service/MongooseService.js

@@ -1,7 +1,7 @@
 import { MongooseOrm } from "../src/orm-core/MongooseOrm.js";
 import mongoose from "mongoose";
 import { Service, runNeedsExternalServices } from "nodefony";
-import { diagnoseConnectionFailure, parseConnectionTarget, queryFlowMonitor, resolveOrmFlowEnabled } from "@nodefony/orm-core";
+import { describeConnectFailure, diagnoseConnectionFailure, parseConnectionTarget, queryFlowMonitor, reportOrphanEntities, resolveOrmFlowEnabled } from "@nodefony/orm-core";
 //#region nodefony/service/MongooseService.ts
 const serviceName = "mongoose";
 /**
@@ -27,6 +27,9 @@ var MongooseService = class MongooseService extends Service {
 			queryFlowMonitor.setEnabled(resolveOrmFlowEnabled(this.kernel));
 			await this.connectAll(runNeedsExternalServices(this.kernel));
 		});
+		this.module.hookKernel("onReady", () => {
+			reportOrphanEntities((message, severity) => this.log(message, severity), this.kernel ?? this, Object.keys(this.#config()?.connectors ?? {}));
+		});
 		this.kernel?.once("onTerminate", async () => {
 			await this.disconnectAll().catch(() => {});
 		});
@@ -79,7 +82,7 @@ var MongooseService = class MongooseService extends Service {
 	/** Connecte un connecteur (URI + options d'auth/pool). */
 	async #connectOne(name, cfg, connect = true) {
 		const uri = MongooseService.buildUri(cfg);
-		const orm = new MongooseOrm(name, uri, MongooseService.buildConnectOptions(cfg));
+		const orm = new MongooseOrm(name, uri, MongooseService.buildConnectOptions(cfg), this.container ?? void 0);
 		if (!connect) {
 			this.#orms.set(name, orm);
 			this.log(`Mongoose « ${name} » enregistré SANS connexion (${orm.safeTarget()}) — ce run n'a pas déclaré \`externalServices\`.`, "DEBUG");
@@ -90,7 +93,7 @@ var MongooseService = class MongooseService extends Service {
 		} catch (e) {
 			const diagnosis = diagnoseConnectionFailure(e, parseConnectionTarget(uri));
 			const cause = e instanceof Error ? e.message : String(e);
-			throw new Error(`Mongoose : le connecteur "${name}" (${orm.safeTarget()}) n'a pas pu se connecter — ${diagnosis.explanation} Cause : ${cause}`, { cause: e });
+			throw new Error(describeConnectFailure(`Mongoose : le connecteur "${name}" (${orm.safeTarget()})`, diagnosis, cause), { cause: e });
 		}
 		this.#orms.set(name, orm);
 		this.log(`Mongoose ORM "${name}" connected (${orm.safeTarget()})`, "INFO");