@nodefony/mongoose 10.0.0-alpha.1

package/dist/nodefony/entity/webhookEndpointEntity.js

@@ -0,0 +1,109 @@
+import { entityRegistry } from "@nodefony/orm-core";
+//#region nodefony/entity/webhookEndpointEntity.ts
+/**
+* Schéma Mongoose du **store d'endpoints webhook** `@nodefony/security` (P6.13,
+* pendant documentaire de la table Drizzle) — implémentation NoSQL d'
+* `IWebhookStore` (registre durable des destinations notifiées).
+*
+* ⚠️ **`_id` = clé naturelle (String), PAS un ObjectId auto** : l'`id` d'un
+* endpoint est un identifiant `wh_<random>` **fourni** (pas généré par Mongo) →
+* on force `_id: String` → l'id EST la clé primaire. Le contrat `IRepository`
+* traduit le critère `{ id }` en `{ _id }` ; le virtuel `id` (activé par
+* `MongooseOrm`, `toObject:{virtuals:true}`) renvoie `String(_id)` = l'id.
+*
+* ⚠️ **Horodatages = `Number` (epoch ms), `timestamps:false`** : `IWebhookEndpoint`
+* porte des `number` (`Date.now()`) et l'appelant fournit `createdAt`/`updatedAt`.
+*
+* `events` = tableau de strings ; `metadata` = objet libre (`Object`/Mixed, idem
+* `tokenEntity.metadata`). Le store réécrit ces champs en bloc (pas de mutation
+* partielle in-place) → pas de souci de change-tracking Mixed.
+*/
+const webhookEndpointSchema = {
+	_id: { type: String },
+	url: {
+		type: String,
+		required: true
+	},
+	secretEnc: {
+		type: String,
+		required: true
+	},
+	events: {
+		type: [String],
+		default: []
+	},
+	enabled: {
+		type: Boolean,
+		required: true
+	},
+	description: {
+		type: String,
+		default: null
+	},
+	tenantId: {
+		type: String,
+		default: null
+	},
+	createdBy: {
+		type: String,
+		default: null
+	},
+	createdAt: {
+		type: Number,
+		required: true
+	},
+	updatedAt: {
+		type: Number,
+		required: true
+	},
+	lastDeliveryAt: {
+		type: Number,
+		default: null
+	},
+	lastDeliveryStatus: {
+		type: Number,
+		default: null
+	},
+	lastDeliveryError: {
+		type: String,
+		default: null
+	},
+	failureCount: {
+		type: Number,
+		required: true
+	},
+	metadata: {
+		type: Object,
+		default: {}
+	}
+};
+/** Nom logique de l'entité (clé de lookup `getRepository`). */
+const WEBHOOK_ENDPOINT_ENTITY = "webhook_endpoint";
+/**
+* Construit le descripteur d'entité du store webhook 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é. `timestamps:false`. À enregistrer **avant** `orm.connect()`.
+*
+* @param orm - clé de l'ORM cible dans le `ormRegistry`.
+*/
+function createWebhookEndpointEntity(connector) {
+	return {
+		connector,
+		name: WEBHOOK_ENDPOINT_ENTITY,
+		module: "security",
+		schema: webhookEndpointSchema
+	};
+}
+/**
+* Enregistre l'entité du store webhook 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 registerWebhookEndpointEntity(connector) {
+	entityRegistry.register(createWebhookEndpointEntity(connector));
+}
+//#endregion
+export { WEBHOOK_ENDPOINT_ENTITY, createWebhookEndpointEntity, registerWebhookEndpointEntity, webhookEndpointSchema };

package/dist/nodefony/interfaces/IMongooseConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/index.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/registerStores.js

@@ -0,0 +1,89 @@
+import { MongooseOrm } from "./src/orm-core/MongooseOrm.js";
+import "./src/orm-core/index.js";
+import { TOKEN_ENTITY_NAMES, registerTokenEntities } from "./entity/tokenEntity.js";
+import { WEBAUTHN_CREDENTIAL_ENTITY, registerWebAuthnCredentialEntity } from "./entity/webAuthnCredentialEntity.js";
+import { WEBHOOK_ENDPOINT_ENTITY, registerWebhookEndpointEntity } from "./entity/webhookEndpointEntity.js";
+import { MongooseTokenStore } from "./src/MongooseTokenStore.js";
+import { MongooseWebAuthnCredentialStore } from "./src/MongooseWebAuthnCredentialStore.js";
+import { MongooseWebhookStore } from "./src/MongooseWebhookStore.js";
+import { entityRegistry, ormRegistry } from "@nodefony/orm-core";
+import { getTokenStoreFactory, getWebAuthnStoreFactory, getWebhookStoreFactory, registerTokenStore, registerWebAuthnStore, registerWebhookStore } from "@nodefony/security";
+//#region nodefony/registerStores.ts
+/**
+* AUTO-ENREGISTREMENT des backends framework portés par Mongoose — « charger le
+* module = ses backends deviennent sélectionnables par simple nom » (convention-
+* frère : `registerDrizzleFrameworkStores` de `@nodefony/drizzle`).
+*
+* Appelé par `Mongoose.onKernelRegister` (AVANT le connect de `onBoot` — les
+* modèles sont compilés à la connexion). Pas de dialecte (NoSQL) : les schémas
+* sont portables par construction.
+*
+* Couverture PARTIELLE assumée : session (auto via `@entity`), tokens, webauthn,
+* webhooks. PAS d'implémentation mongoose pour l'audit ni l'idempotence — les
+* sélectionner sur mongoose échoue franc (« store inconnu »), jamais en silence.
+*
+* Mêmes garde-fous que Drizzle : entité `has`-guarded (l'app garde la main),
+* fabrique `get`-guarded (premier-arrivé-premier-servi).
+*/
+/**
+* Connecteur conventionnel qui héberge le schéma framework (`"nodefony"` pour
+* Mongoose, ≠ `"default"` de Drizzle — isole les entités homonymes dans le
+* `entityRegistry` process-wide si les deux ORM cohabitent).
+*/
+const FRAMEWORK_CONNECTOR = "nodefony";
+/**
+* Résout l'ORM `nodefony` CONNECTÉ pour une fabrique de store — échec FRANC avec
+* la cause exacte (module absent / ordre de boot) : principe « pas de dégradation
+* silencieuse ».
+*/
+function resolveConnectedOrm(store) {
+	let orm;
+	try {
+		orm = ormRegistry.get(FRAMEWORK_CONNECTOR);
+	} catch {
+		throw new Error(`${store} : ORM "${FRAMEWORK_CONNECTOR}" introuvable — charger @nodefony/mongoose AVANT @nodefony/security dans le manifeste "modules".`);
+	}
+	if (!(orm instanceof MongooseOrm)) throw new Error(`${store} : l'ORM "${FRAMEWORK_CONNECTOR}" n'est pas un MongooseOrm (connecteur homonyme d'un autre driver ?).`);
+	if (!orm.isConnected()) throw new Error(`${store} : ORM "${FRAMEWORK_CONNECTOR}" non connecté au montage du store (ordre de boot).`);
+	return orm;
+}
+/**
+* Déclare les entités framework Mongoose (connecteur `nodefony`) et enregistre
+* leurs fabriques de stores dans les registres de `@nodefony/security`.
+* Idempotent (guards) — rejouable sans effet.
+*
+* @returns bilan à logger (registered / appOwned)
+*/
+function registerMongooseFrameworkStores() {
+	const report = {
+		registered: [],
+		appOwned: []
+	};
+	const wire = (entityName, registerEntity, registerFactory) => {
+		if (entityRegistry.has(entityName, "nodefony")) report.appOwned.push(entityName);
+		else {
+			registerEntity();
+			report.registered.push(entityName);
+		}
+		registerFactory();
+	};
+	wire(TOKEN_ENTITY_NAMES.records, () => registerTokenEntities(FRAMEWORK_CONNECTOR), () => {
+		if (getTokenStoreFactory("mongoose")) return;
+		registerTokenStore("mongoose", (ctx) => {
+			const orm = resolveConnectedOrm(`tokenStore "mongoose"`);
+			const days = ctx?.config?.tokenStore?.retentionRevokedDays;
+			return MongooseTokenStore.from(orm, void 0, typeof days === "number" ? days * 864e5 : void 0);
+		});
+	});
+	wire(WEBAUTHN_CREDENTIAL_ENTITY, () => registerWebAuthnCredentialEntity(FRAMEWORK_CONNECTOR), () => {
+		if (getWebAuthnStoreFactory("mongoose")) return;
+		registerWebAuthnStore("mongoose", () => MongooseWebAuthnCredentialStore.from(resolveConnectedOrm(`passkeys.store "mongoose"`)));
+	});
+	wire(WEBHOOK_ENDPOINT_ENTITY, () => registerWebhookEndpointEntity(FRAMEWORK_CONNECTOR), () => {
+		if (getWebhookStoreFactory("mongoose")) return;
+		registerWebhookStore("mongoose", () => MongooseWebhookStore.from(resolveConnectedOrm(`webhooks.store "mongoose"`)));
+	});
+	return report;
+}
+//#endregion
+export { FRAMEWORK_CONNECTOR, registerMongooseFrameworkStores };

