@nodefony/mongoose 10.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,90 @@
+import config, { mongooseConfigSchema } from "./nodefony/config/config.js";
+import { defineMongooseConfig, mongooseConfigJsonSchema } from "./nodefony/config/defineModuleConfig.js";
+import { MongooseRepository } from "./nodefony/src/orm-core/MongooseRepository.js";
+import { MongooseTransaction } from "./nodefony/src/orm-core/MongooseTransaction.js";
+import { MongooseOrm } from "./nodefony/src/orm-core/MongooseOrm.js";
+import MongooseService from "./nodefony/service/MongooseService.js";
+import "./nodefony/src/orm-core/index.js";
+import { TOKEN_ENTITY_NAMES, accessTokenSchema, createTokenEntities, deniedJtiSchema, registerTokenEntities, subjectRevocationSchema } from "./nodefony/entity/tokenEntity.js";
+import { WEBAUTHN_CREDENTIAL_ENTITY, createWebAuthnCredentialEntity, registerWebAuthnCredentialEntity, webAuthnCredentialSchema } from "./nodefony/entity/webAuthnCredentialEntity.js";
+import { WEBHOOK_ENDPOINT_ENTITY, createWebhookEndpointEntity, registerWebhookEndpointEntity, webhookEndpointSchema } from "./nodefony/entity/webhookEndpointEntity.js";
+import { MongooseTokenStore } from "./nodefony/src/MongooseTokenStore.js";
+import { MongooseWebAuthnCredentialStore } from "./nodefony/src/MongooseWebAuthnCredentialStore.js";
+import { MongooseWebhookStore } from "./nodefony/src/MongooseWebhookStore.js";
+import { FRAMEWORK_CONNECTOR, registerMongooseFrameworkStores } from "./nodefony/registerStores.js";
+import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js";
+import sessionEntity_default, { SESSION_CONNECTOR, sessionSchema as schema } from "./nodefony/entity/sessionEntity.js";
+import SessionStorage from "./nodefony/src/SessionStorage.js";
+import { createUserEntity, registerUserEntity, userSchema } from "./nodefony/entity/userEntity.js";
+import { MongooseUserRepository } from "./nodefony/src/MongooseUserRepository.js";
+import mongoose from "mongoose";
+import { Kernel, Module, registerErrorAdapter, services } from "nodefony";
+import { wireOrmAdminPlane } from "@nodefony/orm-core";
+import { registerUserStore } from "@nodefony/user";
+//#region index.ts
+/**
+* `@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`).
+*/
+let Mongoose = class Mongoose extends Module {
+	/**
+	* 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 = false;
+	constructor(kernel) {
+		super("mongoose", kernel, import.meta.url, config);
+	}
+	/** JSON Schema de la config mongoose → data plane admin (config riche Studio). */
+	configSchema() {
+		return mongooseConfigJsonSchema();
+	}
+	/**
+	* 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).
+	*/
+	async onKernelRegister() {
+		const validated = defineMongooseConfig(this.options ?? {});
+		this.options = validated;
+		registerUserStore("mongoose");
+		if (validated.frameworkEntities !== false) {
+			const report = registerMongooseFrameworkStores();
+			if (report.appOwned.length) this.log(`schéma framework : entités déjà enregistrées par l'app [${report.appOwned.join(", ")}] — auto-register respecte l'app`, "DEBUG");
+			if (report.registered.length) this.log(`schéma framework déclaré sur "${FRAMEWORK_CONNECTOR}" : [${report.registered.join(", ")}]`, "DEBUG");
+		}
+		return 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).
+	*/
+	async onKernelBoot() {
+		wireOrmAdminPlane(this.kernel);
+		registerErrorAdapter("mongoose", {
+			isError: (e) => e instanceof mongoose.Error,
+			errorToString: (e) => String(e?.message ?? e)
+		});
+		return this;
+	}
+};
+Mongoose = __decorate([services([MongooseService]), __decorateMetadata("design:paramtypes", [typeof Kernel === "undefined" ? Object : Kernel])], Mongoose);
+var mongoose_default = Mongoose;
+//#endregion
+export { FRAMEWORK_CONNECTOR, MongooseOrm, MongooseRepository, MongooseService, MongooseTokenStore, MongooseTransaction, MongooseUserRepository, MongooseWebAuthnCredentialStore, MongooseWebhookStore, SESSION_CONNECTOR, sessionEntity_default as SessionEntity, SessionStorage, TOKEN_ENTITY_NAMES, WEBAUTHN_CREDENTIAL_ENTITY, WEBHOOK_ENDPOINT_ENTITY, accessTokenSchema, createTokenEntities, createUserEntity, createWebAuthnCredentialEntity, createWebhookEndpointEntity, mongoose_default as default, defineMongooseConfig, deniedJtiSchema, mongoose, mongooseConfigJsonSchema, mongooseConfigSchema, registerMongooseFrameworkStores, registerTokenEntities, registerUserEntity, registerWebAuthnCredentialEntity, registerWebhookEndpointEntity, schema as sessionSchema, subjectRevocationSchema, userSchema, webAuthnCredentialSchema, webhookEndpointSchema };

