@nodefony/drizzle 10.0.0-alpha.1

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

@@ -0,0 +1,106 @@
+//#region nodefony/src/orm-core/DrizzleTransaction.ts
+/**
+* Nom de savepoint sûr (S1) : un `SAVEPOINT` est un **identifiant** SQL, pas une
+* valeur — il ne peut donc pas être *bindé* en paramètre. Pour éliminer toute
+* injection via un nom non contrôlé (`a"; DROP …`), on impose un identifiant
+* strictement alphanumérique. Un nom invalide échoue **tôt et clairement**.
+*/
+const SAVEPOINT_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function assertSavepointName(name) {
+	if (!SAVEPOINT_NAME.test(name)) throw new Error(`DrizzleTransaction: invalid savepoint name ${JSON.stringify(name)} — expected /^[A-Za-z_][A-Za-z0-9_]*$/ (savepoint is an identifier, not a bindable value).`);
+}
+/**
+* Adapte une transaction SQL au contrat portable {@link ITransaction}, sur les
+* trois dialectes (sqlite, postgres, mysql).
+*
+* **Pourquoi une transaction manuelle (`BEGIN`/`COMMIT`/`ROLLBACK`) et pas le
+* helper `db.transaction()` de Drizzle** : `better-sqlite3` est **synchrone** ;
+* son helper attend un callback synchrone et committe au `return` — donc *avant*
+* que les `await` du contrat async (`IRepository`) ne s'exécutent. Encadrer le
+* travail par `BEGIN`…`COMMIT` garantit que toutes les opérations (ordonnées par
+* les `await`) tombent dans la même transaction.
+*
+* **Une transaction vit sur UNE connexion** : {@link DrizzleTransaction.getNative}
+* rend le db Drizzle lié à cette connexion précise (la connexion unique en
+* sqlite ; une connexion empruntée au pool en postgres/mysql). Un repository
+* n'entre dans la transaction que lié par `withTransaction(tx)` — celui rendu par
+* `orm.getRepository()` passe, lui, par le pool, donc HORS transaction.
+*
+* Mode managé (cf `DrizzleOrm.transaction`) : commit auto si la closure résout,
+* rollback auto si elle rejette. `commit`/`rollback` exposés (idempotents via le
+* drapeau interne) pour un pilotage manuel éventuel.
+*/
+var DrizzleTransaction = class {
+	#db;
+	#driver;
+	#done = false;
+	/**
+	* @param db - handle Drizzle lié à la connexion **déjà en `BEGIN`**.
+	* @param driver - pilotage transactionnel de cette connexion.
+	*/
+	constructor(db, driver) {
+		this.#db = db;
+		this.#driver = driver;
+	}
+	/** Indique si la transaction est déjà terminée (commit ou rollback). */
+	isDone() {
+		return this.#done;
+	}
+	/** Valide la transaction (no-op si déjà terminée). */
+	async commit() {
+		await this.#finish("COMMIT");
+	}
+	/** Annule la transaction (no-op si déjà terminée). */
+	async rollback() {
+		await this.#finish("ROLLBACK");
+	}
+	/**
+	* Termine la transaction et rend la connexion — **toujours**, y compris quand
+	* l'instruction échoue (sinon le pool fuit une connexion par échec). Le
+	* drapeau tombe AVANT l'exécution : un `COMMIT` en échec termine quand même la
+	* transaction, et le `rollback()` automatique qui suit doit être un no-op
+	* plutôt qu'une seconde instruction sur une connexion déjà rendue.
+	*
+	* @throws l'erreur du driver, la connexion ayant alors été détruite.
+	*/
+	async #finish(statement) {
+		if (this.#done) return;
+		this.#done = true;
+		try {
+			await this.#driver.exec(statement);
+			this.#driver.release();
+		} catch (error) {
+			this.#driver.release(error);
+			throw error;
+		}
+	}
+	/** Crée un savepoint nommé (nom validé — anti-injection, cf {@link assertSavepointName}). */
+	async savepoint(name) {
+		this.#assertLive("savepoint");
+		assertSavepointName(name);
+		await this.#driver.exec(`SAVEPOINT ${this.#driver.quoteIdent(name)}`);
+	}
+	/** Annule jusqu'au savepoint sans terminer la transaction (nom validé). */
+	async rollbackTo(name) {
+		this.#assertLive("rollbackTo");
+		assertSavepointName(name);
+		await this.#driver.exec(`ROLLBACK TO SAVEPOINT ${this.#driver.quoteIdent(name)}`);
+	}
+	/**
+	* Garde fail-loud : écrire après `commit`/`rollback` viserait une connexion
+	* déjà rendue au pool — donc la transaction d'un TIERS, ou aucune. Le dire ici
+	* plutôt que laisser le driver rendre une erreur cryptique (ou pire, réussir
+	* sur la connexion d'un autre emprunteur).
+	*
+	* @throws si la transaction est terminée.
+	*/
+	#assertLive(verb) {
+		if (this.#done) throw new Error(`DrizzleTransaction: ${verb}() called after the transaction ended (its connection was already released).`);
+	}
+	/** Expose le handle Drizzle lié à la connexion encadrée par la transaction. */
+	getNative() {
+		return this.#db;
+	}
+};
+//#endregion
+export { DrizzleTransaction };

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