package/dist/nodefony/service/MongooseService.js

@@ -0,0 +1,95 @@
+import { MongooseOrm } from "../src/orm-core/MongooseOrm.js";
+import mongoose from "mongoose";
+import { Service } from "nodefony";
+import { queryFlowMonitor, resolveOrmFlowEnabled } from "@nodefony/orm-core";
+//#region nodefony/service/MongooseService.ts
+const serviceName = "mongoose";
+/**
+* Service bootable du module `@nodefony/mongoose` (driver NoSQL).
+*
+* Au boot du kernel (`onBoot`), instancie un {@link MongooseOrm} (adapter
+* orm-core) **par connecteur** déclaré dans la config et le connecte ; chaque
+* ORM s'auto-enregistre dans le `ormRegistry`. Ferme proprement les connexions
+* à `onTerminate`.
+*
+* Refonte de l'ancien `Mongoose extends Orm` (core legacy) : ce service ne
+* dérive plus de la base ORM du core — il **orchestre** des adapters orm-core
+* autonomes, exactement comme `DrizzleService`. Le core ne connaît plus l'ORM.
+*/
+var MongooseService = class MongooseService extends Service {
+	module;
+	/** ORM connectés, indexés par nom de connecteur. */
+	#orms = /* @__PURE__ */ new Map();
+	constructor(module) {
+		super(serviceName, module.container, module.notificationsCenter, module.options ?? {});
+		this.module = module;
+		this.module.hookKernel("onBoot", async () => {
+			queryFlowMonitor.setEnabled(resolveOrmFlowEnabled(this.kernel));
+			await this.connectAll().catch((e) => {
+				this.log(e, "ERROR");
+				throw e;
+			});
+		});
+		this.kernel?.once("onTerminate", async () => {
+			await this.disconnectAll().catch(() => {});
+		});
+	}
+	/** Config validée (Zod) exposée par le Module (`this.module.config`). */
+	#config() {
+		return this.module.config;
+	}
+	/** Connecte tous les connecteurs déclarés en config (validée Zod). */
+	async connectAll() {
+		const config = this.#config();
+		if (config?.debug) mongoose.set("debug", true);
+		const connectors = config?.connectors ?? {};
+		for (const [name, cfg] of Object.entries(connectors)) await this.#connectOne(name, cfg);
+	}
+	/** Assemble l'URI de connexion à partir de la config (`uri` ou composants). */
+	static buildUri(cfg) {
+		if (cfg.uri) return cfg.uri;
+		return `mongodb://${cfg.host ?? "localhost"}:${cfg.port ?? 27017}/${cfg.dbname ?? "nodefony"}`;
+	}
+	/**
+	* Options de connexion Mongoose d'un connecteur.
+	*
+	* `options` reste un fourre-tout transmis tel quel — Mongoose valide ses
+	* propres `ConnectOptions`, les re-modéliser en Zod serait une duplication
+	* qui dériverait. `autoIndex` fait exception, et une seule : il décide si les
+	* contraintes d'unicité sont construites au démarrage, ce qui mérite un champ
+	* typé, décrit, et visible dans la configuration d'un connecteur.
+	*
+	* Il **prime** donc sur une clé homonyme écrite dans `options` : entre deux
+	* canaux, celui qui est déclaré gagne — la même règle que les délais de
+	* connexion, où un choix explicite l'emporte sur un défaut.
+	*
+	* @param cfg - configuration validée du connecteur.
+	* @returns les options à passer à la connexion, ou `undefined` s'il n'y en a aucune.
+	*/
+	static buildConnectOptions(cfg) {
+		if (cfg.autoIndex === void 0) return cfg.options;
+		return {
+			...cfg.options ?? {},
+			autoIndex: cfg.autoIndex
+		};
+	}
+	/** Connecte un connecteur (URI + options d'auth/pool). */
+	async #connectOne(name, cfg) {
+		const uri = MongooseService.buildUri(cfg);
+		const orm = new MongooseOrm(name, uri, MongooseService.buildConnectOptions(cfg));
+		await orm.connect();
+		this.#orms.set(name, orm);
+		this.log(`Mongoose ORM "${name}" connected (${orm.safeTarget()})`, "INFO");
+	}
+	/** Ferme toutes les connexions. */
+	async disconnectAll() {
+		for (const orm of this.#orms.values()) await orm.disconnect();
+		this.#orms.clear();
+	}
+	/** Retourne l'ORM Mongoose d'un connecteur (défaut : `"nodefony"`). */
+	getOrm(name = "nodefony") {
+		return this.#orms.get(name);
+	}
+};
+//#endregion
+export { MongooseService as default };

