@nodefony/drizzle 10.0.0-alpha.1

package/dist/nodefony/entity/auditEventEntity.js

@@ -0,0 +1,93 @@
+import { createFrameworkTableFactory } from "./colKit.js";
+import { entityRegistry } from "@nodefony/orm-core";
+/** Factory de la table du journal (mémoïsée — une instance par dialecte). */
+const createAuditEventTable = createFrameworkTableFactory({
+	name: "audit_event",
+	columns: {
+		id: {
+			kind: "text",
+			primaryKey: true
+		},
+		ts: {
+			kind: "epochMs",
+			notNull: true
+		},
+		category: {
+			kind: "text",
+			notNull: true
+		},
+		action: {
+			kind: "text",
+			notNull: true
+		},
+		outcome: {
+			kind: "text",
+			notNull: true
+		},
+		actor: { kind: "text" },
+		resource: { kind: "text" },
+		reason: { kind: "text" },
+		ip: { kind: "text" },
+		userAgent: { kind: "text" },
+		requestId: { kind: "text" },
+		flags: { kind: "json" },
+		metadata: { kind: "json" }
+	},
+	indexes: [
+		{
+			name: "audit_event_ts_idx",
+			on: ["ts"]
+		},
+		{
+			name: "audit_event_category_idx",
+			on: ["category"]
+		},
+		{
+			name: "audit_event_actor_idx",
+			on: ["actor"]
+		},
+		{
+			name: "audit_event_requestId_idx",
+			on: ["requestId"]
+		}
+	]
+});
+/**
+* Variante SQLite de la table (dialecte par défaut) — export conservé pour
+* l'usage direct/banc-test.
+*/
+const auditEventTable = createAuditEventTable("sqlite");
+/** Noms logiques des entités du store (clés de lookup `getRepository`). */
+const AUDIT_ENTITY_NAMES = { events: "audit_event" };
+/**
+* Construit les descripteurs d'entités du journal d'audit pour un ORM nommé.
+*
+* Le `connector` est **dynamique** (nom du connecteur de l'app, ex. `"default"`) et la
+* variante de table suit le dialecte du connecteur (auto-register
+* `registerStores.ts` à `onKernelRegister`). À enregistrer dans `entityRegistry`
+* **avant** `orm.connect()` (cf {@link registerAuditEntities}).
+*
+* @param orm - clé de l'ORM cible dans le `ormRegistry`.
+* @param dialect - dialecte SQL du connecteur (sélectionne la variante de table).
+* @returns le descripteur {@link IEntity} du journal d'audit.
+*/
+function createAuditEntities(connector, dialect = "sqlite") {
+	return [{
+		connector,
+		name: AUDIT_ENTITY_NAMES.events,
+		module: "security",
+		schema: createAuditEventTable(dialect)
+	}];
+}
+/**
+* Enregistre les entités du journal d'audit dans le `entityRegistry` pour un ORM
+* donné. À appeler **avant** `orm.connect()` (l'adapter crée les tables au connect).
+*
+* @param connector - nom de la connexion cible (clé du registre).
+* @param dialect - dialecte SQL du connecteur (variante de table — défaut `sqlite`).
+*/
+function registerAuditEntities(connector, dialect = "sqlite") {
+	for (const entity of createAuditEntities(connector, dialect)) entityRegistry.register(entity);
+}
+//#endregion
+export { AUDIT_ENTITY_NAMES, auditEventTable, createAuditEntities, createAuditEventTable, registerAuditEntities };

package/dist/nodefony/entity/colKit.js

