@nodefony/drizzle 10.0.0-alpha.1

package/dist/nodefony/src/DrizzleWebAuthnCredentialStore.js

@@ -0,0 +1,159 @@
+import { WEBAUTHN_CREDENTIAL_ENTITY } from "../entity/webAuthnCredentialEntity.js";
+import { assertPageQuery } from "nodefony";
+import { paginate, searchCriteria } from "@nodefony/orm-core";
+//#region nodefony/src/DrizzleWebAuthnCredentialStore.ts
+/**
+* Store de credentials WebAuthn **Drizzle** (driver `better-sqlite3`) —
+* implémentation SQL d'{@link IWebAuthnCredentialStore} au-dessus d'un unique
+* repository `@nodefony/orm-core` (`webauthn_credential`).
+*
+* **Approche B** : l'ORM ne connaît `@nodefony/security` qu'en `import type` → 0
+* dépendance runtime. C'est l'application qui enregistre la fabrique
+* (`registerWebAuthnStore("drizzle", …)`) et l'entité
+* (`registerWebAuthnCredentialEntity(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.
+*
+* **Mapping Row ↔ contrat** : le repository renvoie une {@link WebAuthnCredentialRow}
+* plate (`nickname: string | null`, `transports` mutable) ; le store la normalise
+* en `IWebAuthnCredential` (`nickname?` omis si `null`). Le store de jetons n'a pas
+* ce mapping car `IAccessTokenRecord` est déjà la forme repository (tout `| null`).
+*/
+var DrizzleWebAuthnCredentialStore = class DrizzleWebAuthnCredentialStore {
+	#repo;
+	#location;
+	/**
+	* @param repo - repository de la table `webauthn_credential`.
+	* @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é
+	* (`registerWebAuthnCredentialEntity`) doit avoir été enregistrée **avant**
+	* `orm.connect()`.
+	*
+	* @param orm - ORM Drizzle connecté hébergeant la table du store.
+	*/
+	static from(orm) {
+		return new DrizzleWebAuthnCredentialStore(orm.getRepository(WEBAUTHN_CREDENTIAL_ENTITY), orm.location);
+	}
+	/** Row plate → credential du contrat (`nickname?` omis si `null`). */
+	#toCredential(row) {
+		return {
+			id: row.id,
+			userId: row.userId,
+			publicKey: row.publicKey,
+			signCount: row.signCount,
+			transports: row.transports,
+			backupEligible: row.backupEligible,
+			backupState: row.backupState,
+			uvInitialized: row.uvInitialized,
+			createdAt: row.createdAt,
+			lastUsedAt: row.lastUsedAt,
+			...row.nickname !== null ? { nickname: row.nickname } : {}
+		};
+	}
+	/** Credential du contrat → row plate (`nickname` absent → `null`, transports copié). */
+	#toRow(c) {
+		return {
+			id: c.id,
+			userId: c.userId,
+			publicKey: c.publicKey,
+			signCount: c.signCount,
+			transports: [...c.transports],
+			backupEligible: c.backupEligible,
+			backupState: c.backupState,
+			uvInitialized: c.uvInitialized,
+			nickname: c.nickname ?? null,
+			createdAt: c.createdAt,
+			lastUsedAt: c.lastUsedAt
+		};
+	}
+	async findById(credentialId) {
+		const row = await this.#repo.findOne({ id: credentialId });
+		return row ? this.#toCredential(row) : null;
+	}
+	async findByUser(userId) {
+		return (await this.#repo.find({ userId })).map((row) => this.#toCredential(row));
+	}
+	/** `COUNT(*)` natif — jamais un `find().length` (le plafond ne charge rien). */
+	countByUser(userId) {
+		return this.#repo.count({ userId });
+	}
+	async save(credential) {
+		const { id, ...rest } = this.#toRow(credential);
+		await this.#repo.upsert({ id }, rest);
+	}
+	async update(credentialId, patch) {
+		await this.#repo.updateOne({ id: credentialId }, {
+			signCount: patch.signCount,
+			backupState: patch.backupState,
+			uvInitialized: patch.uvInitialized,
+			lastUsedAt: patch.lastUsedAt
+		});
+	}
+	async delete(credentialId) {
+		await this.#repo.delete({ id: credentialId });
+	}
+	/**
+	* Critères du listing admin. `q` = PRÉFIXE d'`userId` (`LIKE 'x%'`, indexable),
+	* jamais une recherche `%…%`.
+	*/
+	#listCriteria(query) {
+		const criteria = {};
+		if (query.userId !== void 0) criteria.userId = query.userId;
+		else Object.assign(criteria, searchCriteria(query.q, ["userId"]) ?? {});
+		if (query.backedUp !== void 0) criteria.backupState = query.backedUp;
+		return criteria;
+	}
+	/**
+	* {@inheritDoc IWebAuthnCredentialStore.listPage}
+	*
+	* 100 % portable : le helper `paginate()` d'orm-core (LIMIT/OFFSET + COUNT
+	* optionnel). La projection en vue admin retire `publicKey` — elle ne franchit
+	* 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"], ["id", "ASC"]]
+		});
+		return {
+			...page,
+			items: page.items.map((row) => ({
+				id: row.id,
+				userId: row.userId,
+				transports: row.transports,
+				backupEligible: row.backupEligible,
+				backupState: row.backupState,
+				uvInitialized: row.uvInitialized,
+				signCount: row.signCount,
+				createdAt: row.createdAt,
+				lastUsedAt: row.lastUsedAt,
+				...row.nickname !== null ? { nickname: row.nickname } : {}
+			}))
+		};
+	}
+	/** {@inheritDoc IWebAuthnCredentialStore.countCredentials} */
+	countCredentials(query) {
+		return this.#repo.count(this.#listCriteria(query));
+	}
+};
+//#endregion
+export { DrizzleWebAuthnCredentialStore };

