@nodefony/mongoose 10.0.0-alpha.1

package/dist/nodefony/src/SessionStorage.js

@@ -0,0 +1,241 @@
+import { SESSION_CONNECTOR } from "../entity/sessionEntity.js";
+import { assertPageQuery, pickOrder, renameOrderFields } from "nodefony";
+import { ormRegistry, paginate } from "@nodefony/orm-core";
+import { SESSION_COLUMN_ALIASES, SESSION_DEFAULT_ORDER, SESSION_SORTABLE_FIELDS, SessionsService } from "@nodefony/http";
+//#region nodefony/src/SessionStorage.ts
+/**
+* Stockage de session **Mongoose** (driver NoSQL), branché sur `@nodefony/orm-core`.
+*
+* Implémente le contrat {@link ISessionStorage} consommé par le `SessionsService`
+* de `@nodefony/http` — store de session portable. Persiste via le repository
+* orm-core de l'entité `session` (connecteur `nodefony`, modèle compilé au boot
+* par `MongooseOrm`). Logique **identique** au store Drizzle (timestamps en ms,
+* GC via l'opérateur riche portable `$lt`) — la portabilité du contrat orm-core.
+*/
+var SessionStorage = class SessionStorage {
+	manager;
+	idleTimeoutS;
+	absoluteTimeoutS;
+	/**
+	* Même vocabulaire public que les autres backends — le tri part dans le
+	* `sort()` Mongo, où il ne coûte qu'un index.
+	*/
+	sortableFields = SESSION_SORTABLE_FIELDS;
+	constructor(manager) {
+		this.manager = manager;
+		this.idleTimeoutS = manager.options.idleTimeoutS;
+		this.absoluteTimeoutS = manager.options.absoluteTimeoutS;
+	}
+	/**
+	* Repository de l'entité session, ou `null` si l'ORM n'est pas (ou plus)
+	* connecté.
+	*
+	* Pendant le shutdown du kernel, `MongooseService` déconnecte l'ORM alors que
+	* des requêtes peuvent encore être en vol (firewall → `startSession`). On
+	* renvoie `null` et chaque opération dégrade gracieusement (session non
+	* persistée le temps de l'arrêt) plutôt que de jeter (500 + `unhandledRejection`
+	* via le GC fire-and-forget). Une table absente sur un ORM **connecté** (vraie
+	* misconfig) jette toujours via `getRepository`.
+	*/
+	#repo() {
+		const orm = ormRegistry.get(SESSION_CONNECTOR);
+		if (!orm.isConnected()) return null;
+		return orm.getRepository("session");
+	}
+	async read(id) {
+		const criteria = { session_id: id };
+		const repo = this.#repo();
+		if (!repo) return {};
+		const row = await repo.findOne(criteria);
+		if (!row) return {};
+		return {
+			Attributes: row.Attributes ?? {},
+			metaBag: row.metaBag ?? {},
+			flashBag: row.flashBag ?? {},
+			user: row.user ?? "",
+			createdAt: new Date(row.createdAt),
+			updatedAt: new Date(row.updatedAt)
+		};
+	}
+	async start(id) {
+		return this.read(id);
+	}
+	async write(id, data) {
+		const serialize = data;
+		const now = Date.now();
+		const repo = this.#repo();
+		if (!repo) return {
+			...serialize,
+			createdAt: new Date(now),
+			updatedAt: new Date(now)
+		};
+		const fields = {
+			Attributes: serialize.Attributes,
+			flashBag: serialize.flashBag,
+			metaBag: serialize.metaBag,
+			user: serialize.user || null,
+			updatedAt: now
+		};
+		const row = await repo.upsert({ session_id: id }, fields, { createdAt: now });
+		return {
+			...serialize,
+			createdAt: new Date(row.createdAt),
+			updatedAt: new Date(now)
+		};
+	}
+	async open() {
+		await this.gc();
+		const repo = this.#repo();
+		if (!repo) return 0;
+		const count = await repo.count();
+		this.manager.log(`MONGOOSE SESSIONS STORAGE ==> COUNT SESSIONS : ${count}`, "INFO");
+		return count;
+	}
+	close() {
+		this.gc();
+		return true;
+	}
+	async destroy(id) {
+		const criteria = { session_id: id };
+		const repo = this.#repo();
+		if (!repo) return true;
+		await repo.delete(criteria);
+		this.manager.log(`MONGOOSE DESTROY SESSION ID : ${id}`, "DEBUG");
+		return true;
+	}
+	async gc(idleSeconds, absoluteSeconds) {
+		const repo = this.#repo();
+		if (!repo) return;
+		const now = Date.now();
+		const idleCutoff = now - (idleSeconds ?? this.idleTimeoutS) * 1e3;
+		let deleted = await repo.delete({ updatedAt: { $lt: idleCutoff } });
+		const absoluteS = absoluteSeconds ?? this.absoluteTimeoutS;
+		if (absoluteS > 0) deleted += await repo.delete({ createdAt: { $lt: now - absoluteS * 1e3 } });
+		if (deleted > 0) this.manager.log(`MONGOOSE SESSIONS GC ==> ${deleted} DELETED`, "DEBUG");
+	}
+	/**
+	* Prolonge l'idle d'une session (timeout glissant) : `updateOne updatedAt = now`
+	* sur `session_id` — SANS réécrire le blob (touch NIST/OWASP). N'affecte pas
+	* `createdAt` (= borne absolute). ORM déconnecté → no-op ; ligne absente →
+	* no-op silencieux. Parité avec le store Drizzle.
+	*/
+	async touch(id) {
+		const repo = this.#repo();
+		if (!repo) return;
+		await repo.updateOne({ session_id: id }, { updatedAt: Date.now() });
+	}
+	/**
+	* Énumération admin (capacité optionnelle d'`ISessionStorage`) — `find` projeté,
+	* filtrable par `user`. **Redaction par construction** : seuls `user`/`metaBag`/
+	* timestamps sortent de la base ; `Attributes`/`flashBag` (potentiellement
+	* sensibles) restent en base. ORM déconnecté → `[]`. Strictement identique au
+	* store Drizzle (parité du contrat orm-core).
+	*/
+	async listAll(filter) {
+		const repo = this.#repo();
+		if (!repo) return [];
+		return (filter?.user !== void 0 ? await repo.find({ user: filter.user }) : await repo.find()).map((row) => SessionStorage.#toRecord(row));
+	}
+	/**
+	* Projette un document en {@link ISessionRecord} **redacté** : `Attributes` et
+	* `flashBag` restent en base, seuls `user`/`metaBag`/horodatages sortent. Une
+	* session anonyme est stockée `user = null` (cf `write`) et ressort en chaîne
+	* vide — la représentation du « pas d'utilisateur » appartient au backend.
+	*/
+	static #toRecord(row) {
+		return {
+			id: row.session_id,
+			data: {
+				Attributes: {},
+				flashBag: {},
+				metaBag: row.metaBag ?? {},
+				user: row.user ?? "",
+				createdAt: new Date(row.createdAt),
+				updatedAt: new Date(row.updatedAt)
+			}
+		};
+	}
+	/**
+	* Traduit les filtres du contrat en `Criteria` orm-core — **portables** (égalité
+	* + test de nullité), donc poussés dans le `find` Mongo et jamais ré-appliqués
+	* en mémoire. Source unique du périmètre de {@link listPage},
+	* {@link countSessions} et {@link countDistinctUsers}.
+	*
+	* Les deux filtres portent la **même** propriété (`authenticated` signifie
+	* « `user` non nul »). Quand ils se contredisent — un identifiant nommé qu'on
+	* demande anonyme, ou l'inverse — la réponse honnête est l'ensemble vide, et
+	* c'est ce que dit `null`. Parité stricte avec le store Drizzle et le store
+	* mémoire, qui appliquent les deux conditions.
+	*
+	* @returns `undefined` (aucun filtre), le critère, ou **`null`** si les
+	*   filtres sont contradictoires.
+	*/
+	static #criteria(query) {
+		if (!query) return void 0;
+		const { user, authenticated } = query;
+		if (user !== void 0) {
+			const anonymous = user === "";
+			if (authenticated !== void 0 && authenticated === anonymous) return null;
+			return { user: anonymous ? { $null: true } : user };
+		}
+		if (authenticated !== void 0) return { user: { $null: !authenticated } };
+	}
+	/**
+	* Pagination **native** `skip/limit` + `countDocuments` (helper `paginate`
+	* orm-core) : une page = une requête bornée, quel que soit le volume en base.
+	* Ordre `updatedAt` DESC départagé par `session_id` — déterministe à horodatage
+	* égal. ORM déconnecté → page vide. Parité stricte avec le store Drizzle.
+	*/
+	async listPage(query) {
+		assertPageQuery(query, "offset");
+		const repo = this.#repo();
+		if (!repo) return {
+			items: [],
+			total: query.withTotal === false ? void 0 : 0,
+			limit: query.limit,
+			offset: query.offset ?? 0,
+			hasNext: false
+		};
+		const criteria = SessionStorage.#criteria(query);
+		if (criteria === null) return {
+			items: [],
+			total: query.withTotal === false ? void 0 : 0,
+			limit: query.limit,
+			offset: query.offset ?? 0,
+			hasNext: false
+		};
+		const page = await paginate(repo, {
+			criteria,
+			limit: query.limit,
+			offset: query.offset,
+			withTotal: query.withTotal,
+			order: renameOrderFields(pickOrder(query.order, this.sortableFields, SESSION_DEFAULT_ORDER), SESSION_COLUMN_ALIASES)
+		});
+		return {
+			...page,
+			items: page.items.map((row) => SessionStorage.#toRecord(row))
+		};
+	}
+	/** `countDocuments` natif filtré — aucun document matérialisé. Déconnecté → 0. */
+	async countSessions(query) {
+		const repo = this.#repo();
+		if (!repo) return 0;
+		const criteria = SessionStorage.#criteria(query);
+		return criteria === null ? 0 : repo.count(criteria);
+	}
+	/**
+	* Utilisateurs distincts, agrégés côté serveur. Les sessions anonymes portent
+	* un `user` nul ou absent : l'agrégation les écarte, elles ne comptent donc
+	* pas pour un utilisateur. Déconnecté → 0 (même dégradation que
+	* {@link countSessions}).
+	*/
+	async countDistinctUsers(query) {
+		const repo = this.#repo();
+		if (!repo) return 0;
+		const criteria = SessionStorage.#criteria(query);
+		return criteria === null ? 0 : repo.countDistinct("user", criteria);
+	}
+};
+SessionsService.registerStorage("mongoose", SessionStorage);
+//#endregion
+export { SessionStorage as default };