package/dist/nodefony/config/config.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+//#region nodefony/config/config.ts
+/**
+* @nodefony/mongoose — CONFIGURATION DU MODULE (schéma Zod = source unique).
+*
+* ⭐ TL;DR : CE SCHÉMA EST LA CONFIG. Chaque `.default(...)` = la valeur d'usine ;
+* changer un défaut du module = ÉDITER ICI (et nulle part ailleurs). L'app, elle,
+* surcharge via `use("@nodefony/...", { … })` dans SON `nodefony.config.ts`.
+*
+* RÈGLE D'OR (ADR-0006) : ce fichier porte le **schéma Zod commenté** (type +
+* validation + défaut + doc) ET matérialise les défauts via `parse({})`. Aucune
+* valeur n'est re-tapée ailleurs. Le builder (`defineMongooseConfig`) et les types
+* (`interfaces/IMongooseConfig.ts`) importent le schéma D'ICI (nœud bas : ce fichier
+* n'importe que `zod` → pas de cycle).
+*
+* Le type TS est dérivé via `z.infer<>` ({@link MongooseConfig}), et la config est
+* validée au boot du Module class (hook `onKernelRegister`, via le builder
+* {@link defineMongooseConfig}) → plante propre avec messages clairs si la config
+* est invalide, plutôt qu'un `undefined.x` silencieux en runtime.
+*
+* Convention figée (cf `feedback_config_validation_zod` + audit config ORM
+* 2026-06), alignée sur `@nodefony/drizzle` (adapter SQL frère, référence).
+*
+* ⚠️ ENV : ce schéma reste **PUR** (aucune lecture `process.env` ici, sinon il
+* devient non déterministe et non sérialisable en JSON Schema). La surcharge par
+* variables d'environnement (`MONGODB_URI`, `NF_MONGODB_DEBUG`) est appliquée dans
+* {@link defineMongooseConfig}, APRÈS le parse.
+*
+* SURCHARGE (précédence croissante — cf ADR-0006) :
+*   • App (typé)         : `use("@nodefony/mongoose", { debug: true, connectors: { … } })` ;
+*   • Par environnement  : `MONGODB_URI` · `NF_MONGODB_DEBUG` (appliqués dans
+*     `defineMongooseConfig`).
+*
+* ⚠️ NE PAS éditer les défauts matérialisés en bas de fichier : modifier les
+* `.default(...)` du schéma. La validation + le merge env finaux sont faits dans
+* `index.ts` au hook `onKernelRegister` via `defineMongooseConfig`.
+*/
+const connectorSchema = z.strictObject({
+	uri: z.string().min(1).optional().describe("URI de connexion complète (`mongodb://…` ou `mongodb+srv://…`). Si fournie, elle PRIME sur `host`/`port`/`dbname`. Pratique pour les PaaS / Atlas. ⚠️ Zero Trust : un secret (user:pass) NE doit JAMAIS être committé — passer par l'env. Pour la poser par variable : `MONGODB_URI` (ou l'infra `NF_DATABASE_URL` de famille mongo). `NF__MONGOOSE__CONNECTORS__<NOM>__URI` ne marche QUE si la clé `uri` existe déjà dans la config de l'application : la surcharge par chemin remplace une valeur, elle n'en crée pas (elle avertit sinon)."),
+	host: z.string().min(1).default("localhost").describe("Hôte du serveur MongoDB. Défaut `localhost` (jamais d'hôte d'infra hardcodé). Ignoré si `uri` est fournie. Reco prod : hôte managé + TLS."),
+	port: z.number().int().min(1).max(65535).default(27017).describe("Port TCP du serveur. Défaut 27017. Ignoré si `uri` fournie."),
+	dbname: z.string().min(1).default("nodefony").describe("Nom de la base. Défaut `nodefony`. Ignoré si `uri` fournie."),
+	autoIndex: z.boolean().optional().describe("Construire les index déclarés au démarrage (défaut mongoose : true). Mongoose recommande `false` en production : la construction bloque les opérations sur une grosse collection. ⚠️ À `false`, un index manquant N'EST PAS créé — il est seulement CONSTATÉ et journalisé en CRITIC ; le poser devient un geste d'exploitation. Prime sur une clé `autoIndex` écrite dans `options` (canal typé > fourre-tout)."),
+	options: z.record(z.string(), z.unknown()).optional().describe("Options de connexion Mongoose (`ConnectOptions` : `user`/`pass`/`maxPoolSize`/`serverSelectionTimeoutMS`/`socketTimeoutMS`…). NON re-modélisées ici (validées par Mongoose lui-même). ⚠️ Les credentials (`user`/`pass`) doivent venir de l'env, jamais du dépôt.")
+}).describe("Définition d'une connexion Mongoose nommée.");
+const mongooseConfigSchema = z.strictObject({
+	debug: z.boolean().default(false).describe("Active la trace Mongoose des requêtes (`mongoose.set('debug')`). Défaut false. Mettre true en dev pour voir chaque opération. Surchargé par l'env `NF_MONGODB_DEBUG` (1/true). Reco prod : false."),
+	connectors: z.record(z.string(), connectorSchema).default(() => ({ nodefony: connectorSchema.parse({}) })).describe("Connexions indexées par nom (= clé dans le `ormRegistry`). Défaut : un connecteur `nodefony` sur `localhost:27017/nodefony`. Le nom `nodefony` (≠ `default` de Drizzle) évite toute collision d'entité dans le `entityRegistry` (process-wide) si les deux ORM cohabitent."),
+	frameworkEntities: z.boolean().default(true).describe("Déclare le schéma framework sur le connecteur `nodefony` (tokens, webauthn, webhooks — modèles compilés au connect) et rend les stores correspondants sélectionnables par nom (`mongoose`). Couverture partielle assumée : PAS d'audit ni d'idempotence mongoose. `false` = module data-only.")
+}).describe("Configuration de @nodefony/mongoose.");
+/**
+* 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.
+*/
+const config = mongooseConfigSchema.parse({});
+//#endregion
+export { config as default, mongooseConfigSchema };