package/dist/nodefony/src/DrizzleWebhookStore.js

@@ -0,0 +1,169 @@
+import { WEBHOOK_ENDPOINT_ENTITY } from "../entity/webhookEndpointEntity.js";
+import { countWebhookEndpoints, listWebhookIdsPage } from "./queryKit.js";
+import { assertPageQuery } from "nodefony";
+import { WEBHOOK_SORTABLE_FIELDS } from "@nodefony/security";
+//#region nodefony/src/DrizzleWebhookStore.ts
+/**
+* Store d'endpoints webhook **Drizzle** (driver `better-sqlite3`) —
+* implémentation SQL d'{@link IWebhookStore} au-dessus d'un unique repository
+* `@nodefony/orm-core` (`webhook_endpoint`). Persistance DURABLE du registre
+* (les endpoints survivent au redémarrage, contrairement à `MemoryWebhookStore`).
+*
+* **Approche B** : l'ORM ne connaît `@nodefony/security` qu'en `import type` → 0
+* dépendance runtime. C'est l'application qui enregistre la fabrique
+* (`registerWebhookStore("drizzle", …)`) et l'entité
+* (`registerWebhookEndpointEntity(orm)` avant `orm.connect()`).
+*
+* **Portable sauf le listing paginé** : le CRUD passe par le contrat
+* `IRepository` (transposable tel quel aux autres drivers) ; seuls `listPage` /
+* `countEndpoints` descendent au SQL natif via le `queryKit`, parce que le
+* filtre `event` cherche dans un tableau JSON — inexprimable en `Criteria`.
+*
+* **Mapping Row ↔ contrat** minimal : `IWebhookEndpoint` est déjà « plat tout
+* `| null` » ; seuls les champs JSON `events` (`readonly` → mutable) et
+* `metadata` sont copiés défensivement.
+*/
+var DrizzleWebhookStore = class DrizzleWebhookStore {
+	/**
+	* {@inheritDoc IWebhookStore.sortableFields}
+	*
+	* Le moteur SQL trie sur n'importe laquelle de ces colonnes. Cette liste sert
+	* DEUX fois : elle annonce la capacité au data plane, et elle borne le
+	* `ORDER BY` construit par le queryKit (identifiant concaténé, non liable).
+	*/
+	sortableFields = WEBHOOK_SORTABLE_FIELDS;
+	#repo;
+	#location;
+	#db;
+	#dialect;
+	/**
+	* @param repo - repository de la table `webhook_endpoint`.
+	* @param location - emplacement physique de la base (fichier SQLite) pour Studio
+	*   ({@link DrizzleOrm.location}) ; `undefined` pour un backend réseau/`:memory:`.
+	* @param db - handle Drizzle natif, requis par le seul listing paginé (filtre
+	*   `event` = containment dans un tableau JSON, hors `Criteria` portable).
+	*   `null` = store construit sans handle : `listPage` refuse plutôt que de
+	*   charger toute la table en silence.
+	* @param dialect - dialecte SQL du connecteur (route les requêtes du queryKit).
+	*/
+	constructor(repo, location, db = null, dialect = "sqlite") {
+		this.#repo = repo;
+		this.#location = location;
+		this.#db = db;
+		this.#dialect = dialect;
+	}
+	/**
+	* 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é
+	* (`registerWebhookEndpointEntity`) doit avoir été enregistrée **avant**
+	* `orm.connect()`.
+	*
+	* @param orm - ORM Drizzle connecté hébergeant la table du store.
+	*/
+	static from(orm) {
+		return new DrizzleWebhookStore(orm.getRepository(WEBHOOK_ENDPOINT_ENTITY), orm.location, orm.getNativeConnection(), orm.dialect);
+	}
+	/** Row plate → endpoint du contrat (`events` mutable accepté en `readonly`). */
+	#toEndpoint(row) {
+		return { ...row };
+	}
+	/** Endpoint du contrat → row plate (copie défensive des champs JSON). */
+	#toRow(e) {
+		return {
+			...e,
+			events: [...e.events],
+			metadata: { ...e.metadata }
+		};
+	}
+	async save(endpoint) {
+		const { id, ...rest } = this.#toRow(endpoint);
+		await this.#repo.upsert({ id }, rest);
+	}
+	async findById(id) {
+		const row = await this.#repo.findOne({ id });
+		return row ? this.#toEndpoint(row) : null;
+	}
+	async update(id, patch) {
+		const { events, metadata, ...rest } = patch;
+		const row = { ...rest };
+		if (events !== void 0) row.events = [...events];
+		if (metadata !== void 0) row.metadata = { ...metadata };
+		await this.#repo.updateOne({ id }, row);
+	}
+	async delete(id) {
+		await this.#repo.delete({ id });
+	}
+	async listAll() {
+		return (await this.#repo.find({})).map((row) => this.#toEndpoint(row));
+	}
+	/**
+	* Handle natif ou erreur explicite — un `listPage` qui retomberait sur un
+	* `find({})` complet trahirait silencieusement la garantie du contrat
+	* (« jamais plus d'une page en mémoire »).
+	*/
+	#nativeDb() {
+		if (this.#db === null) throw new Error("DrizzleWebhookStore: listing paginé indisponible (store construit sans handle natif). Utiliser DrizzleWebhookStore.from(orm).");
+		return this.#db;
+	}
+	/**
+	* {@inheritDoc IWebhookStore.listPage}
+	*
+	* Chemin NATIF (queryKit) : le filtre `event` cherche dans un tableau JSON —
+	* `json_each` (sqlite) / `@>` jsonb (postgres) / `JSON_CONTAINS` (mysql), non
+	* exprimable en `Criteria` portable. On sélectionne les `id` de la page (SQL
+	* pur, aucune ligne matérialisée), puis on recharge la page typée en 1
+	* requête `IN (...)` — coût O(page), jamais O(table).
+	*/
+	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 db = this.#nativeDb();
+		const filters = {
+			enabled: query.enabled,
+			event: query.event,
+			failing: query.failing,
+			q: query.q
+		};
+		const { ids, hasNext } = await listWebhookIdsPage(db, this.#dialect, filters, {
+			limit,
+			offset,
+			...query.order ? { order: query.order } : {},
+			sortable: this.sortableFields
+		});
+		const total = query.withTotal === false ? void 0 : await countWebhookEndpoints(db, this.#dialect, filters);
+		if (ids.length === 0) return {
+			items: [],
+			total,
+			limit,
+			offset,
+			hasNext
+		};
+		const rows = await this.#repo.find({ id: { $in: ids } });
+		const byId = new Map(rows.map((row) => [row.id, this.#toEndpoint(row)]));
+		return {
+			items: ids.map((id) => byId.get(id)).filter((e) => e !== void 0),
+			total,
+			limit,
+			offset,
+			hasNext
+		};
+	}
+	/** {@inheritDoc IWebhookStore.countEndpoints} */
+	countEndpoints(query) {
+		return countWebhookEndpoints(this.#nativeDb(), this.#dialect, {
+			enabled: query.enabled,
+			event: query.event,
+			failing: query.failing,
+			q: query.q
+		});
+	}
+};
+//#endregion
+export { DrizzleWebhookStore };

package/dist/nodefony/src/SessionStorage.js

@@ -0,0 +1,259 @@
+import { SESSION_CONNECTOR } from "../entity/sessionEntity.js";
+import { assertPageQuery, pickOrder, renameOrderFields } from "nodefony";
+import { ormRegistry, paginate } from "@nodefony/orm-core";
+import { SESSION_COLUMN_ALIASES, SESSION_DEFAULT_ORDER, SESSION_SORTABLE_FIELDS, SessionsService } from "@nodefony/http";
+//#region nodefony/src/SessionStorage.ts
+/**
+* Stockage de session **Drizzle** (driver `better-sqlite3`), branché sur
+* `@nodefony/orm-core`.
+*
+* Implémente le contrat {@link ISessionStorage} consommé par le `SessionsService`
+* de `@nodefony/http` — store de session portable. Persiste via
+* le repository orm-core de l'entité `session` (connecteur `default`, table créée
+* au boot par `DrizzleOrm`). Le GC supprime les sessions expirées avec un
+* opérateur riche portable (`updatedAt < cutoff`).
+*/
+var SessionStorage = class SessionStorage {
+	manager;
+	idleTimeoutS;
+	absoluteTimeoutS;
+	/**
+	* Même vocabulaire public que les autres backends — le tri part dans le
+	* `ORDER BY`, donc il ne coûte rien de plus qu'un index bien posé.
+	*/
+	sortableFields = SESSION_SORTABLE_FIELDS;
+	constructor(manager) {
+		this.manager = manager;
+		this.idleTimeoutS = manager.options.idleTimeoutS;
+		this.absoluteTimeoutS = manager.options.absoluteTimeoutS;
+	}
+	/**
+	* Emplacement physique de la base (fichier SQLite) pour l'écran Studio « Stores »
+	* — lu par `readStoreLocation` du core au boot de `SessionsService`. Résolu
+	* **lazy** depuis l'ORM du connecteur session (comme {@link SessionStorage.#repo}) :
+	* `undefined` si l'ORM n'est pas encore enregistré, en `:memory:`, ou réseau
+	* (postgres/mysql → l'emplacement EST l'infra déclarée, surfacée à part). Lecture
+	* DÉFENSIVE (getter `location` optionnel) — l'ORM base `IOrm` ne l'expose pas.
+	*/
+	get location() {
+		if (!ormRegistry.has("default")) return;
+		const loc = ormRegistry.get(SESSION_CONNECTOR).location;
+		return typeof loc === "string" && loc.length > 0 ? loc : void 0;
+	}
+	/**
+	* Repository de l'entité session, ou `null` si l'ORM n'est pas (ou plus)
+	* connecté.
+	*
+	* Cas concret : pendant le shutdown du kernel, `DrizzleService` déconnecte
+	* l'ORM (`disconnect()` annule ses tables) alors que des requêtes peuvent
+	* encore être en vol (firewall → `startSession`). Plutôt que de jeter
+	* « no entity table registered under session » (qui devenait un 500 sur ces
+	* requêtes + un `unhandledRejection` via le GC fire-and-forget), on renvoie
+	* `null` et chaque opération dégrade gracieusement (session non persistée le
+	* temps de l'arrêt). Une table réellement absente sur un ORM **connecté**
+	* (vraie misconfig) jette toujours via `getRepository`.
+	*/
+	#repo() {
+		const orm = ormRegistry.get(SESSION_CONNECTOR);
+		if (!orm.isConnected()) return null;
+		return orm.getRepository("session");
+	}
+	async read(id) {
+		const criteria = { session_id: id };
+		const repo = this.#repo();
+		if (!repo) return {};
+		const row = await repo.findOne(criteria);
+		if (!row) return {};
+		return {
+			Attributes: row.Attributes ?? {},
+			metaBag: row.metaBag ?? {},
+			flashBag: row.flashBag ?? {},
+			user: row.user ?? "",
+			createdAt: new Date(row.createdAt),
+			updatedAt: new Date(row.updatedAt)
+		};
+	}
+	async start(id) {
+		return this.read(id);
+	}
+	async write(id, data) {
+		const serialize = data;
+		const now = Date.now();
+		const repo = this.#repo();
+		if (!repo) return {
+			...serialize,
+			createdAt: new Date(now),
+			updatedAt: new Date(now)
+		};
+		const fields = {
+			Attributes: serialize.Attributes,
+			flashBag: serialize.flashBag,
+			metaBag: serialize.metaBag,
+			user: serialize.user || null,
+			updatedAt: now
+		};
+		const row = await repo.upsert({ session_id: id }, fields, { createdAt: now });
+		return {
+			...serialize,
+			createdAt: new Date(row.createdAt),
+			updatedAt: new Date(now)
+		};
+	}
+	async open() {
+		await this.gc();
+		const repo = this.#repo();
+		if (!repo) return 0;
+		const count = await repo.count();
+		this.manager.log(`DRIZZLE SESSIONS STORAGE ==> COUNT SESSIONS : ${count}`, "INFO");
+		return count;
+	}
+	close() {
+		this.gc();
+		return true;
+	}
+	async destroy(id) {
+		const criteria = { session_id: id };
+		const repo = this.#repo();
+		if (!repo) return true;
+		await repo.delete(criteria);
+		this.manager.log(`DRIZZLE DESTROY SESSION ID : ${id}`, "DEBUG");
+		return true;
+	}
+	async gc(idleSeconds, absoluteSeconds) {
+		const repo = this.#repo();
+		if (!repo) return;
+		const now = Date.now();
+		const idleCutoff = now - (idleSeconds ?? this.idleTimeoutS) * 1e3;
+		let deleted = await repo.delete({ updatedAt: { $lt: idleCutoff } });
+		const absoluteS = absoluteSeconds ?? this.absoluteTimeoutS;
+		if (absoluteS > 0) deleted += await repo.delete({ createdAt: { $lt: now - absoluteS * 1e3 } });
+		if (deleted > 0) this.manager.log(`DRIZZLE SESSIONS GC ==> ${deleted} DELETED`, "DEBUG");
+	}
+	/**
+	* Prolonge l'idle d'une session (timeout glissant) : `UPDATE updatedAt = now`
+	* sur la PK `session_id` — SANS réécrire le blob (touch NIST/OWASP). N'affecte
+	* pas `createdAt` (= borne absolute). ORM déconnecté → no-op ; une ligne absente
+	* (session expirée) → 0 row affectée, silencieux.
+	*/
+	async touch(id) {
+		const repo = this.#repo();
+		if (!repo) return;
+		await repo.updateOne({ session_id: id }, { updatedAt: Date.now() });
+	}
+	/**
+	* Énumération admin (capacité optionnelle d'`ISessionStorage`) : un `SELECT`
+	* filtrable par `user` (WHERE indexable côté SQL). **Redaction par construction**
+	* — seuls `user`/`metaBag`/timestamps sortent de la base ; `Attributes`/`flashBag`
+	* (potentiellement sensibles) restent en base. ORM déconnecté → `[]`.
+	*/
+	async listAll(filter) {
+		const repo = this.#repo();
+		if (!repo) return [];
+		return (filter?.user !== void 0 ? await repo.find({ user: filter.user }) : await repo.find()).map((row) => SessionStorage.#toRecord(row));
+	}
+	/**
+	* Projette une ligne SQL en {@link ISessionRecord} **redacté** : `Attributes` et
+	* `flashBag` (potentiellement sensibles) restent en base, seuls `user`/`metaBag`/
+	* horodatages sortent. Une session anonyme est stockée `user = NULL` (cf `write`)
+	* et ressort en chaîne vide — la représentation du « pas d'utilisateur » est une
+	* affaire de backend, jamais du contrat.
+	*/
+	static #toRecord(row) {
+		return {
+			id: row.session_id,
+			data: {
+				Attributes: {},
+				flashBag: {},
+				metaBag: row.metaBag ?? {},
+				user: row.user ?? "",
+				createdAt: new Date(row.createdAt),
+				updatedAt: new Date(row.updatedAt)
+			}
+		};
+	}
+	/**
+	* Traduit les filtres du contrat en `Criteria` orm-core — **portables** (égalité
+	* + `IS [NOT] NULL`), donc indexables par le SQL et jamais ré-appliqués en
+	* mémoire. Source unique du périmètre : {@link listPage}, {@link countSessions}
+	* et {@link countDistinctUsers} le partagent, ils ne peuvent pas diverger.
+	*
+	* Les deux filtres portent la **même colonne** (`authenticated` signifie
+	* « `user` non nul »), donc un critère AND-only ne peut en porter qu'une
+	* condition. Quand ils se contredisent — un identifiant nommé qu'on demande
+	* anonyme, ou l'inverse — la réponse honnête est **l'ensemble vide**, et c'est
+	* ce que dit `null`. En jeter un silencieusement rendait un compteur faux :
+	* `?user=alice` + `authenticated:false` répondait « 1 session anonyme »
+	* en désignant la session authentifiée d'alice.
+	*
+	* @returns `undefined` (aucun filtre), le critère, ou **`null`** si les
+	*   filtres sont contradictoires — l'appelant court-circuite alors sa requête.
+	*/
+	static #criteria(query) {
+		if (!query) return void 0;
+		const { user, authenticated } = query;
+		if (user !== void 0) {
+			const anonymous = user === "";
+			if (authenticated !== void 0 && authenticated === anonymous) return null;
+			return { user: anonymous ? { $null: true } : user };
+		}
+		if (authenticated !== void 0) return { user: { $null: !authenticated } };
+	}
+	/**
+	* Pagination **native** `LIMIT/OFFSET` + `COUNT` (helper `paginate` orm-core) :
+	* une page = une requête bornée, quel que soit le nombre de sessions en base.
+	* Ordre `updatedAt` DESC départagé par `session_id` — déterministe même quand
+	* deux sessions partagent la milliseconde. ORM déconnecté → page vide.
+	*/
+	async listPage(query) {
+		assertPageQuery(query, "offset");
+		const repo = this.#repo();
+		if (!repo) return {
+			items: [],
+			total: query.withTotal === false ? void 0 : 0,
+			limit: query.limit,
+			offset: query.offset ?? 0,
+			hasNext: false
+		};
+		const criteria = SessionStorage.#criteria(query);
+		if (criteria === null) return {
+			items: [],
+			total: query.withTotal === false ? void 0 : 0,
+			limit: query.limit,
+			offset: query.offset ?? 0,
+			hasNext: false
+		};
+		const page = await paginate(repo, {
+			criteria,
+			limit: query.limit,
+			offset: query.offset,
+			withTotal: query.withTotal,
+			order: renameOrderFields(pickOrder(query.order, this.sortableFields, SESSION_DEFAULT_ORDER), SESSION_COLUMN_ALIASES)
+		});
+		return {
+			...page,
+			items: page.items.map((row) => SessionStorage.#toRecord(row))
+		};
+	}
+	/** `COUNT(*)` natif filtré — aucune ligne matérialisée. ORM déconnecté → 0. */
+	async countSessions(query) {
+		const repo = this.#repo();
+		if (!repo) return 0;
+		const criteria = SessionStorage.#criteria(query);
+		return criteria === null ? 0 : repo.count(criteria);
+	}
+	/**
+	* `COUNT(DISTINCT user)` natif filtré. `write` normalise l'anonyme en `NULL`,
+	* et `COUNT(DISTINCT …)` ignore les `NULL` : les sessions anonymes ne forment
+	* donc pas un « utilisateur » de plus, sans filtre supplémentaire.
+	* ORM déconnecté → 0 (même dégradation que {@link countSessions}).
+	*/
+	async countDistinctUsers(query) {
+		const repo = this.#repo();
+		if (!repo) return 0;
+		const criteria = SessionStorage.#criteria(query);
+		return criteria === null ? 0 : repo.countDistinct("user", criteria);
+	}
+};
+SessionsService.registerStorage("drizzle", SessionStorage);
+//#endregion
+export { SessionStorage as default };

