@nodefony/user 10.0.0-alpha.1

package/dist/nodefony/src/InMemoryUserRepository.js

@@ -0,0 +1,230 @@
+import { BaseUser } from "./BaseUser.js";
+import { USER_DEFAULT_ORDER, USER_SORTABLE_FIELDS_IN_MEMORY } from "./userSort.js";
+import { attachExtraColumns } from "./userContract.js";
+import { randomUUID } from "node:crypto";
+import { assertPageQuery, compareByOrder } from "nodefony";
+//#region nodefony/src/InMemoryUserRepository.ts
+/**
+* Annuaire d'utilisateurs **en mémoire** — implémentation de référence du contrat
+* {@link IUserRepository} sur une `Map` (aucun ORM).
+*
+* Trois usages :
+* - **tests de charge** : zéro I/O (pas de sync SQLite) → la mesure n'est pas
+*   polluée par la persistance ;
+* - **scripts / tests manuels** : démarrer sans base de données ;
+* - **fixture de banc** déterministe (l'état est reconstruit à chaque boot).
+*
+* La persistance réelle (`@nodefony/drizzle` / `@nodefony/mongoose`) prend ce rôle
+* en application — **même contrat, zéro changement en aval** (`UserService`,
+* authenticators). Branché sous `UserService` comme n'importe quel repository.
+*/
+var InMemoryUserRepository = class {
+	#store = /* @__PURE__ */ new Map();
+	/**
+	* Capacité RÉELLE de cet annuaire : `BaseUser` ne porte ni `createdAt` ni
+	* `updatedAt`, donc ils ne sont pas annoncés. Le data plane refuse alors ces
+	* champs en 400 au lieu de rendre un ordre arbitraire.
+	*/
+	sortableFields = USER_SORTABLE_FIELDS_IN_MEMORY;
+	/**
+	* @param seed - comptes initiaux (identité + rôles + hash de mot de passe
+	*   éventuel). Hacher en amont (hash pré-calculé) évite tout coût CPU au boot.
+	*/
+	constructor(seed = []) {
+		for (const options of seed) {
+			const user = new BaseUser(options);
+			this.#store.set(user.id, user);
+		}
+	}
+	#match(user, criteria) {
+		if (!criteria) return true;
+		return Object.entries(criteria).every(([key, value]) => user[key] === value);
+	}
+	find(criteria) {
+		return Promise.resolve([...this.#store.values()].filter((u) => this.#match(u, criteria)));
+	}
+	findOne(criteria) {
+		return Promise.resolve([...this.#store.values()].find((u) => this.#match(u, criteria)) ?? null);
+	}
+	create(data) {
+		const d = data;
+		const user = new BaseUser({
+			id: randomUUID(),
+			identifier: d.identifier,
+			roles: d.roles ? [...d.roles] : [],
+			password: d.password ?? null,
+			socialProviders: d.socialProviders,
+			enabled: d.enabled,
+			locked: d.locked
+		});
+		this.#store.set(user.id, user);
+		return Promise.resolve(attachExtraColumns(user, data));
+	}
+	updateOne(criteria, data) {
+		const user = [...this.#store.values()].find((u) => this.#match(u, criteria));
+		if (!user) return Promise.resolve(null);
+		this.#apply(user, data);
+		return Promise.resolve(user);
+	}
+	/**
+	* Applique un patch sur une instance, **comme le ferait un backend réel**.
+	*
+	* Le contrat d'`IRepository.updateOne` promet d'écrire « les champs à
+	* modifier » : n'en honorer qu'une partie ferait de ce dépôt un menteur
+	* silencieux — un `{ enabled: false }` semblerait réussir (l'entité est
+	* renvoyée) sans rien désactiver, alors que Drizzle et Mongoose, eux,
+	* l'appliqueraient. Un banc de charge ou un test manuel en `NF_USER_STORE=memory`
+	* n'exercerait alors pas le comportement de production.
+	*
+	* `enabled`/`locked` sont `protected` sur {@link BaseUser} (l'état de compte
+	* s'exprime par des verbes) → on passe par ses méthodes plutôt que de forcer
+	* l'accès. `id` et `identifier` sont `readonly` : sur ce backend l'entité EST
+	* l'instance, sa clé n'est pas réécrivable — les ignorer est plus honnête que
+	* de muter un champ déclaré immuable.
+	*/
+	#apply(user, data) {
+		const d = data;
+		if ("password" in d) user.password = d.password ?? null;
+		if (d.roles) user.roles = [...d.roles];
+		if (d.socialProviders) user.socialProviders = [...d.socialProviders];
+		if (d.metadata) user.metadata = { ...d.metadata };
+		if ("currentRole" in d) user.currentRole = d.currentRole ?? null;
+		if (d.enabled !== void 0) {
+			if (d.enabled) user.enable();
+			else user.disable();
+		}
+		if (d.locked !== void 0) {
+			if (d.locked) user.lock();
+			else user.unlock();
+		}
+		attachExtraColumns(user, data);
+	}
+	async upsert(criteria, update, insertOnly) {
+		const updated = await this.updateOne(criteria, update);
+		if (updated) return updated;
+		return this.create({
+			...criteria,
+			...insertOnly,
+			...update
+		});
+	}
+	async createMany(data) {
+		const out = [];
+		for (const d of data) out.push(await this.create(d));
+		return out;
+	}
+	exists(criteria) {
+		return Promise.resolve([...this.#store.values()].some((u) => this.#match(u, criteria)));
+	}
+	deleteOne(criteria) {
+		for (const [id, user] of this.#store) if (this.#match(user, criteria)) {
+			this.#store.delete(id);
+			return Promise.resolve(true);
+		}
+		return Promise.resolve(false);
+	}
+	findOneAndDelete(criteria) {
+		for (const [id, user] of this.#store) if (this.#match(user, criteria)) {
+			this.#store.delete(id);
+			return Promise.resolve(user);
+		}
+		return Promise.resolve(null);
+	}
+	increment(criteria, changes) {
+		const user = [...this.#store.values()].find((u) => this.#match(u, criteria));
+		if (!user) return Promise.resolve(null);
+		const rec = user;
+		for (const [field, delta] of Object.entries(changes)) rec[field] = (rec[field] ?? 0) + delta;
+		return Promise.resolve(user);
+	}
+	async updateMany(criteria, data) {
+		const users = await this.find(criteria);
+		for (const user of users) await this.updateOne({ id: user.id }, data);
+		return users.length;
+	}
+	delete(criteria) {
+		let deleted = 0;
+		for (const [id, user] of this.#store) if (this.#match(user, criteria)) {
+			this.#store.delete(id);
+			deleted += 1;
+		}
+		return Promise.resolve(deleted);
+	}
+	async count(criteria) {
+		return (await this.find(criteria)).length;
+	}
+	/**
+	* Déduplication en mémoire — l'annuaire est déjà entièrement chargé, il n'y a
+	* donc pas de parcours à éviter comme en SQL. `null`/`undefined` sont écartés
+	* pour tenir la même sémantique que `COUNT(DISTINCT col)`.
+	*/
+	async countDistinct(field, criteria) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const user of await this.find(criteria)) {
+			const value = user[field];
+			if (value !== null && value !== void 0) seen.add(value);
+		}
+		return seen.size;
+	}
+	/** In-memory : pas de transaction — le repository est sa propre unité. */
+	withTransaction(_tx) {
+		return this;
+	}
+	findByIdentifier(identifier) {
+		return Promise.resolve([...this.#store.values()].find((u) => u.identifier === identifier) ?? null);
+	}
+	findBySocialProvider(provider, providerId) {
+		return Promise.resolve([...this.#store.values()].find((u) => u.socialProviders.some((s) => s.provider === provider && s.providerId === providerId)) ?? null);
+	}
+	/**
+	* {@inheritDoc IUserRepository.listPage}
+	*
+	* In-memory : la collection est déjà en RAM (bornée par conception), donc le
+	* filtrage/tri/slice se fait sur la structure — pas de matérialisation
+	* supplémentaire. `total` gratuit (longueur du filtré) sauf `withTotal: false`.
+	*/
+	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 q = query.q?.toLowerCase();
+		let filtered = [...this.#store.values()];
+		if (query.role !== void 0) filtered = filtered.filter((u) => u.roles.includes(query.role));
+		if (query.enabled !== void 0) filtered = filtered.filter((u) => u.isActive() === query.enabled);
+		if (query.locked !== void 0) filtered = filtered.filter((u) => u.isLocked() === query.locked);
+		if (query.hasSocial !== void 0) filtered = filtered.filter((u) => u.socialProviders.length > 0 === query.hasSocial);
+		if (q !== void 0 && q.length > 0) filtered = filtered.filter((u) => u.identifier.toLowerCase().includes(q));
+		const order = query.order?.length ? query.order : USER_DEFAULT_ORDER;
+		filtered.sort(compareByOrder(order, (u, field) => u[field]));
+		const items = filtered.slice(offset, offset + limit);
+		const total = query.withTotal === false ? void 0 : filtered.length;
+		return Promise.resolve({
+			items,
+			total,
+			limit,
+			offset,
+			hasNext: offset + items.length < filtered.length
+		});
+	}
+	/** {@inheritDoc IUserRepository.countActiveAdmins} */
+	/**
+	* {@inheritDoc IUserRepository.countUsers}
+	*
+	* Réutilise `listPage` avec une fenêtre nulle : le filtrage est écrit une
+	* seule fois, donc compter et lister ne peuvent pas diverger.
+	*/
+	async countUsers(query) {
+		return (await this.listPage({
+			...query,
+			limit: 1,
+			offset: 0
+		})).total ?? 0;
+	}
+	countActiveAdmins(adminRole) {
+		let count = 0;
+		for (const u of this.#store.values()) if (u.isActive() && u.roles.includes(adminRole)) count += 1;
+		return Promise.resolve(count);
+	}
+};
+//#endregion
+export { InMemoryUserRepository, InMemoryUserRepository as default };