@nodefony/mongoose 10.0.0-alpha.1

package/dist/nodefony/src/orm-core/MongooseRepository.js

@@ -0,0 +1,300 @@
+import { RequestContext, redactSecrets } from "nodefony";
+import { UnknownCriteriaField, assertOrderOption, isFieldOperators, isUpdateOperators, likePatternToRegExp, queryFlowMonitor } from "@nodefony/orm-core";
+//#region nodefony/src/orm-core/MongooseRepository.ts
+/**
+* Repository portable (contrat {@link IRepository}) au-dessus d'un modèle Mongoose.
+*
+* Démontre la portabilité du contrat sur un **store documentaire hétérogène** :
+* - `options.relations` → `populate()` (virtuels/refs déclarés), pas `include` ;
+* - **clé primaire `_id`** (MongoDB) ↔ `id` (contrat) : le critère `{ id }` est
+*   traduit en `{ _id }`, et la sortie (`toObject({ virtuals: true })`) porte le
+*   virtuel `id` (string hex de l'ObjectId) → contrat `id: string` respecté ;
+* - liaison transactionnelle via {@link MongooseRepository.withTransaction}
+*   (`{ session }` sur toutes les ops ; requiert un replica set).
+*
+* @typeParam T - forme plate de l'entité gérée.
+*/
+var MongooseRepository = class MongooseRepository {
+	#model;
+	#session;
+	/** Connecteur ORM (clé du registre) — tag des métriques de flux. */
+	#connector;
+	/**
+	* @param model - modèle Mongoose compilé.
+	* @param connector - nom de la connexion (clé du registre) — défaut `"nodefony"`.
+	* @param session - session transactionnelle à laquelle lier les ops (ou `null`).
+	*/
+	constructor(model, connector = "nodefony", session = null) {
+		this.#model = model;
+		this.#connector = connector;
+		this.#session = session;
+	}
+	/**
+	* Tap dev-only : mesure la durée d'une opération et alimente **deux** sondes
+	* complémentaires (sans surcoût quand les deux sont inactives — flags lus avant
+	* toute allocation, prod = coût nul) :
+	*  1. **profiler par-requête** (buffer de scope ALS, debug bar) — descripteur
+	*     de CHAQUE opération tracée ;
+	*  2. **flux ORM agrégé** ({@link queryFlowMonitor}, process-wide) — débit +
+	*     latence ; le descripteur n'est sérialisé que sur le chemin **lent** (rare).
+	*
+	* @param descr - fabrique du descripteur (collection.op + filtre redacté) —
+	*   thunk : jamais évalué hors observation.
+	* @param exec - exécution de l'opération.
+	* @param rowsOf - extraction du nombre de documents (optionnel).
+	*/
+	async #prof(descr, exec, rowsOf) {
+		const buf = RequestContext.get()?.queries;
+		const flow = queryFlowMonitor.enabled;
+		if (!buf && !flow) return exec();
+		const start = performance.now();
+		const result = await exec();
+		const durationMs = performance.now() - start;
+		if (flow) {
+			const q = durationMs >= queryFlowMonitor.slowMs ? descr() : void 0;
+			queryFlowMonitor.record(this.#connector, durationMs, q);
+		}
+		if (buf) buf.push({
+			sql: descr(),
+			startMs: start,
+			durationMs,
+			rows: rowsOf?.(result),
+			connector: "mongoose"
+		});
+		return result;
+	}
+	/** Descripteur compact `Model.op {filtre}` (redacté + tronqué) pour les sondes. */
+	#descr(op, filter) {
+		const tail = filter !== void 0 ? ` ${JSON.stringify(filter)}` : "";
+		const s = `${this.#model.modelName}.${op}${tail}`;
+		return redactSecrets(s.length > 2e3 ? `${s.slice(0, 2e3)}…` : s);
+	}
+	/**
+	* Traduit les opérateurs riches portables en opérateurs MongoDB.
+	*
+	* Quasi-identité : `$gt`/`$in`/`$nin`/`$ne`/`$eq`/`$lt`... sont natifs Mongo ;
+	* `$like` (motif SQL) devient `$regex`, et `$null` une comparaison à `null`
+	* (`$eq`/`$ne`) — en Mongo `null` matche aussi le champ **absent**, ce qui est
+	* bien l'équivalent du `NULL` SQL (colonne sans valeur).
+	*
+	* @throws Error si `$null` est combiné à `$eq`/`$ne` sur le même champ : les
+	*   deux viseraient la même clé Mongo et l'une écraserait l'autre **en
+	*   silence** (le contrat les déclare exclusifs — cf `FieldOperators.$null`).
+	*/
+	#mongoOps(ops) {
+		const out = {};
+		for (const [key, value] of Object.entries(ops)) if (key === "$like") out.$regex = likePatternToRegExp(value);
+		else if (key === "$null") {
+			const target = value ? "$eq" : "$ne";
+			if (target in out) throw new Error(`criteria: $null ne se combine pas avec ${target} sur le même champ (${this.#model.modelName})`);
+			out[target] = null;
+		} else if ((key === "$eq" || key === "$ne") && key in out) throw new Error(`criteria: $null ne se combine pas avec ${key} sur le même champ (${this.#model.modelName})`);
+		else out[key] = value;
+		return out;
+	}
+	/**
+	* Valide qu'un champ de critère existe sur le schéma (strict B2, parité
+	* Drizzle) et renvoie sa clé Mongo (`id` → `_id`, PK). Un champ inconnu lève
+	* {@link UnknownCriteriaField} au lieu d'être passé tel quel à Mongo (qui
+	* donnait 0 résultat silencieux — et divergeait de Drizzle qui, lui, renvoyait
+	* tout). Échoue tôt et pareil sur les deux drivers.
+	*
+	* @param field - clé brute du critère.
+	* @returns la clé Mongo résolue.
+	* @throws UnknownCriteriaField si le champ n'existe pas sur le schéma.
+	*/
+	#resolveField(field) {
+		const key = field === "id" ? "_id" : field;
+		const paths = this.#model.schema.paths;
+		if (key === "_id" || paths[key] !== void 0 || paths[key.split(".")[0]] !== void 0) return key;
+		throw new UnknownCriteriaField(field, this.#model.modelName, Object.keys(paths));
+	}
+	/**
+	* Traduit le critère portable : `id` → `_id` (PK MongoDB) + opérateurs riches.
+	* Chaque champ est validé contre le schéma (strict, cf {@link MongooseRepository.#resolveField}).
+	*/
+	#filter(criteria) {
+		if (!criteria) return {};
+		const out = {};
+		for (const [field, value] of Object.entries(criteria)) {
+			if (field === "$or") {
+				if (!Array.isArray(value)) throw new TypeError(`MongooseRepository(${this.#model.modelName}): $or attend un tableau de critères.`);
+				const branches = value.map((branch) => this.#filter(branch)).filter((f) => Object.keys(f).length > 0);
+				if (branches.length > 0) out.$or = branches;
+				continue;
+			}
+			const key = this.#resolveField(field);
+			out[key] = isFieldOperators(value) ? this.#mongoOps(value) : value;
+		}
+		return out;
+	}
+	/** Sérialise un document en objet plat (virtuels inclus → `id`, populates). */
+	#plain(doc) {
+		return doc.toObject({ virtuals: true });
+	}
+	async find(criteria, options) {
+		assertOrderOption(options?.order, this.#model.modelName);
+		const filter = this.#filter(criteria);
+		return this.#prof(() => this.#descr("find", filter), async () => {
+			let query = this.#model.find(filter);
+			if (this.#session) query = query.session(this.#session);
+			if (options?.relations?.length) query = query.populate(options.relations);
+			if (options?.offset !== void 0) query = query.skip(options.offset);
+			if (options?.limit !== void 0) query = query.limit(options.limit);
+			if (options?.order?.length) query = query.sort(Object.fromEntries(options.order.map(([field, dir]) => [field, dir === "DESC" ? -1 : 1])));
+			return (await query.exec()).map((doc) => this.#plain(doc));
+		}, (docs) => docs.length);
+	}
+	async findOne(criteria, options) {
+		assertOrderOption(options?.order, this.#model.modelName);
+		const filter = this.#filter(criteria);
+		return this.#prof(() => this.#descr("findOne", filter), async () => {
+			let query = this.#model.findOne(filter);
+			if (this.#session) query = query.session(this.#session);
+			if (options?.relations?.length) query = query.populate(options.relations);
+			if (options?.order?.length) query = query.sort(Object.fromEntries(options.order.map(([field, dir]) => [field, dir === "DESC" ? -1 : 1])));
+			const doc = await query.exec();
+			return doc ? this.#plain(doc) : null;
+		}, (doc) => doc ? 1 : 0);
+	}
+	async create(data) {
+		return this.#prof(() => this.#descr("create"), async () => {
+			const [doc] = await this.#model.create([data], { session: this.#session ?? void 0 });
+			return this.#plain(doc);
+		}, () => 1);
+	}
+	async createMany(data) {
+		if (data.length === 0) return [];
+		return this.#prof(() => this.#descr("insertMany"), async () => {
+			return (await this.#model.insertMany(data, { session: this.#session ?? void 0 })).map((doc) => this.#plain(doc));
+		}, (rows) => rows.length);
+	}
+	async updateOne(criteria, data) {
+		const filter = this.#filter(criteria);
+		return this.#prof(() => this.#descr("findOneAndUpdate", filter), async () => {
+			const doc = await this.#model.findOneAndUpdate(filter, data, {
+				returnDocument: "after",
+				session: this.#session ?? void 0
+			}).exec();
+			return doc ? this.#plain(doc) : null;
+		}, (doc) => doc ? 1 : 0);
+	}
+	async upsert(criteria, update, insertOnly) {
+		const filter = this.#filter(criteria);
+		return this.#prof(() => this.#descr("findOneAndUpdate", filter), async () => {
+			const doc = await this.#model.findOneAndUpdate(filter, {
+				...this.#writeDoc(update),
+				$setOnInsert: insertOnly ?? {}
+			}, {
+				upsert: true,
+				returnDocument: "after",
+				session: this.#session ?? void 0
+			}).exec();
+			if (!doc) throw new Error("MongooseRepository.upsert: aucun document retourné");
+			return this.#plain(doc);
+		}, () => 1);
+	}
+	/**
+	* Traduit le `update` d'un upsert en document de mise à jour Mongo : les
+	* valeurs nues vont dans `$set`, les {@link UpdateOperators} dans l'opérateur
+	* natif de même nom (`$max`/`$min`).
+	*
+	* Mongo fait exactement ce qu'on attend : il n'écrit que si la valeur proposée
+	* est supérieure (resp. inférieure) à celle en base, et la pose telle quelle à
+	* l'insertion — donc pas de `$setOnInsert` à doubler. Pendant exact du
+	* `GREATEST(col, ?)` des adapters SQL.
+	*/
+	#writeDoc(update) {
+		const $set = {};
+		const ops = {};
+		for (const [field, value] of Object.entries(update)) {
+			if (!isUpdateOperators(value)) {
+				$set[this.#resolveField(field)] = value;
+				continue;
+			}
+			const key = this.#resolveField(field);
+			if (value.$max !== void 0) (ops.$max ??= {})[key] = value.$max;
+			if (value.$min !== void 0) (ops.$min ??= {})[key] = value.$min;
+		}
+		return Object.keys($set).length > 0 ? {
+			$set,
+			...ops
+		} : ops;
+	}
+	async updateMany(criteria, data) {
+		const filter = this.#filter(criteria);
+		return this.#prof(() => this.#descr("updateMany", filter), async () => {
+			return (await this.#model.updateMany(filter, data, { session: this.#session ?? void 0 })).modifiedCount ?? 0;
+		}, (n) => n);
+	}
+	async increment(criteria, changes) {
+		const filter = this.#filter(criteria);
+		return this.#prof(() => this.#descr("findOneAndUpdate", filter), async () => {
+			const doc = await this.#model.findOneAndUpdate(filter, { $inc: changes }, {
+				returnDocument: "after",
+				session: this.#session ?? void 0
+			}).exec();
+			return doc ? this.#plain(doc) : null;
+		}, (doc) => doc ? 1 : 0);
+	}
+	async delete(criteria) {
+		const filter = this.#filter(criteria);
+		return this.#prof(() => this.#descr("deleteMany", filter), async () => {
+			return (await this.#model.deleteMany(filter, { session: this.#session ?? void 0 })).deletedCount ?? 0;
+		}, (n) => n);
+	}
+	async deleteOne(criteria) {
+		const filter = this.#filter(criteria);
+		return this.#prof(() => this.#descr("deleteOne", filter), async () => {
+			return ((await this.#model.deleteOne(filter, { session: this.#session ?? void 0 })).deletedCount ?? 0) > 0;
+		}, (ok) => ok ? 1 : 0);
+	}
+	async findOneAndDelete(criteria) {
+		const filter = this.#filter(criteria);
+		return this.#prof(() => this.#descr("findOneAndDelete", filter), async () => {
+			const doc = await this.#model.findOneAndDelete(filter, { session: this.#session ?? void 0 }).exec();
+			return doc ? this.#plain(doc) : null;
+		}, (doc) => doc ? 1 : 0);
+	}
+	async count(criteria) {
+		const filter = this.#filter(criteria);
+		return this.#prof(() => this.#descr("countDocuments", filter), () => this.#model.countDocuments(filter, { session: this.#session ?? void 0 }));
+	}
+	/**
+	* `COUNT(DISTINCT …)` en agrégation — `$group` puis `$count`, donc la
+	* déduplication reste dans le serveur. `Model.distinct()` aurait rapatrié
+	* toutes les valeurs pour n'en mesurer que la longueur.
+	*
+	* `{$ne: null}` écarte à la fois la valeur nulle et le champ absent, ce qui
+	* aligne le résultat sur le `COUNT(DISTINCT col)` SQL — sans lui, les
+	* documents sans valeur formeraient un groupe `null` compté comme une valeur.
+	*/
+	async countDistinct(field, criteria) {
+		const filter = this.#filter(criteria);
+		const path = this.#resolveField(field);
+		return this.#prof(() => this.#descr("countDistinct", filter), async () => {
+			const pipeline = [
+				{ $match: filter },
+				{ $match: { [path]: { $ne: null } } },
+				{ $group: { _id: `$${path}` } },
+				{ $count: "n" }
+			];
+			const agg = this.#model.aggregate(pipeline);
+			if (this.#session) agg.session(this.#session);
+			return (await agg.exec())[0]?.n ?? 0;
+		});
+	}
+	async exists(criteria) {
+		const filter = this.#filter(criteria);
+		return this.#prof(() => this.#descr("exists", filter), async () => {
+			const q = this.#model.exists(filter);
+			if (this.#session) q.session(this.#session);
+			return await q.exec() !== null;
+		});
+	}
+	withTransaction(tx) {
+		return new MongooseRepository(this.#model, this.#connector, tx.getNative());
+	}
+};
+//#endregion
+export { MongooseRepository };