package/dist/nodefony/src/connectorTarget.js

@@ -0,0 +1,59 @@
+import path from "node:path";
+//#region nodefony/src/connectorTarget.ts
+/**
+* OÙ vit la base d'un connecteur — **une seule implémentation, deux lecteurs**.
+*
+* Le service qui connecte l'application au démarrage et les commandes de
+* migration doivent désigner exactement la même base. Ce n'est pas une
+* commodité : quand les deux divergent, rien ne le signale. La commande décrit
+* alors une base que l'application n'utilise pas, annonce « à jour » ou
+* « appliqué », et rend le code de sortie du succès.
+*
+* C'est arrivé, et voici comment : `filename` est **optionnel sans défaut**
+* dans le schéma de configuration, parce que sa valeur dépend du kernel
+* (`<app>/var/databases/…`) et que le schéma reste pur. Une lecture naïve de la
+* configuration rend donc `undefined` — et le pilote SQLite retombe alors sur
+* une base **en mémoire**, vide, jetée à la fin du processus. Toutes les
+* migrations s'y « appliquent » parfaitement.
+*
+* La règle vit donc ici, et les deux appelants l'appellent.
+*/
+/**
+* Chemin SQLite par défaut d'un connecteur, résolu depuis le kernel.
+*
+* Sous `kernel.varDir` (`<app>/var`) — la base commune des données persistées :
+* un seul répertoire à sauvegarder et à ignorer du dépôt, et « où sont mes
+* données » a une réponse unique.
+*
+* @param kernel - kernel courant (`null` accepté : repli sur le répertoire courant).
+* @param name - nom du connecteur.
+* @returns le chemin absolu du fichier de base.
+*/
+function defaultConnectorFilename(kernel, name) {
+	const root = (typeof kernel?.path === "string" ? kernel.path : null) ?? process.cwd();
+	const varPath = kernel?.varDir?.path;
+	const base = typeof varPath === "string" ? varPath : path.resolve(root, "var");
+	const file = name === "default" ? "nodefony-drizzle.db" : `nodefony-${name}.db`;
+	return path.resolve(base, "databases", file);
+}
+/**
+* Résout les coordonnées d'un connecteur : dialecte, et fichier ou URL.
+*
+* @param kernel - kernel courant, pour le chemin par défaut.
+* @param name - nom du connecteur.
+* @param cfg - configuration déclarée du connecteur.
+* @returns les coordonnées, avec le fichier SQLite TOUJOURS résolu.
+*/
+function resolveConnectorTarget(kernel, name, cfg) {
+	const dialect = cfg.dialect ?? "sqlite";
+	if (dialect !== "sqlite") return {
+		dialect,
+		url: cfg.url
+	};
+	return {
+		dialect,
+		filename: cfg.filename ?? defaultConnectorFilename(kernel, name)
+	};
+}
+//#endregion
+export { defaultConnectorFilename, resolveConnectorTarget };

