@nodefony/drizzle 10.0.0-alpha.8 → 10.0.0-alpha.9

package/dist/nodefony/src/migrator/appSchema.js

@@ -1,4 +1,5 @@
 import { FORMAT_MARKER } from "./types.js";
+import { ownsSharedMigrations } from "../frameworkConnector.js";
 import "./kit.js";
 import { registerHooks } from "node:module";
 import { entityRegistry } from "@nodefony/orm-core";
@@ -410,5 +411,47 @@ function registeredTables(connector) {
 	}
 	return out;
 }
+/**
+* Tables d'un connecteur parmi celles que les fichiers fournissent — le
+* partage qui fait qu'une migration ne décrit que SA base.
+*
+* Une table appartient au connecteur de l'entité qui la déclare (le REGISTRE
+* le sait, un fichier non). Une table qu'aucune entité ne réclame reste au
+* connecteur du framework, comme avant que les connecteurs secondaires aient
+* leurs migrations. Sans ce partage, la table d'une entité secondaire entrait
+* AUSSI dans les migrations du framework : créée dans une base qui ne s'en sert
+* jamais, et proposée à la suppression le jour où elle n'y figure plus.
+*
+* @param tables - tables fournies par les fichiers de l'application.
+* @param connector - connecteur visé.
+* @param owners - `table → connecteurs` qui la déclarent ; par défaut, le registre.
+* @returns les tables de ce connecteur, dans l'ordre reçu.
+*/
+function tablesOfConnector(tables, connector, owners = registeredOwners()) {
+	return tables.filter((t) => {
+		const claimed = owners.get(t.tableName);
+		return claimed === void 0 ? ownsSharedMigrations(connector) : claimed.has(connector);
+	});
+}
+/**
+* Pour chaque table enregistrée, les connecteurs dont une entité la déclare.
+*
+* @returns la table de correspondance, lue dans le registre des entités.
+*/
+function registeredOwners() {
+	const owners = /* @__PURE__ */ new Map();
+	for (const entity of entityRegistry.list()) {
+		const schema = entity.schema;
+		if (!is(schema, Table)) continue;
+		const table = getTableName(schema);
+		let set = owners.get(table);
+		if (set === void 0) {
+			set = /* @__PURE__ */ new Set();
+			owners.set(table, set);
+		}
+		set.add(entity.connector);
+	}
+	return owners;
+}
 //#endregion
-export { collectTables, dialectOf, entityFilesOf, importSpecifier, missingProviders, postgresSchemaOf, registeredTables, usurpedTables, writeCustomMigration, writeKitConfig, writeSchemaModule };
+export { collectTables, dialectOf, entityFilesOf, importSpecifier, missingProviders, postgresSchemaOf, registeredOwners, registeredTables, tablesOfConnector, usurpedTables, writeCustomMigration, writeKitConfig, writeSchemaModule };

package/dist/nodefony/src/migrator/drivers/sqliteDriver.js

@@ -1,5 +1,6 @@
 import { HISTORY_TABLE } from "../types.js";
 import { schemaReader } from "../catalog.js";