@@ -0,0 +1,260 @@
+import { sql } from "drizzle-orm";
+import { check, index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { bigint, boolean, check as check$1, index as index$1, integer as integer$1, jsonb, pgTable, text as text$1, timestamp, uniqueIndex as uniqueIndex$1 } from "drizzle-orm/pg-core";
+import { bigint as bigint$1, boolean as boolean$1, check as check$2, customType, datetime, index as index$2, int, mysqlTable, text as text$2, uniqueIndex as uniqueIndex$2, varchar } from "drizzle-orm/mysql-core";
+//#region nodefony/entity/colKit.ts
+/** Applique les modificateurs d'une spec sur un builder (dialecte déjà choisi). */
+function applyMods(builder, spec) {
+	let out = builder;
+	if (spec.primaryKey) out = out.primaryKey();
+	if (spec.notNull) out = out.notNull();
+	if (spec.unique) out = out.unique();
+	if (spec.defaultFn) out = out.$defaultFn(spec.defaultFn);
+	if (spec.onUpdateFn) out = out.$onUpdateFn(spec.onUpdateFn);
+	return out;
+}
+/** Colonne SQLite d'une spec logique. */
+function sqliteColumn(name, spec) {
+	let base;
+	switch (spec.kind) {
+		case "text":
+		case "enum":
+			base = text(name);
+			break;
+		case "json":
+			base = text(name, { mode: "json" });
+			break;
+		case "bool":
+			base = integer(name, { mode: "boolean" });
+			break;
+		case "epochMs":
+		case "int64":
+		case "int":
+			base = integer(name);
+			break;
+		case "dateMs": base = integer(name, { mode: "timestamp_ms" });
+	}
+	return applyMods(base, spec);
+}
+/** Colonne Postgres d'une spec logique. */
+function pgColumn(name, spec) {
+	let base;
+	switch (spec.kind) {
+		case "text":
+		case "enum":
+			base = text$1(name);
+			break;
+		case "json":
+			base = jsonb(name);
+			break;
+		case "bool":
+			base = boolean(name);
+			break;
+		case "epochMs":
+		case "int64":
+			base = bigint(name, { mode: "number" });
+			break;
+		case "int":
+			base = integer$1(name);
+			break;
+		case "dateMs": base = timestamp(name, {
+			withTimezone: true,
+			mode: "date",
+			precision: 3
+		});
+	}
+	return applyMods(base, spec);
+}
+/** Colonnes d'index résolues + validées (fail-loud sur un nom inconnu). */
+function indexColumns(spec, ix, table) {
+	const cols = ix.on.map((name) => {
+		const col = table[name];
+		if (!col) throw new Error(`[@nodefony/drizzle] colKit "${spec.name}": index "${ix.name}" references unknown column "${name}" (declared: ${Object.keys(spec.columns).join(", ")}).`);
+		return col;
+	});
+	if (cols.length === 0) throw new Error(`[@nodefony/drizzle] colKit "${spec.name}": index "${ix.name}" has no column.`);
+	return cols;
+}
+/**
+* Dérive les contraintes `CHECK` des colonnes `enum` d'une spec.
+*
+* Le prédicat est composé en **`sql.raw` intégral** — donc sans le moindre
+* paramètre lié : un placeholder n'a aucun sens dans une définition de table,
+* et `drizzle-kit` comme le DDL dérivé rendent la clause telle quelle. Les
+* valeurs viennent du code du framework, jamais d'une entrée ; l'apostrophe est
+* malgré tout doublée — un littéral SQL se compose toujours de la même façon.
+*
+* Le nom de la contrainte est `<table>_<colonne>_check` : il apparaîtra dans le
+* message d'erreur du serveur, et il est gravé dans la migration `0000`.
+*
+* @param spec - spec logique de la table.
+* @param quote - caractère de citation des identifiants du dialecte.
+* @returns une contrainte par colonne `enum` (vide s'il n'y en a aucune).
+*/
+function enumChecks(spec, quote) {
+	const checks = [];
+	for (const [name, col] of Object.entries(spec.columns)) {
+		if (col.kind !== "enum") continue;
+		if (col.values.length === 0) throw new Error(`[@nodefony/drizzle] colKit "${spec.name}": enum column "${name}" has no value.`);
+		const list = col.values.map((value) => `'${value.replace(/'/g, "''")}'`).join(", ");
+		checks.push({
+			name: `${spec.name}_${name}_check`,
+			value: sql.raw(`${quote}${name}${quote} IN (${list})`)
+		});
+	}
+	return checks;
+}
+/** Construit la variante SQLite d'une spec. */
+function buildSqliteTable(spec) {
+	const columns = {};
+	for (const [name, col] of Object.entries(spec.columns)) columns[name] = sqliteColumn(name, col);
+	const indexes = spec.indexes;
+	const checks = enumChecks(spec, "\"");
+	if (!indexes?.length && !checks.length) return sqliteTable(spec.name, columns);
+	return sqliteTable(spec.name, columns, (t) => {
+		const out = {};
+		for (const ix of indexes ?? []) {
+			const cols = indexColumns(spec, ix, t);
+			out[ix.name] = (ix.unique ? uniqueIndex(ix.name) : index(ix.name)).on(...cols);
+		}
+		for (const ck of checks) out[ck.name] = check(ck.name, ck.value);
+		return out;
+	});
+}
+/** Construit la variante Postgres d'une spec. */
+function buildPgTable(spec) {
+	const columns = {};
+	for (const [name, col] of Object.entries(spec.columns)) columns[name] = pgColumn(name, col);
+	const indexes = spec.indexes;
+	const checks = enumChecks(spec, "\"");
+	if (!indexes?.length && !checks.length) return pgTable(spec.name, columns);
+	return pgTable(spec.name, columns, (t) => {
+		const out = {};
+		for (const ix of indexes ?? []) {
+			const cols = indexColumns(spec, ix, t);
+			out[ix.name] = (ix.unique ? uniqueIndex$1(ix.name) : index$1(ix.name)).on(...cols);
+		}
+		for (const ck of checks) out[ck.name] = check$1(ck.name, ck.value);
+		return out;
+	});
+}
+/**
+* Longueur des colonnes `text` **indexables** en MySQL (`varchar(512)`) :
+* InnoDB ne peut pas porter de PK/UNIQUE/index sur un `TEXT` sans longueur de
+* préfixe → toute colonne `text` PK/UNIQUE/référencée par un index devient un
+* `varchar`. 512 chars × 4 bytes (utf8mb4) = 2048 bytes < 3072 (limite d'index
+* InnoDB en row format DYNAMIC, défaut MySQL ≥ 8.0) et couvre la plus longue
+* valeur framework (clé d'idempotence : `JSON.stringify([identity, clientKey])`
+* ≤ ~330 chars — `IDEMPOTENCY_KEY_MAX` 255 + identité sha256 + ponctuation).
+*/
+const MYSQL_INDEXED_TEXT_LENGTH = 512;
+/**
+* Largeur des colonnes `enum` en MySQL (`varchar(64)`) — fixe et généreuse : la
+* valeur admise est bornée par la contrainte `CHECK`, pas par le type, donc
+* ajouter une valeur à l'énumération ne doit pas devenir un changement de type
+* de colonne. 64 chars couvre tout identifiant d'état, et reste indexable.
+*/
+const MYSQL_ENUM_LENGTH = 64;
+/**
+* Type `json` du dialecte mysql, TOLÉRANT au serveur : MySQL possède un type
+* JSON binaire que mysql2 désérialise en objet, mais **MariaDB** (la cible
+* libre du projet, même dialecte) le stocke en alias LONGTEXT → le driver rend
+* une **string** brute. Le `json()` natif drizzle ne parse pas côté lecture →
+* un objet stocké reviendrait en string sur MariaDB (prouvé e2e). Ce customType
+* parse si string, passe tel quel sinon — un seul kind `json` pour les deux
+* serveurs.
+*/
+const mysqlJsonCompat = customType({
+	dataType() {
+		return "json";
+	},
+	toDriver(value) {
+		return JSON.stringify(value);
+	},
+	fromDriver(value) {
+		return typeof value === "string" ? JSON.parse(value) : value;
+	}
+});
+/** Colonne MySQL d'une spec logique (`indexed` = référencée par un index de table). */
+function mysqlColumn(name, spec, indexed) {
+	let base;
+	switch (spec.kind) {
+		case "text":
+			base = spec.primaryKey || spec.unique || indexed ? varchar(name, { length: MYSQL_INDEXED_TEXT_LENGTH }) : text$2(name);
+			break;
+		case "enum":
+			base = varchar(name, { length: MYSQL_ENUM_LENGTH });
+			break;
+		case "json":
+			base = mysqlJsonCompat(name);
+			break;
+		case "bool":
+			base = boolean$1(name);
+			break;
+		case "epochMs":
+		case "int64":
+			base = bigint$1(name, { mode: "number" });
+			break;
+		case "int":
+			base = int(name);
+			break;
+		case "dateMs": base = datetime(name, {
+			mode: "date",
+			fsp: 3
+		});
+	}
+	return applyMods(base, spec);
+}
+/** Construit la variante MySQL d'une spec. */
+function buildMysqlTable(spec) {
+	const indexedCols = /* @__PURE__ */ new Set();
+	for (const ix of spec.indexes ?? []) for (const name of ix.on) indexedCols.add(name);
+	const columns = {};
+	for (const [name, col] of Object.entries(spec.columns)) columns[name] = mysqlColumn(name, col, indexedCols.has(name));
+	const indexes = spec.indexes;
+	const checks = enumChecks(spec, "`");
+	if (!indexes?.length && !checks.length) return mysqlTable(spec.name, columns);
+	return mysqlTable(spec.name, columns, (t) => {
+		const out = {};
+		for (const ix of indexes ?? []) {
+			const cols = indexColumns(spec, ix, t);
+			out[ix.name] = (ix.unique ? uniqueIndex$2(ix.name) : index$2(ix.name)).on(...cols);
+		}
+		for (const ck of checks) out[ck.name] = check$2(ck.name, ck.value);
+		return out;
+	});
+}
+function buildFrameworkTable(dialect, spec) {
+	for (const ix of spec.indexes ?? []) {
+		if (ix.on.length === 0) throw new Error(`[@nodefony/drizzle] colKit "${spec.name}": index "${ix.name}" has no column.`);
+		for (const name of ix.on) if (!(name in spec.columns)) throw new Error(`[@nodefony/drizzle] colKit "${spec.name}": index "${ix.name}" references unknown column "${name}" (declared: ${Object.keys(spec.columns).join(", ")}).`);
+	}
+	switch (dialect) {
+		case "sqlite": return buildSqliteTable(spec);
+		case "postgres": return buildPgTable(spec);
+		case "mysql": return buildMysqlTable(spec);
+	}
+}
+/**
+* Fabrique la factory `createXTable(dialect)` d'une entité framework : une
+* table par dialecte, construite au premier usage puis **mémoïsée** (une seule
+* instance par dialecte — le DDL, le registre d'entités et les stores voient
+* le même objet table).
+*
+* @param spec - spec logique de la table.
+* @returns factory mémoïsée (défaut `sqlite`).
+*/
+function createFrameworkTableFactory(spec) {
+	const cache = /* @__PURE__ */ new Map();
+	const factory = (dialect = "sqlite") => {
+		let table = cache.get(dialect);
+		if (!table) {
+			table = buildFrameworkTable(dialect, spec);
+			cache.set(dialect, table);
+		}
+		return table;
+	};
+	return factory;
+}
+//#endregion
+export { buildFrameworkTable, createFrameworkTableFactory };

package/dist/nodefony/entity/idempotencyEntity.js

@@ -0,0 +1,74 @@
+import { createFrameworkTableFactory } from "./colKit.js";
+import { entityRegistry } from "@nodefony/orm-core";
+/**
+* Factory de la table d'idempotence pour un dialecte donné — **premier maillon du
+* chantier portabilité multi-dialecte** (un schéma logique → la table Drizzle du
+* bon dialecte), migrée du switch manuel 2 tables vers le colKit (S4 : la
+* variante mysql sort du kit). Le `DrizzleOrm` l'appelle selon `connector.dialect`.
+*/
+const createIdempotencyTable = createFrameworkTableFactory({
+	name: "idempotency_key",
+	columns: {
+		key: {
+			kind: "text",
+			primaryKey: true
+		},
+		fingerprint: {
+			kind: "text",
+			notNull: true
+		},
+		state: {
+			kind: "enum",
+			values: ["if", "done"],
+			notNull: true
+		},
+		response: { kind: "json" },
+		expiresAt: {
+			kind: "epochMs",
+			notNull: true
+		}
+	},
+	indexes: [{
+		name: "idempotency_key_expiresAt_idx",
+		on: ["expiresAt"]
+	}]
+});
+/**
+* Variante SQLite mémoïsée (dialecte par défaut) — export statique de compat
+* (bancs, typage du store {@link DrizzleIdempotencyStore}).
+*/
+const idempotencyKeyTable = createIdempotencyTable("sqlite");
+/** Nom logique de l'entité (clé de lookup `getRepository` / `entityRegistry`). */
+const IDEMPOTENCY_ENTITY_NAME = "idempotency_key";
+/**
+* Construit le descripteur d'entité du store d'idempotence pour un ORM nommé.
+*
+* Le `connector` est **dynamique** (nom du connecteur de l'app, ex. `"default"`) : la
+* table est statique mais sa liaison à un ORM dépend de la config → on ne peut
+* pas la figer via `@entity`. À enregistrer dans `entityRegistry` **avant**
+* `orm.connect()` (cf {@link registerIdempotencyEntities}).
+*
+* @param orm - clé de l'ORM cible dans le `ormRegistry`.
+* @param dialect - dialecte SQL du connecteur (sélectionne la variante de table).
+* @returns le descripteur {@link IEntity} de la table d'idempotence.
+*/
+function createIdempotencyEntities(connector, dialect = "sqlite") {
+	return [{
+		connector,
+		name: IDEMPOTENCY_ENTITY_NAME,
+		module: "framework",
+		schema: createIdempotencyTable(dialect)
+	}];
+}
+/**
+* Enregistre l'entité du store d'idempotence dans le `entityRegistry` pour un ORM
+* donné. À appeler **avant** `orm.connect()` (l'adapter crée la table au connect).
+*
+* @param connector - nom de la connexion cible (clé du registre).
+* @param dialect - dialecte SQL du connecteur (variante de table — défaut `sqlite`).
+*/
+function registerIdempotencyEntities(connector, dialect = "sqlite") {
+	for (const entity of createIdempotencyEntities(connector, dialect)) entityRegistry.register(entity);
+}
+//#endregion
+export { IDEMPOTENCY_ENTITY_NAME, createIdempotencyEntities, createIdempotencyTable, idempotencyKeyTable, registerIdempotencyEntities };

package/dist/nodefony/entity/sessionEntity.js

@@ -0,0 +1,75 @@
+import { createFrameworkTableFactory } from "./colKit.js";
+import { entityRegistry } from "@nodefony/orm-core";
+//#region nodefony/entity/sessionEntity.ts
+/** ORM cible du stockage de session (connecteur par défaut du module). */
+const SESSION_CONNECTOR = "default";
+/** Nom logique de l'entité (clé de lookup `getRepository` / `entityRegistry`). */
+const SESSION_ENTITY_NAME = "session";
+/**
+* Factory de la table de session pour un dialecte donné (mémoïsée — une
+* instance par dialecte). `sqlite` (défaut) et `postgres` sont portés ;
+* `mysql` jette (S4).
+*/
+const createSessionTable = createFrameworkTableFactory({
+	name: "session",
+	columns: {
+		session_id: {
+			kind: "text",
+			primaryKey: true
+		},
+		Attributes: { kind: "json" },
+		flashBag: { kind: "json" },
+		metaBag: { kind: "json" },
+		user: { kind: "text" },
+		createdAt: {
+			kind: "epochMs",
+			notNull: true
+		},
+		updatedAt: {
+			kind: "epochMs",
+			notNull: true
+		}
+	},
+	indexes: [{
+		name: "session_user_idx",
+		on: ["user"]
+	}]
+});
+/**
+* Variante SQLite de la table de session (dialecte par défaut) — export
+* conservé pour l'usage direct/banc-test.
+*/
+const sessionTable = createSessionTable("sqlite");
+/**
+* Construit le descripteur d'entité session pour un ORM nommé.
+*
+* Le `connector` est **dynamique** (nom du connecteur de l'app, ex. `"default"`) et la
+* variante de table suit le dialecte du connecteur → l'enregistrement est fait
+* par `registerStores.ts` à `onKernelRegister` (plus de décorateur `@entity`
+* figé au chargement du fichier, qui imposait la variante sqlite quel que soit
+* le dialecte configuré). À enregistrer **avant** `orm.connect()`.
+*
+* @param orm - clé de l'ORM cible dans le `ormRegistry`.
+* @param dialect - dialecte SQL du connecteur (sélectionne la variante de table).
+* @returns le descripteur {@link IEntity} de la table de session.
+*/
+function createSessionEntity(connector, dialect = "sqlite") {
+	return [{
+		connector,
+		name: SESSION_ENTITY_NAME,
+		module: "http",
+		schema: createSessionTable(dialect)
+	}];
+}
+/**
+* Enregistre l'entité session dans le `entityRegistry` pour un ORM donné.
+* À appeler **avant** `orm.connect()` (l'adapter crée la table au connect).
+*
+* @param connector - nom de la connexion cible (clé du registre).
+* @param dialect - dialecte SQL du connecteur (variante de table — défaut `sqlite`).
+*/
+function registerSessionEntity(connector, dialect = "sqlite") {
+	for (const entity of createSessionEntity(connector, dialect)) entityRegistry.register(entity);
+}
+//#endregion
+export { SESSION_CONNECTOR, SESSION_ENTITY_NAME, createSessionEntity, createSessionTable, registerSessionEntity, sessionTable };

package/dist/nodefony/entity/tokenEntity.js

@@ -0,0 +1,198 @@
+import { createFrameworkTableFactory } from "./colKit.js";
+import { entityRegistry } from "@nodefony/orm-core";
+//#region nodefony/entity/tokenEntity.ts
+/**
+* Entités du **store de jetons** `@nodefony/security` (schema-as-code) —
+* implémentation SQL d'`ITokenStore` (PAT, refresh, denylist `jti`, seuil de
+* révocation en masse), déclinées via le `colKit` (S2 multi-dialecte) : une
+* spec logique par table, la variante du dialecte du connecteur.
+*
+* ⚠️ **Horodatages en epoch ms (kind `epochMs`, exposés `number`)** :
+* `IAccessTokenRecord` porte des `number` (`Date.now()`), pas des `Date` →
+* `AccessTokenRow` (forme repository) est **identique** à `IAccessTokenRecord`
+* → zéro mapping store ↔ entité.
+*
+* ⚠️ **Pas de `.default()` SQL** (règle colKit) : le DDL dérivé n'émet pas de
+* `DEFAULT`, seulement les contraintes colonne (PK / NOT NULL / UNIQUE). D'où
+* `secretHash` en `unique` **colonne** (unicité réelle en dev). Les index
+* déclarés, eux, sont bien créés des DEUX côtés — par `drizzle-kit` dans la
+* migration, et par le DDL dérivé en développement — et le banc de parité le
+* vérifie table par table (`tests/integration/migrations-parity.ts`).
+*
+* Les unions du contrat (`kind`, `subjectType`, `revokedReason`,
+* `IResourcePermission[]`) vivent sur les types `Row`/`IAccessTokenRecord`
+* (frontière typée), plus sur les colonnes — décision S1 : les types publics
+* des entités framework sont leurs interfaces `Row`, pas l'inférence Drizzle.
+*/
+const ACCESS_TOKEN_TABLE_SPEC = {
+	name: "access_token",
+	columns: {
+		id: {
+			kind: "text",
+			primaryKey: true
+		},
+		kind: {
+			kind: "text",
+			notNull: true
+		},
+		name: {
+			kind: "text",
+			notNull: true
+		},
+		prefix: { kind: "text" },
+		subjectId: {
+			kind: "text",
+			notNull: true
+		},
+		subjectType: {
+			kind: "text",
+			notNull: true
+		},
+		tenantId: { kind: "text" },
+		scopes: {
+			kind: "json",
+			notNull: true,
+			defaultFn: () => []
+		},
+		audience: {
+			kind: "json",
+			notNull: true,
+			defaultFn: () => []
+		},
+		resources: { kind: "json" },
+		secretHash: {
+			kind: "text",
+			notNull: true,
+			unique: true
+		},
+		hashAlg: {
+			kind: "text",
+			notNull: true
+		},
+		clientId: { kind: "text" },
+		cnf: { kind: "text" },
+		family: { kind: "text" },
+		replacedBy: { kind: "text" },
+		createdAt: {
+			kind: "epochMs",
+			notNull: true
+		},
+		expiresAt: { kind: "epochMs" },
+		lastUsedAt: { kind: "epochMs" },
+		lastUsedIp: { kind: "text" },
+		lastUsedUserAgent: { kind: "text" },
+		revokedAt: { kind: "epochMs" },
+		revokedReason: { kind: "text" },
+		metadata: {
+			kind: "json",
+			notNull: true,
+			defaultFn: () => ({})
+		}
+	},
+	indexes: [{
+		name: "access_token_subjectId_idx",
+		on: ["subjectId"]
+	}, {
+		name: "access_token_family_idx",
+		on: ["family"]
+	}]
+};
+/**
+* Denylist des access tokens (`jti`) révoqués avant leur `exp` — révocation
+* immédiate ciblée. Purgée par `gc` une fois `expiresAt` (epoch ms) dépassé.
+*/
+const DENIED_JTI_TABLE_SPEC = {
+	name: "denied_jti",
+	columns: {
+		jti: {
+			kind: "text",
+			primaryKey: true
+		},
+		expiresAt: {
+			kind: "epochMs",
+			notNull: true
+		}
+	}
+};
+/**
+* Seuil de révocation **en masse** par porteur : tout access auto-porté émis
+* avant `invalidBefore` (epoch ms) est rejeté (logout global / ban).
+*/
+const SUBJECT_REVOCATION_TABLE_SPEC = {
+	name: "subject_revocation",
+	columns: {
+		subjectId: {
+			kind: "text",
+			primaryKey: true
+		},
+		invalidBefore: {
+			kind: "epochMs",
+			notNull: true
+		}
+	}
+};
+/** Factory de la table des records (mémoïsée — une instance par dialecte). */
+const createAccessTokenTable = createFrameworkTableFactory(ACCESS_TOKEN_TABLE_SPEC);
+/** Factory de la denylist `jti` (mémoïsée — une instance par dialecte). */
+const createDeniedJtiTable = createFrameworkTableFactory(DENIED_JTI_TABLE_SPEC);
+/** Factory des seuils de révocation (mémoïsée — une instance par dialecte). */
+const createSubjectRevocationTable = createFrameworkTableFactory(SUBJECT_REVOCATION_TABLE_SPEC);
+/**
+* Variantes SQLite des trois tables (dialecte par défaut) — exports conservés
+* pour l'usage direct/banc-test.
+*/
+const accessTokenTable = createAccessTokenTable("sqlite");
+const deniedJtiTable = createDeniedJtiTable("sqlite");
+const subjectRevocationTable = createSubjectRevocationTable("sqlite");
+/** Noms logiques des entités du store (clés de lookup `getRepository`). */
+const TOKEN_ENTITY_NAMES = {
+	records: "access_token",
+	denied: "denied_jti",
+	revocations: "subject_revocation"
+};
+/**
+* Construit les descripteurs d'entités du store de jetons pour un ORM nommé.
+*
+* Le `connector` est **dynamique** (nom du connecteur de l'app, ex. `"default"`) et la
+* variante de table suit le dialecte du connecteur (auto-register
+* `registerStores.ts` à `onKernelRegister`). À enregistrer dans `entityRegistry`
+* **avant** `orm.connect()` (cf {@link registerTokenEntities}).
+*
+* @param orm - clé de l'ORM cible dans le `ormRegistry`.
+* @param dialect - dialecte SQL du connecteur (sélectionne la variante des tables).
+* @returns les trois descripteurs {@link IEntity} (records / denylist / seuils).
+*/
+function createTokenEntities(connector, dialect = "sqlite") {
+	return [
+		{
+			connector,
+			name: TOKEN_ENTITY_NAMES.records,
+			module: "security",
+			schema: createAccessTokenTable(dialect)
+		},
+		{
+			connector,
+			name: TOKEN_ENTITY_NAMES.denied,
+			module: "security",
+			schema: createDeniedJtiTable(dialect)
+		},
+		{
+			connector,
+			name: TOKEN_ENTITY_NAMES.revocations,
+			module: "security",
+			schema: createSubjectRevocationTable(dialect)
+		}
+	];
+}
+/**
+* Enregistre les entités du store de jetons dans le `entityRegistry` pour un ORM
+* donné. À appeler **avant** `orm.connect()` (l'adapter crée les tables au connect).
+*
+* @param connector - nom de la connexion cible (clé du registre).
+* @param dialect - dialecte SQL du connecteur (variante des tables — défaut `sqlite`).
+*/
+function registerTokenEntities(connector, dialect = "sqlite") {
+	for (const entity of createTokenEntities(connector, dialect)) entityRegistry.register(entity);
+}
+//#endregion
+export { TOKEN_ENTITY_NAMES, accessTokenTable, createAccessTokenTable, createDeniedJtiTable, createSubjectRevocationTable, createTokenEntities, deniedJtiTable, registerTokenEntities, subjectRevocationTable };