package/dist/nodefony/src/likeSql.js

@@ -0,0 +1,50 @@
+import { LIKE_ESCAPE_CHAR } from "@nodefony/orm-core";
+import { sql } from "drizzle-orm";
+//#region nodefony/src/likeSql.ts
+/**
+* Le littéral SQL portant le caractère d'échappement d'un `LIKE`, par dialecte.
+*
+* MySQL réinterprète l'antislash **à l'intérieur d'un littéral de chaîne** : y
+* écrire `'\'` produit une chaîne inachevée, il faut `'\\'`. SQLite et
+* PostgreSQL prennent le littéral tel quel. Cette divergence d'une ligne était
+* recopiée à chaque site qui émettait une clause `ESCAPE` — et n'existait
+* évidemment pas sur ceux qui l'oubliaient.
+*
+* @param dialect - dialecte du connecteur branché.
+* @returns le littéral prêt à concaténer après `ESCAPE`.
+*/
+function escapeLiteral(dialect) {
+	const doubled = dialect === "mysql";
+	return sql.raw(`'${doubled ? LIKE_ESCAPE_CHAR : ""}${LIKE_ESCAPE_CHAR}'`);
+}
+/**
+* Compose une condition `LIKE` **avec sa clause `ESCAPE`** — le seul endroit de
+* l'adapter Drizzle qui écrive un `LIKE`.
+*
+* La clause n'est pas un raffinement : sans elle, le contrat `$like` n'a pas une
+* sémantique mais trois. PostgreSQL et MySQL appliquent déjà l'antislash comme
+* échappement par défaut, SQLite n'en a aucun et cherche l'antislash littéral —
+* si bien qu'un motif échappé rendait la bonne ligne en production et rien du
+* tout en développement (mesuré sur les trois moteurs). L'émettre aligne les
+* trois sur le comportement déjà majoritaire, et rend enfin exprimable un `%`
+* littéral.
+*
+* Le motif est **bindé** (paramètre), jamais concaténé : seul le littéral
+* d'échappement est brut, et il ne dépend que du dialecte.
+*
+* @param dialect - dialecte du connecteur branché.
+* @param expr - l'expression de gauche, déjà composée (colonne, `LOWER(col)`…).
+* @param pattern - le motif, dont les fragments littéraux ont été neutralisés
+*   par `escapeLikeTerm` (`@nodefony/orm-core`).
+* @returns la condition complète.
+*
+* @example
+* ```ts
+* likeCond(dialect, sql`LOWER(${col})`, `${escapeLikeTerm(q.toLowerCase())}%`)
+* ```
+*/
+function likeCond(dialect, expr, pattern) {
+	return sql`${expr} LIKE ${pattern} ESCAPE ${escapeLiteral(dialect)}`;
+}
+//#endregion
+export { likeCond };