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

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

@@ -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/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);
@@ -97,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
 						} });
@@ -111,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
 						} });
@@ -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);
@@ -180,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: []
 			};
@@ -268,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()]
 		];
@@ -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;
+				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);
+		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;
@@ -311,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.`);
@@ -362,8 +405,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 +418,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,