@@ -0,0 +1,4 @@
+import { DrizzleRepository } from "./DrizzleRepository.js";
+import { DrizzleTransaction } from "./DrizzleTransaction.js";
+import { DrizzleOrm } from "./DrizzleOrm.js";
+export { DrizzleOrm, DrizzleRepository, DrizzleTransaction };

package/dist/nodefony/src/queryKit.js

@@ -0,0 +1,318 @@
+import { likeCond } from "./likeSql.js";
+import { pickOrder } from "nodefony";
+import { escapeLikeTerm } from "@nodefony/orm-core";
+import { USER_DEFAULT_ORDER, USER_SORTABLE_FIELDS, USER_TABLE_NAME } from "@nodefony/user";
+import { sql } from "drizzle-orm";
+//#region nodefony/src/queryKit.ts
+/**
+* Cherche l'`id` du user dont le tableau JSON `socialProviders` contient un
+* lien `{provider, providerId}` — le finder du pattern **Shadow User** OAuth
+* (`DrizzleUserRepository.findBySocialProvider`).
+*
+* Sémantique IDENTIQUE sur tous les dialectes : « il EXISTE un élément du
+* tableau dont `provider` ET `providerId` valent exactement ces valeurs »
+* (les autres clés de l'élément, ex. `createdAt`, sont ignorées) :
+* - **sqlite** : `EXISTS (SELECT 1 FROM json_each(col) WHERE json_extract…)`
+*   — scan du tableau, valeurs bindées ;
+* - **postgres** : `col @> '[{"provider":…,"providerId":…}]'::jsonb` —
+*   containment jsonb natif (indexable GIN), le motif est UN paramètre bindé
+*   sérialisé JSON ;
+* - **mysql** : `JSON_CONTAINS(col, <motif>)` — containment JSON natif (même
+*   sémantique partielle que `@>` : un objet candidat est contenu dans un
+*   élément du tableau si toutes SES clés y matchent), motif = UN paramètre
+*   bindé sérialisé JSON, casté par MySQL.
+*
+* @param db - handle Drizzle natif (racine ou transaction) du dialecte.
+* @param dialect - dialecte SQL du connecteur.
+* @param provider - fournisseur d'identité (`"github"`, `"google"`…).
+* @param providerId - identifiant du compte CHEZ le fournisseur.
+* @returns l'`id` du user lié, ou `null` si aucun lien.
+*/
+async function findUserIdBySocialProvider(db, dialect, provider, providerId) {
+	switch (dialect) {
+		case "sqlite": return (await db.all(sql`SELECT "id" AS id FROM ${ident("sqlite", USER_TABLE_NAME)}
+            WHERE EXISTS (
+              SELECT 1 FROM json_each(${ident("sqlite", USER_TABLE_NAME)}."socialProviders")
+              WHERE json_extract(value, '$.provider') = ${provider}
+                AND json_extract(value, '$.providerId') = ${providerId}
+            ) LIMIT 1`))[0]?.id ?? null;
+		case "postgres": {
+			const pattern = JSON.stringify([{
+				provider,
+				providerId
+			}]);
+			const id = (await db.execute(sql`SELECT "id" AS id FROM ${ident("postgres", USER_TABLE_NAME)}
+            WHERE "socialProviders" @> ${pattern}::jsonb LIMIT 1`)).rows[0]?.id;
+			return typeof id === "string" ? id : null;
+		}
+		case "mysql": {
+			const pattern = JSON.stringify([{
+				provider,
+				providerId
+			}]);
+			const [rows] = await db.execute(sql`SELECT ${sql.raw("`id`")} AS id FROM ${ident("mysql", USER_TABLE_NAME)}
+            WHERE JSON_CONTAINS(${sql.raw("`socialProviders`")}, ${pattern}) LIMIT 1`);
+			const id = rows[0]?.id;
+			return typeof id === "string" ? id : null;
+		}
+	}
+}
+/**
+* Réservation **atomique** d'une clé d'idempotence en **MySQL** — l'équivalent
+* du `INSERT … ON CONFLICT DO UPDATE … WHERE expiré RETURNING` des dialectes
+* sqlite/pg (cf `DrizzleIdempotencyStore.begin`), reconstruit avec les moyens
+* du dialecte : MySQL n'a **ni `RETURNING` ni `WHERE` sur le `ON DUPLICATE KEY
+* UPDATE`** — et le verdict `affectedRows` d'un ODKU est AMBIGU sous mysql2
+* (flag `CLIENT_FOUND_ROWS` par défaut : ligne « matched inchangée » = 1,
+* indistinguable d'un INSERT — prouvé sur serveur réel). D'où DEUX
+* instructions, chacune atomique et au verdict non-ambigu :
+*
+* 1. **`INSERT IGNORE`** — clé neuve : `affectedRows = 1` ⇒ réservation
+*    acquise ; clé existante : TOUJOURS `0` (`FOUND_ROWS` ne concerne pas les
+*    doublons d'INSERT). L'unicité de la PK garantit UN seul gagnant sous
+*    concurrence. (`IGNORE` downgrade aussi le mode strict en warnings — sans
+*    enjeu ici : la clé est bornée en amont, `IDEMPOTENCY_KEY_MAX` 255 ≪
+*    varchar(512).)
+* 2. **Vol d'une entrée MORTE** : `UPDATE … WHERE key = ? AND expiresAt < now`
+*    — le WHERE porte la condition « morte » ; l'UPDATE change TOUJOURS
+*    `expiresAt` (nouveau > now > ancien) donc `affectedRows = 1` ⇔ vol acquis,
+*    quel que soit le flag. Deux voleurs concurrents se sérialisent sur le
+*    verrou de ligne InnoDB : le second ré-évalue le WHERE sur la version
+*    committée (current read) → 0 ligne. Jamais de double-vol.
+*
+* Course résiduelle INSERT(0) → UPDATE(0) alors que la clé vient d'être
+* supprimée (gc/abort) : verdict « contention » → le SELECT de `begin` ne la
+* trouve plus → `in-flight` prudent (jamais `fresh` hors réservation atomique,
+* l'invariant anti double-effet du contrat).
+*
+* @param db - handle Drizzle natif mysql.
+* @param args - clé scopée, empreinte payload, horloge et échéance du bail.
+* @returns `true` si la réservation est acquise (= le `fresh` du contrat).
+*/
+async function reserveIdempotencyKeyMysql(db, args) {
+	const { key, fingerprint, now, leaseExpiresAt } = args;
+	const exec = db;
+	const [inserted] = await exec.execute(sql`INSERT IGNORE INTO ${sql.raw("`idempotency_key`")}
+          (${sql.raw("`key`, `fingerprint`, `state`, `response`, `expiresAt`")})
+        VALUES (${key}, ${fingerprint}, 'if', NULL, ${leaseExpiresAt})`);
+	if ((inserted?.affectedRows ?? 0) === 1) return true;
+	const [stolen] = await exec.execute(sql`UPDATE ${sql.raw("`idempotency_key`")}
+        SET ${sql.raw("`fingerprint`")} = ${fingerprint},
+            ${sql.raw("`state`")} = 'if',
+            ${sql.raw("`response`")} = NULL,
+            ${sql.raw("`expiresAt`")} = ${leaseExpiresAt}
+        WHERE ${sql.raw("`key`")} = ${key}
+          AND ${sql.raw("`expiresAt`")} < ${now}`);
+	return (stolen?.affectedRows ?? 0) > 0;
+}
+/** Identifiant quoté selon le dialecte (`"x"` SQL standard, `` `x` `` MySQL). */
+function ident(dialect, name) {
+	return dialect === "mysql" ? sql.raw("`" + name + "`") : sql.raw("\"" + name + "\"");
+}
+/** Condition `enabled = ?` — booléen natif en PG, `0/1` ailleurs (better-sqlite3/mysql2). */
+function enabledCond(dialect, flag) {
+	const col = ident(dialect, "enabled");
+	if (dialect === "postgres") return sql`${col} = ${flag}`;
+	return sql`${col} = ${flag ? 1 : 0}`;
+}
+/** Condition `locked = ?` — même routage booléen qu'`enabled`. */
+function lockedCond(dialect, flag) {
+	const col = ident(dialect, "locked");
+	if (dialect === "postgres") return sql`${col} = ${flag}`;
+	return sql`${col} = ${flag ? 1 : 0}`;
+}
+/**
+* Condition « le compte a (ou n'a pas) au moins un fournisseur externe ».
+*
+* `socialProviders` est un tableau JSON, dont la VACUITÉ s'exprime différemment
+* selon le dialecte — d'où le routage, comme pour le containment de `roles` :
+* SQLite compte les éléments, PostgreSQL compare au tableau vide `jsonb`, MySQL
+* lit la longueur native. La colonne est `NOT NULL` avec `[]` par défaut, donc
+* aucun `NULL` à considérer.
+*/
+function hasSocialCond(dialect, flag) {
+	const col = ident(dialect, "socialProviders");
+	switch (dialect) {
+		case "sqlite": return flag ? sql`json_array_length(${col}) > 0` : sql`json_array_length(${col}) = 0`;
+		case "postgres": return flag ? sql`jsonb_array_length(${col}) > 0` : sql`jsonb_array_length(${col}) = 0`;
+		case "mysql": return flag ? sql`JSON_LENGTH(${col}) > 0` : sql`JSON_LENGTH(${col}) = 0`;
+	}
+}
+/** Condition « le tableau JSON `roles` contient `role` » — forme native du dialecte. */
+function roleCond(dialect, role) {
+	const roles = ident(dialect, "roles");
+	switch (dialect) {
+		case "sqlite": return sql`EXISTS (SELECT 1 FROM json_each(${roles}) WHERE value = ${role})`;
+		case "postgres": return sql`${roles} @> ${JSON.stringify([role])}::jsonb`;
+		case "mysql": return sql`JSON_CONTAINS(${roles}, ${JSON.stringify(role)})`;
+	}
+}
+/** Condition `LOWER(identifier) LIKE %q%` (sous-chaîne insensible à la casse, `%`/`_` échappés). */
+function likeIdentifierCond(dialect, q) {
+	const idCol = ident(dialect, "identifier");
+	const pattern = `%${escapeLikeTerm(q.toLowerCase())}%`;
+	return likeCond(dialect, sql`LOWER(${idCol})`, pattern);
+}
+/** Compose la clause WHERE des filtres actifs (undefined si aucun filtre). */
+function userWhere(dialect, f) {
+	const conds = [];
+	if (f.enabled !== void 0) conds.push(enabledCond(dialect, f.enabled));
+	if (f.locked !== void 0) conds.push(lockedCond(dialect, f.locked));
+	if (f.hasSocial !== void 0) conds.push(hasSocialCond(dialect, f.hasSocial));
+	if (f.role !== void 0) conds.push(roleCond(dialect, f.role));
+	if (f.q !== void 0 && f.q.length > 0) conds.push(likeIdentifierCond(dialect, f.q));
+	if (conds.length === 0) return void 0;
+	return sql.join(conds, sql` AND `);
+}
+/**
+* Compose la clause `ORDER BY` d'un listing natif, quelle que soit l'entité.
+*
+* 🔒 Un nom de colonne ne se lie pas en paramètre : il est **concaténé** dans la
+* requête (`ident()` → `sql.raw`). Le tri est donc borné par `pickOrder` (core),
+* exactement comme dans les stores mémoire et Mongo — une seconde
+* implémentation de ce filtre divergerait sans que rien ne le signale, et ici
+* elle ouvrirait une injection. Le data plane a déjà refusé l'inconnu en 400 ;
+* cet étage existe pour l'appelant interne qui l'oublierait.
+*
+* @param allowed - les seuls champs acceptés (vocabulaire public de l'entité).
+* @param fallback - ordre appliqué si rien de recevable n'a été demandé.
+* @param tiebreaker - colonne ajoutée en dernier ressort quand l'ordre retenu ne
+*   la contient pas : sans elle, deux lignes ex æquo peuvent changer de page
+*   entre deux appels, et l'une des deux ne jamais apparaître.
+*/
+function orderBySql(dialect, order, allowed, fallback, tiebreaker) {
+	const effective = pickOrder(order, allowed, fallback);
+	const chunks = effective.map(([field, dir]) => sql`${ident(dialect, field)} ${sql.raw(dir === "DESC" ? "DESC" : "ASC")}`);
+	if (tiebreaker !== void 0 && !effective.some(([f]) => f === tiebreaker)) chunks.push(sql`${ident(dialect, tiebreaker)} ASC`);
+	return sql.join(chunks, sql`, `);
+}
+/** Exécute un SELECT et normalise le retour en tableau de lignes (API native divergente). */
+async function runSelect(db, dialect, query) {
+	switch (dialect) {
+		case "sqlite": return await db.all(query);
+		case "postgres": return (await db.execute(query)).rows;
+		case "mysql": {
+			const [rows] = await db.execute(query);
+			return rows;
+		}
+	}
+}
+/**
+* Sélectionne les `id` d'une **page** d'utilisateurs (filtres + tri + `LIMIT/
+* OFFSET`), sans matérialiser les lignes. `limit + 1` → `hasNext` sans `COUNT`.
+*
+* @returns les `id` de la page (au plus `window.limit`, dans l'ordre du tri) et
+*   `hasNext`.
+*/
+async function listUserIdsPage(db, dialect, filters, window) {
+	const limit = Math.max(1, Math.floor(window.limit));
+	const offset = Math.max(0, Math.floor(window.offset));
+	const where = userWhere(dialect, filters);
+	const whereSql = where ? sql` WHERE ${where}` : sql``;
+	const ids = (await runSelect(db, dialect, sql`SELECT ${ident(dialect, "id")} AS id FROM ${ident(dialect, USER_TABLE_NAME)}${whereSql}
+      ORDER BY ${orderBySql(dialect, window.order, USER_SORTABLE_FIELDS, USER_DEFAULT_ORDER, "id")} LIMIT ${limit + 1} OFFSET ${offset}`)).map((r) => r.id).filter((id) => typeof id === "string");
+	const hasNext = ids.length > limit;
+	return {
+		ids: hasNext ? ids.slice(0, limit) : ids,
+		hasNext
+	};
+}
+/**
+* Condition « endpoint en échec » — `failureCount > 0` (ou `= 0` pour les sains).
+*
+* Même forme sur les trois dialectes : la colonne est un entier, la comparaison
+* est indexable, et aucun `NULL` n'est possible (`failureCount` est `NOT NULL`,
+* initialisé à 0 à la création).
+*/
+function failingCond(dialect, flag) {
+	const col = ident(dialect, "failureCount");
+	return flag ? sql`${col} > 0` : sql`${col} = 0`;
+}
+/** Condition « le tableau JSON `events` contient `event` » — forme native du dialecte. */
+function eventCond(dialect, event) {
+	const events = ident(dialect, "events");
+	switch (dialect) {
+		case "sqlite": return sql`EXISTS (SELECT 1 FROM json_each(${events}) WHERE value = ${event})`;
+		case "postgres": return sql`${events} @> ${JSON.stringify([event])}::jsonb`;
+		case "mysql": return sql`JSON_CONTAINS(${events}, ${JSON.stringify(event)})`;
+	}
+}
+/**
+* Condition `LOWER(url) LIKE %q% OR LOWER(description) LIKE %q%` — la recherche
+* d'un humain porte sur l'adresse OU le libellé. `description` est nullable :
+* `COALESCE` évite qu'un `NULL` fasse retomber tout le `OR` à `NULL` (donc faux).
+*/
+function likeWebhookCond(dialect, q) {
+	const url = ident(dialect, "url");
+	const description = ident(dialect, "description");
+	const pattern = `%${escapeLikeTerm(q.toLowerCase())}%`;
+	const onUrl = likeCond(dialect, sql`LOWER(${url})`, pattern);
+	const onDescription = likeCond(dialect, sql`LOWER(COALESCE(${description}, ''))`, pattern);
+	return sql`(${onUrl} OR ${onDescription})`;
+}
+/** Compose la clause WHERE des filtres actifs (undefined si aucun filtre). */
+function webhookWhere(dialect, f) {
+	const conds = [];
+	if (f.enabled !== void 0) conds.push(enabledCond(dialect, f.enabled));
+	if (f.failing !== void 0) conds.push(failingCond(dialect, f.failing));
+	if (f.event !== void 0) conds.push(eventCond(dialect, f.event));
+	if (f.q !== void 0 && f.q.length > 0) conds.push(likeWebhookCond(dialect, f.q));
+	if (conds.length === 0) return void 0;
+	return sql.join(conds, sql` AND `);
+}
+/**
+* Sélectionne les `id` d'une **page** d'endpoints webhook (filtres + tri +
+* `LIMIT/OFFSET`), sans matérialiser les lignes. `limit + 1` → `hasNext` sans
+* `COUNT`.
+*
+* Le tri descend dans le `ORDER BY` — jamais appliqué après découpe, sinon la
+* 2ᵉ page recommencerait au lieu de continuer la 1ʳᵉ. À défaut d'`order`
+* recevable, l'ordre par défaut `createdAt DESC, id ASC` rend l'offset
+* déterministe quand deux endpoints partagent la même milliseconde de création.
+*
+* @param window - fenêtre de page **et** tri demandé (déjà en noms publics ; il
+*   est re-filtré ici par l'allowlist, cf {@link orderBySql}).
+* @returns les `id` de la page (au plus `limit`, dans l'ordre) et `hasNext`.
+*/
+async function listWebhookIdsPage(db, dialect, filters, window) {
+	const limit = Math.max(1, Math.floor(window.limit));
+	const offset = Math.max(0, Math.floor(window.offset));
+	const where = webhookWhere(dialect, filters);
+	const whereSql = where ? sql` WHERE ${where}` : sql``;
+	const orderSql = orderBySql(dialect, window.order, window.sortable ?? [], [["createdAt", "DESC"], ["id", "ASC"]], "id");
+	const ids = (await runSelect(db, dialect, sql`SELECT ${ident(dialect, "id")} AS id FROM ${ident(dialect, "webhook_endpoint")}${whereSql}
+      ORDER BY ${orderSql}
+      LIMIT ${limit + 1} OFFSET ${offset}`)).map((r) => r.id).filter((id) => typeof id === "string");
+	const hasNext = ids.length > limit;
+	return {
+		ids: hasNext ? ids.slice(0, limit) : ids,
+		hasNext
+	};
+}
+/**
+* Compte les endpoints qui matchent les filtres (`COUNT(*)` natif filtré) —
+* base du `total` d'une page d'endpoints.
+*
+* @returns le nombre de lignes correspondantes.
+*/
+async function countWebhookEndpoints(db, dialect, filters) {
+	const where = webhookWhere(dialect, filters);
+	const whereSql = where ? sql` WHERE ${where}` : sql``;
+	const rows = await runSelect(db, dialect, sql`SELECT COUNT(*) AS cnt FROM ${ident(dialect, "webhook_endpoint")}${whereSql}`);
+	return Number(rows[0]?.cnt ?? 0);
+}
+/**
+* Compte les utilisateurs qui matchent les filtres (`COUNT(*)` natif filtré) —
+* base commune du `total` de la page ET du garde-fou `countActiveAdmins`
+* (`{ enabled: true, role: adminRole }`).
+*
+* @returns le nombre de lignes correspondantes.
+*/
+async function countUsers(db, dialect, filters) {
+	const where = userWhere(dialect, filters);
+	const whereSql = where ? sql` WHERE ${where}` : sql``;
+	const rows = await runSelect(db, dialect, sql`SELECT COUNT(*) AS cnt FROM ${ident(dialect, USER_TABLE_NAME)}${whereSql}`);
+	return Number(rows[0]?.cnt ?? 0);
+}
+//#endregion
+export { countUsers, countWebhookEndpoints, findUserIdBySocialProvider, listUserIdsPage, listWebhookIdsPage, reserveIdempotencyKeyMysql };

