nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/cli/scaffold/entityFields.js

@@ -0,0 +1,589 @@
+//#region src/cli/scaffold/entityFields.ts
+/**
+* Champs d'entité : de la syntaxe `title:string` au code Drizzle du dialecte visé.
+*
+* Module **pur** (aucune I/O, aucun template) : c'est lui qui porte la traduction
+* « vocabulaire Nodefony → colonne Drizzle native », donc c'est lui qu'on teste.
+*
+* Vocabulaire volontairement restreint — le scaffold doit produire du code qu'un
+* humain relit et étend, pas couvrir toute la surface SQL. Un besoin exotique
+* (`numeric(12,4)`, `citext`, tableau PG…) s'écrit à la main dans la table générée :
+* c'est du Drizzle natif, il n'y a rien à contourner.
+*/
+/** Dialectes SQL supportés par le scaffold (ceux de `@nodefony/drizzle`). */
+const ENTITY_DIALECTS = [
+	"sqlite",
+	"postgres",
+	"mysql"
+];
+/** Stratégies de clé primaire. */
+const ENTITY_ID_KINDS = [
+	"uuid7",
+	"uuid4",
+	"serial"
+];
+/** Types de champ du vocabulaire Nodefony (jamais le vocabulaire Drizzle). */
+const ENTITY_FIELD_TYPES = [
+	"string",
+	"text",
+	"int",
+	"float",
+	"bool",
+	"json",
+	"date",
+	"uuid",
+	"enum",
+	"char",
+	"decimal"
+];
+/**
+* Casses de nom de colonne SQL proposées — la propriété TypeScript ne bouge jamais.
+*
+* `camel` reproduit la propriété telle quelle (défaut historique) ; `snake` émet
+* `site_id` là où la propriété reste `siteId`. Drizzle porte nativement cette
+* dissociation — le premier argument d'un constructeur de colonne EST le nom SQL.
+*
+* Une seule option couvre l'écrasante majorité des schémas existants : sur les 134
+* renommages qu'exige le schéma d'Umami, **115 sont ce passage mécanique** au
+* `snake_case`. Les nommer un par un aurait demandé un dictionnaire ; ils tiennent
+* dans un choix.
+*/
+const COLUMN_CASES = ["camel", "snake"];
+/** `BlogPost` / `blog-post` / `siteId` → `blog_post` / `site_id`. */
+function toSnakeCase(name) {
+	return name.replace(/([a-z0-9])([A-Z])/gu, "$1_$2").replaceAll("-", "_").toLowerCase();
+}
+/**
+* Nom SQL d'une colonne, dérivé de sa propriété TypeScript.
+*
+* @param property - nom de la propriété (`siteId`).
+* @param columnCase - casse demandée ; `camel` rend la propriété inchangée.
+*/
+function sqlColumn(property, columnCase) {
+	return columnCase === "snake" ? toSnakeCase(property) : property;
+}
+/** Erreur de syntaxe dans la déclaration d'un champ — message actionnable. */
+var EntityFieldError = class extends Error {};
+const NAME_RE = /^[a-z][a-zA-Z0-9]*$/u;
+const ENTITY_RE = /^[A-Z][A-Za-z0-9]*$/u;
+/** Types qui n'acceptent pas de valeur par défaut littérale. */
+const NO_DEFAULT = /* @__PURE__ */ new Set([
+	"json",
+	"date",
+	"ref"
+]);
+/**
+* Analyse la déclaration textuelle des champs.
+*
+* Grammaire : `nom:type[?][!][=defaut][:index]` · `nom:ref:Entité[?][!][:index]`
+* - `?` → nullable (sinon **NOT NULL** : une colonne nullable est une décision, pas un oubli) ;
+* - `!` → unique ;
+* - `=valeur` → valeur par défaut (`price:float=0`, `status:enum(draft,published)=draft`) ;
+* - `:index` → index simple.
+*
+* Le type `enum` porte ses valeurs entre parenthèses : `status:enum(draft,published)`.
+*
+* @param input - `"title:string! content:text? views:int=0 author:ref:User"`.
+* @returns les champs, dans l'ordre de déclaration.
+* @throws EntityFieldError si un champ est mal formé (le mot « invalide » est attendu
+*   par le routeur d'erreurs du CLI pour sortir en `EX_USAGE`).
+*/
+function parseEntityFields(input) {
+	const fields = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const raw of input.split(/\s+/u).filter(Boolean)) {
+		let spec = raw;
+		let indexed = false;
+		if (spec.endsWith(":index")) {
+			indexed = true;
+			spec = spec.slice(0, -6);
+		}
+		let defaultValue;
+		const equalsAt = spec.indexOf("=", spec.lastIndexOf(")") + 1);
+		if (equalsAt >= 0) {
+			defaultValue = spec.slice(equalsAt + 1);
+			spec = spec.slice(0, equalsAt);
+			if (defaultValue === "") throw new EntityFieldError(`champ invalide « ${raw} » — valeur par défaut vide après « = » (ex : views:int=0)`);
+		}
+		let nullable = false;
+		let unique = false;
+		for (;;) {
+			if (spec.endsWith("?")) {
+				nullable = true;
+				spec = spec.slice(0, -1);
+				continue;
+			}
+			if (spec.endsWith("!")) {
+				unique = true;
+				spec = spec.slice(0, -1);
+				continue;
+			}
+			break;
+		}
+		const parts = spec.split(":");
+		const name = parts[0];
+		if (!name || !NAME_RE.test(name)) throw new EntityFieldError(`champ invalide « ${raw} » — nom attendu en camelCase (ex : title, publishedAt)`);
+		if (seen.has(name)) throw new EntityFieldError(`champ invalide « ${raw} » — « ${name} » déclaré deux fois`);
+		if (name === "id") throw new EntityFieldError(`champ invalide « ${raw} » — « id » est la clé primaire, posée par --id (uuid7 | uuid4 | serial)`);
+		seen.add(name);
+		if (parts[1] === "ref") {
+			const target = parts[2];
+			if (!target || !ENTITY_RE.test(target)) throw new EntityFieldError(`champ invalide « ${raw} » — cible attendue : nom d'entité en PascalCase (ex : author:ref:User)`);
+			if (defaultValue !== void 0) throw new EntityFieldError(`champ invalide « ${raw} » — une relation n'a pas de valeur par défaut`);
+			fields.push({
+				name,
+				type: "ref",
+				target,
+				nullable,
+				unique,
+				indexed: indexed || !unique
+			});
+			continue;
+		}
+		const enumMatch = /^enum\((.*)\)$/u.exec(parts[1] ?? "");
+		if (enumMatch) {
+			const values = (enumMatch[1] ?? "").split(",").map((value) => value.trim()).filter(Boolean);
+			if (values.length === 0) throw new EntityFieldError(`champ invalide « ${raw} » — enum sans valeur (ex : status:enum(draft,published))`);
+			if (defaultValue !== void 0 && !values.includes(defaultValue)) throw new EntityFieldError(`champ invalide « ${raw} » — défaut « ${defaultValue} » absent des valeurs (${values.join(", ")})`);
+			fields.push({
+				name,
+				type: "enum",
+				values,
+				nullable,
+				unique,
+				indexed,
+				...defaultValue !== void 0 ? { defaultValue } : {}
+			});
+			continue;
+		}
+		const spec2 = parts[1] ?? "string";
+		let length;
+		let precision;
+		let scale;
+		const sized = /^(string|char)\((\d+)\)$/u.exec(spec2);
+		const decimalMatch = /^decimal\((\d+),\s*(\d+)\)$/u.exec(spec2);
+		if (sized) {
+			length = Number(sized[2]);
+			if (length < 1) throw new EntityFieldError(`champ invalide « ${raw} » — longueur nulle (ex : title:string(200), country:char(2))`);
+			parts[1] = sized[1];
+		} else if (decimalMatch) {
+			precision = Number(decimalMatch[1]);
+			scale = Number(decimalMatch[2]);
+			if (precision < 1 || scale > precision) throw new EntityFieldError(`champ invalide « ${raw} » — décimal incohérent : l'échelle (${scale}) ne peut dépasser la précision (${precision}), ex : price:decimal(12,2)`);
+			parts[1] = "decimal";
+		} else if (spec2 === "char" || spec2 === "decimal") throw new EntityFieldError(spec2 === "char" ? `champ invalide « ${raw} » — char doit déclarer sa longueur (ex : country:char(2))` : `champ invalide « ${raw} » — décimal doit déclarer sa précision et son échelle (ex : price:decimal(12,2))`);
+		const type = parts[1] ?? "string";
+		if (!ENTITY_FIELD_TYPES.includes(type)) throw new EntityFieldError(`champ invalide « ${raw} » — type « ${type} » inconnu ; attendus : ${ENTITY_FIELD_TYPES.join(" | ")} | ref:<Entité>`);
+		if (type === "enum") throw new EntityFieldError(`champ invalide « ${raw} » — enum doit lister ses valeurs (ex : status:enum(draft,published))`);
+		if (parts.length > 2) throw new EntityFieldError(`champ invalide « ${raw} » — trop de segments (attendu nom:type[?][!][=defaut][:index])`);
+		if (defaultValue !== void 0) {
+			if (NO_DEFAULT.has(type)) throw new EntityFieldError(`champ invalide « ${raw} » — le type « ${type} » n'accepte pas de valeur par défaut`);
+			if ((type === "int" || type === "float") && !Number.isFinite(Number(defaultValue))) throw new EntityFieldError(`champ invalide « ${raw} » — défaut « ${defaultValue} » n'est pas un nombre`);
+			if (type === "bool" && defaultValue !== "true" && defaultValue !== "false") throw new EntityFieldError(`champ invalide « ${raw} » — défaut d'un booléen : true ou false`);
+		}
+		fields.push({
+			name,
+			type,
+			nullable,
+			unique,
+			indexed,
+			...length !== void 0 ? { length } : {},
+			...precision !== void 0 ? {
+				precision,
+				scale
+			} : {},
+			...defaultValue !== void 0 ? { defaultValue } : {}
+		});
+	}
+	return fields;
+}
+/**
+* Colonnes qu'une entité possède SANS qu'un champ les déclare.
+*
+* Elles sont indexables comme les autres — un index composite sur la date de
+* création est même le cas le plus courant sur une table d'événements — mais elles
+* n'apparaissent pas dans la liste des champs analysés, d'où cette table.
+*/
+function implicitColumns(options) {
+	const names = ["id"];
+	if (options.timestamps) names.push("createdAt", "updatedAt");
+	if (options.softDelete) names.push("deletedAt");
+	return names;
+}
+/**
+* Analyse les index de table déclarés par `--index` / `--unique`.
+*
+* Chaque valeur est une liste de colonnes séparées par des virgules
+* (`"websiteId,createdAt"`). Toute colonne citée doit exister : sans ce contrôle, on
+* écrirait une entité qui ne compile pas, et l'erreur tomberait chez l'utilisateur
+* sous la forme d'une propriété inconnue — loin de la commande qui l'a causée.
+*
+* @param specs - valeurs brutes des options, dans l'ordre de la ligne de commande.
+* @param fields - champs déjà analysés, qui fournissent les noms légitimes.
+* @param options - présence des colonnes implicites (horodatages, suppression douce).
+* @param unique - `true` quand ces valeurs viennent de `--unique`.
+* @returns les index analysés, doublons retirés.
+* @throws {EntityFieldError} colonne inconnue, liste vide, ou colonne répétée.
+*/
+function parseEntityIndexes(specs, fields, options, unique = false) {
+	const known = /* @__PURE__ */ new Set([...implicitColumns(options), ...fields.map((f) => f.name)]);
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const raw of specs) {
+		const columns = raw.split(",").map((c) => c.trim()).filter((c) => c.length > 0);
+		if (columns.length === 0) throw new EntityFieldError(`index « ${raw} » : aucune colonne — attendu une liste séparée par des virgules, ex. --index "websiteId,createdAt"`);
+		for (const column of columns) if (!known.has(column)) throw new EntityFieldError(`index « ${raw} » : la colonne « ${column} » n'existe pas sur cette entité — colonnes disponibles : ${[...known].join(", ")}`);
+		const duplicate = columns.find((c, i) => columns.indexOf(c) !== i);
+		if (duplicate !== void 0) throw new EntityFieldError(`index « ${raw} » : la colonne « ${duplicate} » est citée deux fois`);
+		const key = `${unique ? "u" : "i"}:${columns.join(",")}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push({
+			columns,
+			unique
+		});
+	}
+	return out;
+}
+/** Liste de valeurs d'énumération, écrite comme option Drizzle (`{ enum: [...] }`). */
+const enumOption = (values = []) => `enum: [${values.map((value) => JSON.stringify(value)).join(", ")}] as const`;
+/** Longueur d'une chaîne, avec le repli historique quand rien n'est déclaré. */
+const len = (size) => size?.length ?? 255;
+/**
+* Option de précision d'un décimal, écrite comme Drizzle l'attend.
+*
+* Sans précision déclarée, on n'écrit RIEN plutôt qu'un défaut inventé : les
+* moteurs n'ont pas la même idée d'un `numeric` nu, et choisir à leur place
+* masquerait ce désaccord au lieu de le laisser paraître.
+*/
+const decimalOption = (size) => size?.precision === void 0 ? "" : `, { precision: ${size.precision}, scale: ${size.scale ?? 0} }`;
+/**
+* Constructeur de colonne Drizzle par (dialecte, type) — le cœur de la traduction.
+*
+* Le second argument ne sert qu'aux énumérations, le troisième aux tailles
+* (longueur d'une chaîne, précision d'un décimal).
+*
+* Les trois moteurs n'offrent pas le même vocabulaire, et la table le dit au lieu
+* de le contourner : SQLite ignore `varchar` et `char` — toute chaîne y est un
+* `text`, la longueur n'y est de toute façon pas appliquée —, et MySQL n'expose
+* pas `numeric`, dont `decimal` est l'exact équivalent.
+*/
+const COLUMN = {
+	sqlite: {
+		string: (c) => `text("${c}")`,
+		char: (c) => `text("${c}")`,
+		decimal: (c) => `numeric("${c}")`,
+		text: (c) => `text("${c}")`,
+		int: (c) => `integer("${c}")`,
+		float: (c) => `real("${c}")`,
+		bool: (c) => `integer("${c}", { mode: "boolean" })`,
+		json: (c) => `text("${c}", { mode: "json" })`,
+		date: (c) => `integer("${c}", { mode: "timestamp_ms" })`,
+		uuid: (c) => `text("${c}")`,
+		ref: (c) => `text("${c}")`,
+		enum: (c, v) => `text("${c}", { ${enumOption(v)} })`
+	},
+	postgres: {
+		string: (c, _v, s) => `varchar("${c}", { length: ${len(s)} })`,
+		char: (c, _v, s) => `char("${c}", { length: ${len(s)} })`,
+		decimal: (c, _v, s) => `numeric("${c}"${decimalOption(s)})`,
+		text: (c) => `text("${c}")`,
+		int: (c) => `integer("${c}")`,
+		float: (c) => `doublePrecision("${c}")`,
+		bool: (c) => `boolean("${c}")`,
+		json: (c) => `jsonb("${c}")`,
+		date: (c) => `timestamp("${c}", { withTimezone: true, precision: 3 })`,
+		uuid: (c) => `uuid("${c}")`,
+		ref: (c) => `text("${c}")`,
+		enum: (c, v) => `varchar("${c}", { length: 255, ${enumOption(v)} })`
+	},
+	mysql: {
+		string: (c, _v, s) => `varchar("${c}", { length: ${len(s)} })`,
+		char: (c, _v, s) => `char("${c}", { length: ${len(s)} })`,
+		decimal: (c, _v, s) => `decimal("${c}"${decimalOption(s)})`,
+		text: (c) => `text("${c}")`,
+		int: (c) => `int("${c}")`,
+		float: (c) => `double("${c}")`,
+		bool: (c) => `boolean("${c}")`,
+		json: (c) => `json("${c}")`,
+		date: (c) => `datetime("${c}", { fsp: 3 })`,
+		uuid: (c) => `varchar("${c}", { length: 36 })`,
+		ref: (c) => `varchar("${c}", { length: 255 })`,
+		enum: (c, v) => `varchar("${c}", { length: 255, ${enumOption(v)} })`
+	}
+};
+/**
+* Ce que chaque type de champ devient, dans chaque moteur.
+*
+* Montrer la traduction plutôt que la promettre : `json` devient `jsonb` en
+* PostgreSQL et une colonne texte en SQLite, `string` un `varchar(255)` ici et un
+* `text` là. C'est une information dont dépend le choix de celui qui modélise, et
+* elle n'est déductible d'aucune documentation générique.
+*
+* Dérivé de la table de traduction elle-même : impossible que ce catalogue
+* dérive de ce que le générateur produit réellement.
+*
+* @returns un descripteur par type, avec sa colonne Drizzle par dialecte.
+*/
+function describeColumnTypes() {
+	return [...ENTITY_FIELD_TYPES, "ref"].map((type) => ({
+		type,
+		byDialect: Object.fromEntries(ENTITY_DIALECTS.map((dialect) => [dialect, COLUMN[dialect][type]("exemple", ["a", "b"], {
+			...type === "char" ? { length: 2 } : {},
+			...type === "decimal" ? {
+				precision: 12,
+				scale: 2
+			} : {}
+		})]))
+	}));
+}
+/** Fonction de table Drizzle du dialecte (`sqliteTable`…) et son import. */
+const TABLE_FN = {
+	sqlite: {
+		fn: "sqliteTable",
+		module: "drizzle-orm/sqlite-core"
+	},
+	postgres: {
+		fn: "pgTable",
+		module: "drizzle-orm/pg-core"
+	},
+	mysql: {
+		fn: "mysqlTable",
+		module: "drizzle-orm/mysql-core"
+	}
+};
+/** Type TypeScript de la propriété correspondante (interface `XRow`). */
+const TS_TYPE = {
+	string: "string",
+	text: "string",
+	int: "number",
+	float: "number",
+	bool: "boolean",
+	json: "unknown",
+	date: "Date",
+	uuid: "string",
+	ref: "string",
+	enum: "string",
+	char: "string",
+	decimal: "string"
+};
+/** Schéma Zod correspondant (validation à la frontière). */
+const ZOD_TYPE = {
+	string: "z.string().min(1).max(255)",
+	text: "z.string()",
+	int: "z.number().int()",
+	float: "z.number()",
+	bool: "z.boolean()",
+	json: "z.unknown()",
+	date: "z.coerce.date()",
+	uuid: "z.string().uuid()",
+	ref: "z.string()",
+	enum: "z.string()",
+	char: "z.string()",
+	decimal: "z.string()"
+};
+/**
+* Littéral TypeScript d'une valeur par défaut, selon le type du champ.
+*
+* Les nombres et booléens sont écrits nus, tout le reste est une chaîne : c'est
+* la seule interprétation possible d'un texte saisi en ligne de commande.
+*/
+function defaultLiteral(field) {
+	if (field.type === "int" || field.type === "float") return String(Number(field.defaultValue));
+	if (field.type === "bool") return String(field.defaultValue === "true");
+	if (field.type === "json") try {
+		return JSON.stringify(JSON.parse(String(field.defaultValue)));
+	} catch {
+		return JSON.stringify(field.defaultValue);
+	}
+	return JSON.stringify(field.defaultValue);
+}
+/** Type TS d'un champ — union littérale pour une énumération. */
+function tsTypeOf(field) {
+	if (field.type === "enum" && field.values) return field.values.map((value) => JSON.stringify(value)).join(" | ");
+	return TS_TYPE[field.type];
+}
+/**
+* Schéma Zod d'un champ — `z.enum` pour une énumération, borné pour une taille.
+*
+* C'est ici que les tailles deviennent une garantie RÉELLE. La colonne, elle, ne
+* protège pas partout : SQLite n'applique aucune longueur, et une valeur trop
+* longue y entrerait sans un mot pour ressortir tronquée le jour d'une migration
+* vers PostgreSQL. Le schéma, lui, s'applique sur tous les transports — REST,
+* socket, ligne de commande — et dans les trois moteurs.
+*/
+function zodTypeOf(field) {
+	if (field.type === "enum" && field.values) return `z.enum([${field.values.map((value) => JSON.stringify(value)).join(", ")}])`;
+	if (field.type === "string") return `z.string().min(1).max(${field.length ?? 255})`;
+	if (field.type === "char") return field.length === void 0 ? "z.string()" : `z.string().length(${field.length})`;
+	if (field.type === "decimal") {
+		const hint = field.precision === void 0 ? "décimal attendu" : `d\u00e9cimal attendu (${field.precision} chiffres dont ${field.scale ?? 0} apr\u00e8s la virgule)`;
+		return `z.string().regex(/^-?\\d+(\\.\\d+)?$/, ${JSON.stringify(hint)})`;
+	}
+	return ZOD_TYPE[field.type];
+}
+/**
+* Colonne de clé primaire, selon la stratégie retenue.
+*
+* La PROPRIÉTÉ reste `id` en toutes circonstances : le service CRUD, le controller,
+* le tri par défaut et les tests générés la nomment ainsi, et un schéma existant
+* n'a aucune raison d'imposer sa convention au code TypeScript. Seule la COLONNE
+* SQL suit le nom demandé — c'est elle qui doit épouser la table déjà en place
+* (`website_id` chez Umami, `session_id`, `user_id`… : 18 des 134 renommages).
+*
+* @param column - nom SQL de la colonne (`id` par défaut).
+*/
+function primaryKeyColumn(dialect, id, column) {
+	if (id === "serial") return {
+		line: dialect === "sqlite" ? `id: integer("${column}").primaryKey({ autoIncrement: true }),` : dialect === "postgres" ? `id: serial("${column}").primaryKey(),` : `id: int("${column}").autoincrement().primaryKey(),`,
+		tsType: "number",
+		imports: dialect === "sqlite" ? ["integer"] : dialect === "postgres" ? ["serial"] : ["int"]
+	};
+	const generator = id === "uuid7" ? "Nodefony.generateSortableId()" : "Nodefony.generateId()";
+	return {
+		line: `id: ${COLUMN[dialect].uuid(column)}.primaryKey().$defaultFn(() => ${generator}),`,
+		tsType: "string",
+		imports: [dialect === "postgres" ? "uuid" : dialect === "mysql" ? "varchar" : "text"]
+	};
+}
+/**
+* Colonne qui PORTE une référence — le pendant exact de {@link primaryKeyColumn}.
+*
+* Une clé étrangère doit avoir le TYPE de la clé qu'elle désigne, et c'est la
+* raison d'être de cette fonction : la référence était jusqu'ici une colonne
+* texte, quelle que soit la clé visée. En PostgreSQL, comparer un `text` à un
+* `uuid` échoue — « operator does not exist: text = uuid ». La jointure que cette
+* colonne existe précisément pour servir refusait donc de s'exécuter, et le
+* `?include=` avec elle. En SQLite, moteur du développement, la même comparaison
+* passe sans broncher : la panne n'attendait que le premier vrai serveur.
+*
+* La stratégie retenue est celle de l'entité qu'on crée. C'est le seul indice
+* dont dispose le générateur — il ne lit pas l'entité visée —, et il est juste
+* tant qu'une application ne mélange pas ses styles d'identifiant, ce qui est le
+* cas ordinaire. Une cible d'un autre style se corrige dans la table générée :
+* c'est du Drizzle natif.
+*
+* Aucune contrainte `REFERENCES` n'est émise — même raison qu'ailleurs : le DDL
+* dérivé du mode développement ne l'appliquerait pas, et une promesse non tenue
+* coûte plus cher qu'un commentaire honnête.
+*
+* @param dialect - moteur visé.
+* @param id - stratégie de clé primaire de l'entité en cours.
+* @param col - nom de la colonne.
+* @returns l'expression Drizzle, son type TypeScript et l'import nécessaire.
+*/
+function foreignKeyColumn(dialect, id, col) {
+	if (id === "serial") return {
+		expr: dialect === "mysql" ? `int("${col}")` : `integer("${col}")`,
+		tsType: "number",
+		imports: [dialect === "mysql" ? "int" : "integer"]
+	};
+	return {
+		expr: COLUMN[dialect].uuid(col),
+		tsType: "string",
+		imports: [dialect === "postgres" ? "uuid" : dialect === "mysql" ? "varchar" : "text"]
+	};
+}
+/** Nom du constructeur Drizzle utilisé par un champ (pour la liste d'imports). */
+function columnImport(dialect, type) {
+	return COLUMN[dialect][type]("x").split("(")[0];
+}
+/**
+* Produit le code des colonnes, de l'interface de ligne et du schéma Zod.
+*
+* Les horodatages sont posés **côté JS** (`$defaultFn`/`$onUpdateFn`) et non en SQL :
+* le DDL dérivé du mode dev n'émet pas les `DEFAULT` — un défaut SQL serait donc
+* silencieusement absent des tables créées au boot.
+*
+* @param fields - champs analysés par {@link parseEntityFields}.
+* @param options - dialecte, stratégie d'identifiant, horodatages, suppression douce.
+*/
+function buildEntityCodegen(fields, options) {
+	const { dialect, id, timestamps, softDelete, table } = options;
+	const columnCase = options.columnCase ?? "camel";
+	const idName = options.idName ?? "id";
+	/** Nom SQL d'une propriété, dans la casse retenue. */
+	const sql = (property) => sqlColumn(property, columnCase);
+	const imports = /* @__PURE__ */ new Set();
+	const columns = [];
+	const rowProps = [];
+	const zodProps = [];
+	const pk = primaryKeyColumn(dialect, id, idName);
+	pk.imports.forEach((i) => imports.add(i));
+	columns.push(pk.line);
+	rowProps.push(`id: ${pk.tsType};`);
+	for (const field of fields) {
+		const column = sql(field.name);
+		const fk = field.type === "ref" ? foreignKeyColumn(dialect, id, column) : void 0;
+		if (fk) fk.imports.forEach((i) => imports.add(i));
+		else imports.add(columnImport(dialect, field.type));
+		let col = fk?.expr ?? COLUMN[dialect][field.type](column, field.values, {
+			length: field.length,
+			precision: field.precision,
+			scale: field.scale
+		});
+		if (!field.nullable) col += ".notNull()";
+		if (field.unique) col += ".unique()";
+		if (field.defaultNow) {
+			col += ".$defaultFn(() => new Date())";
+			if (field.refreshedOnWrite) col += ".$onUpdateFn(() => new Date())";
+		}
+		if (field.defaultValue !== void 0) col += `.default(${defaultLiteral(field)}).$defaultFn(() => ${defaultLiteral(field)})`;
+		columns.push(`${field.name}: ${col},`);
+		const optional = field.nullable ? " | null" : "";
+		rowProps.push(`${field.name}: ${fk?.tsType ?? tsTypeOf(field)}${optional};`);
+		let zod = fk?.tsType === "number" ? "z.number().int()" : zodTypeOf(field);
+		if (field.nullable) zod += ".nullable().optional()";
+		if (field.defaultValue !== void 0) zod += `.default(${defaultLiteral(field)})`;
+		zodProps.push(`${field.name}: ${zod},`);
+		if (field.type === "ref") columns[columns.length - 1] += ` // → ${field.target}.id (contrainte FK à ajouter en migration)`;
+	}
+	if (timestamps) {
+		const dateCol = COLUMN[dialect].date;
+		imports.add(columnImport(dialect, "date"));
+		columns.push(`createdAt: ${dateCol("created_at")}.notNull().$defaultFn(() => new Date()),`, `updatedAt: ${dateCol("updated_at")}.notNull().$defaultFn(() => new Date()).$onUpdateFn(() => new Date()),`);
+		rowProps.push("createdAt: Date;", "updatedAt: Date;");
+	}
+	if (softDelete) {
+		const dateCol = COLUMN[dialect].date;
+		imports.add(columnImport(dialect, "date"));
+		columns.push(`deletedAt: ${dateCol("deleted_at")},`);
+		rowProps.push("deletedAt: Date | null;");
+	}
+	const declared = [...fields.filter((field) => field.indexed).map((field) => ({
+		columns: [field.name],
+		unique: false
+	})), ...options.indexes ?? []];
+	let tableExtras = "";
+	if (declared.length > 0) {
+		const seen = /* @__PURE__ */ new Set();
+		const lines = [];
+		for (const entry of declared) {
+			const suffix = entry.unique ? "key" : "idx";
+			const name = `${table}_${entry.columns.map(sql).join("_")}_${suffix}`;
+			if (seen.has(name)) continue;
+			seen.add(name);
+			const fn = entry.unique ? "uniqueIndex" : "index";
+			imports.add(fn);
+			const cols = entry.columns.map((c) => `t.${c}`).join(", ");
+			lines.push(`    ${fn}("${name}").on(${cols}),`);
+		}
+		tableExtras = `, (t) => [\n${lines.join("\n")}\n  ]`;
+	}
+	const { fn, module } = TABLE_FN[dialect];
+	imports.add(fn);
+	const block = (lines) => lines.join("\n  ");
+	const blockLn = (lines) => `${block(lines)}\n`;
+	return {
+		columns: blockLn(columns),
+		drizzleImport: `import { ${[...imports].sort().join(", ")} } from "${module}";`,
+		tableFn: fn,
+		rowProps: block(rowProps),
+		zodProps: block(zodProps),
+		tableExtras,
+		needsNodefony: id !== "serial",
+		idType: pk.tsType
+	};
+}
+//#endregion
+export { COLUMN_CASES, ENTITY_DIALECTS, ENTITY_FIELD_TYPES, ENTITY_ID_KINDS, EntityFieldError, TABLE_FN, buildEntityCodegen, describeColumnTypes, parseEntityFields, parseEntityIndexes, sqlColumn, toSnakeCase };