package/dist/nodefony/src/MongooseTokenStore.js

@@ -0,0 +1,237 @@
+import { TOKEN_ENTITY_NAMES } from "../entity/tokenEntity.js";
+import { mongoOrder } from "./mongoOrder.js";
+import { assertPageQuery } from "nodefony";
+import { paginate } from "@nodefony/orm-core";
+import { TOKEN_DEFAULT_ORDER, TOKEN_SORTABLE_FIELDS, tokenStatusCriteria } from "@nodefony/security";
+//#region nodefony/src/MongooseTokenStore.ts
+/**
+* Traduit les filtres de listing en `Criteria` portable (`id`→`_id` géré par le
+* repo).
+*
+* L'état de vie (`status`) vient de `tokenStatusCriteria`, partagé avec
+* l'adapter SQL : une seule écriture de la règle « révoqué l'emporte sur
+* expiré », donc aucune divergence possible entre les deux backends.
+*/
+function tokenListCriteria(query, now) {
+	const criteria = { ...tokenStatusCriteria(query.status, now) };
+	if (query.subjectId !== void 0) criteria.subjectId = query.subjectId;
+	if (query.kind !== void 0) criteria.kind = query.kind;
+	return criteria;
+}
+/** Fenêtre par défaut de conservation d'un PAT révoqué sans expiration (30 j). */
+const DEFAULT_RETENTION_REVOKED_MS = 2592e6;
+/**
+* Store de jetons **Mongoose** (NoSQL) — implémentation d'{@link ITokenStore} au
+* dessus de trois repositories `@nodefony/orm-core` (`access_token`, `denied_jti`,
+* `subject_revocation`). Pendant documentaire de `DrizzleTokenStore`.
+*
+* **Approche B** : `@nodefony/security` n'est connu qu'en `import type` (0 dép
+* runtime). C'est l'application qui enregistre la fabrique (`registerTokenStore`)
+* et les entités (`registerTokenEntities(orm)` avant `orm.connect()`).
+*
+* **Spécificité Mongo** : la clé naturelle (`jti` / `subjectId`) est portée par
+* `_id` (cf {@link tokenEntity}). 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 jti). Les reads sont normalisés (`id` ← `_id`)
+* pour ne pas dépendre du virtuel. Le reste est identique au store Drizzle : `gc`
+* via `$lte` (le type bracketing Mongo exclut les `null`), idempotence de `revoke`
+* par read-then-write.
+*/
+var MongooseTokenStore = class MongooseTokenStore {
+	/**
+	* {@inheritDoc ITokenStore.sortableFields}
+	*
+	* Capacité pleine : le vocabulaire public entier est trié par Mongo, `id`
+	* compris — traduit en `_id` au moment de la requête.
+	*/
+	sortableFields = TOKEN_SORTABLE_FIELDS;
+	#records;
+	#denied;
+	#revocations;
+	#now;
+	#retentionRevokedMs;
+	/**
+	* @param records - repository de `access_token` (PAT + refresh).
+	* @param denied - repository de la denylist `denied_jti`.
+	* @param revocations - repository des seuils `subject_revocation`.
+	* @param now - horloge (epoch ms) injectable pour les tests.
+	* @param retentionRevokedMs - rétention d'un PAT révoqué sans `exp` avant purge.
+	*/
+	constructor(records, denied, revocations, now = Date.now, retentionRevokedMs = DEFAULT_RETENTION_REVOKED_MS) {
+		this.#records = records;
+		this.#denied = denied;
+		this.#revocations = revocations;
+		this.#now = now;
+		this.#retentionRevokedMs = retentionRevokedMs;
+	}
+	/**
+	* Construit le store depuis un {@link MongooseOrm} connecté. Les entités
+	* (`registerTokenEntities`) doivent avoir été enregistrées **avant** `connect()`.
+	*
+	* @param orm - ORM Mongoose connecté hébergeant les collections du store.
+	* @param now - horloge injectable (tests).
+	* @param retentionRevokedMs - rétention des PAT révoqués sans `exp`.
+	*/
+	static from(orm, now, retentionRevokedMs) {
+		return new MongooseTokenStore(orm.getRepository(TOKEN_ENTITY_NAMES.records), orm.getRepository(TOKEN_ENTITY_NAMES.denied), orm.getRepository(TOKEN_ENTITY_NAMES.revocations), now, retentionRevokedMs);
+	}
+	/** Identité réelle d'un record (jti) : `_id` fait foi, le virtuel `id` en repli. */
+	#idOf(row) {
+		return row._id ?? row.id;
+	}
+	/** Normalise `id` (← `_id`) sur un record lu, sans dépendre du virtuel Mongoose. */
+	#withId(row) {
+		if (row) row.id = this.#idOf(row);
+		return row;
+	}
+	/**
+	* Insère ou remplace un record (PAT / refresh) — 1 round-trip, `upsert`
+	* atomique sur la PK plutôt qu'un `findOne` d'existence + `create`/`updateOne`
+	* (dont l'`await` laisse deux put concurrents du même id lire « absent » et
+	* insérer tous les deux → E11000 pour le perdant). `put` pose le record
+	* COMPLET → tout hors `id` est ré-appliqué au conflit.
+	*
+	* `id` en critère suffit à poser `_id` : Mongo ajoute les égalités du filtre
+	* au document inséré (cf `MongooseRepository.upsert`), plus besoin du `_id`
+	* explicite. Parité stricte avec l'adapter Drizzle.
+	*
+	* @param record - le record complet à persister.
+	*/
+	async put(record) {
+		const { id, ...rest } = record;
+		await this.#records.upsert({ id }, rest);
+	}
+	async findById(id) {
+		return this.#withId(await this.#records.findOne({ id }));
+	}
+	async findByHash(secretHash) {
+		return this.#withId(await this.#records.findOne({ secretHash }));
+	}
+	async findBySubject(subjectId) {
+		const rows = await this.#records.find({ subjectId });
+		for (const row of rows) row.id = this.#idOf(row);
+		return rows;
+	}
+	/** Tous les jetons (PAT + refresh) — vue d'administration cross-porteur. */
+	async listAll() {
+		const rows = await this.#records.find({});
+		for (const row of rows) row.id = this.#idOf(row);
+		return rows;
+	}
+	/**
+	* {@inheritDoc ITokenStore.listPage}
+	*
+	* `paginate()` d'orm-core (skip/limit + countDocuments) sur un filtre portable ;
+	* les `id` sont re-normalisés (`_id` → `id`) comme dans {@link listAll}.
+	*
+	* Le tri demandé est **traduit** avant de descendre : au repos, le jeton n'a
+	* pas de champ `id` (le `jti` 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.
+	*/
+	async listPage(query) {
+		assertPageQuery(query, "offset");
+		const page = await paginate(this.#records, {
+			criteria: tokenListCriteria(query, this.#now()),
+			limit: query.limit,
+			offset: query.offset,
+			withTotal: query.withTotal,
+			order: mongoOrder(query.order, this.sortableFields, TOKEN_DEFAULT_ORDER)
+		});
+		for (const row of page.items) row.id = this.#idOf(row);
+		return page;
+	}
+	/** {@inheritDoc ITokenStore.countTokens} */
+	countTokens(query) {
+		return this.#records.count(tokenListCriteria(query, this.#now()));
+	}
+	async markUsed(id, usage) {
+		await this.#records.updateOne({ id }, {
+			lastUsedAt: usage.at,
+			lastUsedIp: usage.ip ?? null,
+			lastUsedUserAgent: usage.userAgent ?? null
+		});
+	}
+	/**
+	* Révoque un jeton — **idempotent** : la 1ʳᵉ date/raison est conservée.
+	*
+	* Le « pas encore révoqué » est dans le filtre (`revokedAt: { $null: true }`),
+	* pas dans un `if` JS après lecture : une seule instruction, donc deux
+	* révocations concurrentes ne se recouvrent plus (la 2ᵉ ne matche rien au lieu
+	* d'écraser la date/raison de la 1ʳᵉ). Parité stricte avec l'adapter Drizzle.
+	*
+	* @param id - identifiant du jeton.
+	* @param reason - motif, posé seulement à la 1ʳᵉ révocation.
+	*/
+	async revoke(id, reason) {
+		await this.#records.updateOne({
+			id,
+			revokedAt: { $null: true }
+		}, {
+			revokedAt: this.#now(),
+			revokedReason: reason
+		});
+	}
+	/**
+	* Coupe toute une famille de refresh (détection de rejeu, RFC 9700) — les
+	* membres déjà révoqués gardent leur raison d'origine.
+	*
+	* Un seul `updateMany` filtré : atomique, et N+1 requêtes (1 find + 1 update
+	* par membre actif) tombent à 1.
+	*
+	* @param family - famille de refresh à couper.
+	* @param reason - motif appliqué aux membres encore actifs.
+	*/
+	async revokeFamily(family, reason) {
+		await this.#records.updateMany({
+			family,
+			revokedAt: { $null: true }
+		}, {
+			revokedAt: this.#now(),
+			revokedReason: reason
+		});
+	}
+	async denyJti(jti, expiresAt) {
+		await this.#denied.upsert({ id: jti }, { expiresAt });
+	}
+	async isJtiDenied(jti) {
+		return await this.#denied.findOne({
+			id: jti,
+			expiresAt: { $gt: this.#now() }
+		}) !== null;
+	}
+	/**
+	* Pose le seuil de révocation en masse d'un porteur (« déconnecte-moi de
+	* partout ») : tout jeton émis avant `invalidBefore` est mort.
+	*
+	* **Monotone — le seuil ne recule JAMAIS**, y compris sous deux logouts
+	* simultanés : la comparaison vit dans la valeur écrite (`$max`, natif Mongo),
+	* pas dans un `if` JS après lecture. Une lecture suivie d'une écriture
+	* laisserait les deux appels voir le même état et écrire tous les deux — c'est
+	* le dernier qui resterait, même porteur d'un seuil plus ANCIEN, et **des
+	* jetons révoqués redeviendraient valides**. Parité stricte avec l'adapter
+	* Drizzle (`GREATEST`/`MAX` SQL).
+	*
+	* @param subjectId - porteur visé.
+	* @param invalidBefore - seuil (epoch ms) ; ignoré s'il est antérieur au seuil courant.
+	*/
+	async revokeAllForSubject(subjectId, invalidBefore) {
+		await this.#revocations.upsert({ id: subjectId }, { invalidBefore: { $max: invalidBefore } });
+	}
+	async getInvalidBefore(subjectId) {
+		const row = await this.#revocations.findOne({ id: subjectId });
+		return row ? row.invalidBefore : null;
+	}
+	async gc(now = this.#now()) {
+		let purged = 0;
+		purged += await this.#denied.delete({ expiresAt: { $lte: now } });
+		purged += await this.#records.delete({ expiresAt: { $lte: now } });
+		purged += await this.#records.delete({
+			revokedAt: { $lte: now - this.#retentionRevokedMs },
+			expiresAt: { $null: true }
+		});
+		return purged;
+	}
+};
+//#endregion
+export { MongooseTokenStore };