package/dist/nodefony/src/safeTarget.js

@@ -0,0 +1,55 @@
+import path from "node:path";
+//#region nodefony/src/safeTarget.ts
+/**
+* Comment DÉSIGNER la base d'un connecteur sans rien faire fuiter.
+*
+* **Pourquoi une règle à part, et pourquoi elle est PURE.** Trois endroits
+* doivent nommer la même base — l'adaptateur, qui la publie au plan
+* d'administration ; les commandes de migration, qui doivent dire sur QUOI
+* elles ont travaillé ; et le rapport d'état, que lisent un humain, un script
+* et une console. Trois rendus recopiés divergeraient, et la divergence serait
+* silencieuse : chacun passerait ses propres tests. Écrite ici, la règle
+* s'éprouve sans base, sans kernel et sans variable d'environnement.
+*
+* Deux familles, deux dangers différents :
+*
+* - **une base FICHIER** (sqlite) : le danger est l'arborescence du serveur —
+*   le nom de l'utilisateur, la structure du disque. Le chemin est donc rendu
+*   RELATIF au répertoire de travail, et se réduit au nom de fichier dès qu'il
+*   sort du projet ;
+* - **une base RÉSEAU** (PostgreSQL, MySQL) : le danger est le compte. Une URL
+*   de migration porte l'identifiant et le mot de passe du seul compte autorisé
+*   à modifier un schéma de production. Seuls l'hôte, le port et le nom de la
+*   base sont rendus — jamais la partie qui précède l'arobase.
+*
+* ⚠️ `redactSecrets` ne couvre PAS ce cas : aucune de ses familles ne masque un
+* mot de passe d'URL. C'est pourquoi cette fonction ne masque pas, elle
+* RECONSTRUIT — on ne publie que les morceaux dont on a décidé qu'ils sont
+* publiables, ce qui reste vrai pour une URL dont la forme nous surprendrait.
+*
+* @param target - dialecte et coordonnées, telles que la résolution les rend.
+* @param cwd - répertoire de référence pour relativiser un chemin de fichier.
+* @param grammar - grammaire de chemins à employer. Injectée pour une seule
+*   raison : une fonction qui lit `path` global ne s'éprouve que sur la
+*   plateforme qu'elle décrit, c'est-à-dire jamais ici. Avec `path.win32`, le
+*   cas Windows se joue sur n'importe quel système.
+* @returns une désignation affichable, sans identifiant ni mot de passe.
+*/
+function describeTargetSafely(target, cwd = process.cwd(), grammar = path) {
+	if (target.dialect === "sqlite") {
+		const file = target.filename ?? ":memory:";
+		if (file === ":memory:" || !grammar.isAbsolute(file)) return file;
+		const relatif = grammar.relative(cwd, file);
+		return relatif && !relatif.startsWith("..") ? relatif.split(grammar.sep).join("/") : grammar.basename(file);
+	}
+	const defaultPort = target.dialect === "postgres" ? "5432" : "3306";
+	if (target.url === void 0 || target.url === "") return target.dialect;
+	try {
+		const u = new URL(target.url);
+		return `${u.hostname}:${u.port || defaultPort}${u.pathname}`;
+	} catch {
+		return target.dialect;
+	}
+}
+//#endregion
+export { describeTargetSafely };

