@nodefony/mongoose 10.0.0-alpha.1

package/dist/nodefony/src/MongooseUserRepository.js

@@ -0,0 +1,205 @@
+import { mongoOrder, toMongoSort } from "./mongoOrder.js";
+import { DOCUMENT_USER_COLUMNS } from "../entity/userEntity.js";
+import { assertPageQuery, escapeRegExp } from "nodefony";
+import { BaseUser, USER_DEFAULT_ORDER, USER_SORTABLE_FIELDS, assertUserContract, attachExtraColumns } from "@nodefony/user";
+//#region nodefony/src/MongooseUserRepository.ts
+/**
+* Ce que le MOTEUR ajoute à chaque document, et qui n'appartient à personne
+* d'autre : la clé primaire brute et la clé de version. Le contrat utilisateur
+* ne peut pas les connaître — il ignore qu'il existe un Mongo — donc c'est ce
+* dépôt qui les tait, au lieu de les laisser passer pour des champs métier.
+*/
+const MONGOOSE_INTERNAL_KEYS = /* @__PURE__ */ new Set(["_id", "__v"]);
+/**
+* Adapter Mongoose du contrat {@link IUserRepository} — persistance NoSQL de
+* l'utilisateur (P5.8), pendant documentaire de `DrizzleUserRepository` (P5.9).
+*
+* Décore le repository portable (`IRepository<UserRow>` de {@link MongooseOrm}) de
+* deux responsabilités propres à l'utilisateur :
+* - **mapping document ↔ `BaseUser`** : les consommateurs reçoivent le comportement
+*   (`hasRole`/`isActive`/`isLocked`), pas un document nu ;
+* - **finders métier** : `findByIdentifier` (lookup unique) et
+*   `findBySocialProvider` (scan du tableau `socialProviders` via `$elemMatch` —
+*   équivalent Mongo du `json_each` SQL de Drizzle, pattern Shadow User OAuth).
+*
+* Le credential (`password`) transite par cette frontière — attendu : le repository
+* **est** la frontière de persistance du hash (cf `IUserRepository`).
+*/
+var MongooseUserRepository = class MongooseUserRepository {
+	/**
+	* Même vocabulaire public que les autres repositories — ici le tri part
+	* dans la requête, où il ne coûte qu'un index.
+	*/
+	sortableFields = USER_SORTABLE_FIELDS;
+	#base;
+	#model;
+	#session;
+	/**
+	* @param base - repository portable sur l'entité `User` (CRUD + criteria).
+	* @param model - modèle Mongoose natif `User` (pour le scan `$elemMatch`).
+	* @param session - session transactionnelle liée aux ops natives, ou `null`.
+	*/
+	constructor(base, model, session = null) {
+		this.#base = base;
+		this.#model = model;
+		this.#session = session;
+	}
+	/**
+	* Construit le repository utilisateur depuis un {@link MongooseOrm} connecté.
+	* L'entité `User` doit avoir été enregistrée (cf `registerUserEntity`) **avant**
+	* `orm.connect()` (le modèle est compilé au connect).
+	*
+	* @param orm - ORM Mongoose connecté.
+	* @returns le repository utilisateur prêt à l'emploi.
+	*/
+	static from(orm) {
+		const model = orm.getNativeConnection().model("User");
+		assertUserContract(Object.keys(model.schema.paths), `L'entité « User » de cette application (connecteur « ${orm.name} », mongoose)`, DOCUMENT_USER_COLUMNS);
+		return new MongooseUserRepository(orm.getRepository("User"), model);
+	}
+	/** Mappe une ligne plate en `BaseUser` (comportement + champs anti-migration). */
+	#toUser(row) {
+		const user = new BaseUser({
+			id: row.id,
+			identifier: row.identifier,
+			roles: row.roles,
+			password: row.password,
+			enabled: row.enabled,
+			locked: row.locked,
+			currentRole: row.currentRole,
+			socialProviders: row.socialProviders,
+			metadata: row.metadata
+		});
+		return attachExtraColumns(user, row, MONGOOSE_INTERNAL_KEYS);
+	}
+	async find(criteria, options) {
+		return (await this.#base.find(criteria, options)).map((row) => this.#toUser(row));
+	}
+	async findOne(criteria, options) {
+		const row = await this.#base.findOne(criteria, options);
+		return row ? this.#toUser(row) : null;
+	}
+	async create(data) {
+		const row = await this.#base.create(data);
+		return this.#toUser(row);
+	}
+	async updateOne(criteria, data) {
+		const row = await this.#base.updateOne(criteria, data);
+		return row ? this.#toUser(row) : null;
+	}
+	async upsert(criteria, update, insertOnly) {
+		const row = await this.#base.upsert(criteria, update, insertOnly);
+		return this.#toUser(row);
+	}
+	async createMany(data) {
+		return (await this.#base.createMany(data)).map((row) => this.#toUser(row));
+	}
+	exists(criteria) {
+		return this.#base.exists(criteria);
+	}
+	deleteOne(criteria) {
+		return this.#base.deleteOne(criteria);
+	}
+	async findOneAndDelete(criteria) {
+		const row = await this.#base.findOneAndDelete(criteria);
+		return row ? this.#toUser(row) : null;
+	}
+	async increment(criteria, changes) {
+		const row = await this.#base.increment(criteria, changes);
+		return row ? this.#toUser(row) : null;
+	}
+	updateMany(criteria, data) {
+		return this.#base.updateMany(criteria, data);
+	}
+	delete(criteria) {
+		return this.#base.delete(criteria);
+	}
+	count(criteria) {
+		return this.#base.count(criteria);
+	}
+	countDistinct(field, criteria) {
+		return this.#base.countDistinct(field, criteria);
+	}
+	withTransaction(tx) {
+		return new MongooseUserRepository(this.#base.withTransaction(tx), this.#model, tx.getNative());
+	}
+	findByIdentifier(identifier) {
+		return this.findOne({ identifier });
+	}
+	/**
+	* Recherche par compte externe lié — scanne le tableau `socialProviders` via
+	* `$elemMatch` (1 requête, équivalent Mongo du `json_each` Drizzle). `null` si
+	* aucun lien. Liée à la session transactionnelle courante le cas échéant.
+	*/
+	async findBySocialProvider(provider, providerId) {
+		let query = this.#model.findOne({ socialProviders: { $elemMatch: {
+			provider,
+			providerId
+		} } });
+		if (this.#session) query = query.session(this.#session);
+		const doc = await query.exec();
+		return doc ? this.#toUser(doc.toObject({ virtuals: true })) : null;
+	}
+	/** Construit le filtre Mongo natif des filtres de listing (role/enabled/q). */
+	#listFilter(query) {
+		const filter = {};
+		if (query.role !== void 0) filter.roles = query.role;
+		if (query.enabled !== void 0) filter.enabled = query.enabled;
+		if (query.locked !== void 0) filter.locked = query.locked;
+		if (query.hasSocial !== void 0) filter["socialProviders.0"] = { $exists: query.hasSocial };
+		if (query.q !== void 0 && query.q.length > 0) filter.identifier = {
+			$regex: escapeRegExp(query.q),
+			$options: "i"
+		};
+		return filter;
+	}
+	/**
+	* {@inheritDoc IUserRepository.listPage}
+	*
+	* Query native Mongo : `find(filter).sort().skip().limit(limit + 1)` — le store
+	* ne renvoie qu'une page (jamais de matérialisation complète). `roles: role` =
+	* containment de tableau natif, `$regex/i` = sous-chaîne insensible casse.
+	* `_id` en tiebreaker de tri (pagination offset déterministe).
+	*/
+	async listPage(query) {
+		assertPageQuery(query, "offset");
+		const limit = Math.max(1, Math.floor(query.limit));
+		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;
+		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();
+		const hasNext = docs.length > limit;
+		const items = (hasNext ? docs.slice(0, limit) : docs).map((doc) => this.#toUser(doc.toObject({ virtuals: true })));
+		let total;
+		if (query.withTotal !== false) {
+			let countQuery = this.#model.countDocuments(filter);
+			if (this.#session) countQuery = countQuery.session(this.#session);
+			total = await countQuery.exec();
+		}
+		return {
+			items,
+			total,
+			limit,
+			offset,
+			hasNext
+		};
+	}
+	/** {@inheritDoc IUserRepository.countActiveAdmins} */
+	/** {@inheritDoc IUserRepository.countUsers} */
+	countUsers(query) {
+		return this.#model.countDocuments(this.#listFilter(query)).exec();
+	}
+	async countActiveAdmins(adminRole) {
+		let countQuery = this.#model.countDocuments({
+			enabled: true,
+			roles: adminRole
+		});
+		if (this.#session) countQuery = countQuery.session(this.#session);
+		return countQuery.exec();
+	}
+};
+//#endregion
+export { MongooseUserRepository };