package/dist/nodefony/config/defineModuleConfig.js

@@ -0,0 +1,60 @@
+import { mongooseConfigSchema } from "./config.js";
+import { parseModuleConfig, resolveInfra } from "nodefony";
+import { z } from "zod";
+//#region nodefony/config/defineModuleConfig.ts
+/**
+* Applique la surcharge par variables d'environnement APRÈS le parse Zod.
+*
+* Le schéma reste pur (déterministe, sérialisable en JSON Schema) ; l'env est une
+* couche explicite par-dessus. Précédence : env > config app > défauts.
+*
+* - `MONGODB_URI`, sinon infra database `NF_DATABASE_URL`/`DATABASE_URL` de
+*   famille mongo (`mongodb://`/`mongodb+srv://` — une URL SQL est IGNORÉE ici,
+*   elle appartient à `@nodefony/drizzle`) → `uri` du connecteur primaire
+*   (`nodefony`, sinon le premier). ⚠️ La place pour le secret de connexion
+*   (user:pass) — JAMAIS dans le dépôt.
+* - `NF_MONGODB_DEBUG` (1/true) → `debug`.
+*/
+function applyEnvOverrides(config) {
+	const env = process.env;
+	const database = resolveInfra(env).database;
+	const uri = env.MONGODB_URI ?? (database && database.family === "mongo" ? database.url : void 0);
+	if (uri) {
+		const target = config.connectors.nodefony ? "nodefony" : Object.keys(config.connectors)[0];
+		if (target && config.connectors[target]) config.connectors[target].uri = uri;
+	}
+	if (env.NF_MONGODB_DEBUG === "1" || env.NF_MONGODB_DEBUG === "true") config.debug = true;
+	return config;
+}
+/**
+* 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.
+*/
+function defineMongooseConfig(config = {}) {
+	const parsed = parseModuleConfig(mongooseConfigSchema, config, "@nodefony/mongoose");
+	return Object.freeze(applyEnvOverrides(parsed));
+}
+/**
+* JSON Schema introspectable de la config Mongoose — destiné au formulaire
+* d'édition Studio (futur) et à la documentation générée.
+*/
+function mongooseConfigJsonSchema() {
+	return z.toJSONSchema(mongooseConfigSchema);
+}
+//#endregion
+export { defineMongooseConfig, mongooseConfigJsonSchema };