package/dist/types/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * `@nodefony/drizzle` — module Drizzle ORM (driver `better-sqlite3`) sur
+ * `@nodefony/orm-core`.
+ *
+ * **Module bootable** : enregistré dans `@modules()`, son {@link DrizzleService}
+ * connecte au boot un {@link DrizzleOrm} par connecteur configuré (ORM par défaut
+ * SQL recommandé). Expose aussi les **classes adapter** (orm-core) pour un usage
+ * direct/banc-test. driver concret du socle multi-ORM (avec Mongoose) ; type-safe-first (a figé la forme des opérateurs riches, ADR-0003 #3).
+ */
+import { Kernel, Module } from "nodefony";
+import { defineDrizzleConfig, drizzleConfigJsonSchema } from "./nodefony/config/defineModuleConfig.js";
+import DrizzleService from "./nodefony/service/DrizzleService.js";
+import type { IDrizzleConfig, IDrizzleConfigInput } from "./nodefony/interfaces/IDrizzleConfig.js";
+declare module "nodefony" {
+    interface NodefonyModuleConfig {
+        "@nodefony/drizzle": IDrizzleConfigInput;
+    }
+}
+declare class Drizzle extends Module<IDrizzleConfig> {
+    constructor(kernel: Kernel);
+    /** JSON Schema de la config drizzle → data plane admin (config riche Studio). */
+    configSchema(): unknown;
+    /**
+     * Valide la config (défauts + `module.options` + surcharge env) au boot via
+     * `defineDrizzleConfig`, et l'expose au container sous `drizzleConfig` pour que
+     * le `DrizzleService` la consomme. Plante propre si la config est invalide
+     * (convention Zod, alignée sur `@nodefony/mongoose` — audit config ORM 2026-06).
+     */
+    onKernelRegister(): Promise<this>;
+    /**
+     * Monte le data plane ORM (`/nodefony/orm/api/*` + providers santé/flux pour la
+     * sonde cluster et le drill Studio) via {@link wireOrmAdminPlane}. Branchement
+     * GLOBAL (couvre tous les ORM) et idempotent — factorisé en orm-core (C5), chaque
+     * driver l'invoque à l'identique. orm-core étant une lib pure, c'est un module
+     * driver qui le déclenche (avant le `mountAll` de framework à `onKernelReady`).
+     */
+    onKernelBoot(): Promise<this>;
+}
+export default Drizzle;
+export { DrizzleService };
+export { defineDrizzleConfig, drizzleConfigJsonSchema };
+export { drizzleConfigSchema, type DrizzleConfig, } from "./nodefony/config/config.js";
+export type { IDrizzleConfig, IDrizzleConfigInput, IDrizzleConnectorConfig, } from "./nodefony/interfaces/IDrizzleConfig.js";
+export { default as SessionStorage } from "./nodefony/src/SessionStorage.js";
+export { sessionTable, createSessionTable, createSessionEntity, registerSessionEntity, SESSION_CONNECTOR, SESSION_ENTITY_NAME, } from "./nodefony/entity/sessionEntity.js";
+export type { SessionRow } from "./nodefony/entity/sessionEntity.js";
+export { DrizzleMigrator, DEFAULT_LOCK_TIMEOUT_MS, openMigrationDriver, frameworkMigrationsDir, defaultMigrationSources, migrationHash, loadSources, orderSources, HISTORY_TABLE, FORMAT_MARKER, FRAMEWORK_SOURCE, APP_SOURCE, FRAMEWORK_RANK, APP_RANK, PG_LOCK_KEY, MYSQL_LOCK_NAME_SQL, MigrationVerdictError, type IDrizzleMigratorOptions, type IMigrateOptions, type IMigrationTarget, type IMigrationSource, type IMigrationFile, type IMigrationPlan, type IMigrationRun, type IMigrationApplied, type IMigrationDrift, type IMigrationDriver, type IAppliedMigration, type IMigrationVerdict, type IMigrationAction, type MigrationVerdictCode, type ISchemaComparison, type ISchemaGap, } from "./nodefony/src/migrator/index.js";
+export { MIGRATION_FORMAT_VERSION, EXIT, buildReport, verdictOf, exitCodeOf, meaningOf, renderStatus, renderRefusal, styleFor, action, type IMigrationReport, type IMigrationSourceReport, type IReportContext, type MigrationVerdictName, type IStyle, } from "./nodefony/src/migrator/explain.js";
+export { MIGRATE_URL_ENV, readMigrationEnv, resolveDdlMode, resolveCheckMode, resetAllowed, resolveConnector, resolveDivergenceMode, knownConnectors, appMigrationsDir, buildMigrator, type IMigrationEnv, type IConnectorResolution, } from "./nodefony/src/migrator/resolve.js";
+export { DDL_MODES, MIGRATION_CHECK_MODES, DIVERGENCE_MODES, type DdlMode, type MigrationCheckMode, type DivergenceMode, } from "./nodefony/config/config.js";
+export { DrizzleOrm, DrizzleRepository, DrizzleTransaction, } from "./nodefony/src/orm-core/index.js";
+export type { DrizzleOrmOptions, DrizzleDb, DrizzleResolvedRelation, } from "./nodefony/src/orm-core/index.js";
+export { userTable, createUserTable, createUserEntity, registerUserEntity, } from "./nodefony/entity/userTable.js";
+export type { UserRow } from "./nodefony/entity/userTable.js";
+export { DrizzleUserRepository } from "./nodefony/src/DrizzleUserRepository.js";
+export { accessTokenTable, deniedJtiTable, subjectRevocationTable, createAccessTokenTable, createDeniedJtiTable, createSubjectRevocationTable, createTokenEntities, registerTokenEntities, TOKEN_ENTITY_NAMES, } from "./nodefony/entity/tokenEntity.js";
+export type { DeniedJtiRow, SubjectRevocationRow, } from "./nodefony/entity/tokenEntity.js";
+export { DrizzleTokenStore } from "./nodefony/src/DrizzleTokenStore.js";
+export { auditEventTable, createAuditEventTable, createAuditEntities, registerAuditEntities, AUDIT_ENTITY_NAMES, } from "./nodefony/entity/auditEventEntity.js";
+export type { AuditEventRow } from "./nodefony/entity/auditEventEntity.js";
+export { DrizzleAuditStore } from "./nodefony/src/DrizzleAuditStore.js";
+export { webAuthnCredentialTable, createWebAuthnCredentialTable, createWebAuthnCredentialEntity, registerWebAuthnCredentialEntity, WEBAUTHN_CREDENTIAL_ENTITY, } from "./nodefony/entity/webAuthnCredentialEntity.js";
+export type { WebAuthnCredentialRow } from "./nodefony/entity/webAuthnCredentialEntity.js";
+export { DrizzleWebAuthnCredentialStore } from "./nodefony/src/DrizzleWebAuthnCredentialStore.js";
+export { totpSecretTable, createTotpSecretTable, createTotpSecretEntity, registerTotpSecretEntity, TOTP_SECRET_ENTITY, } from "./nodefony/entity/totpSecretEntity.js";
+export type { TotpSecretRow } from "./nodefony/entity/totpSecretEntity.js";
+export { DrizzleTotpSecretStore } from "./nodefony/src/DrizzleTotpSecretStore.js";
+export { idempotencyKeyTable, createIdempotencyTable, createIdempotencyEntities, registerIdempotencyEntities, IDEMPOTENCY_ENTITY_NAME, } from "./nodefony/entity/idempotencyEntity.js";
+export type { IdempotencyKeyRow } from "./nodefony/entity/idempotencyEntity.js";
+export { DrizzleIdempotencyStore } from "./nodefony/src/DrizzleIdempotencyStore.js";
+export type { SqlDialect } from "./nodefony/config/config.js";
+export { webhookEndpointTable, createWebhookEndpointTable, createWebhookEndpointEntity, registerWebhookEndpointEntity, WEBHOOK_ENDPOINT_ENTITY, } from "./nodefony/entity/webhookEndpointEntity.js";
+export type { WebhookEndpointRow } from "./nodefony/entity/webhookEndpointEntity.js";
+export { DrizzleWebhookStore } from "./nodefony/src/DrizzleWebhookStore.js";
+export { registerDrizzleFrameworkStores, isFrameworkFallbackEntity, FRAMEWORK_CONNECTOR, } from "./nodefony/registerStores.js";
+export type { IFrameworkStoresReport } from "./nodefony/registerStores.js";