package/dist/nodefony/src/MongooseWebAuthnCredentialStore.js

@@ -0,0 +1,144 @@
+import { WEBAUTHN_CREDENTIAL_ENTITY } from "../entity/webAuthnCredentialEntity.js";
+import { assertPageQuery } from "nodefony";
+import { paginate } from "@nodefony/orm-core";
+//#region nodefony/src/MongooseWebAuthnCredentialStore.ts
+/**
+* Store de credentials WebAuthn **Mongoose** (NoSQL) — implémentation d'
+* {@link IWebAuthnCredentialStore} au-dessus d'un unique repository
+* `@nodefony/orm-core` (`webauthn_credential`). Pendant documentaire de
+* `DrizzleWebAuthnCredentialStore`.
+*
+* **Approche B** : `@nodefony/security` n'est connu qu'en `import type` (0 dép
+* runtime). C'est l'application qui enregistre la fabrique
+* (`registerWebAuthnStore("mongoose", …)`) et l'entité
+* (`registerWebAuthnCredentialEntity(orm)` avant `orm.connect()`).
+*
+* **Spécificité Mongo** : la clé naturelle (credentialId) est portée par `_id`
+* (cf {@link webAuthnCredentialSchema}). Le contrat traduit `{ id }` → `{ _id }`,
+* donc les lookups passent par le champ `id` ; les **écritures** posent
+* explicitement `_id` (Mongo ne génère pas notre credentialId). Le mapping
+* `Row ↔ IWebAuthnCredential` normalise `nickname` (`null` → omis).
+*/
+var MongooseWebAuthnCredentialStore = class MongooseWebAuthnCredentialStore {
+	#repo;
+	/** @param repo - repository de la collection `webauthn_credential`. */
+	constructor(repo) {
+		this.#repo = repo;
+	}
+	/**
+	* Construit le store depuis un {@link MongooseOrm} connecté. L'entité
+	* (`registerWebAuthnCredentialEntity`) doit avoir été enregistrée **avant**
+	* `connect()`.
+	*
+	* @param orm - ORM Mongoose connecté hébergeant la collection du store.
+	*/
+	static from(orm) {
+		return new MongooseWebAuthnCredentialStore(orm.getRepository(WEBAUTHN_CREDENTIAL_ENTITY));
+	}
+	/** Identité réelle d'un credential : `_id` fait foi, le virtuel `id` en repli. */
+	#idOf(row) {
+		return row._id ?? row.id;
+	}
+	/** Row plate → credential du contrat (`nickname?` omis si `null`/absent). */
+	#toCredential(row) {
+		return {
+			id: this.#idOf(row),
+			userId: row.userId,
+			publicKey: row.publicKey,
+			signCount: row.signCount,
+			transports: row.transports,
+			backupEligible: row.backupEligible,
+			backupState: row.backupState,
+			uvInitialized: row.uvInitialized,
+			createdAt: row.createdAt,
+			lastUsedAt: row.lastUsedAt,
+			...row.nickname != null ? { nickname: row.nickname } : {}
+		};
+	}
+	async findById(credentialId) {
+		const row = await this.#repo.findOne({ id: credentialId });
+		return row ? this.#toCredential(row) : null;
+	}
+	async findByUser(userId) {
+		return (await this.#repo.find({ userId })).map((row) => this.#toCredential(row));
+	}
+	/** `countDocuments` natif — jamais un `find().length` (le plafond ne charge rien). */
+	countByUser(userId) {
+		return this.#repo.count({ userId });
+	}
+	async save(credential) {
+		const data = {
+			userId: credential.userId,
+			publicKey: credential.publicKey,
+			signCount: credential.signCount,
+			transports: [...credential.transports],
+			backupEligible: credential.backupEligible,
+			backupState: credential.backupState,
+			uvInitialized: credential.uvInitialized,
+			nickname: credential.nickname ?? null,
+			createdAt: credential.createdAt,
+			lastUsedAt: credential.lastUsedAt
+		};
+		await this.#repo.upsert({ id: credential.id }, data);
+	}
+	async update(credentialId, patch) {
+		await this.#repo.updateOne({ id: credentialId }, {
+			signCount: patch.signCount,
+			backupState: patch.backupState,
+			uvInitialized: patch.uvInitialized,
+			lastUsedAt: patch.lastUsedAt
+		});
+	}
+	async delete(credentialId) {
+		await this.#repo.delete({ id: credentialId });
+	}
+	/**
+	* Critères du listing admin. `q` = PRÉFIXE d'`userId` (`$like 'x%'`, traduit en
+	* ancrage `^` côté Mongo), jamais une recherche non ancrée.
+	*/
+	#listCriteria(query) {
+		const criteria = {};
+		if (query.userId !== void 0) criteria.userId = query.userId;
+		else if (query.q !== void 0 && query.q.length > 0) criteria.userId = { $like: `${query.q.replace(/[\\%_]/g, (c) => "\\" + c)}%` };
+		if (query.backedUp !== void 0) criteria.backupState = query.backedUp;
+		return criteria;
+	}
+	/**
+	* {@inheritDoc IWebAuthnCredentialStore.listPage}
+	*
+	* Même helper `paginate()` que l'adapter SQL (`skip`/`limit` + `countDocuments`).
+	* La projection retire `publicKey` — elle ne franchit jamais la frontière du store.
+	* ⚠️ L'identité vient de `_id` (`#idOf`), pas du champ `id` de la row.
+	*/
+	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"], ["_id", "ASC"]]
+		});
+		return {
+			...page,
+			items: page.items.map((row) => ({
+				id: this.#idOf(row),
+				userId: row.userId,
+				transports: row.transports,
+				backupEligible: row.backupEligible,
+				backupState: row.backupState,
+				uvInitialized: row.uvInitialized,
+				signCount: row.signCount,
+				createdAt: row.createdAt,
+				lastUsedAt: row.lastUsedAt,
+				...row.nickname != null ? { nickname: row.nickname } : {}
+			}))
+		};
+	}
+	/** {@inheritDoc IWebAuthnCredentialStore.countCredentials} */
+	countCredentials(query) {
+		return this.#repo.count(this.#listCriteria(query));
+	}
+};
+//#endregion
+export { MongooseWebAuthnCredentialStore };