package/dist/nodefony/entity/sessionEntity.js

@@ -0,0 +1,63 @@
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js";
+import { entity } from "@nodefony/orm-core";
+//#region nodefony/entity/sessionEntity.ts
+/** ORM cible du stockage de session (connecteur par défaut du module). */
+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).
+*/
+const schema = {
+	session_id: {
+		type: String,
+		index: true,
+		unique: true
+	},
+	Attributes: {
+		type: Object,
+		default: {}
+	},
+	flashBag: {
+		type: Object,
+		default: {}
+	},
+	metaBag: {
+		type: Object,
+		default: {}
+	},
+	user: {
+		type: String,
+		default: null
+	},
+	createdAt: { type: Number },
+	updatedAt: { type: 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.
+*/
+let SessionEntity = class SessionEntity {};
+SessionEntity = __decorate([entity({
+	connector: SESSION_CONNECTOR,
+	name: "session",
+	schema
+})], SessionEntity);
+var sessionEntity_default = SessionEntity;
+//#endregion
+export { SESSION_CONNECTOR, sessionEntity_default as default, schema as sessionSchema };

package/dist/nodefony/entity/tokenEntity.js

@@ -0,0 +1,184 @@
+import { entityRegistry } from "@nodefony/orm-core";
+//#region nodefony/entity/tokenEntity.ts
+/**
+* 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`).
+*/
+const accessTokenSchema = {
+	_id: { type: String },
+	kind: {
+		type: String,
+		required: true
+	},
+	name: {
+		type: String,
+		required: true
+	},
+	prefix: {
+		type: String,
+		default: null
+	},
+	subjectId: {
+		type: String,
+		required: true,
+		index: true
+	},
+	subjectType: {
+		type: String,
+		required: true
+	},
+	tenantId: {
+		type: String,
+		default: null
+	},
+	scopes: {
+		type: [String],
+		default: []
+	},
+	audience: {
+		type: [String],
+		default: []
+	},
+	resources: {
+		type: Object,
+		default: null
+	},
+	secretHash: {
+		type: String,
+		required: true,
+		unique: true,
+		index: true
+	},
+	hashAlg: {
+		type: String,
+		required: true
+	},
+	clientId: {
+		type: String,
+		default: null
+	},
+	cnf: {
+		type: String,
+		default: null
+	},
+	family: {
+		type: String,
+		default: null,
+		index: true
+	},
+	replacedBy: {
+		type: String,
+		default: null
+	},
+	createdAt: {
+		type: Number,
+		required: true
+	},
+	expiresAt: {
+		type: Number,
+		default: null
+	},
+	lastUsedAt: {
+		type: Number,
+		default: null
+	},
+	lastUsedIp: {
+		type: String,
+		default: null
+	},
+	lastUsedUserAgent: {
+		type: String,
+		default: null
+	},
+	revokedAt: {
+		type: Number,
+		default: null
+	},
+	revokedReason: {
+		type: String,
+		default: null
+	},
+	metadata: {
+		type: Object,
+		default: {}
+	}
+};
+/** Denylist des access tokens (`jti` = `_id`) révoqués avant leur `exp`. */
+const deniedJtiSchema = {
+	_id: { type: String },
+	expiresAt: {
+		type: Number,
+		required: true
+	}
+};
+/** Seuil de révocation en masse par porteur (`subjectId` = `_id`). */
+const subjectRevocationSchema = {
+	_id: { type: String },
+	invalidBefore: {
+		type: Number,
+		required: true
+	}
+};
+/** Noms logiques des entités du store (clés de lookup `getRepository`). */
+const TOKEN_ENTITY_NAMES = {
+	records: "access_token",
+	denied: "denied_jti",
+	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).
+*/
+function createTokenEntities(connector) {
+	return [
+		{
+			connector,
+			name: TOKEN_ENTITY_NAMES.records,
+			module: "security",
+			schema: accessTokenSchema
+		},
+		{
+			connector,
+			name: TOKEN_ENTITY_NAMES.denied,
+			module: "security",
+			schema: deniedJtiSchema
+		},
+		{
+			connector,
+			name: TOKEN_ENTITY_NAMES.revocations,
+			module: "security",
+			schema: subjectRevocationSchema
+		}
+	];
+}
+/**
+* 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).
+*/
+function registerTokenEntities(connector) {
+	for (const entity of createTokenEntities(connector)) entityRegistry.register(entity);
+}
+//#endregion
+export { TOKEN_ENTITY_NAMES, accessTokenSchema, createTokenEntities, deniedJtiSchema, registerTokenEntities, subjectRevocationSchema };

package/dist/nodefony/entity/userEntity.js

@@ -0,0 +1,106 @@
+import { entityRegistry } from "@nodefony/orm-core";
+import { USER_COLUMNS } from "@nodefony/user";
+//#region nodefony/entity/userEntity.ts
+/**
+* Traduction d'un type LOGIQUE du contrat utilisateur vers un type Mongoose.
+*
+* C'est le seul endroit du module document qui connaisse ce vocabulaire : le
+* contrat dit ce que la donnée EST, ce fichier dit comment un document la range.
+* `object[]` reste un `Array` LIBRE — pas un sous-schéma : c'est ce qui permet
+* d'accueillir un nouveau fournisseur d'identité sans migration.
+*/
+const TYPE_BY_COLUMN = {
+	uuid: String,
+	string: String,
+	"string[]": [String],
+	boolean: Boolean,
+	object: Object,
+	"object[]": Array,
+	date: Date
+};
+/**
+* Construit la définition Mongoose d'une colonne du contrat utilisateur.
+*
+* Un défaut structuré est passé en FABRIQUE, jamais en valeur : Mongoose
+* partagerait sinon le même tableau entre tous les documents. Une colonne
+* facultative reçoit `null` explicite plutôt que rien, pour qu'un document
+* ancien et un document neuf se lisent pareil. Une colonne obligatoire QUI A un
+* défaut n'est pas `required` : la valeur ne peut pas manquer, l'exiger de
+* l'appelant n'ajouterait qu'un refus.
+*/
+function toFieldDefinition(column) {
+	const base = {
+		type: TYPE_BY_COLUMN[column.type],
+		...column.nullable || column.makeDefault ? {} : { required: true },
+		...column.unique ? {
+			unique: true,
+			index: true
+		} : {}
+	};
+	if (column.makeDefault) return {
+		...base,
+		default: column.makeDefault
+	};
+	if (column.nullable) return {
+		...base,
+		default: null
+	};
+	return base;
+}
+/**
+* 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.
+*/
+const userSchema = Object.fromEntries(USER_COLUMNS.filter((column) => column.origin === "column").map((column) => [column.name, toFieldDefinition(column)]));
+/**
+* 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.
+*/
+const DOCUMENT_USER_COLUMNS = USER_COLUMNS.filter((column) => Object.prototype.hasOwnProperty.call(userSchema, column.name));
+/**
+* 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`).
+*/
+function createUserEntity(connector) {
+	return {
+		connector,
+		name: "User",
+		module: "user",
+		schema: userSchema,
+		timestamps: true
+	};
+}
+/**
+* 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).
+*/
+function registerUserEntity(connector) {
+	entityRegistry.register(createUserEntity(connector));
+}
+//#endregion
+export { DOCUMENT_USER_COLUMNS, createUserEntity, registerUserEntity, userSchema };

package/dist/nodefony/entity/webAuthnCredentialEntity.js

@@ -0,0 +1,97 @@
+import { entityRegistry } from "@nodefony/orm-core";
+//#region nodefony/entity/webAuthnCredentialEntity.ts
+/**
+* Schéma Mongoose du **store de credentials WebAuthn** `@nodefony/security`
+* (pendant documentaire de la table Drizzle) — implémentation NoSQL d'
+* `IWebAuthnCredentialStore` (passkeys).
+*
+* ⚠️ **`_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 credential est un **identifiant base64url fourni par
+* l'authenticator** (pas généré par Mongo), on force `_id: String` → le
+* credentialId EST la clé primaire. Le virtuel `id` (activé par `MongooseOrm`,
+* `toObject:{virtuals:true}`) renvoie `String(_id)` = le credentialId.
+*
+* ⚠️ **Horodatages = `Number` (epoch ms), `timestamps:false`** : `IWebAuthnCredential`
+* porte des `number` (`Date.now()`) et l'appelant fournit `createdAt`.
+*
+* Le store ne lit/écrit JAMAIS `IWebAuthnCredential` directement : il traduit via
+* {@link WebAuthnCredentialRow} (forme plate, `nickname: string | null`) — le
+* contrat porte un `nickname?` optionnel et des champs `readonly`, que la
+* frontière de persistance normalise.
+*/
+const webAuthnCredentialSchema = {
+	_id: { type: String },
+	userId: {
+		type: String,
+		required: true,
+		index: true
+	},
+	publicKey: {
+		type: String,
+		required: true
+	},
+	signCount: {
+		type: Number,
+		required: true
+	},
+	transports: {
+		type: [String],
+		default: []
+	},
+	backupEligible: {
+		type: Boolean,
+		required: true
+	},
+	backupState: {
+		type: Boolean,
+		required: true
+	},
+	uvInitialized: {
+		type: Boolean,
+		required: true
+	},
+	nickname: {
+		type: String,
+		default: null
+	},
+	createdAt: {
+		type: Number,
+		required: true
+	},
+	lastUsedAt: {
+		type: Number,
+		default: null
+	}
+};
+/** Nom logique de l'entité (clé de lookup `getRepository`). */
+const WEBAUTHN_CREDENTIAL_ENTITY = "webauthn_credential";
+/**
+* Construit le descripteur d'entité du store de credentials 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é `createTokenEntities`). `timestamps:false`. À enregistrer **avant**
+* `orm.connect()`.
+*
+* @param orm - clé de l'ORM cible dans le `ormRegistry`.
+*/
+function createWebAuthnCredentialEntity(connector) {
+	return {
+		connector,
+		name: WEBAUTHN_CREDENTIAL_ENTITY,
+		module: "security",
+		schema: webAuthnCredentialSchema
+	};
+}
+/**
+* Enregistre l'entité du store de credentials 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).
+*/
+function registerWebAuthnCredentialEntity(connector) {
+	entityRegistry.register(createWebAuthnCredentialEntity(connector));
+}
+//#endregion
+export { WEBAUTHN_CREDENTIAL_ENTITY, createWebAuthnCredentialEntity, registerWebAuthnCredentialEntity, webAuthnCredentialSchema };