package/dist/nodefony/src/mongoOrder.js

@@ -0,0 +1,49 @@
+import { pickOrder, renameOrderFields } from "nodefony";
+//#region nodefony/src/mongoOrder.ts
+/**
+* **La** table d'alias du dialecte Mongo — `id` public → `_id` au repos.
+*
+* Elle vit ici, chez l'adapter qui possède la convention, et non dans le
+* vocabulaire de chaque ressource : ce n'est pas une propriété des jetons ni des
+* endpoints, c'est une propriété de **Mongo**, où la clé primaire s'appelle
+* `_id` et où aucun champ `id` n'existe au repos (`id` n'est qu'un virtuel de
+* lecture). Trois copies de cette même règle vivaient auparavant dans trois
+* fichiers de vocabulaire, une par ressource.
+*
+* Ce que la traduction évite : Mongo ne se plaint **pas** d'un tri sur un champ
+* absent — il rend les documents dans un ordre arbitraire. Sans elle, un
+* `?order=id` serait donc silencieusement inerte sur Mongo et correct partout
+* ailleurs, et l'écart ne se verrait qu'en production, chez un tiers.
+*/
+const MONGO_ORDER_ALIASES = { id: "_id" };
+/**
+* Borne un `order` reçu à ce que le store DÉCLARE savoir trier, puis l'exprime
+* dans le schéma Mongo — les deux gestes que tout store Mongo doit faire, dans
+* cet ordre, avant de descendre le tri au driver.
+*
+* L'ordre compte : filtrer d'abord (sur le vocabulaire **public**, celui que le
+* store annonce), traduire ensuite. L'inverse comparerait des noms de colonnes à
+* une liste de noms publics, et laisserait passer ce qu'elle est censée refuser.
+*
+* @param order - l'ordre demandé, en vocabulaire public.
+* @param sortable - ce que le store déclare ({@link ISortableSource}).
+* @param fallback - l'ordre contractuel appliqué à défaut, en vocabulaire public.
+* @returns l'ordre prêt pour `.sort()` / `paginate()`, en noms de champs Mongo.
+*/
+function mongoOrder(order, sortable, fallback) {
+	return renameOrderFields(pickOrder(order, sortable ?? [], fallback), MONGO_ORDER_ALIASES);
+}
+/**
+* Forme `{ champ: 1 | -1 }` attendue par `Model.sort()` — le dernier maillon,
+* pour les stores qui parlent au driver Mongo directement plutôt que par
+* `paginate()`.
+*
+* @param order - un ordre déjà borné et traduit (sortie de {@link mongoOrder}).
+*/
+function toMongoSort(order) {
+	const sort = {};
+	for (const [field, dir] of order) sort[field] = dir === "DESC" ? -1 : 1;
+	return sort;
+}
+//#endregion
+export { MONGO_ORDER_ALIASES, mongoOrder, toMongoSort };