package/dist/nodefony/src/MongooseWebhookStore.js

@@ -0,0 +1,181 @@
+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
+/**
+* Store d'endpoints webhook **Mongoose** (NoSQL) — implémentation d'
+* {@link IWebhookStore} au-dessus d'un unique repository `@nodefony/orm-core`
+* (`webhook_endpoint`). Pendant documentaire de `DrizzleWebhookStore` ; registre
+* DURABLE des endpoints (survit au redémarrage, ≠ `MemoryWebhookStore`).
+*
+* **Approche B** : `@nodefony/security` n'est connu qu'en `import type` (0 dép
+* runtime). C'est l'application qui enregistre la fabrique
+* (`registerWebhookStore("mongoose", …)`) et l'entité
+* (`registerWebhookEndpointEntity(orm)` avant `orm.connect()`).
+*
+* **Spécificité Mongo** : la clé naturelle (`wh_<random>`) est portée par `_id`
+* (cf {@link webhookEndpointSchema}). Le contrat traduit `{ id }` → `{ _id }`,
+* donc les lookups passent par `id` ; les **écritures** posent explicitement
+* `_id` (Mongo ne génère pas notre id). Mapping `Row ↔ IWebhookEndpoint` :
+* `IWebhookEndpoint` est déjà « plat tout `| null` », seuls les champs JSON
+* `events`/`metadata` sont copiés défensivement.
+*/
+var MongooseWebhookStore = class MongooseWebhookStore {
+	/**
+	* {@inheritDoc IWebhookStore.sortableFields}
+	*
+	* Capacité pleine : le vocabulaire public entier est trié par Mongo, `id`
+	* compris — traduit en `_id` au moment de la requête.
+	*/
+	sortableFields = WEBHOOK_SORTABLE_FIELDS;
+	#repo;
+	#model;
+	/**
+	* @param repo - repository de la collection `webhook_endpoint`.
+	* @param model - modèle Mongoose natif, requis par le seul listing paginé
+	*   (recherche `q` = `$or` sur deux champs, hors `Criteria` AND-only).
+	*   `null` = `listPage` refuse plutôt que de tout charger en silence.
+	*/
+	constructor(repo, model = null) {
+		this.#repo = repo;
+		this.#model = model;
+	}
+	/**
+	* Construit le store depuis un {@link MongooseOrm} connecté. L'entité
+	* (`registerWebhookEndpointEntity`) doit avoir été enregistrée **avant**
+	* `connect()`.
+	*
+	* @param orm - ORM Mongoose connecté hébergeant la collection du store.
+	*/
+	static from(orm) {
+		const connection = orm.getNativeConnection();
+		return new MongooseWebhookStore(orm.getRepository(WEBHOOK_ENDPOINT_ENTITY), connection.model(WEBHOOK_ENDPOINT_ENTITY));
+	}
+	/** Identité réelle d'un endpoint : `_id` fait foi, le virtuel `id` en repli. */
+	#idOf(row) {
+		return row._id ?? row.id;
+	}
+	/** Row plate → endpoint du contrat (sans `_id`/`__v` ; `events` en `readonly`). */
+	#toEndpoint(row) {
+		return {
+			id: this.#idOf(row),
+			url: row.url,
+			secretEnc: row.secretEnc,
+			events: row.events,
+			enabled: row.enabled,
+			description: row.description,
+			tenantId: row.tenantId,
+			createdBy: row.createdBy,
+			createdAt: row.createdAt,
+			updatedAt: row.updatedAt,
+			lastDeliveryAt: row.lastDeliveryAt,
+			lastDeliveryStatus: row.lastDeliveryStatus,
+			lastDeliveryError: row.lastDeliveryError,
+			failureCount: row.failureCount,
+			metadata: row.metadata
+		};
+	}
+	async save(endpoint) {
+		const data = {
+			url: endpoint.url,
+			secretEnc: endpoint.secretEnc,
+			events: [...endpoint.events],
+			enabled: endpoint.enabled,
+			description: endpoint.description,
+			tenantId: endpoint.tenantId,
+			createdBy: endpoint.createdBy,
+			createdAt: endpoint.createdAt,
+			updatedAt: endpoint.updatedAt,
+			lastDeliveryAt: endpoint.lastDeliveryAt,
+			lastDeliveryStatus: endpoint.lastDeliveryStatus,
+			lastDeliveryError: endpoint.lastDeliveryError,
+			failureCount: endpoint.failureCount,
+			metadata: { ...endpoint.metadata }
+		};
+		await this.#repo.upsert({ id: endpoint.id }, data);
+	}
+	async findById(id) {
+		const row = await this.#repo.findOne({ id });
+		return row ? this.#toEndpoint(row) : null;
+	}
+	async update(id, patch) {
+		const { events, metadata, ...rest } = patch;
+		const data = { ...rest };
+		if (events !== void 0) data.events = [...events];
+		if (metadata !== void 0) data.metadata = { ...metadata };
+		await this.#repo.updateOne({ id }, data);
+	}
+	async delete(id) {
+		await this.#repo.delete({ id });
+	}
+	async listAll() {
+		return (await this.#repo.find({})).map((row) => this.#toEndpoint(row));
+	}
+	/**
+	* Modèle natif ou erreur explicite — un `listPage` qui retomberait sur un
+	* `find({})` complet trahirait silencieusement la garantie du contrat.
+	*/
+	#nativeModel() {
+		if (this.#model === null) throw new Error("MongooseWebhookStore: listing paginé indisponible (store construit sans modèle natif). Utiliser MongooseWebhookStore.from(orm).");
+		return this.#model;
+	}
+	/**
+	* Filtre Mongo des filtres du listing. `events: <event>` = **containment de
+	* tableau natif** (Mongo matche un scalaire contre chaque élément) ; `q` =
+	* `$or` de deux `$regex/i` — le `$or` sort du `Criteria` AND-only, d'où la
+	* query native.
+	*/
+	#listFilter(query) {
+		const filter = {};
+		if (query.enabled !== void 0) filter.enabled = query.enabled;
+		if (query.failing !== void 0) filter.failureCount = query.failing ? { $gt: 0 } : 0;
+		if (query.event !== void 0) filter.events = query.event;
+		if (query.q !== void 0 && query.q.length > 0) {
+			const needle = escapeRegExp(query.q);
+			filter.$or = [{ url: {
+				$regex: needle,
+				$options: "i"
+			} }, { description: {
+				$regex: needle,
+				$options: "i"
+			} }];
+		}
+		return filter;
+	}
+	/**
+	* {@inheritDoc IWebhookStore.listPage}
+	*
+	* Query native : `find(filter).sort(…).skip().limit(limit+1)` — une page,
+	* jamais la collection. Le `limit + 1` donne `hasNext` sans compter.
+	*
+	* Le tri demandé est **traduit** avant de descendre : au repos, l'endpoint n'a
+	* pas de champ `id` (l'identifiant EST le `_id`), et Mongo ne se plaint pas
+	* d'un tri sur un champ absent — il rend un ordre arbitraire. Sans traduction,
+	* un `?order=id` serait donc inerte ici et correct partout ailleurs. À défaut
+	* d'`order`, l'ordre par défaut `createdAt DESC, _id ASC` reste déterministe.
+	*/
+	async listPage(query) {
+		assertPageQuery(query, "offset");
+		const limit = Math.max(1, Math.floor(query.limit));
+		const offset = Math.max(0, Math.floor(query.offset ?? 0));
+		const model = this.#nativeModel();
+		const filter = this.#listFilter(query);
+		const order = mongoOrder(query.order, this.sortableFields, WEBHOOK_DEFAULT_ORDER);
+		const docs = await model.find(filter).sort(toMongoSort(order)).skip(offset).limit(limit + 1).exec();
+		const hasNext = docs.length > limit;
+		return {
+			items: (hasNext ? docs.slice(0, limit) : docs).map((doc) => this.#toEndpoint(doc.toObject({ virtuals: true }))),
+			total: query.withTotal === false ? void 0 : await model.countDocuments(filter).exec(),
+			limit,
+			offset,
+			hasNext
+		};
+	}
+	/** {@inheritDoc IWebhookStore.countEndpoints} */
+	async countEndpoints(query) {
+		return this.#nativeModel().countDocuments(this.#listFilter(query)).exec();
+	}
+};
+//#endregion
+export { MongooseWebhookStore };