+import "../../memoryDatabase.js";
 //#region nodefony/src/migrator/drivers/sqliteDriver.ts
 /**
 * Pilote SQLite de l'applicateur — connexion `better-sqlite3` dédiée.

package/dist/nodefony/src/migrator/kit.js

@@ -1,5 +1,5 @@
 import { FORMAT_MARKER } from "./types.js";
-import { MigrationToolError, generationFailed, generationNeedsAnswer, generationToolMissing, introspectFailed } from "./refusals.js";
+import { MigrationToolError, generationFailed, generationNeedsAnswer, generationToolMissing, generationTopLevelAwait, introspectFailed } from "./refusals.js";
 import { droppedTables, rebuiltTables } from "./destructive.js";
 import fs from "node:fs";
 import path from "node:path";
@@ -71,6 +71,8 @@ function runGenerate({ cwd, configRel, name, label, regenerateCommand }) {
 	});
 	const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
 	if (result.status !== 0 || !generationHappened(output)) {
+		const awaited = topLevelAwaitFailure(output);
+		if (awaited !== null) throw new MigrationToolError(generationTopLevelAwait(label, awaited.file, awaited.line, regenerateCommand ?? `nodefony orm:generate --name ${name}`));
 		if (isInteractivePromptFailure(output)) throw new MigrationToolError(generationNeedsAnswer(label, regenerateCommand ?? `nodefony orm:generate --name ${name}`));
 		throw new MigrationToolError(generationFailed(label, result.status, output));
 	}
@@ -273,6 +275,25 @@ function isInteractivePromptFailure(output) {
 	return /Interactive prompts require a TTY/i.test(output);
 }
 /**
+* Reconnaît le refus de l'outil devant un `await` de premier niveau.
+*
+* C'est l'esbuild de `drizzle-kit` qui le détecte, en transpilant le fichier en
+* CommonJS : sa ligne d'erreur nomme le fichier et la position. On la lit plutôt
+* que d'analyser nous-mêmes les sources — l'outil qui refuse est aussi celui qui
+* sait exactement où, sans faux positif. Fonction PURE, éprouvée sans process.
+*
+* @param output - sortie complète de l'outil.
+* @returns le fichier et la ligne, ou `null` si l'échec est d'une autre nature.
+*/
+function topLevelAwaitFailure(output) {
+	const plain = output.replace(/\u001B\[[0-9;]*m/g, "");
+	const m = /(?:^|\n)[^\S\n]*(\S[^\n]*?\.[cm]?[jt]sx?):(\d+):\d+: ERROR: Top-level await is currently not supported with the \\?"cjs\\?" output format/u.exec(plain);
+	return m ? {
+		file: m[1],
+		line: Number(m[2])
+	} : null;
+}
+/**
 * Pose le marqueur de format en tête des `.sql` d'un dossier qui ne l'ont pas.
 *
 * Écrit en fins de ligne `\n` quel que soit le système : le dépôt et le gabarit
@@ -296,4 +317,4 @@ function stampFormatMarker(dir) {
 	return stamped;
 }
 //#endregion
-export { FORMAT_MARKER, auditMigrationSql, generationHappened, isInteractivePromptFailure, resolveDrizzleKitBin, runGenerate, runIntrospect, stampFormatMarker };
+export { FORMAT_MARKER, auditMigrationSql, generationHappened, isInteractivePromptFailure, resolveDrizzleKitBin, runGenerate, runIntrospect, stampFormatMarker, topLevelAwaitFailure };

package/dist/nodefony/src/migrator/paths.js

@@ -1,3 +1,4 @@
+import { ownsSharedMigrations } from "../frameworkConnector.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { fileURLToPath } from "node:url";
@@ -15,6 +16,47 @@ const FRAMEWORK_RANK = 0;
 * celles des modules ; l'inverse n'arrive jamais.
 */
 const APP_RANK = 1e6;
+/**
+* Noms qui ne peuvent PAS désigner le dossier d'un connecteur secondaire : ce
+* sont ceux des dossiers de dialecte (et du journal) que le connecteur du
+* framework range déjà sous `migrations/`. Un connecteur `postgres` y lirait les
+* migrations de `default` comme les siennes.
+*/
+const RESERVED_MIGRATION_DIRS = [
+	"sqlite",
+	"postgres",
+	"mysql",
+	"meta"
+];
+/**
+* Le nom de ce connecteur collisionne-t-il avec un dossier de dialecte ?
+*
+* @param connector - nom du connecteur (clé de `connectors`).
+* @returns `true` pour un connecteur SECONDAIRE nommé comme un dossier réservé.
+*/
+function isReservedConnectorName(connector) {
+	return !ownsSharedMigrations(connector) && RESERVED_MIGRATION_DIRS.includes(connector);
+}
+/**
+* Dossier des migrations PROPRES à un connecteur — la seule règle qui dit où
+* elles vivent.
+*
+* Le connecteur du framework garde la racine (`migrations/<dialecte>`) : ses
+* migrations décrivent la base du framework et des entités de l'application.
+* Un connecteur secondaire reçoit son sous-dossier (`migrations/<connecteur>/
+* <dialecte>`) : sa base ne reçoit que ce qui y est écrit, et celle du
+* framework n'en voit rien — le dossier de dialecte qu'elle lit n'est pas le
+* même.
+*
+* @param appDir - dossier de migrations de l'application (`appMigrationsDir`).
+* @param connector - nom du connecteur.
+* @returns le dossier parent des sous-dossiers de dialecte, ou `undefined` sans
+*   racine d'application, ou pour un nom réservé ({@link isReservedConnectorName}).
+*/
+function connectorMigrationsDir(appDir, connector) {
+	if (appDir === void 0 || isReservedConnectorName(connector)) return;
+	return ownsSharedMigrations(connector) ? appDir : path.join(appDir, connector);
+}
 /** Dossier de migrations, mémoïsé — la remontée ne se fait qu'une fois. */
 let cachedDir = null;
 /**
@@ -68,10 +110,22 @@ async function frameworkMigrationsDir() {
 *
 * @param appDir - dossier de migrations de l'application, s'il y en a un.
 * @param options.framework - `false` quand le module est data-only.
+* @param options.connector - connecteur visé ; un connecteur secondaire ne
+*   reçoit que SES migrations ({@link connectorMigrationsDir}), jamais celles
+*   du framework. Omis : le registre complet (usage direct).
 * @returns le registre, prêt pour l'applicateur.
 */
 async function defaultMigrationSources(appDir, options = {}) {
 	const sources = [];
+	if (options.connector !== void 0 && !ownsSharedMigrations(options.connector)) {
+		const own = connectorMigrationsDir(appDir, options.connector);
+		if (own !== void 0) sources.push({
+			name: "app",
+			dir: own,
+			rank: APP_RANK
+		});
+		return sources;
+	}
 	if (options.framework !== false) sources.push({
 		name: FRAMEWORK_SOURCE,
 		dir: await frameworkMigrationsDir(),
@@ -85,4 +139,4 @@ async function defaultMigrationSources(appDir, options = {}) {
 	return sources;
 }
 //#endregion
-export { APP_RANK, APP_SOURCE, FRAMEWORK_RANK, FRAMEWORK_SOURCE, defaultMigrationSources, frameworkMigrationsDir };
+export { APP_RANK, APP_SOURCE, FRAMEWORK_RANK, FRAMEWORK_SOURCE, RESERVED_MIGRATION_DIRS, connectorMigrationsDir, defaultMigrationSources, frameworkMigrationsDir, isReservedConnectorName };

package/dist/nodefony/src/migrator/refusals.js

@@ -1,5 +1,7 @@
 import { MIGRATE_URL_ENV } from "./types.js";
 import { action } from "./explain.js";
+import { FRAMEWORK_CONNECTOR } from "../frameworkConnector.js";
+import { RESERVED_MIGRATION_DIRS } from "./paths.js";
 import { knownConnectors } from "./resolve.js";
 //#region nodefony/src/migrator/refusals.ts
 /**
@@ -79,6 +81,30 @@ function generationNeedsAnswer(label, replay) {
 	};
 }
 /**
+* Un fichier lu par l'outil de génération porte un `await` de premier niveau.
+*
+* Nodefony est ESM, et l'application démarre très bien avec ce fichier. Mais
+* l'outil qui écrit les migrations (`drizzle-kit`) relit les fichiers de schéma
+* HORS de la chaîne de l'application, en les transpilant en CommonJS — où un
+* `await` de premier niveau n'existe pas. Sans ce refus, l'utilisateur recevait
+* une pile d'appels d'esbuild qui ne nomme ni l'outil ni le remède.
+*
+* @param label - ce qui était généré, tel qu'on le cite à l'utilisateur.
+* @param file - fichier fautif, tel que l'outil l'a nommé.
+* @param line - ligne de l'`await`.
+* @param replay - la commande à relancer une fois le fichier corrigé.
+* @returns le refus, prêt pour la ligne de commande comme pour l'écran.
+*/
+function generationTopLevelAwait(label, file, line, replay) {
+	return {
+		code: "NF_GENERATE_TOP_LEVEL_AWAIT",
+		summary: `${file}:${line} — un \`await\` de premier niveau empêche de générer ${label} ; rien n'a été écrit.`,
+		meaning: "L'application démarre avec ce fichier : elle est ESM. Mais l'outil qui écrit les migrations (drizzle-kit) relit les fichiers de schéma de son côté, en CommonJS, où un `await` de premier niveau n'existe pas. Un fichier d'entité DÉCLARE un schéma : ce qui se décide à l'exécution (choisir une entité selon l'infrastructure, importer un module à la demande) se place dans l'`index.ts` du module — `@entities([...])` accepte une liste calculée. La base n'est pas en cause : elle n'a pas été interrogée.",
+		nextActions: [action(replay)],
+		exitCode: 2
+	};
+}
+/**
 * L'outil de génération s'est arrêté, et ce qu'il a dit est remonté TEL QUEL.
 *
 * 🔴 Ne JAMAIS remplacer sa sortie par une hypothèse. Le fourre-tout des
@@ -176,6 +202,29 @@ function notConfigured(connector, driver) {
 	};
 }
 /**
+* Écrire une migration pour un connecteur secondaire dont le NOM est celui d'un
+* dossier de dialecte — refusé.
+*
+* Un connecteur secondaire range ses migrations sous `migrations/<connecteur>/`,
+* à côté des dossiers de dialecte du connecteur du framework. Nommé `postgres`,
+* son dossier SERAIT celui des migrations PostgreSQL du framework : il les
+* lirait comme les siennes, et les siennes seraient appliquées à la base du
+* framework. On le refuse en nommant la collision, plutôt que de le découvrir
+* au premier déploiement.
+*
+* @param connector - connecteur demandé.
+* @returns le refus, prêt pour la ligne de commande comme pour l'écran.
+*/
+function reservedConnectorName(connector) {
+	return {
+		code: "NF_MIGRATE_SECONDARY_CONNECTOR",
+		summary: `Le connecteur « ${connector} » porte le nom d'un dossier réservé (${RESERVED_MIGRATION_DIRS.join(", ")}) : ses migrations ne peuvent pas avoir de dossier propre. Rien n'a été écrit.`,
+		meaning: `Les migrations d'un connecteur secondaire vivent sous \`migrations/<connecteur>/<dialecte>\`, à côté des dossiers de dialecte du connecteur « ${FRAMEWORK_CONNECTOR} ». Le dossier \`migrations/${connector}\` est déjà l'un d'eux : les deux connecteurs y liraient les migrations de l'autre, et chacune serait appliquée à la mauvaise base. Renomme le connecteur dans \`connectors\` (par exemple « ${connector}_data ») : son nom ne sert qu'à le désigner.`,
+		nextActions: [action("nodefony inspect config --json")],
+		exitCode: 2
+	};
+}
+/**
 * Traduit une résolution qui n'est PAS `ready` en refus lisible.
 *
 * @param wanted - nom demandé par l'appelant.
@@ -222,4 +271,4 @@ function describeResolutionRefusal(wanted, resolution, config) {
 	};
 }
 //#endregion
-export { MigrationToolError, describeResolutionRefusal, formatToolOutput, generationFailed, generationNeedsAnswer, generationToolMissing, introspectFailed, moduleAbsent, notConfigured };
+export { MigrationToolError, describeResolutionRefusal, formatToolOutput, generationFailed, generationNeedsAnswer, generationToolMissing, generationTopLevelAwait, introspectFailed, moduleAbsent, notConfigured, reservedConnectorName };

package/dist/nodefony/src/migrator/resolve.js

@@ -1,6 +1,7 @@
 import { MIGRATE_URL_ENV } from "./types.js";
 import { resolveConnectorTarget } from "../connectorTarget.js";
-import { defaultMigrationSources } from "./paths.js";
+import { MEMORY_DATABASE } from "../memoryDatabase.js";
+import { connectorMigrationsDir, defaultMigrationSources } from "./paths.js";
 import { DrizzleMigrator } from "./DrizzleMigrator.js";
 import { parseDatabaseUrl, sqliteFilenameFromUrl } from "nodefony";
 import { ormRegistry } from "@nodefony/orm-core";
@@ -103,11 +104,20 @@ function generateApplyAllowed(env) {
 *
 * @param explicit - valeur écrite dans la configuration du connecteur, si elle l'est.
 * @param env - environnement constaté.
+* 🔴 **Une base VOLATILE (`:memory:`) dérive toujours son schéma**, en
+* production comprise. Rien d'autre ne peut la peupler : elle repart vide à
+* chaque démarrage, et une migration appliquée ne survit pas au processus. En
+* `none`, elle restait vide, le verdict de schéma tombait à `divergent` et la
+* sonde de disponibilité retenait la mise en service (vécu en CI : le connecteur
+* d'un module de banc, ouvert en production sous dérogation).
+*
 * @param appHasMigrations - l'application versionne au moins une migration.
+* @param volatile - la base est en mémoire (`:memory:`).
 * @returns le mode effectif.
 */
-function resolveDdlMode(explicit, env, appHasMigrations = false) {
+function resolveDdlMode(explicit, env, appHasMigrations = false, volatile = false) {
 	if (explicit) return explicit;
+	if (volatile) return "auto";
 	if (env.runtime === "development" || env.nodeEnv === "test") return appHasMigrations && env.nodeEnv !== "test" ? "migrate" : "auto";
 	return "none";
 }
@@ -142,6 +152,23 @@ function appVersionsMigrations(dir) {
 	return false;
 }
 /**
+* Des migrations versionnées CONCERNENT-elles ce connecteur ?
+*
+* C'est la question que pose la bascule `auto` → `migrate`, et elle n'est pas
+* « l'application versionne-t-elle des migrations ? » : celles de la racine
+* décrivent la base du framework. Posée telle quelle, elle faisait basculer en
+* `migrate` un connecteur secondaire qui n'en recevra jamais une — sa base
+* restait alors sans schéma, ni dérivé ni migré. On regarde donc le dossier
+* DU connecteur ({@link connectorMigrationsDir}).
+*
+* @param connector - nom du connecteur.
+* @param dir - dossier de migrations de l'application ({@link appMigrationsDir}).
+* @returns `true` si le dossier propre au connecteur porte au moins un `.sql`.
+*/
+function connectorVersionsMigrations(connector, dir) {
+	return appVersionsMigrations(connectorMigrationsDir(dir, connector));
+}
+/**
 * La conduite de la sonde de disponibilité face à un schéma en retard.
 *
 * En production, un exemplaire dont le schéma est en retard ne doit pas
@@ -158,6 +185,26 @@ function resolveCheckMode(explicit, env) {
 	return env.runtime === "production" ? "fail" : "warn";
 }
 /**
+* En schéma `auto`, faut-il ÉNONCER au démarrage les migrations enregistrées
+* que personne n'a appliquées ?
+*
+* Oui en développement, sauf conduite `off` — c'est ce conseil qui évite de
+* conclure à une base incohérente devant une colonne inconnue. Jamais sur une
+* base `:memory:` : elle repart VIDE à chaque démarrage, son historique aussi,
+* si bien que tout y paraît « à appliquer » à chaque fois — un avertissement
+* permanent qui n'apprend rien (vécu : le connecteur de banc `mediasoup`,
+* une fois déclaré, réclamait à chaque démarrage les migrations du framework
+* et de l'application, qui ne le concernent pas).
+*
+* @param check - conduite résolue ({@link resolveCheckMode}).
+* @param env - environnement constaté.
+* @param filename - fichier sqlite du connecteur, s'il en a un.
+* @returns `true` si le conseil doit être rendu.
+*/
+function adviseMigrations(check, env, filename) {
+	return check !== "off" && env.runtime === "development" && filename !== ":memory:";
+}
+/**
 * Décrit ce qui porte un connecteur, pour le nommer dans un refus.
 *
 * Un message qui dit seulement « ce connecteur ne porte pas de migrations »
@@ -287,7 +334,7 @@ function resolveConnector(connector, config, env, kernel, options = {}) {
 			url: fromMigrateUrl && dialect !== "sqlite" ? parsedUrl.url : base.url
 		},
 		fromMigrateUrl,
-		ddl: resolveDdlMode(declared.ddl, env, appVersionsMigrations(appMigrationsDir(kernel, config.migrations.dir)))
+		ddl: resolveDdlMode(declared.ddl, env, connectorVersionsMigrations(connector, appMigrationsDir(kernel, config.migrations.dir)), declared.filename === MEMORY_DATABASE)
 	};
 }
 /**
@@ -335,7 +382,10 @@ function appMigrationsDir(kernel, dir) {
 */
 async function buildMigrator(resolution, config, kernel) {
 	const appDir = appMigrationsDir(kernel, config.migrations.dir);
-	const sources = await defaultMigrationSources(appDir, { framework: config.frameworkEntities !== false });
+	const sources = await defaultMigrationSources(appDir, {
+		framework: config.frameworkEntities !== false,
+		connector: resolution.connector
+	});
 	return new DrizzleMigrator({
 		connector: resolution.connector,
 		...resolution.target,
@@ -348,4 +398,4 @@ function resolveDivergenceMode(config) {
 	return config.migrations.divergence;
 }
 //#endregion
-export { MIGRATE_URL_ENV, appMigrationsDir, appVersionsMigrations, buildMigrator, generateApplyAllowed, knownConnectors, readMigrationEnv, resetAllowed, resolveCheckMode, resolveConnector, resolveDdlMode, resolveDivergenceMode };
+export { MEMORY_DATABASE, MIGRATE_URL_ENV, adviseMigrations, appMigrationsDir, appVersionsMigrations, buildMigrator, connectorVersionsMigrations, generateApplyAllowed, knownConnectors, readMigrationEnv, resetAllowed, resolveCheckMode, resolveConnector, resolveDdlMode, resolveDivergenceMode };

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

@@ -1,4 +1,5 @@
 import { schemaReader, toDollarParams } from "../migrator/catalog.js";
+import "../memoryDatabase.js";
 import { notConfigured } from "../migrator/refusals.js";
 import { additiveSql, compareSchema, hasGap } from "../migrator/schemaDiff.js";
 import { describeTargetSafely } from "../safeTarget.js";
@@ -182,7 +183,7 @@ var DrizzleOrm = class DrizzleOrm extends Orm {
 	* @param options - options de connexion (`dialect`, `filename` sqlite, `url` pg).
 	*/
 	constructor(name, options = {}) {
-		super(name);
+		super(name, options.container);
 		this.#dialect = options.dialect ?? "sqlite";
 		this.#deriveSchema = options.deriveSchema !== false;
 		this.#filename = options.filename ?? ":memory:";

package/dist/nodefony/src/safeTarget.js

@@ -1,3 +1,4 @@
+import "./memoryDatabase.js";
 import path from "node:path";
 //#region nodefony/src/safeTarget.ts
 /**

package/dist/types/nodefony/command/migrateShared.d.ts

@@ -107,6 +107,16 @@ export declare abstract class OrmMigrateCommand extends Command {
         }>;
         config: IDrizzleConfig;
     } | null;
+    /**
+     * Arrête une commande qui ÉCRIRAIT une migration pour un connecteur
+     * secondaire dont le nom est celui d'un dossier de dialecte — son dossier
+     * propre se confondrait avec celui des migrations du framework.
+     *
+     * @param connector - connecteur résolu.
+     * @param json - mode machine.
+     * @returns `true` si la commande est arrêtée.
+     */
+    protected refuseReservedConnector(connector: string, json?: boolean): boolean;
     /**
      * Construit l'applicateur d'un connecteur résolu.
      *

package/dist/types/nodefony/config/defineModuleConfig.d.ts

@@ -13,10 +13,14 @@ import type { IDrizzleConfig, IDrizzleConfigInput } from "../interfaces/IDrizzle
  * au boot — cf audit config ORM 2026-06 §3.2.
  *
  * @param config - configuration brute (sections omises = défauts sûrs).
+ * @param declared - ce que l'APPLICATION a écrit elle-même. Au boot, `config`
+ *   arrive déjà fusionné avec les défauts du module (`config.ts`) : on ne peut
+ *   plus y distinguer un `default` demandé d'un `default` posé par défaut. Omis,
+ *   `config` fait foi (appel direct, tests).
  * @returns config validée, surchargée par l'env, et gelée.
  * @throws ZodError si la config est invalide.
  */
-export declare function defineDrizzleConfig(config?: IDrizzleConfigInput): IDrizzleConfig;
+export declare function defineDrizzleConfig(config?: IDrizzleConfigInput, declared?: IDrizzleConfigInput): IDrizzleConfig;
 /**
  * JSON Schema introspectable de la config Drizzle — destiné au formulaire
  * d'édition Studio (futur) et à la documentation générée.

package/dist/types/nodefony/entity/userTable.d.ts

@@ -1,16 +1,59 @@
-import type { SQLiteTable } from "drizzle-orm/sqlite-core";
+import type { AnySQLiteColumn, SQLiteTable } from "drizzle-orm/sqlite-core";
+import type { AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
+import type { AnyMySqlColumn, MySqlTable } from "drizzle-orm/mysql-core";
 import type { IEntity } from "@nodefony/orm-core";
 import type { SqlDialect } from "../interfaces/IDrizzleConfig.js";
+/**
+ * Factory de la table `User` — comme {@link FrameworkTableFactory}, mais sa clé
+ * primaire reste ATTEIGNABLE au type.
+ *
+ * 🔴 Sans cela, une application ne peut pas RÉFÉRENCER l'utilisateur, et c'est
+ * la première relation que quiconque écrit : `create entity Message
+ * "author:ref(User)"` rend `.references(() => userTable.id)`, qui ne compilait
+ * pas (`TS2339: Property 'id' does not exist on type 'SQLiteTable<TableConfig>'`).
+ * La table est bâtie depuis une spec dont les colonnes sont calculées
+ * (`Object.fromEntries`) : l'inférence les perd, et le type rendu ne porte plus
+ * aucune colonne — alors qu'elles existent toutes à l'exécution.
+ *
+ * Cette précision reste LOCALE à `User`, et n'est pas remontée dans le colKit :
+ * les tables du framework n'ont pas toutes une colonne `id` (`session` et
+ * `idempotency_key` portent une autre clé), donc l'y déclarer mentirait sur
+ * elles. `tests/unit/userTableReference.test.ts` garde le fait — par sa
+ * COMPILATION, qu'un cas d'exécution ne pourrait pas prouver.
+ */
+export interface UserTableFactory {
+    (dialect: "sqlite"): SQLiteTable & {
+        readonly id: AnySQLiteColumn;
+    };
+    (dialect: "postgres"): PgTable & {
+        readonly id: AnyPgColumn;
+    };
+    (dialect: "mysql"): MySqlTable & {
+        readonly id: AnyMySqlColumn;
+    };
+    (dialect?: SqlDialect): (SQLiteTable & {
+        readonly id: AnySQLiteColumn;
+    }) | (PgTable & {
+        readonly id: AnyPgColumn;
+    }) | (MySqlTable & {
+        readonly id: AnyMySqlColumn;
+    });
+}
 /**
  * Factory de la table `User` pour un dialecte donné (mémoïsée — une instance
  * par dialecte). Les trois dialectes sont portés (`sqlite` par défaut).
  */
-export declare const createUserTable: import("./colKit.js").FrameworkTableFactory;
+export declare const createUserTable: UserTableFactory;
 /**
  * Variante SQLite de la table `User` (dialecte par défaut) — export conservé
  * pour l'usage direct/banc-test (ex. module mediasoup).
+ *
+ * Son type n'est PAS réécrit en `SQLiteTable` : l'annoter ainsi effaçait la
+ * clé primaire que la factory vient d'exposer, et c'était la moitié du défaut.
  */
-export declare const userTable: SQLiteTable;
+export declare const userTable: SQLiteTable<import("drizzle-orm/sqlite-core").TableConfig> & {
+    readonly id: AnySQLiteColumn;
+};
 /**
  * Forme plate d'une ligne `User` renvoyée par le repository de base — le contrat
  * `IUserRow` de `@nodefony/user`, ré-exporté sous son nom historique.

package/dist/types/nodefony/registerStores.d.ts

@@ -1,3 +1,4 @@
+import { FRAMEWORK_CONNECTOR } from "./src/frameworkConnector.js";
 import type { SqlDialect } from "./config/config.js";
 /**
  * AUTO-ENREGISTREMENT des backends framework portés par Drizzle — « charger le
@@ -20,10 +21,10 @@ import type { SqlDialect } from "./config/config.js";
  * boot (« store inconnu ») — jamais de table fantôme ni d'erreur SQL différée.
  */
 /**
- * Connecteur conventionnel qui héberge le schéma framework (même convention que
- * `SESSION_CONNECTOR` : `"default"` pour Drizzle, `"nodefony"` pour Mongoose).
+ * Connecteur conventionnel qui héberge le schéma framework — défini dans
+ * `src/frameworkConnector.ts`, que les migrations lisent aussi.
  */
-export declare const FRAMEWORK_CONNECTOR = "default";
+export { FRAMEWORK_CONNECTOR };
 /** Bilan de l'auto-enregistrement (loggé par le module — jamais silencieux). */
 export interface IFrameworkStoresReport {
     /** Entités déclarées par l'auto-register (tables créées au connect). */

package/dist/types/nodefony/src/DrizzleAuditStore.d.ts

@@ -47,6 +47,12 @@ export declare class DrizzleAuditStore implements IAuditStore {
      * — lu par `readStoreLocation`. `undefined` = backend réseau ou `:memory:`.
      */
     get location(): string | undefined;
+    /**
+     * Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+     * registre des stores : la console rattache la brique à SON connecteur au
+     * lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+     */
+    get connector(): string | undefined;
     /**
      * Construit le store depuis un {@link DrizzleOrm}. Le handle est résolu **lazy**
      * (gardé par `isConnected()` → `null` tant que l'ORM n'est pas/plus connecté).

package/dist/types/nodefony/src/DrizzleIdempotencyStore.d.ts

@@ -73,8 +73,9 @@ export declare class DrizzleIdempotencyStore implements IIdempotencyStore {
      *   base ({@link DrizzleOrm.location}) pour Studio. Lazy (comme `resolveDb`) car
      *   le store est fabriqué AVANT le connect de l'ORM → l'emplacement n'est lisible
      *   qu'une fois l'ORM enregistré (lu au `onReady`, pas à la construction).
+     * @param connector - connecteur ORM qui porte la table, publié au registre des stores.
      */
-    constructor(resolveDb: () => DrizzleDb | null, now?: () => number, leaseMs?: number, ttlMs?: number, table?: DrizzleTable, resolveLocation?: () => string | undefined);
+    constructor(resolveDb: () => DrizzleDb | null, now?: () => number, leaseMs?: number, ttlMs?: number, table?: DrizzleTable, resolveLocation?: () => string | undefined, connector?: string);
     /**
      * Emplacement physique de la base (fichier SQLite) pour l'écran Studio « Stores »
      * — lu par `readStoreLocation`. Résolu **lazy** (l'ORM n'existe pas à la
@@ -82,6 +83,12 @@ export declare class DrizzleIdempotencyStore implements IIdempotencyStore {
      * ou sur un backend réseau (pg/mysql → voir l'infra déclarée).
      */
     get location(): string | undefined;
+    /**
+     * Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+     * registre des stores : la console rattache la brique à SON connecteur au
+     * lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+     */
+    get connector(): string | undefined;
     /**
      * Construit le store depuis un {@link DrizzleOrm}. Le handle est résolu **lazy**
      * (gardé par `isConnected()` → `null` tant que l'ORM n'est pas/plus connecté).

package/dist/types/nodefony/src/DrizzleTokenStore.d.ts

@@ -46,6 +46,12 @@ export declare class DrizzleTokenStore implements ITokenStore {
      * — lu par `readStoreLocation`. `undefined` = backend réseau ou `:memory:`.
      */
     get location(): string | undefined;
+    /**
+     * Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+     * registre des stores : la console rattache la brique à SON connecteur au
+     * lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+     */
+    get connector(): string | undefined;
     /**
      * Construit le store depuis un {@link DrizzleOrm} connecté. Les entités
      * (`registerTokenEntities`) doivent avoir été enregistrées **avant**

package/dist/types/nodefony/src/DrizzleTotpSecretStore.d.ts

@@ -35,6 +35,12 @@ export declare class DrizzleTotpSecretStore implements ITotpSecretStore {
      * — lu par `readStoreLocation`. `undefined` = backend réseau ou `:memory:`.
      */
     get location(): string | undefined;
+    /**
+     * Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+     * registre des stores : la console rattache la brique à SON connecteur au
+     * lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+     */
+    get connector(): string | undefined;
     /**
      * Construit le store depuis un {@link DrizzleOrm} connecté. L'entité
      * (`registerTotpSecretEntity`) doit avoir été enregistrée **avant** `orm.connect()`.

package/dist/types/nodefony/src/DrizzleWebAuthnCredentialStore.d.ts

@@ -34,6 +34,12 @@ export declare class DrizzleWebAuthnCredentialStore implements IWebAuthnCredenti
      * — lu par `readStoreLocation`. `undefined` = backend réseau ou `:memory:`.
      */
     get location(): string | undefined;
+    /**
+     * Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+     * registre des stores : la console rattache la brique à SON connecteur au
+     * lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+     */
+    get connector(): string | undefined;
     /**
      * Construit le store depuis un {@link DrizzleOrm} connecté. L'entité
      * (`registerWebAuthnCredentialEntity`) doit avoir été enregistrée **avant**

package/dist/types/nodefony/src/DrizzleWebhookStore.d.ts

@@ -51,6 +51,12 @@ export declare class DrizzleWebhookStore implements IWebhookStore {
      * — lu par `readStoreLocation`. `undefined` = backend réseau ou `:memory:`.
      */
     get location(): string | undefined;
+    /**
+     * Connecteur ORM qui porte ce store, lu par `readStoreConnector` pour le
+     * registre des stores : la console rattache la brique à SON connecteur au
+     * lieu de le déduire. `undefined` pour un store construit sans ORM (bancs).
+     */
+    get connector(): string | undefined;
     /**
      * Construit le store depuis un {@link DrizzleOrm} connecté. L'entité
      * (`registerWebhookEndpointEntity`) doit avoir été enregistrée **avant**

package/dist/types/nodefony/src/SessionStorage.d.ts

@@ -31,6 +31,12 @@ declare class SessionStorage implements ISessionStorage {
      * DÉFENSIVE (getter `location` optionnel) — l'ORM base `IOrm` ne l'expose pas.
      */
     get location(): string | undefined;
+    /**
+     * Connecteur ORM qui porte les sessions — lu par `readStoreConnector` pour le
+     * registre des stores. `undefined` tant que l'ORM de ce connecteur n'est pas
+     * enregistré : on ne publie pas un rattachement que rien ne porte.
+     */
+    get connector(): string | undefined;
     read(id: string): Promise<ISerializedSession>;
     start(id: string): Promise<ISerializedSession>;
     write(id: string, data: ISerializedSession): Promise<ISerializedSession>;

package/dist/types/nodefony/src/frameworkConnector.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Connecteur conventionnel qui héberge le schéma framework (même convention que
+ * `SESSION_CONNECTOR` : `"default"` pour Drizzle, `"nodefony"` pour Mongoose).
+ *
+ * Vit dans ce fichier sans dépendance parce que DEUX familles le lisent : le
+ * registre des stores (où résoudre les briques du framework) et les migrations
+ * (qui les reçoit). Une copie du littéral de chaque côté dériverait en silence.
+ */
+export declare const FRAMEWORK_CONNECTOR = "default";
+/**
+ * Ce connecteur possède-t-il les migrations du framework et de l'application ?
+ *
+ * **Seul le connecteur du framework les possède.** Le dossier des migrations de
+ * l'application (`migrations/<dialect>`) ne porte aucune notion de connecteur :
+ * il décrit UNE base, celle où vivent les briques du framework et les entités
+ * de l'application. Les attribuer à tout connecteur faisait qu'une base
+ * secondaire (analyse, base d'un module) en mode `migrate` y créait des tables
+ * qui ne lui appartiennent pas, et qu'en mode `auto` elle annonçait à chaque
+ * démarrage des migrations qui ne la concernent pas.
+ *
+ * @param connector - nom du connecteur (clé de `connectors`).
+ * @returns `true` pour le connecteur du framework, `false` pour tout autre.
+ */
+export declare function ownsSharedMigrations(connector: string): boolean;