package/dist/nodefony/src/orm-core/MongooseTransaction.js

@@ -0,0 +1,53 @@
+//#region nodefony/src/orm-core/MongooseTransaction.ts
+/**
+* Adapte une `ClientSession` MongoDB au contrat portable {@link ITransaction}.
+*
+* Obtenue dans le callback de `MongooseOrm.transaction()`, qui gère le
+* commit/abort automatique via `session.withTransaction()`. Les transactions
+* MongoDB **exigent un replica set** (un standalone ne les supporte pas).
+*
+* MongoDB n'a **pas de savepoints** : {@link MongooseTransaction.savepoint} /
+* {@link MongooseTransaction.rollbackTo} sont des no-op documentés (limite du
+* driver, prévue par le contrat).
+*/
+var MongooseTransaction = class {
+	#session;
+	#done = false;
+	/**
+	* @param session - session MongoDB transactionnelle sous-jacente.
+	*/
+	constructor(session) {
+		this.#session = session;
+	}
+	/** Indique si la transaction est déjà terminée (commit ou rollback). */
+	isDone() {
+		return this.#done;
+	}
+	/**
+	* Valide la transaction (no-op si déjà terminée — idempotent, parité avec
+	* `DrizzleTransaction`). En mode managé (défaut via `IOrm.transaction`), le
+	* commit/abort est piloté par `session.withTransaction` : un appel manuel est
+	* inutile, et l'idempotence évite un double-commit accidentel.
+	*/
+	async commit() {
+		if (this.#done) return;
+		this.#done = true;
+		await this.#session.commitTransaction();
+	}
+	/** Annule la transaction (no-op si déjà terminée — idempotent). */
+	async rollback() {
+		if (this.#done) return;
+		this.#done = true;
+		await this.#session.abortTransaction();
+	}
+	/** No-op : MongoDB ne gère pas les savepoints. */
+	async savepoint(_name) {}
+	/** No-op : MongoDB ne gère pas les savepoints. */
+	async rollbackTo(_name) {}
+	/** Expose la `ClientSession` native (trappe bas niveau). */
+	getNative() {
+		return this.#session;
+	}
+};
+//#endregion
+export { MongooseTransaction };

package/dist/nodefony/src/orm-core/index.js

@@ -0,0 +1,4 @@
+import { MongooseRepository } from "./MongooseRepository.js";
+import { MongooseTransaction } from "./MongooseTransaction.js";
+import { MongooseOrm } from "./MongooseOrm.js";
+export { MongooseOrm, MongooseRepository, MongooseTransaction };

package/dist/types/index.d.ts

@@ -0,0 +1,74 @@
+/**
+ * `@nodefony/mongoose` — module Mongoose ORM (driver NoSQL) sur `@nodefony/orm-core`.
+ *
+ * **Module bootable** : enregistré dans le manifeste `modules`, son
+ * {@link MongooseService} connecte au boot un {@link MongooseOrm} par connecteur
+ * configuré. Refonte 2026-06-08 (Ph.2 virage ORM) : ne dérive plus de l'`Orm`
+ * legacy du core — le service `extends Service` et orchestre des adapters
+ * orm-core autonomes (modèle `DrizzleService`). Le core ne connaît plus l'ORM.
+ *
+ * Config = source de vérité Zod (`nodefony/config/config.ts`), validée au boot
+ * via {@link defineMongooseConfig} (style `@nodefony/redis`/`@nodefony/realtime`).
+ */
+import mongoose from "mongoose";
+import { Kernel, Module } from "nodefony";
+import { defineMongooseConfig, mongooseConfigJsonSchema } from "./nodefony/config/defineModuleConfig.js";
+import MongooseService from "./nodefony/service/MongooseService.js";
+import type { IMongooseConfig, IMongooseConfigInput } from "./nodefony/interfaces/IMongooseConfig.js";
+declare module "nodefony" {
+    interface NodefonyModuleConfig {
+        "@nodefony/mongoose": IMongooseConfigInput;
+    }
+}
+declare class Mongoose extends Module<IMongooseConfig> {
+    /**
+     * Module **optionnel** (driver NoSQL externe, opt-in) : un échec de son boot
+     * (Mongo injoignable) ne tue jamais le process — le store de session dégrade
+     * gracieusement (`#repo()` → null). Résilience cloud-native (l'orchestrateur
+     * relèvera Mongo). Convention-frère `@nodefony/redis`.
+     */
+    static critical: boolean;
+    constructor(kernel: Kernel);
+    /** JSON Schema de la config mongoose → data plane admin (config riche Studio). */
+    configSchema(): unknown;
+    /**
+     * Valide la config (défauts + `module.options` + surcharge env) au boot via
+     * `defineMongooseConfig`, et l'expose au container sous `mongooseConfig` pour
+     * que le `MongooseService` la consomme sans redupliquer la validation. Plante
+     * propre avec messages clairs si la config est invalide (convention Zod).
+     */
+    onKernelRegister(): Promise<this>;
+    /**
+     * Monte le data plane ORM (`/nodefony/orm/api/*` + providers santé/flux) via
+     * {@link wireOrmAdminPlane} — branchement GLOBAL et idempotent factorisé en
+     * orm-core (C5), identique à Drizzle. Avant la factorisation, ce wiring était
+     * déclenché par le seul module Drizzle → une app Mongoose-only avait un Studio
+     * ORM muet ; chaque driver l'invoque désormais. En plus, enregistre l'adapter
+     * d'erreurs Mongoose (spécifique au driver, hors plan d'administration).
+     */
+    onKernelBoot(): Promise<this>;
+}
+export default Mongoose;
+export { mongoose, MongooseService };
+export { defineMongooseConfig, mongooseConfigJsonSchema };
+export { mongooseConfigSchema, type MongooseConfig, } from "./nodefony/config/config.js";
+export type { IMongooseConfig, IMongooseConfigInput, IMongooseConnectorConfig, } from "./nodefony/interfaces/IMongooseConfig.js";
+export { default as SessionStorage } from "./nodefony/src/SessionStorage.js";
+export { default as SessionEntity, sessionSchema, SESSION_CONNECTOR, } from "./nodefony/entity/sessionEntity.js";
+export type { SessionRow } from "./nodefony/entity/sessionEntity.js";
+export { MongooseOrm, MongooseRepository, MongooseTransaction, } from "./nodefony/src/orm-core/index.js";
+export type { IIndexAudit } from "./nodefony/src/orm-core/index.js";
+export { userSchema, createUserEntity, registerUserEntity, } from "./nodefony/entity/userEntity.js";
+export type { UserRow } from "./nodefony/entity/userEntity.js";
+export { MongooseUserRepository } from "./nodefony/src/MongooseUserRepository.js";
+export { accessTokenSchema, deniedJtiSchema, subjectRevocationSchema, createTokenEntities, registerTokenEntities, TOKEN_ENTITY_NAMES, } from "./nodefony/entity/tokenEntity.js";
+export type { DeniedJtiRow, SubjectRevocationRow, } from "./nodefony/entity/tokenEntity.js";
+export { MongooseTokenStore } from "./nodefony/src/MongooseTokenStore.js";
+export { webAuthnCredentialSchema, createWebAuthnCredentialEntity, registerWebAuthnCredentialEntity, WEBAUTHN_CREDENTIAL_ENTITY, } from "./nodefony/entity/webAuthnCredentialEntity.js";
+export type { WebAuthnCredentialRow } from "./nodefony/entity/webAuthnCredentialEntity.js";
+export { MongooseWebAuthnCredentialStore } from "./nodefony/src/MongooseWebAuthnCredentialStore.js";
+export { webhookEndpointSchema, createWebhookEndpointEntity, registerWebhookEndpointEntity, WEBHOOK_ENDPOINT_ENTITY, } from "./nodefony/entity/webhookEndpointEntity.js";
+export type { WebhookEndpointRow } from "./nodefony/entity/webhookEndpointEntity.js";
+export { MongooseWebhookStore } from "./nodefony/src/MongooseWebhookStore.js";
+export { registerMongooseFrameworkStores, FRAMEWORK_CONNECTOR, } from "./nodefony/registerStores.js";
+export type { IFrameworkStoresReport } from "./nodefony/registerStores.js";

package/dist/types/nodefony/config/config.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const mongooseConfigSchema: z.ZodObject<{
+    debug: z.ZodDefault<z.ZodBoolean>;
+    connectors: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        uri: z.ZodOptional<z.ZodString>;
+        host: z.ZodDefault<z.ZodString>;
+        port: z.ZodDefault<z.ZodNumber>;
+        dbname: z.ZodDefault<z.ZodString>;
+        autoIndex: z.ZodOptional<z.ZodBoolean>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    frameworkEntities: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+/** Type de sortie (config normalisée + défauts appliqués). */
+export type MongooseConfig = z.infer<typeof mongooseConfigSchema>;
+/**
+ * Défauts du module, matérialisés depuis le schéma (source unique). Toujours
+ * valides par construction ; passés au `super(..., config)` du Module class.
+ */
+declare const config: MongooseConfig;
+export default config;

package/dist/types/nodefony/config/defineModuleConfig.d.ts

@@ -0,0 +1,26 @@
+import type { IMongooseConfig, IMongooseConfigInput } from "../interfaces/IMongooseConfig.js";
+/**
+ * Builder type-safe de la configuration de `@nodefony/mongoose`.
+ *
+ * ⭐ TL;DR : MACHINERIE DE BOOT — on n'édite (presque) jamais ce fichier. Même
+ * pattern que `nodefony.config.ts` ↔ `defineConfig()` du core : `config.ts` PORTE
+ * la config (schéma + défauts), `define<X>Config()` la VALIDE au boot (parse +
+ * env + freeze) et publie le JSON Schema Studio.
+ *
+ * Principes (alignés sur `defineRedisConfig` / `defineRealtimeConfig`) :
+ * - **Source unique** : `./config.ts` (Zod). Le builder VALIDE, applique l'ENV,
+ *   puis GÈLE — il ne dévie jamais du schéma.
+ * - **Auto-documenté** : chaque champ Zod porte un `.describe()` →
+ *   {@link mongooseConfigJsonSchema} produit un JSON Schema qu'un formulaire Studio
+ *   (futur) consommera pour générer son UI d'édition.
+ *
+ * @param config - configuration brute (sections omises = défauts sûrs).
+ * @returns config validée, surchargée par l'env, et gelée.
+ * @throws ZodError si la config est invalide.
+ */
+export declare function defineMongooseConfig(config?: IMongooseConfigInput): IMongooseConfig;
+/**
+ * JSON Schema introspectable de la config Mongoose — destiné au formulaire
+ * d'édition Studio (futur) et à la documentation générée.
+ */
+export declare function mongooseConfigJsonSchema(): unknown;

package/dist/types/nodefony/entity/sessionEntity.d.ts

@@ -0,0 +1,42 @@
+import type { SchemaDefinition } from "mongoose";
+/** ORM cible du stockage de session (connecteur par défaut du module). */
+export declare const SESSION_CONNECTOR = "nodefony";
+/**
+ * Schéma Mongoose de stockage des sessions (compilé par `MongooseOrm` au boot).
+ *
+ * Équivalent portable de l'entité session legacy : mêmes champs logiques
+ * (`session_id` PK applicative, sacs `Attributes`/`flashBag`/`metaBag`,
+ * `user`). Les horodatages sont des **nombres** (ms epoch), comme l'adapter
+ * Drizzle, pour que `SessionStorage` reste strictement portable entre les ORM
+ * (cutoff GC = `updatedAt < now - ttl`, opérateur riche `$lt` natif Mongo).
+ */
+declare const schema: SchemaDefinition;
+/** Forme plate d'une ligne de session telle que renvoyée par le repository. */
+export interface SessionRow {
+    session_id: string;
+    Attributes: unknown;
+    flashBag: unknown;
+    metaBag: unknown;
+    user: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * Entité session enregistrée dans le `entityRegistry` pour le connecteur
+ * `nodefony` — `MongooseOrm` compile le modèle à la connexion (au boot).
+ *
+ * ⚠️ **`frameworkEntities: false` ne la coupe PAS.** Ce commutateur gouverne les
+ * entités déclarées dans le flux de boot (tokens, webauthn, webhooks) ; la
+ * session, elle, s'enregistre à l'**import** de ce fichier — le décorateur
+ * `@entity` s'exécute au chargement du barrel, avant que la moindre config soit
+ * lue. Même chose pour son store (`SessionStorage.ts`, `registerStorage`).
+ *
+ * Conséquence pratique : couper `frameworkEntities` retire les autres entités,
+ * pas la collection `session`. Pour ne pas avoir de session Mongo du tout, il
+ * faut ne pas router le store session vers mongoose (`session.store`), pas
+ * baisser ce drapeau.
+ */
+declare class SessionEntity {
+}
+export default SessionEntity;
+export { schema as sessionSchema };

package/dist/types/nodefony/entity/tokenEntity.d.ts

@@ -0,0 +1,59 @@
+import type { SchemaDefinition } from "mongoose";
+import type { IEntity } from "@nodefony/orm-core";
+/**
+ * Schémas Mongoose du **store de jetons** `@nodefony/security` (pendant
+ * documentaire des tables Drizzle) — implémentation NoSQL d'`ITokenStore` (PAT,
+ * refresh, denylist `jti`, seuil de révocation en masse).
+ *
+ * ⚠️ **`_id` = clé naturelle (String), PAS un ObjectId auto** : le contrat
+ * `IRepository` traduit le critère `{ id }` en `{ _id }` (cf `MongooseRepository`).
+ * Comme l'`id` d'un jeton est un **jti fourni par l'appelant** (pas généré par
+ * Mongo), on force `_id: String` → le jti EST la clé primaire (gratuit : unique +
+ * éligible à un TTL index natif). Le virtuel `id` (activé par `MongooseOrm`,
+ * `toObject:{virtuals:true}`) renvoie `String(_id)` = le jti.
+ *
+ * ⚠️ **Horodatages = `Number` (epoch ms), `timestamps:false`** : `IAccessTokenRecord`
+ * porte des `number` (`Date.now()`) et l'appelant fournit `createdAt` → pas de
+ * gestion auto Mongoose. Le `gc()` applicatif reste portable (`$lte` exclut les
+ * `null` par type bracketing Mongo, comme Drizzle exclut `NULL`).
+ */
+export declare const accessTokenSchema: SchemaDefinition;
+/** Denylist des access tokens (`jti` = `_id`) révoqués avant leur `exp`. */
+export declare const deniedJtiSchema: SchemaDefinition;
+/** Forme plate d'une ligne de denylist (`id` = virtuel = jti). */
+export interface DeniedJtiRow {
+    id: string;
+    expiresAt: number;
+}
+/** Seuil de révocation en masse par porteur (`subjectId` = `_id`). */
+export declare const subjectRevocationSchema: SchemaDefinition;
+/** Forme plate d'une ligne de révocation par porteur (`id` = virtuel = subjectId). */
+export interface SubjectRevocationRow {
+    id: string;
+    invalidBefore: number;
+}
+/** Noms logiques des entités du store (clés de lookup `getRepository`). */
+export declare const TOKEN_ENTITY_NAMES: {
+    readonly records: "access_token";
+    readonly denied: "denied_jti";
+    readonly revocations: "subject_revocation";
+};
+/**
+ * Construit les descripteurs d'entités du store de jetons pour un ORM nommé.
+ *
+ * Le `connector` est **dynamique** (nom du connecteur de l'app, ex. `"nodefony"`) : les
+ * schémas sont statiques mais leur liaison à un ORM dépend de la config → pas
+ * d'`@entity` figé (parité `createUserEntity`). `timestamps:false` (l'appelant
+ * gère `createdAt`). À enregistrer **avant** `orm.connect()`.
+ *
+ * @param orm - clé de l'ORM cible dans le `ormRegistry`.
+ * @returns les trois descripteurs {@link IEntity} (records / denylist / seuils).
+ */
+export declare function createTokenEntities(connector: string): IEntity[];
+/**
+ * Enregistre les entités du store de jetons 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).
+ */
+export declare function registerTokenEntities(connector: string): void;

package/dist/types/nodefony/entity/userEntity.d.ts

@@ -0,0 +1,54 @@
+import type { SchemaDefinition } from "mongoose";
+import type { IEntity } from "@nodefony/orm-core";
+import type { IUserColumn } from "@nodefony/user";
+/**
+ * Schéma Mongoose de l'utilisateur Nodefony — implémentation NoSQL du contrat
+ * `@nodefony/user`, **dérivée** de `USER_COLUMNS` (pendant documentaire de
+ * `userTable`).
+ *
+ * Rien n'est recopié : noms, types logiques, défauts et unicité viennent du
+ * contrat, et `tests/unit/userContractParity.test.ts` refuse le contraire.
+ *
+ * Deux origines du contrat ne sont pas déclarées ici, et c'est voulu : la clé
+ * primaire est `_id` (ObjectId), servie au contrat `id: string` par le
+ * **virtuel `id`** activé à la sérialisation par `MongooseOrm`
+ * (`toObject/toJSON: { virtuals: true }`) ; les horodatages sont gérés par
+ * l'option `timestamps: true` du descripteur. Le moteur les fournit — les
+ * redéclarer les mettrait en concurrence avec lui.
+ */
+export declare const userSchema: SchemaDefinition;
+/**
+ * Les colonnes du contrat qu'un schéma DOCUMENT porte EN PROPRE.
+ *
+ * Dérivée de {@link userSchema}, jamais recopiée : ce que le framework exige de
+ * l'entité d'une application est exactement ce qu'il produit pour la sienne. La
+ * clé (`_id` + virtuel `id`) et les horodatages (option `timestamps`) restent
+ * donc hors de cette liste — les exiger comme chemins refuserait une entité
+ * parfaitement correcte, et un refus faux apprend à passer outre les refus.
+ */
+export declare const DOCUMENT_USER_COLUMNS: readonly IUserColumn[];
+/**
+ * Forme plate d'une ligne `User` (virtuel `id` + horodatages inclus) renvoyée par
+ * le repository — le contrat `IUserRow` de `@nodefony/user`, ré-exporté sous son
+ * nom historique.
+ */
+export type { IUserRow as UserRow } from "@nodefony/user";
+/**
+ * Construit le descripteur d'entité `User` Mongoose 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é (parité avec `createUserEntity` Drizzle). À enregistrer **avant**
+ * `orm.connect()` (le modèle est compilé à la connexion par `MongooseOrm`).
+ *
+ * @param orm - clé de l'ORM cible dans le `ormRegistry`.
+ * @returns descripteur {@link IEntity} (`name: "User"`, `timestamps: true`).
+ */
+export declare function createUserEntity(connector: string): IEntity;
+/**
+ * Enregistre l'entité `User` Mongoose 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).
+ */
+export declare function registerUserEntity(connector: string): void;