@nodefony/drizzle 10.0.0-alpha.1

package/dist/nodefony/src/DrizzleTokenStore.js

@@ -0,0 +1,244 @@
+import { TOKEN_ENTITY_NAMES } from "../entity/tokenEntity.js";
+import { assertPageQuery, pickOrder } from "nodefony";
+import { paginate } from "@nodefony/orm-core";
+import { TOKEN_DEFAULT_ORDER, TOKEN_SORTABLE_FIELDS, tokenStatusCriteria } from "@nodefony/security";
+//#region nodefony/src/DrizzleTokenStore.ts
+/**
+* Traduit les filtres de listing en `Criteria` portable (champs indexés/simples).
+*
+* L'état de vie (`status`) vient de `tokenStatusCriteria`, partagé avec
+* l'adapter Mongo : une seule écriture de la règle « révoqué l'emporte sur
+* expiré ». Tout descend en `WHERE` natif — aucun post-filtre en mémoire.
+*/
+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 **Drizzle** (driver `better-sqlite3`) — implémentation SQL
+* d'{@link ITokenStore} au-dessus de trois repositories `@nodefony/orm-core`
+* (`access_token`, `denied_jti`, `subject_revocation`).
+*
+* **Approche B** (validée 2026-06-14) : l'ORM ne connaît `@nodefony/security`
+* qu'en `import type` → 0 dépendance runtime. C'est l'application qui enregistre
+* la fabrique (`registerTokenStore("drizzle", ({ container }) =>
+* DrizzleTokenStore.from(container.get("…orm…")))`) et les entités
+* (`registerTokenEntities(orm)` avant `orm.connect()`).
+*
+* **100 % portable** (aucun SQL natif) — toutes les opérations passent par le
+* contrat `IRepository`, donc le code se transpose tel quel aux autres drivers.
+* Les écritures conditionnelles portent leur condition dans le `WHERE` plutôt
+* que dans un `if` JS après lecture (`{ revokedAt: { $null: true } }`) : chacune
+* est une instruction unique, donc atomique — un `findOne` suivi d'un `update`
+* laisse deux appels concurrents agir sur un état déjà périmé.
+*
+* Horloge injectable (`now`) pour des tests déterministes.
+*/
+var DrizzleTokenStore = class DrizzleTokenStore {
+	/**
+	* {@inheritDoc ITokenStore.sortableFields}
+	*
+	* Le moteur SQL trie sur n'importe laquelle de ces colonnes : capacité pleine.
+	*/
+	sortableFields = TOKEN_SORTABLE_FIELDS;
+	#records;
+	#denied;
+	#revocations;
+	#now;
+	#retentionRevokedMs;
+	#location;
+	/**
+	* @param records - repository de la table `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.
+	* @param location - emplacement physique de la base (fichier SQLite) pour Studio
+	*   ({@link DrizzleOrm.location}) ; `undefined` pour un backend réseau/`:memory:`.
+	*/
+	constructor(records, denied, revocations, now = Date.now, retentionRevokedMs = DEFAULT_RETENTION_REVOKED_MS, location) {
+		this.#records = records;
+		this.#denied = denied;
+		this.#revocations = revocations;
+		this.#now = now;
+		this.#retentionRevokedMs = retentionRevokedMs;
+		this.#location = location;
+	}
+	/**
+	* Emplacement physique de la base (fichier SQLite) pour l'écran Studio « Stores »
+	* — lu par `readStoreLocation`. `undefined` = backend réseau ou `:memory:`.
+	*/
+	get location() {
+		return this.#location;
+	}
+	/**
+	* Construit le store depuis un {@link DrizzleOrm} connecté. Les entités
+	* (`registerTokenEntities`) doivent avoir été enregistrées **avant**
+	* `orm.connect()`.
+	*
+	* @param orm - ORM Drizzle connecté hébergeant les tables 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 DrizzleTokenStore(orm.getRepository(TOKEN_ENTITY_NAMES.records), orm.getRepository(TOKEN_ENTITY_NAMES.denied), orm.getRepository(TOKEN_ENTITY_NAMES.revocations), now, retentionRevokedMs, orm.location);
+	}
+	/**
+	* Insère ou remplace un record (PAT / refresh) — 1 requête, `upsert` atomique
+	* sur la PK `id` plutôt qu'un `findOne` d'existence + `create`/`updateOne`
+	* (2 round-trips). `put` pose le record COMPLET (`createdAt` inclus) → tout
+	* hors `id` est ré-appliqué en cas de conflit ; pas de champ insert-only.
+	*
+	* ⚠️ **Limite `ON CONFLICT`, propre à cette table** : `access_token` porte
+	* DEUX contraintes uniques (`id` PK + `secretHash`), or un upsert n'arbitre
+	* qu'UN index. Deux INSERT **concurrents** d'un record **absent** partageant
+	* le même `secretHash` feraient donc lever le perdant (PG : `23505` sur
+	* `access_token_secretHash_unique`) — l'arbitre `id` ne couvre pas la seconde
+	* unique. Ce n'est pas atteignable : les trois appelants (`tokenService`
+	* émission + rotation, `apiKeys`) posent un `id` **généré** (`randomUUID` /
+	* `#randomId`), donc jamais deux `put` du même id neuf ; le seul `put`
+	* concurrent d'un même id porte sur une ligne **existante** (rotation
+	* rejouée), qui tombe sur le chemin DO UPDATE et passe. Une entité à deux
+	* uniques dont les DEUX seraient réellement disputées demanderait un autre
+	* remède (réservation en deux instructions, cf `reserveIdempotencyKeyMysql`).
+	*
+	* @param record - le record complet à persister.
+	*/
+	async put(record) {
+		const { id, ...rest } = record;
+		await this.#records.upsert({ id }, rest);
+	}
+	findById(id) {
+		return this.#records.findOne({ id });
+	}
+	findByHash(secretHash) {
+		return this.#records.findOne({ secretHash });
+	}
+	findBySubject(subjectId) {
+		return this.#records.find({ subjectId });
+	}
+	/** Tous les jetons (PAT + refresh) — vue d'administration cross-porteur. */
+	listAll() {
+		return this.#records.find({});
+	}
+	/**
+	* {@inheritDoc ITokenStore.listPage}
+	*
+	* Portable à 100 % : le helper `paginate()` d'orm-core (LIMIT/OFFSET + COUNT
+	* optionnel) sur un `Criteria` simple — ne matérialise qu'une page. Le tri
+	* demandé descend dans le `ORDER BY` (jamais de tri après découpe : la 2ᵉ page
+	* doit continuer la 1ʳᵉ) ; à défaut, l'ordre contractuel `createdAt DESC, id
+	* DESC` rend l'offset déterministe. Les noms de colonnes SQL sont ceux du
+	* vocabulaire public — aucune traduction n'est nécessaire ici.
+	*/
+	listPage(query) {
+		assertPageQuery(query, "offset");
+		return paginate(this.#records, {
+			criteria: tokenListCriteria(query, this.#now()),
+			limit: query.limit,
+			offset: query.offset,
+			withTotal: query.withTotal,
+			order: pickOrder(query.order, this.sortableFields, TOKEN_DEFAULT_ORDER)
+		});
+	}
+	/** {@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 de révocation est
+	* conservée (l'audit ne se réécrit pas).
+	*
+	* Le « pas encore révoqué » vit dans le `WHERE` (`revokedAt IS NULL`), pas
+	* dans un `if` JS après lecture : une seule instruction, donc deux révocations
+	* concurrentes ne peuvent plus se recouvrir (la seconde n'affecte 0 ligne au
+	* lieu d'écraser la date de la première).
+	*
+	* @param id - identifiant du jeton.
+	* @param reason - motif de révocation, posé seulement à la 1ʳᵉ.
+	*/
+	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 (ex. `rotated`) gardent leur raison d'origine.
+	*
+	* Un seul `UPDATE … WHERE family = ? AND revokedAt IS NULL` : atomique, et
+	* N+1 requêtes (1 SELECT + 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({ jti }, { expiresAt });
+	}
+	async isJtiDenied(jti) {
+		return await this.#denied.findOne({
+			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`), 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 les jetons que le logout
+	* le plus récent venait d'invalider repasseraient sous le seuil : **des jetons
+	* révoqués redeviendraient valides**. Une instruction unique sur les 4
+	* backends (`MAX()` sqlite, `GREATEST()` pg/mysql, `$max` Mongo) — un `WHERE`
+	* sur le `DO UPDATE` n'existe pas en MySQL.
+	*
+	* @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({ subjectId }, { invalidBefore: { $max: invalidBefore } });
+	}
+	async getInvalidBefore(subjectId) {
+		const row = await this.#revocations.findOne({ 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 { DrizzleTokenStore };

package/dist/nodefony/src/DrizzleTotpSecretStore.js

@@ -0,0 +1,151 @@
+import { TOTP_SECRET_ENTITY } from "../entity/totpSecretEntity.js";
+import { assertPageQuery } from "nodefony";
+import { paginate, searchCriteria } from "@nodefony/orm-core";
+//#region nodefony/src/DrizzleTotpSecretStore.ts
+/**
+* Store de secrets TOTP **Drizzle** (driver `better-sqlite3`) — implémentation SQL
+* d'{@link ITotpSecretStore} au-dessus d'un unique repository `@nodefony/orm-core`
+* (`totp_secret`). Comble le gap « 2FA persistant sans fichier » : là où
+* `MemoryTotpSecretStore` est volatile, ce store survit au redémarrage et se
+* partage entre pods (base durable).
+*
+* **Modèle 1 secret / utilisateur** (clé = `userId`) → `save` est un upsert par PK.
+*
+* **Approche B** : l'ORM ne connaît `@nodefony/security` qu'en `import type` → 0
+* dépendance runtime. L'entité (`registerTotpSecretEntity(orm)`) doit être
+* enregistrée **avant** `orm.connect()`.
+*
+* **100 % portable** (aucun SQL natif) — toutes les opérations passent par le
+* contrat `IRepository`, donc le code se transpose tel quel aux autres drivers.
+*
+* **`secretEnc` opaque** : le store persiste le secret DÉJÀ chiffré (AES-256-GCM
+* côté service) — il ne déchiffre jamais, ne voit que des octets.
+*/
+var DrizzleTotpSecretStore = class DrizzleTotpSecretStore {
+	#repo;
+	#location;
+	/**
+	* @param repo - repository de la table `totp_secret`.
+	* @param location - emplacement physique de la base (fichier SQLite) pour Studio
+	*   ({@link DrizzleOrm.location}) ; `undefined` pour un backend réseau/`:memory:`.
+	*/
+	constructor(repo, location) {
+		this.#repo = repo;
+		this.#location = location;
+	}
+	/**
+	* Emplacement physique de la base (fichier SQLite) pour l'écran Studio « Stores »
+	* — lu par `readStoreLocation`. `undefined` = backend réseau ou `:memory:`.
+	*/
+	get location() {
+		return this.#location;
+	}
+	/**
+	* Construit le store depuis un {@link DrizzleOrm} connecté. L'entité
+	* (`registerTotpSecretEntity`) doit avoir été enregistrée **avant** `orm.connect()`.
+	*
+	* @param orm - ORM Drizzle connecté hébergeant la table du store.
+	*/
+	static from(orm) {
+		return new DrizzleTotpSecretStore(orm.getRepository(TOTP_SECRET_ENTITY), orm.location);
+	}
+	/** Row plate → secret du contrat (recoveryCodes copié = mutable indépendant). */
+	#toSecret(row) {
+		return {
+			userId: row.userId,
+			secretEnc: row.secretEnc,
+			algorithm: row.algorithm,
+			digits: row.digits,
+			period: row.period,
+			recoveryCodes: [...row.recoveryCodes],
+			confirmedAt: row.confirmedAt,
+			lastUsedStep: row.lastUsedStep,
+			createdAt: row.createdAt,
+			lastUsedAt: row.lastUsedAt
+		};
+	}
+	/** Secret du contrat → row plate (colonnes `notNull` toutes fournies). */
+	#toRow(s) {
+		return {
+			userId: s.userId,
+			secretEnc: s.secretEnc,
+			algorithm: s.algorithm,
+			digits: s.digits,
+			period: s.period,
+			recoveryCodes: [...s.recoveryCodes],
+			confirmedAt: s.confirmedAt,
+			lastUsedStep: s.lastUsedStep,
+			createdAt: s.createdAt,
+			lastUsedAt: s.lastUsedAt
+		};
+	}
+	async findByUser(userId) {
+		const row = await this.#repo.findOne({ userId });
+		return row ? this.#toSecret(row) : null;
+	}
+	async save(secret) {
+		const { userId, ...rest } = this.#toRow(secret);
+		await this.#repo.upsert({ userId }, rest);
+	}
+	async update(userId, patch) {
+		const set = {};
+		if (patch.confirmedAt !== void 0) set.confirmedAt = patch.confirmedAt;
+		if (patch.recoveryCodes !== void 0) set.recoveryCodes = patch.recoveryCodes;
+		if (patch.lastUsedStep !== void 0) set.lastUsedStep = patch.lastUsedStep;
+		if (patch.lastUsedAt !== void 0) set.lastUsedAt = patch.lastUsedAt;
+		if (Object.keys(set).length === 0) return;
+		await this.#repo.updateOne({ userId }, set);
+	}
+	async delete(userId) {
+		await this.#repo.delete({ userId });
+	}
+	/**
+	* Critère portable des filtres du listing. `confirmed` s'exprime en `$null`
+	* sur `confirmedAt` (pas de colonne booléenne dérivée à maintenir), `q` en
+	* `$like` **ancré à gauche** (`préfixe%`) — donc indexable, contrairement à
+	* une recherche `%…%`.
+	*/
+	#listCriteria(query) {
+		const criteria = {};
+		if (query.confirmed !== void 0) criteria.confirmedAt = { $null: !query.confirmed };
+		Object.assign(criteria, searchCriteria(query.q, ["userId"]) ?? {});
+		return criteria;
+	}
+	/**
+	* {@inheritDoc ITotpSecretStore.listPage}
+	*
+	* 100 % portable : le helper `paginate()` d'orm-core (LIMIT/OFFSET + COUNT
+	* optionnel) sur un critère simple. La projection en vue d'enrôlement retire
+	* `secretEnc` et les condensats — ils ne franchissent jamais la frontière du
+	* store, quel que soit l'appelant.
+	*/
+	async listPage(query) {
+		assertPageQuery(query, "offset");
+		const page = await paginate(this.#repo, {
+			criteria: this.#listCriteria(query),
+			limit: query.limit,
+			offset: query.offset,
+			withTotal: query.withTotal,
+			order: [["createdAt", "DESC"], ["userId", "ASC"]]
+		});
+		return {
+			...page,
+			items: page.items.map((row) => ({
+				userId: row.userId,
+				algorithm: row.algorithm,
+				digits: row.digits,
+				period: row.period,
+				confirmedAt: row.confirmedAt,
+				createdAt: row.createdAt,
+				lastUsedAt: row.lastUsedAt,
+				recoveryCodesLeft: row.recoveryCodes.length
+			}))
+		};
+	}
+	/** {@inheritDoc ITotpSecretStore.countEnrollments} */
+	countEnrollments(query) {
+		return this.#repo.count(this.#listCriteria(query));
+	}
+};
+//#endregion
+export { DrizzleTotpSecretStore };

package/dist/nodefony/src/DrizzleUserRepository.js

@@ -0,0 +1,217 @@
+import { countUsers, findUserIdBySocialProvider, listUserIdsPage } from "./queryKit.js";
+import { isFrameworkFallbackEntity } from "../registerStores.js";
+import { assertPageQuery } from "nodefony";
+import { BaseUser, USER_DEFAULT_ORDER, USER_SORTABLE_FIELDS, attachExtraColumns } from "@nodefony/user";
+//#region nodefony/src/DrizzleUserRepository.ts
+/**
+* Adapter Drizzle du contrat {@link IUserRepository} — implémentation SQL **par
+* défaut** de la persistance utilisateur (P5.9).
+*
+* Décore le repository portable générique (`IRepository<UserRow>` de
+* {@link DrizzleOrm}) de deux responsabilités propres à l'utilisateur :
+* - **mapping ligne ↔ `BaseUser`** : les consommateurs reçoivent un objet
+*   porteur du comportement (`hasRole`/`isActive`/`isLocked`), pas une ligne nue ;
+* - **finders métier** : `findByIdentifier` (lookup unique) et
+*   `findBySocialProvider` (recherche dans le JSON `socialProviders`, routée
+*   par dialecte via le queryKit — pattern Shadow User OAuth).
+*
+* Le credential (`password`) transite par cette frontière — c'est attendu : le
+* repository **est** la frontière de persistance du hash (cf `IUserRepository`).
+*/
+/**
+* Refuse de servir un annuaire dont la table n'existera nulle part.
+*
+* L'entité `User` du framework est un REPLI : elle dépanne quand l'application
+* n'a pas encore la sienne. Depuis que la table appartient à l'application, elle
+* n'est plus dans aucune chaîne de migration — donc hors développement, où le
+* schéma est dérivé du code, **personne ne la crée**. Sans ce refus,
+* l'application démarrerait, servirait ses pages, et échouerait à la première
+* authentification sur une table absente : le pire des trois moments pour
+* l'apprendre.
+*
+* Le refus ne vise que le cas où les deux conditions se rencontrent — entité de
+* repli ET schéma non dérivé. Une application qui possède son entité, ou qui
+* tourne en développement, ne le voit jamais.
+*
+* @param orm - l'ORM sur lequel l'annuaire s'apprête à lire.
+* @throws Error si la table `User` ne sera créée par personne.
+*/
+function assertUserTableIsOwned(orm) {
+	if (orm.derivesSchema || !isFrameworkFallbackEntity("User", orm.name)) return;
+	throw new Error(`Cette application doit posséder son entité « User » : le framework a posé la sienne par défaut, et elle n'est dans AUCUNE migration — la table n'existera donc pas sur le connecteur « ${orm.name} », où le schéma appartient aux migrations.\n  → la créer : nodefony create entity User\n  → puis générer sa migration : nodefony orm:generate --name user\n  → puis l'appliquer : nodefony orm:migrate\n(en développement le schéma est dérivé du code, ce qui masquait le manque.)`);
+}
+var DrizzleUserRepository = class DrizzleUserRepository {
+	/**
+	* Même vocabulaire public que les autres repositories — ici le tri part
+	* dans la requête, où il ne coûte qu'un index.
+	*/
+	sortableFields = USER_SORTABLE_FIELDS;
+	#base;
+	#db;
+	#dialect;
+	/**
+	* @param base - repository portable sur la table `User` (CRUD + criteria).
+	* @param db - handle Drizzle (racine ou transaction) pour les requêtes JSON brutes.
+	* @param dialect - dialecte SQL du connecteur (route les requêtes du queryKit).
+	*/
+	constructor(base, db, dialect = "sqlite") {
+		this.#base = base;
+		this.#db = db;
+		this.#dialect = dialect;
+	}
+	/**
+	* Construit le repository utilisateur depuis un {@link DrizzleOrm} connecté.
+	* L'entité `User` doit avoir été enregistrée (cf `registerUserEntity`) avant
+	* `orm.connect()` — sur la variante de table du dialecte de l'ORM.
+	*
+	* @param orm - ORM Drizzle connecté.
+	* @returns le repository utilisateur prêt à l'emploi.
+	*/
+	static from(orm) {
+		assertUserTableIsOwned(orm);
+		return new DrizzleUserRepository(orm.getRepository("User"), orm.getNativeConnection(), orm.dialect);
+	}
+	/** Mappe une ligne plate en {@link BaseUser} — colonnes hors contrat comprises. */
+	#toUser(row) {
+		const user = new BaseUser({
+			id: row.id,
+			identifier: row.identifier,
+			roles: row.roles,
+			password: row.password,
+			enabled: row.enabled,
+			locked: row.locked,
+			currentRole: row.currentRole,
+			socialProviders: row.socialProviders,
+			metadata: row.metadata
+		});
+		return attachExtraColumns(user, row);
+	}
+	async find(criteria, options) {
+		return (await this.#base.find(criteria, options)).map((row) => this.#toUser(row));
+	}
+	async findOne(criteria, options) {
+		const row = await this.#base.findOne(criteria, options);
+		return row ? this.#toUser(row) : null;
+	}
+	async create(data) {
+		const row = await this.#base.create(data);
+		return this.#toUser(row);
+	}
+	async updateOne(criteria, data) {
+		const row = await this.#base.updateOne(criteria, data);
+		return row ? this.#toUser(row) : null;
+	}
+	async upsert(criteria, update, insertOnly) {
+		const row = await this.#base.upsert(criteria, update, insertOnly);
+		return this.#toUser(row);
+	}
+	async createMany(data) {
+		return (await this.#base.createMany(data)).map((row) => this.#toUser(row));
+	}
+	exists(criteria) {
+		return this.#base.exists(criteria);
+	}
+	deleteOne(criteria) {
+		return this.#base.deleteOne(criteria);
+	}
+	async findOneAndDelete(criteria) {
+		const row = await this.#base.findOneAndDelete(criteria);
+		return row ? this.#toUser(row) : null;
+	}
+	async increment(criteria, changes) {
+		const row = await this.#base.increment(criteria, changes);
+		return row ? this.#toUser(row) : null;
+	}
+	updateMany(criteria, data) {
+		return this.#base.updateMany(criteria, data);
+	}
+	delete(criteria) {
+		return this.#base.delete(criteria);
+	}
+	count(criteria) {
+		return this.#base.count(criteria);
+	}
+	countDistinct(field, criteria) {
+		return this.#base.countDistinct(field, criteria);
+	}
+	withTransaction(tx) {
+		return new DrizzleUserRepository(this.#base.withTransaction(tx), tx.getNative(), this.#dialect);
+	}
+	findByIdentifier(identifier) {
+		return this.findOne({ identifier });
+	}
+	/**
+	* Recherche par compte externe lié — cherche dans le JSON `socialProviders`
+	* via le queryKit (forme native du dialecte : `json_each` SQLite / `@>`
+	* jsonb PG, 1 requête), récupère l'`id`, puis recharge par le chemin typé
+	* (parsing JSON/booléens cohérent). `null` si aucun lien.
+	*/
+	async findBySocialProvider(provider, providerId) {
+		const id = await findUserIdBySocialProvider(this.#db, this.#dialect, provider, providerId);
+		if (id === null) return null;
+		return this.findOne({ id });
+	}
+	/**
+	* {@inheritDoc IUserRepository.listPage}
+	*
+	* SQL natif (queryKit, routé par dialecte) → **uniquement les `id`** de la page
+	* (containment de rôle + `LIKE` insensible casse non exprimables par le query
+	* builder portable), puis rechargement des lignes complètes par le chemin typé
+	* (`find({ id: $in })`, parsing JSON/booléens cohérent), **ré-ordonnées** selon
+	* le tri SQL. Jamais plus d'une page matérialisée.
+	*/
+	async listPage(query) {
+		assertPageQuery(query, "offset");
+		const limit = Math.max(1, Math.floor(query.limit));
+		const offset = Math.max(0, Math.floor(query.offset ?? 0));
+		const filters = {
+			role: query.role,
+			enabled: query.enabled,
+			locked: query.locked,
+			hasSocial: query.hasSocial,
+			q: query.q
+		};
+		const order = query.order?.length ? query.order : USER_DEFAULT_ORDER;
+		const { ids, hasNext } = await listUserIdsPage(this.#db, this.#dialect, filters, {
+			limit,
+			offset,
+			order
+		});
+		const total = query.withTotal === false ? void 0 : await countUsers(this.#db, this.#dialect, filters);
+		if (ids.length === 0) return {
+			items: [],
+			total,
+			limit,
+			offset,
+			hasNext
+		};
+		const rows = await this.#base.find({ id: { $in: ids } });
+		const byId = new Map(rows.map((row) => [row.id, this.#toUser(row)]));
+		return {
+			items: ids.map((id) => byId.get(id)).filter((u) => u !== void 0),
+			total,
+			limit,
+			offset,
+			hasNext
+		};
+	}
+	/** {@inheritDoc IUserRepository.countUsers} */
+	countUsers(query) {
+		return countUsers(this.#db, this.#dialect, {
+			role: query.role,
+			enabled: query.enabled,
+			locked: query.locked,
+			hasSocial: query.hasSocial,
+			q: query.q
+		});
+	}
+	/** {@inheritDoc IUserRepository.countActiveAdmins} */
+	countActiveAdmins(adminRole) {
+		return countUsers(this.#db, this.#dialect, {
+			enabled: true,
+			role: adminRole
+		});
+	}
+};
+//#endregion
+export { DrizzleUserRepository };