@rebasepro/server-postgres 0.17.3 → 0.18.1

package/dist/introspect-db-logic-C6LQdTxj.js

@@ -0,0 +1,1378 @@
+import { createRequire as __createRequire } from "module";
+__createRequire(import.meta.url);
+import { firstFreeKey, toWireKey } from "@rebasepro/utils";
+//#region src/schema/introspect-db-naming.ts
+/**
+* Naming helpers shared by the introspection modules. These live apart from
+* `introspect-db-logic.ts` because the inference pass needs them too, and
+* importing them from there would close a cycle back through this module.
+*/
+/**
+* Convert a snake_case name to a human-readable Title Case label.
+* e.g. "created_at" -> "Created At", "customer_id" -> "Customer Id"
+*/
+function humanize(snakeName) {
+	return snakeName.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+//#endregion
+//#region src/schema/introspect-db-inference.ts
+var ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var CUID_REGEX = /^c[^\s-]{7,}$/i;
+function inferPropertyFromData(columnName, pgDataType, currentPropType, sampleValues, isPk, emitAdmin = true) {
+	const result = {};
+	const extraLines = [];
+	const adminOptions = [];
+	const validValues = sampleValues.filter((v) => v !== null && v !== void 0 && v !== "");
+	if (validValues.length === 0) return result;
+	const colNameLower = columnName.toLowerCase();
+	if (currentPropType === "number") {
+		if (validValues.every((v) => v === 0 || v === 1 || v === "0" || v === "1")) {
+			result.propType = "boolean";
+			return result;
+		}
+		const numValues = validValues.map((v) => Number(v)).filter((v) => !isNaN(v));
+		if (numValues.length === validValues.length) {
+			const min = Math.min(...numValues);
+			const max = Math.max(...numValues);
+			if (min >= 0 && max <= 100 && (colNameLower.includes("percent") || colNameLower.includes("rate") || colNameLower.includes("score"))) extraLines.push("            validation: {\n                min: 0,\n                max: 100\n            }");
+			else if (min >= 0 && (colNameLower.includes("count") || colNameLower.includes("total") || colNameLower.includes("amount"))) extraLines.push("            validation: {\n                min: 0\n            }");
+		}
+	}
+	if (currentPropType === "map" || pgDataType.includes("json")) {
+		let allArrays = true;
+		let allObjects = true;
+		for (const v of validValues) {
+			let parsed = v;
+			if (typeof v === "string") try {
+				parsed = JSON.parse(v);
+			} catch (e) {
+				allArrays = false;
+				allObjects = false;
+				break;
+			}
+			if (Array.isArray(parsed)) allObjects = false;
+			else if (typeof parsed === "object" && parsed !== null) allArrays = false;
+			else {
+				allArrays = false;
+				allObjects = false;
+			}
+		}
+		if (allArrays && !allObjects) {
+			result.propType = "array";
+			let allNumbers = true;
+			let allStrings = true;
+			for (const v of validValues) {
+				const parsed = typeof v === "string" ? JSON.parse(v) : v;
+				for (const item of parsed) {
+					if (typeof item !== "number") allNumbers = false;
+					if (typeof item !== "string") allStrings = false;
+				}
+			}
+			const innerType = allNumbers ? "number" : allStrings ? "string" : "map";
+			extraLines.push(`            of: { name: "${humanize(columnName)} Item", type: "${innerType}" }`);
+		} else {
+			result.propType = "map";
+			if (allObjects && validValues.length > 0) {
+				const schema = {};
+				for (const v of validValues) {
+					const parsed = typeof v === "string" ? JSON.parse(v) : v;
+					for (const [k, val] of Object.entries(parsed)) {
+						if (val === null || val === void 0) continue;
+						const type = typeof val;
+						if (type === "string" || type === "number" || type === "boolean") {
+							if (!schema[k]) schema[k] = type;
+							else if (schema[k] !== type) schema[k] = "mixed";
+						} else if (Array.isArray(val)) {
+							if (!schema[k]) schema[k] = "array";
+							else if (schema[k] !== "array") schema[k] = "mixed";
+						} else if (type === "object") {
+							if (!schema[k]) schema[k] = "map";
+							else if (schema[k] !== "map") schema[k] = "mixed";
+						}
+					}
+				}
+				const keys = Object.keys(schema).filter((k) => schema[k] !== "mixed");
+				if (keys.length > 0) {
+					const props = keys.map((k) => {
+						return `\n                ${k}: { name: "${humanize(k)}", type: "${schema[k]}" }`;
+					}).join(",");
+					extraLines.push(`            properties: {${props}\n            }`);
+				} else extraLines.push("            keyValue: true");
+			} else extraLines.push("            keyValue: true");
+		}
+	}
+	if (currentPropType === "string") {
+		if (validValues.every((v) => typeof v === "string" && ISO_8601_REGEX.test(v))) {
+			result.propType = "date";
+			return result;
+		}
+		const uniqueValues = new Set(validValues);
+		let maxEnumLength = 0;
+		for (const v of uniqueValues) if (typeof v === "string" && v.length > maxEnumLength) maxEnumLength = v.length;
+		if (uniqueValues.size > 0 && uniqueValues.size <= 5 && maxEnumLength <= 50 && validValues.length > uniqueValues.size && !uniqueValues.has("")) {
+			if (!(isPk || colNameLower.endsWith("_id"))) {
+				const enumEntries = Array.from(uniqueValues).map((v) => `{ id: ${JSON.stringify(v)}, label: ${JSON.stringify(humanize(v))} }`).join(", ");
+				extraLines.push(`            enum: [${enumEntries}]`);
+				result.extra = extraLines.length > 0 ? "\n" + extraLines.join(",\n") + "," : "";
+				return result;
+			}
+		}
+		const allUuid = validValues.every((v) => typeof v === "string" && UUID_REGEX.test(v));
+		const allCuid = validValues.every((v) => typeof v === "string" && CUID_REGEX.test(v));
+		if (allUuid) {
+			if (isPk) extraLines.push("            isId: \"uuid\"");
+		} else if (allCuid) {
+			if (isPk) extraLines.push("            isId: \"cuid\"");
+		}
+		let maxLength = 0;
+		let hasNewlines = false;
+		let hasMarkdown = false;
+		for (const v of validValues) if (typeof v === "string") {
+			if (v.length > maxLength) maxLength = v.length;
+			if (v.includes("\n")) hasNewlines = true;
+			if (/^#{1,6}\s+.+/m.test(v) || /\*\*.+\*\*/.test(v) || /\[.+\]\(.+\)/.test(v) || /^\s*[-*]\s+.+/m.test(v)) hasMarkdown = true;
+		}
+		if (hasMarkdown) adminOptions.push("multiline: true", "markdown: true");
+		else if (hasNewlines || maxLength > 100) adminOptions.push("multiline: true");
+		if (maxLength > 0 && maxLength < 1e4) {
+			const paddedMax = Math.ceil(maxLength * 1.5 / 10) * 10;
+			if (paddedMax < 255) extraLines.push(`            validation: {\n                max: ${paddedMax}\n            }`);
+		}
+		const isUrl = colNameLower.endsWith("_url") || colNameLower.endsWith("_uri") || colNameLower.endsWith("_link");
+		const isMedia = colNameLower.includes("image") || colNameLower.includes("avatar") || colNameLower.includes("photo") || colNameLower.includes("logo") || colNameLower.includes("cover");
+		if (validValues.every((v) => typeof v === "string" && (v.startsWith("http://") || v.startsWith("https://")))) if (validValues.some((v) => typeof v === "string" && v.match(/\.(jpeg|jpg|gif|png|webp|svg)/i)) || isMedia) {
+			extraLines.push("            url: true");
+			adminOptions.push("urlPreview: \"image\"");
+		} else extraLines.push("            url: true");
+		else if (validValues.some((v) => typeof v === "string" && v.match(/\.[a-zA-Z0-9]+$/))) {
+			const firstVal = validValues[0];
+			const lastSlash = firstVal.lastIndexOf("/");
+			const inferredStoragePath = lastSlash > 0 ? firstVal.substring(0, lastSlash) : "files";
+			extraLines.push(`            storage: {\n                storagePath: "${inferredStoragePath}"\n            }`);
+		} else if (isUrl) {
+			extraLines.push("            url: true");
+			if (isMedia) adminOptions.push("urlPreview: \"image\"");
+		}
+	}
+	if (emitAdmin && adminOptions.length > 0) extraLines.push(`            admin: {\n${adminOptions.map((o) => `                ${o}`).join(",\n")}\n            }`);
+	result.extra = extraLines.length > 0 ? "\n" + extraLines.join(",\n") + "," : "";
+	return result;
+}
+//#endregion
+//#region src/schema/introspect-db-types.ts
+/**
+* The PostgreSQL type → Rebase property type mapping.
+*
+* Split out of `introspect-db-logic` so that the structural analysis can use it
+* without importing the generator, which imports the analysis. Re-exported from
+* `introspect-db-logic` so existing callers keep their import path.
+*/
+/**
+* Map a PostgreSQL data type to a Rebase property type.
+*/
+function mapPgType(dataType) {
+	const dt = dataType.toLowerCase();
+	if (dt === "interval") return "string";
+	if (dt === "array" || dt.startsWith("_")) return "array";
+	if (dt.includes("int") || dt.includes("numeric") || dt.includes("decimal") || dt.includes("serial") || dt === "real" || dt === "float4" || dt === "float8" || dt === "double precision" || dt === "money") return "number";
+	if (dt.includes("bool")) return "boolean";
+	if (dt.includes("time") || dt.includes("date")) return "date";
+	if (dt === "json" || dt === "jsonb") return "map";
+	if (dt === "bytea") return "binary";
+	if (dt === "inet" || dt === "cidr" || dt === "macaddr" || dt === "macaddr8") return "string";
+	if (dt === "uuid") return "string";
+	return "string";
+}
+/**
+* A timestamp the database maintains: a temporal column defaulting to the
+* transaction clock.
+*
+* This is the structural stand-in for the `created_at`/`updated_at` name check.
+* It is strictly better than the name: it catches `fecha_creacion` and
+* `last_update` (pagila's spelling, which the name list misses), and it does not
+* fire on a user-editable `created_at date` column that has no default and which
+* the name check would wrongly make read-only.
+*/
+function isAutoTimestamp(column) {
+	if (mapPgType(column.data_type) !== "date") return false;
+	const columnDefault = (column.column_default ?? "").toLowerCase();
+	if (!columnDefault) return false;
+	return /\b(now\(\)|current_timestamp|current_date|current_time|localtimestamp|localtime|transaction_timestamp\(\)|statement_timestamp\(\)|clock_timestamp\(\))/.test(columnDefault);
+}
+/** A column Postgres computes; writing to it is an error. */
+function isGeneratedColumn(column) {
+	return column.is_generated === "ALWAYS";
+}
+/**
+* Types that exist to be searched or indexed, never to be typed into.
+*
+* A `tsvector` column is a derived search index — maintained by a trigger, a
+* generated expression, or an application job — and its contents are lexeme
+* positions, not text. Pagila's `film.fulltext` is one, and introspection used
+* to emit it as an ordinary required string: a mandatory form field whose
+* correct value no user can produce, on the sixth column of the list view.
+*/
+function isDerivedIndexColumn(column) {
+	return column.udt_name === "tsvector" || column.udt_name === "tsquery";
+}
+/** Anything the user cannot meaningfully edit, whatever the reason. */
+function isReadOnlyColumn(column) {
+	return isGeneratedColumn(column) || isDerivedIndexColumn(column);
+}
+/**
+* A string column with a declared maximum length.
+*
+* `varchar(50)` and `text` are the same type to an application but not to the
+* author: choosing a bound is a statement that the value is short and
+* label-like, which is what makes this usable for picking a display column.
+*/
+function isBoundedString(column) {
+	return mapPgType(column.data_type) === "string" && typeof column.character_maximum_length === "number" && column.character_maximum_length > 0;
+}
+/**
+* A column carrying data rather than structure: not a key, not a foreign key,
+* not a database-maintained timestamp, not computed.
+*
+* The count of these is what tells a pure join table from an association that
+* carries its own attributes — `northwind.order_details` has the key shape of a
+* junction and three payload columns, so it is not one.
+*/
+function isPayloadColumn(column, pks, fkColumns) {
+	if (pks.includes(column.column_name)) return false;
+	if (fkColumns.has(column.column_name)) return false;
+	if (isAutoTimestamp(column)) return false;
+	if (isGeneratedColumn(column)) return false;
+	return true;
+}
+/**
+* Groups per-column foreign key rows back into constraints.
+*
+* Rows arrive one per referencing column. A composite key looks exactly like two
+* separate keys until they are grouped by constraint name, and the difference
+* matters: two single-column keys to two tables can be a junction, one
+* two-column key never is.
+*/
+function groupForeignKeys(fks) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const fk of fks) {
+		const key = `${fk.table_name}::${fk.constraint_name ?? `${fk.column_name}->${fk.foreign_table_name}`}`;
+		const existing = byName.get(key);
+		if (existing) {
+			existing.columns.push(fk.column_name);
+			existing.foreignColumns.push(fk.foreign_column_name);
+			continue;
+		}
+		byName.set(key, {
+			name: fk.constraint_name ?? `${fk.table_name}_${fk.column_name}_fkey`,
+			table: fk.table_name,
+			columns: [fk.column_name],
+			foreignTable: fk.foreign_table_name,
+			foreignColumns: [fk.foreign_column_name],
+			deleteRule: fk.delete_rule
+		});
+	}
+	return Array.from(byName.values());
+}
+/** Column sets that are unique in a table: its primary key and every unique index. */
+function uniqueColumnSets(table, pks, uniques) {
+	const sets = [];
+	if (pks.length > 0) sets.push(pks);
+	for (const unique of uniques) if (unique.table_name === table) sets.push(unique.column_names);
+	return sets;
+}
+function sameColumnSet(a, b) {
+	if (a.length !== b.length) return false;
+	const left = [...a].sort();
+	const right = [...b].sort();
+	return left.every((value, index) => value === right[index]);
+}
+function buildContext(metadata, tables) {
+	const allConstraints = groupForeignKeys(metadata.fks);
+	const constraintsByTable = /* @__PURE__ */ new Map();
+	const inboundByTable = /* @__PURE__ */ new Map();
+	for (const constraint of allConstraints) {
+		const outbound = constraintsByTable.get(constraint.table) ?? [];
+		outbound.push(constraint);
+		constraintsByTable.set(constraint.table, outbound);
+		const inbound = inboundByTable.get(constraint.foreignTable) ?? [];
+		inbound.push(constraint);
+		inboundByTable.set(constraint.foreignTable, inbound);
+	}
+	return {
+		tables,
+		constraintsByTable,
+		inboundByTable,
+		uniques: metadata.uniques,
+		rowCounts: metadata.rowCounts
+	};
+}
+/**
+* A table that exists only to relate two others.
+*
+* Requires all of:
+* - exactly two single-column foreign keys, to two distinct columns;
+* - that pair is unique — it is the primary key, or a unique index covers it.
+*   Without this the table can hold the same pair twice, which is a list of
+*   events between two things, not a set membership;
+* - no payload columns. A join row that carries a quantity is an association
+*   with attributes, and collapsing it into a many-to-many silently drops those
+*   attributes from the UI entirely;
+* - nothing references it. A junction with its own dependents is something rows
+*   point *at*, so it needs an identity of its own.
+*/
+function classifyJunction(table, context) {
+	const meta = context.tables.get(table);
+	if (!meta) return null;
+	const constraints = context.constraintsByTable.get(table) ?? [];
+	if (constraints.length !== 2) return null;
+	if (constraints.some((c) => c.columns.length !== 1)) return null;
+	const [first, second] = constraints;
+	if (first.columns[0] === second.columns[0]) return null;
+	if ((context.inboundByTable.get(table) ?? []).length > 0) return null;
+	const pair = [first.columns[0], second.columns[0]];
+	if (!uniqueColumnSets(table, meta.pks, context.uniques).some((set) => sameColumnSet(set, pair))) return null;
+	const fkColumns = new Set(pair);
+	if (meta.columns.filter((column) => isPayloadColumn(column, meta.pks, fkColumns)).length > 0) return null;
+	return {
+		table,
+		role: "junction",
+		reason: `only relates ${first.foreignTable} to ${second.foreignTable}: two foreign keys, unique together, no other data`,
+		junction: {
+			sourceTable: first.foreignTable,
+			sourceColumn: first.columns[0],
+			targetTable: second.foreignTable,
+			targetColumn: second.columns[0]
+		}
+	};
+}
+/**
+* A small, referenced, self-contained code list.
+*
+* Requires: something references it, it references nothing, it carries few and
+* simple payload columns, and it is small — where "small" is a real count, not
+* an estimate. `reltuples` is -1 on any table that has never been analyzed,
+* which is every table in a freshly restored dump, so a count that is merely
+* absent must not read as "small".
+*/
+function classifyLookup(table, context) {
+	if (!isLookupCandidate(table, context)) return null;
+	const rowCount = context.rowCounts[table];
+	if (typeof rowCount !== "number") return null;
+	if (rowCount < 1 || rowCount > 50) return null;
+	return {
+		table,
+		role: "lookup",
+		reason: `a ${rowCount}-row code list: referenced by ${(context.inboundByTable.get(table) ?? []).length} table(s), references none, 3 or fewer simple columns`
+	};
+}
+/**
+* The structural half of the lookup test — everything except the row count.
+*
+* Separate because the count costs a query per table, and the caller only wants
+* to pay it for tables that could possibly qualify.
+*/
+function isLookupCandidate(table, context) {
+	const meta = context.tables.get(table);
+	if (!meta) return false;
+	if ((context.constraintsByTable.get(table) ?? []).length > 0) return false;
+	if ((context.inboundByTable.get(table) ?? []).length === 0) return false;
+	const payload = meta.columns.filter((column) => isPayloadColumn(column, meta.pks, /* @__PURE__ */ new Set()));
+	if (payload.length > 3) return false;
+	return payload.every((column) => {
+		const type = mapPgType(column.data_type);
+		return type === "boolean" || type === "number" || type === "string";
+	});
+}
+/**
+* Names the tables whose classification depends on a row count.
+*
+* The caller counts these — and only these — before calling
+* {@link classifyTables}. On a schema of any size this is a handful of tables,
+* and the count itself is capped (see `countRowsUpTo`), so the whole extra cost
+* is bounded regardless of how much data the database holds.
+*/
+function lookupCandidates(metadata, tables) {
+	const context = buildContext(metadata, tables);
+	return Array.from(tables.keys()).filter((table) => isLookupCandidate(table, context));
+}
+/**
+* Rows that belong to one parent row and are reached through it.
+*
+* Requires nothing to reference the table — a table others point at has an
+* identity of its own and belongs in the navigation — and an *unambiguous*
+* owner among its foreign keys. The evidence ladder runs strongest first; each
+* rung is only taken when exactly one key satisfies it, so a table with two
+* equally plausible parents stays an entity rather than being filed under a
+* coin-flip.
+*/
+function classifyOwnedChild(table, context) {
+	const meta = context.tables.get(table);
+	if (!meta) return null;
+	const constraints = context.constraintsByTable.get(table) ?? [];
+	if (constraints.length === 0) return null;
+	if ((context.inboundByTable.get(table) ?? []).length > 0) return null;
+	const owner = pickOwner(meta, constraints);
+	if (!owner) return null;
+	return {
+		table,
+		role: "owned-child",
+		reason: `belongs to ${owner.constraint.foreignTable} (${describeEvidence(owner.evidence)}) and nothing else references it`,
+		owner: {
+			table: owner.constraint.foreignTable,
+			column: owner.constraint.columns[0],
+			evidence: owner.evidence
+		}
+	};
+}
+function describeEvidence(evidence) {
+	switch (evidence) {
+		case "cascade-delete": return "its only ON DELETE CASCADE foreign key";
+		case "identifying-key": return "its only foreign key inside the primary key";
+		case "sole-required-key": return "its only NOT NULL foreign key";
+		case "leading-key-column": return "the leading column of a primary key made only of foreign keys";
+	}
+}
+function pickOwner(meta, constraints) {
+	const singleColumn = constraints.filter((c) => c.columns.length === 1);
+	if (singleColumn.length === 0) return null;
+	const nullability = new Map(meta.columns.map((c) => [c.column_name, c.is_nullable === "NO"]));
+	const cascading = singleColumn.filter((c) => c.deleteRule === "CASCADE");
+	if (cascading.length === 1) return {
+		constraint: cascading[0],
+		evidence: "cascade-delete"
+	};
+	const identifying = singleColumn.filter((c) => meta.pks.includes(c.columns[0]));
+	if (identifying.length === 1) return {
+		constraint: identifying[0],
+		evidence: "identifying-key"
+	};
+	const required = singleColumn.filter((c) => nullability.get(c.columns[0]) === true);
+	if (required.length === 1) return {
+		constraint: required[0],
+		evidence: "sole-required-key"
+	};
+	if (identifying.length === meta.pks.length && meta.pks.length > 1) {
+		const leading = identifying.find((c) => c.columns[0] === meta.pks[0]);
+		if (leading) return {
+			constraint: leading,
+			evidence: "leading-key-column"
+		};
+	}
+	return null;
+}
+/**
+* Classifies every table in the schema.
+*
+* Order matters: junction is the most specific and most consequential (the
+* table disappears), so it is tested first; then lookup, which needs no
+* ownership reasoning; then ownership. Anything unmatched is an entity, which
+* is also what every rule falls back to when its evidence is ambiguous.
+*/
+function classifyTables(metadata, tables) {
+	const context = buildContext(metadata, tables);
+	const result = /* @__PURE__ */ new Map();
+	for (const table of tables.keys()) {
+		const classification = classifyJunction(table, context) ?? classifyLookup(table, context) ?? classifyOwnedChild(table, context) ?? {
+			table,
+			role: "entity",
+			reason: "no structural evidence that it is a join table, a code list, or owned by another table"
+		};
+		result.set(table, classification);
+	}
+	return result;
+}
+function buildColumnFacts(meta, metadata, enumMap, checkFacts) {
+	const fkColumns = new Set(meta.fks.map((fk) => fk.column_name));
+	const singleColumnUniques = new Set(metadata.uniques.filter((u) => u.table_name === meta.name && u.column_names.length === 1).map((u) => u.column_names[0]));
+	const tableChecks = checkFacts.get(meta.name);
+	const facts = /* @__PURE__ */ new Map();
+	for (const column of meta.columns) {
+		const pgEnum = column.data_type === "USER-DEFINED" ? enumMap.get(column.udt_name) : void 0;
+		const checkEnum = tableChecks?.get(column.column_name)?.enumValues;
+		facts.set(column.column_name, {
+			column,
+			isPk: meta.pks.includes(column.column_name),
+			isFk: fkColumns.has(column.column_name),
+			isUniqueAlone: singleColumnUniques.has(column.column_name),
+			isAutoTimestamp: isAutoTimestamp(column),
+			isGenerated: isGeneratedColumn(column),
+			enumValues: pgEnum ?? checkEnum,
+			propType: pgEnum ? "string" : mapPgType(column.data_type)
+		});
+	}
+	return facts;
+}
+/**
+* The column that identifies a row to a human.
+*
+* Structural, in three rungs, strongest first:
+*
+* 1. A single-column unique constraint on a required string. This is as close
+*    as a schema comes to declaring "this is what a row is called": it is the
+*    column a person looks a row up by, and the database guarantees it picks
+*    out one row.
+* 2. The first required string that declares a length, when the table also has
+*    strings that do not. Choosing `varchar(n)` for one column and `text` for
+*    another is the author distinguishing a label from prose.
+* 3. The first required string in declaration order. Weak, but it is the same
+*    rung the panel's own fallback stands on, and column order carries real
+*    information — the identifying column of a table is written near the top of
+*    it, in every schema, in every language.
+*
+* Deliberately not: a column called `name`, or `title`. That works on English
+* schemas written by someone who read the same tutorial. This picks
+* `film.title`, `actor.first_name` and `category.name` out of pagila without
+* knowing what any of those words mean.
+*/
+function deriveTitleProperty(facts) {
+	const candidates = Array.from(facts.values()).filter((f) => !f.isPk && !f.isFk && !f.isGenerated && f.propType === "string" && !f.enumValues && f.column.is_nullable === "NO");
+	if (candidates.length === 0) return void 0;
+	const unique = candidates.find((f) => f.isUniqueAlone);
+	if (unique) return unique.column.column_name;
+	const bounded = candidates.filter((f) => isBoundedString(f.column));
+	if (bounded.length > 0 && bounded.length < candidates.length) return bounded[0].column.column_name;
+	return candidates[0].column.column_name;
+}
+/**
+* The enum column a board should have as its columns.
+*
+* A board needs a small, closed, always-present set of states. `NOT NULL` is
+* required because a null has no column to sit in; the bounds keep out
+* two-state flags (a filter, not a board) and long code lists (a scrolling
+* table). The first qualifying column in declaration order wins, so the output
+* is stable across runs.
+*/
+function deriveKanbanProperty(facts) {
+	for (const fact of facts.values()) {
+		if (fact.isPk || fact.isFk || fact.isGenerated) continue;
+		if (!fact.enumValues) continue;
+		if (fact.column.is_nullable !== "NO") continue;
+		if (fact.enumValues.length < 2 || fact.enumValues.length > 12) continue;
+		return fact.column.column_name;
+	}
+}
+/**
+* The column a list should be sorted by, newest first.
+*
+* Only when the table has exactly one database-maintained timestamp. With two —
+* a created and an updated stamp — the two orderings differ and the schema does
+* not say which the user means, so neither is chosen.
+*/
+function deriveSort(facts) {
+	const stamps = Array.from(facts.values()).filter((f) => f.isAutoTimestamp);
+	if (stamps.length !== 1) return void 0;
+	return [stamps[0].column.column_name, "desc"];
+}
+/**
+* The first `LIST_PROPERTIES_CAP` visible properties, or nothing.
+*
+* Returning nothing when the table is already narrow matters: `listProperties`
+* that restates every column is config the reader has to check against the
+* property list to discover it does nothing, and it silently stops new columns
+* from appearing in the list view when someone adds one later.
+*
+* `hidden` names the properties already marked `hideFromCollection` — spending
+* one of six columns on a value the list does not render is worse than not
+* capping at all.
+*/
+function deriveListProperties(propertiesOrder, hidden = /* @__PURE__ */ new Set()) {
+	const visible = propertiesOrder.filter((key) => !hidden.has(key));
+	if (visible.length <= 6) return void 0;
+	return visible.slice(0, 6);
+}
+//#endregion
+//#region src/schema/introspect-db-logic.ts
+/**
+* Introspection logic — pure functions and the pipeline that transforms
+* raw PostgreSQL metadata into Rebase collection definition files.
+*
+* This module contains NO side-effects: no fs writes, no pg.Client creation,
+* no process.exit.  It is imported by introspect-db.ts (the CLI entry-point)
+* and consumed directly by tests.
+*/
+var IRREGULAR_SINGULARS = {
+	people: "person",
+	children: "child",
+	men: "man",
+	women: "woman",
+	mice: "mouse",
+	geese: "goose",
+	teeth: "tooth",
+	feet: "foot",
+	data: "datum",
+	media: "medium",
+	criteria: "criterion",
+	phenomena: "phenomenon"
+};
+/**
+* Plurals in "-ves" whose singular really ends in f/fe, and which of the two.
+*
+* A blanket "-ves" -> "-f" rule gets `knives` -> `knif`, and mangles every
+* ordinary "-ive" noun that happens to be plural along with it: `archives` ->
+* `archif`, `objectives` -> `objectif`. The set of English words that genuinely
+* swap f/fe for ves is small and closed, so it is listed rather than guessed —
+* anything else ending in "ves" drops the trailing 's' like any other plural.
+*
+* Matched on the whole word, not on the suffix: `olives` ends in `lives`.
+*/
+var VES_SINGULAR_ENDINGS = {
+	calves: "f",
+	dwarves: "f",
+	elves: "f",
+	halves: "f",
+	hooves: "f",
+	leaves: "f",
+	loaves: "f",
+	scarves: "f",
+	selves: "f",
+	sheaves: "f",
+	shelves: "f",
+	thieves: "f",
+	wharves: "f",
+	wolves: "f",
+	knives: "fe",
+	lives: "fe",
+	wives: "fe"
+};
+/** Words ending in 's' that are already singular. */
+var UNCOUNTABLE = /* @__PURE__ */ new Set([
+	"status",
+	"campus",
+	"virus",
+	"bus",
+	"plus",
+	"census",
+	"diagnosis",
+	"analysis",
+	"basis",
+	"crisis",
+	"thesis",
+	"synopsis",
+	"parenthesis",
+	"hypothesis",
+	"emphasis",
+	"news",
+	"series",
+	"species",
+	"means",
+	"athletics",
+	"economics",
+	"electronics",
+	"mathematics",
+	"physics",
+	"politics",
+	"statistics"
+]);
+function singularize(word) {
+	const lower = word.toLowerCase();
+	if (IRREGULAR_SINGULARS[lower]) {
+		const singular = IRREGULAR_SINGULARS[lower];
+		return word[0] === word[0].toUpperCase() ? singular.charAt(0).toUpperCase() + singular.slice(1) : singular;
+	}
+	if (UNCOUNTABLE.has(lower)) return word;
+	if (lower.endsWith("ices") && lower.length > 5) return word.slice(0, -4) + "ex";
+	if (lower.endsWith("ies") && lower.length > 3) return word.slice(0, -3) + "y";
+	if (VES_SINGULAR_ENDINGS[lower]) return word.slice(0, -3) + VES_SINGULAR_ENDINGS[lower];
+	if (lower.endsWith("ches") || lower.endsWith("shes") || lower.endsWith("sses") || lower.endsWith("xes") || lower.endsWith("zes")) return word.slice(0, -2);
+	if (lower.endsWith("ses") && !lower.endsWith("sses")) return word.slice(0, -1);
+	if (lower.endsWith("s") && !lower.endsWith("ss") && !lower.endsWith("us") && !lower.endsWith("is")) return word.slice(0, -1);
+	return word;
+}
+/**
+* Convert a snake_case table name to a camelCase + "Collection" variable name.
+* e.g. "company_token" -> "companyTokenCollection"
+*/
+function toCollectionVarName(tableName) {
+	const camel = tableName.replace(/_([a-z])/g, (_g, letter) => letter.toUpperCase()) + "Collection";
+	if (JS_IDENTIFIER.test(camel)) return camel;
+	const sanitized = camel.replace(/[^A-Za-z0-9_$]/g, "_");
+	return /^[0-9]/.test(sanitized) ? `_${sanitized}` : sanitized;
+}
+function getIconForTable(tableName) {
+	const table = tableName.toLowerCase();
+	if (table.includes("user") || table.includes("account") || table.includes("member") || table.includes("customer") || table.includes("client") || table.includes("patient")) return "Users";
+	if (table.includes("post") || table.includes("article") || table.includes("blog") || table.includes("page")) return "FileText";
+	if (table.includes("product") || table.includes("item")) return "Package";
+	if (table.includes("order") || table.includes("cart") || table.includes("purchase") || table.includes("invoice")) return "ShoppingCart";
+	if (table.includes("setting") || table.includes("config")) return "Settings";
+	if (table.includes("tag") || table.includes("categor")) return "Tag";
+	if (table.includes("image") || table.includes("photo") || table.includes("media") || table.includes("asset")) return "Image";
+	if (table.includes("notification") || table.includes("message") || table.includes("email")) return "Mail";
+	if (table.includes("log") || table.includes("audit") || table.includes("event")) return "Activity";
+	if (table.includes("subscription") || table.includes("plan") || table.includes("billing")) return "CreditCard";
+	if (table.includes("comment") || table.includes("review") || table.includes("feedback")) return "MessageCircle";
+	return "Database";
+}
+function buildEnumMap(enumValues) {
+	const enumMap = /* @__PURE__ */ new Map();
+	for (const ev of enumValues) {
+		const existing = enumMap.get(ev.enum_name);
+		if (existing) existing.push(ev.enum_value);
+		else enumMap.set(ev.enum_name, [ev.enum_value]);
+	}
+	return enumMap;
+}
+function buildTablesMap(tables, columns, pks, fks) {
+	const tablesMap = /* @__PURE__ */ new Map();
+	for (const t of tables) tablesMap.set(t.table_name, {
+		name: t.table_name,
+		columns: columns.filter((c) => c.table_name === t.table_name),
+		pks: pks.filter((pk) => pk.table_name === t.table_name).map((pk) => pk.column_name),
+		fks: fks.filter((fk) => fk.table_name === t.table_name)
+	});
+	return tablesMap;
+}
+/**
+* Join tables, identified by column name.
+*
+* Superseded for the CLI by `classifyTables` in `./introspect-db-structure`,
+* which asks the database instead: two single-column keys, unique together, no
+* payload column, nothing referencing the table. This rule folds away
+* `northwind.order_details` — which has the key shape and carries unit price,
+* quantity and discount — because it recognises `id`, `created_at` and
+* `updated_at` by name and calls everything else a foreign key.
+*
+* Still used by `./introspect-runtime`, which builds collections in memory from
+* a narrower set of catalog queries and has no unique-constraint or row-count
+* data to reason with.
+*/
+function identifyJoinTables(tablesMap) {
+	const joinTables = /* @__PURE__ */ new Set();
+	for (const [tableName, meta] of tablesMap.entries()) if (meta.fks.length === 2) {
+		if (meta.columns.every((c) => meta.fks.some((fk) => fk.column_name === c.column_name) || c.column_name === "id" || c.column_name === "created_at" || c.column_name === "updated_at")) joinTables.add(tableName);
+	}
+	return joinTables;
+}
+var IDENTITY_EXACT = {
+	id: 0,
+	uuid: 1,
+	_id: 2
+};
+var TITLE_EXACT = {
+	name: 10,
+	title: 11,
+	label: 12,
+	display_name: 13,
+	displayname: 13,
+	headline: 14,
+	subject: 15,
+	heading: 16
+};
+var HUMAN_IDENTITY_EXACT = {
+	first_name: 20,
+	firstname: 20,
+	last_name: 21,
+	lastname: 21,
+	full_name: 22,
+	fullname: 22,
+	given_name: 22,
+	family_name: 23,
+	middle_name: 24,
+	username: 25,
+	user_name: 25,
+	email: 26,
+	email_address: 26,
+	phone: 27,
+	phone_number: 27,
+	mobile: 27
+};
+var DESCRIPTOR_EXACT = {
+	slug: 30,
+	code: 31,
+	sku: 32,
+	reference: 33,
+	ref: 33,
+	type: 34,
+	kind: 34,
+	status: 35,
+	state: 35,
+	role: 36,
+	category: 37,
+	group: 38,
+	priority: 39,
+	order: 39,
+	sort_order: 39,
+	position: 39
+};
+var SYSTEM_TIMESTAMP_EXACT = {
+	created_at: 120,
+	createdat: 120,
+	creation_date: 120,
+	inserted_at: 121,
+	updated_at: 122,
+	updatedat: 122,
+	modified_at: 122,
+	last_modified: 122,
+	deleted_at: 123,
+	deletedat: 123,
+	archived_at: 124
+};
+var TITLE_PATTERNS = [
+	"name",
+	"title",
+	"label"
+];
+var LONG_TEXT_NAMES = /* @__PURE__ */ new Set([
+	"description",
+	"summary",
+	"excerpt",
+	"abstract",
+	"overview",
+	"bio",
+	"biography",
+	"about"
+]);
+var RICH_CONTENT_NAMES = /* @__PURE__ */ new Set([
+	"content",
+	"body",
+	"html",
+	"markup",
+	"text",
+	"article_body",
+	"post_body"
+]);
+var MEDIA_PATTERNS = [
+	"image",
+	"avatar",
+	"photo",
+	"logo",
+	"cover",
+	"thumbnail",
+	"banner",
+	"icon",
+	"picture",
+	"poster"
+];
+var JSON_MAP_NAMES = /* @__PURE__ */ new Set([
+	"metadata",
+	"meta",
+	"config",
+	"configuration",
+	"settings",
+	"options",
+	"preferences",
+	"data",
+	"payload",
+	"attributes",
+	"extra",
+	"additional_info"
+]);
+/**
+* Compute a numeric priority score for a property.
+* Lower scores appear first in the generated `propertiesOrder` array.
+*
+* The system uses 14 tiers (0–139), with the original column index
+* added as a fractional tiebreaker (originalIndex / 10000) to
+* guarantee stable ordering within the same tier.
+*
+* Pure function — no side effects.
+*/
+function computePropertyPriority(columnName, ctx) {
+	const col = columnName.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+	const tiebreaker = ctx.originalIndex / 1e4;
+	if (ctx.isPk) return (IDENTITY_EXACT[col] ?? 5) + tiebreaker;
+	const systemTs = SYSTEM_TIMESTAMP_EXACT[col];
+	if (systemTs !== void 0) return systemTs + tiebreaker;
+	const titleExact = TITLE_EXACT[col];
+	if (titleExact !== void 0) return titleExact + tiebreaker;
+	const humanExact = HUMAN_IDENTITY_EXACT[col];
+	if (humanExact !== void 0) return humanExact + tiebreaker;
+	const descriptorExact = DESCRIPTOR_EXACT[col];
+	if (descriptorExact !== void 0) return descriptorExact + tiebreaker;
+	for (const pattern of TITLE_PATTERNS) if (col.includes(pattern) && col !== pattern) return 17 + tiebreaker;
+	if (ctx.isStorage) return 90 + tiebreaker;
+	for (const pattern of MEDIA_PATTERNS) if (col.includes(pattern)) return 91 + tiebreaker;
+	if (col.endsWith("_url") || col.endsWith("_uri") || col.endsWith("_link")) return 92 + tiebreaker;
+	if (LONG_TEXT_NAMES.has(col)) return 70 + tiebreaker;
+	if (RICH_CONTENT_NAMES.has(col)) return 80 + tiebreaker;
+	if (ctx.propType === "map") return JSON_MAP_NAMES.has(col) ? 100 + tiebreaker : 105 + tiebreaker;
+	if (ctx.propType === "array") return 110 + tiebreaker;
+	if (ctx.propType === "relation") return 60 + tiebreaker;
+	if (ctx.isEnum) return 40 + tiebreaker;
+	if (ctx.propType === "boolean") return 45 + tiebreaker;
+	if (ctx.propType === "string" && ctx.pgDataType !== "text") return 42 + tiebreaker;
+	if (ctx.propType === "number") return 50 + tiebreaker;
+	if (ctx.propType === "date") return 55 + tiebreaker;
+	if (ctx.propType === "string" && ctx.pgDataType === "text") return 75 + tiebreaker;
+	return 130 + tiebreaker;
+}
+function sortPropertiesOrder(entries) {
+	return [...entries].sort((a, b) => computePropertyPriority(a.key, a.ctx) - computePropertyPriority(b.key, b.ctx)).map((e) => e.key);
+}
+/**
+* The package specifiers the generated files name, spelled once.
+*
+* Written as constants rather than inline in the import templates below because
+* `scripts/headless-guard/check-types.mjs` scans core sources for `from
+* "@rebasepro/cms-types"` and cannot tell a real import from one this module
+* *writes*. It is right to be that blunt — the guard's whole value is that it
+* cannot be reasoned around — so the string simply never appears in that shape
+* here. Inlining them back into the templates re-breaks `check:types-headless`.
+*/
+var ADMIN_TYPES_PACKAGE = "@rebasepro/cms-types";
+var COMMON_PACKAGE = "@rebasepro/common";
+var TYPES_PACKAGE = "@rebasepro/types";
+/** Adds entries to a property's `validation` block, creating it if absent. */
+function withValidation(extra, entries) {
+	if (entries.length === 0) return extra;
+	const block = entries.map((e) => `                ${e}`).join(",\n");
+	if (extra.includes("validation: {")) return extra.replace("validation: {", `validation: {\n${block},`);
+	return `${extra}\n            validation: {\n${block}\n            },`;
+}
+/**
+* Whether a property's generated text already sets `key:` as an object key.
+*
+* A bare `extra.includes("min:")` looks like it answers this and does not:
+* `admin:` ends in `min:`, so every property with an admin block claimed to
+* have a minimum already and silently lost the one the database declared. The
+* leading-delimiter requirement is the whole point — a key is preceded by a
+* newline, a brace or a comma, never by another identifier character.
+*/
+function hasGeneratedKey(extra, key) {
+	return new RegExp(`(^|[\\s{,])${key}\\s*:`).test(extra);
+}
+/**
+* Adds entries to a property's `admin` block, creating it if absent.
+*
+* `emitAdmin` is false for the headless flavours, where `BaseProperty` has no
+* `admin` field to put them in — see {@link CollectionBuilder}. The options are
+* dropped rather than relocated: every one of them (`readOnly`, `multiline`,
+* `hideFromCollection`, `urlPreview`) describes a form widget, and there is no
+* form.
+*/
+function withAdminOptions(extra, entries, emitAdmin = true) {
+	if (!emitAdmin) return extra;
+	if (entries.length === 0) return extra;
+	const block = entries.map((e) => `                ${e}`).join(",\n");
+	if (extra.includes("admin: {")) return extra.replace("admin: {", `admin: {\n${block},`);
+	return `${extra}\n            admin: {\n${block}\n            },`;
+}
+/** A TypeScript string literal, escaped. */
+function quote(value) {
+	return JSON.stringify(value);
+}
+var JS_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+* An object key for the generated file: verbatim when the name is a JavaScript
+* identifier, quoted otherwise.
+*
+* Postgres constrains an identifier only by quoting, so `order`, `full name`
+* and `2fa_enabled` are all ordinary column names — and all three produced a
+* file that did not parse when written as a bare key.
+*
+* Still needed now that keys are camel-cased rather than copied from the
+* column: `toWireKey` splits on separators and joins, which fixes `full name`
+* but cannot fix a name that is not an identifier for some other reason —
+* `2fa_enabled` becomes `2faEnabled`, still leading with a digit, and `order`
+* was never a separator problem at all.
+*/
+function propKey(name) {
+	return JS_IDENTIFIER.test(name) ? name : quote(name);
+}
+/**
+* Text safe to put after `//`.
+*
+* A table comment or a classification reason is free text out of the database.
+* A newline in one ended the comment and let the rest of the value continue as
+* code.
+*/
+function commentText(value) {
+	return value.replace(/\s*[\r\n]+\s*/g, " ");
+}
+/** A property-key array, one key per line, indented for the admin block. */
+function formatKeyList(keys) {
+	if (keys.length === 0) return "[]";
+	return `[\n${keys.map((k) => `            ${quote(k)}`).join(",\n")}\n        ]`;
+}
+/**
+* Generate the full TypeScript file content for a single collection.
+* Pure function — no I/O.
+*/
+function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap, enumMap, sampleData, context = {}) {
+	const collectionName = humanize(tableName);
+	const singular = singularize(collectionName);
+	const icon = getIconForTable(tableName);
+	const classification = context.classifications?.get(tableName);
+	const checkFacts = context.checkFacts ?? /* @__PURE__ */ new Map();
+	const tableChecks = checkFacts.get(tableName);
+	const columnComments = /* @__PURE__ */ new Map();
+	let tableComment;
+	for (const comment of context.metadata?.comments ?? []) {
+		if (comment.table_name !== tableName) continue;
+		if (comment.column_name === null) tableComment = comment.comment;
+		else columnComments.set(comment.column_name, comment.comment);
+	}
+	const singleColumnUniques = new Set((context.metadata?.uniques ?? []).filter((u) => u.table_name === tableName && u.column_names.length === 1).map((u) => u.column_names[0]));
+	const builder = context.builder ?? "admin-types";
+	/** Whether the target project has an `admin` field to write into at all. */
+	const emitAdmin = builder === "admin-types";
+	const BUILDER_IMPORT = {
+		"admin-types": `import { defineCollection } from ${quote(ADMIN_TYPES_PACKAGE)};`,
+		common: `import { defineCollection } from ${quote(COMMON_PACKAGE)};`,
+		annotation: `import { PostgresCollectionConfig } from ${quote(TYPES_PACKAGE)};`
+	};
+	const imports = /* @__PURE__ */ new Set([BUILDER_IMPORT[builder]]);
+	/**
+	* Imports the collection a relation points at — unless it is this one.
+	*
+	* A self-referencing key (`employees.reports_to -> employees`, which both
+	* northwind and chinook have) otherwise made the file import its own default
+	* export under the name it declares three lines later: `TS2440: Import
+	* declaration conflicts with local declaration`. The relation target is a
+	* thunk, so referring to the local const directly is fine — it is only
+	* dereferenced after the module has finished evaluating.
+	*/
+	const importCollection = (otherTable) => {
+		const varName = toCollectionVarName(otherTable);
+		if (otherTable !== tableName) imports.add(`import ${varName} from ${quote(`./${otherTable}`)};`);
+		return varName;
+	};
+	/**
+	* A relation's `target` thunk, with its return type spelled out.
+	*
+	* The annotation is what makes `defineCollection` survive a relational schema.
+	* Without an explicit type on the const, the collection's type is *inferred*,
+	* and a relation cycle — `posts` belongs to `authors`, `authors` has many
+	* `posts`; or `employees.reports_to -> employees`, which northwind, chinook and
+	* musicbrainz all have — makes that inference circular: `TS7022: implicitly has
+	* type 'any' because it is referenced directly or indirectly in its own
+	* initializer`, plus `TS7023` on the thunk and `TS2303` on the import alias.
+	* Naming the return type lets the checker type the thunk without resolving the
+	* collection it points at, which breaks the cycle. Nothing else is given up:
+	* the inference that matters runs over `properties`, not over `relations`.
+	*
+	* The annotated flavour has no cycle to break — its const is already typed — so
+	* it keeps the plainer thunk it has always emitted.
+	*/
+	const relationTarget = (targetVarName) => {
+		if (builder === "annotation") return `() => ${targetVarName}`;
+		imports.add(`import type { AnyCollectionConfig } from ${quote(TYPES_PACKAGE)};`);
+		return `(): AnyCollectionConfig => ${targetVarName}`;
+	};
+	let propsOutput = "";
+	let relationsOutput = "";
+	const orderEntries = [];
+	const propertyBlocks = /* @__PURE__ */ new Map();
+	/**
+	* Column → the property key it was generated under.
+	*
+	* Needed because the structural helpers below (`deriveTitleProperty`,
+	* `deriveKanbanProperty`, `deriveSort`) answer in *columns* — they read
+	* `pg_attribute` — while `display.title`, `kanban.columnProperty` and
+	* `sort` name **properties**. The two used to be the same string, so
+	* nothing carried the translation; now `full_name` is generated as
+	* `fullName` and a title pointing at `full_name` points at nothing.
+	*/
+	const keyByColumn = /* @__PURE__ */ new Map();
+	/** Properties the list view will not render, so `listProperties` skips them. */
+	const hiddenFromCollection = /* @__PURE__ */ new Set();
+	let columnIndex = 0;
+	const isCompositePk = meta.pks.length > 1;
+	for (const col of meta.columns) {
+		if (meta.fks.some((fk) => fk.column_name === col.column_name) && !meta.pks.includes(col.column_name)) continue;
+		const currentIndex = columnIndex++;
+		const propertyKey = firstFreeKey([toWireKey(col.column_name), col.column_name], propertyBlocks);
+		keyByColumn.set(col.column_name, propertyKey);
+		const colEnumValues = enumMap.get(col.udt_name);
+		const isEnumColumn = col.data_type === "USER-DEFINED" && colEnumValues !== void 0;
+		const isVectorColumn = col.udt_name === "vector";
+		const propType = isEnumColumn ? "string" : isVectorColumn ? "vector" : mapPgType(col.data_type);
+		let extra = "";
+		const colNameLower = col.column_name.toLowerCase();
+		let finalPropType = propType;
+		let inferenceExtra = "";
+		if (!isEnumColumn && sampleData && sampleData.length > 0) {
+			const values = sampleData.map((r) => r[col.column_name]);
+			const inferred = inferPropertyFromData(col.column_name, col.data_type, propType, values, meta.pks.includes(col.column_name), emitAdmin);
+			if (inferred.propType) finalPropType = inferred.propType;
+			if (inferred.extra) inferenceExtra = inferred.extra;
+		}
+		const columnChecks = tableChecks?.get(col.column_name);
+		if (isEnumColumn && colEnumValues) {
+			const enumEntries = colEnumValues.map((v) => `{ id: ${quote(v)}, label: ${quote(humanize(v))} }`).join(", ");
+			extra += `\n            enum: [${enumEntries}],`;
+		} else if (columnChecks?.enumValues && !inferenceExtra.includes("enum:") && propType === "string") {
+			const enumEntries = columnChecks.enumValues.map((v) => `{ id: ${quote(v)}, label: ${quote(humanize(v))} }`).join(", ");
+			extra += `\n            enum: [${enumEntries}],`;
+		}
+		if (finalPropType === "date") {
+			if (colNameLower === "created_at" || colNameLower === "createdat") {
+				extra += "\n            autoValue: \"on_create\",";
+				extra = withAdminOptions(extra, ["readOnly: true", "hideFromCollection: true"], emitAdmin);
+				hiddenFromCollection.add(propertyKey);
+			} else if (colNameLower === "updated_at" || colNameLower === "updatedat") {
+				extra += "\n            autoValue: \"on_update\",";
+				extra = withAdminOptions(extra, ["readOnly: true", "hideFromCollection: true"], emitAdmin);
+				hiddenFromCollection.add(propertyKey);
+			} else if (col.column_default && (col.column_default.includes("now()") || col.column_default.includes("CURRENT_TIMESTAMP"))) {
+				extra += "\n            autoValue: \"on_create\",";
+				extra = withAdminOptions(extra, ["readOnly: true"], emitAdmin);
+			}
+		}
+		if (finalPropType === "array" && !inferenceExtra.includes("of: {")) {
+			let innerType = "string";
+			let colType = "";
+			if (col.udt_name.startsWith("_")) {
+				innerType = mapPgType(col.udt_name.substring(1));
+				if (innerType === "string") colType = "text[]";
+				else if (innerType === "number") colType = col.udt_name === "_numeric" ? "numeric[]" : "integer[]";
+				else if (innerType === "boolean") colType = "boolean[]";
+			}
+			if (colType) extra += `\n            columnType: ${quote(colType)},`;
+			extra += `\n            of: { name: ${quote(`${humanize(col.column_name)} Item`)}, type: ${quote(innerType)} },`;
+		} else if (finalPropType === "map" && !inferenceExtra.includes("keyValue: true") && !inferenceExtra.includes("properties: {")) extra += "\n            keyValue: true,";
+		if (finalPropType === "string" && !isEnumColumn && !inferenceExtra) {
+			const isUrl = colNameLower.endsWith("_url") || colNameLower.endsWith("_uri") || colNameLower.endsWith("_link");
+			if (colNameLower.includes("image") || colNameLower.includes("avatar") || colNameLower.includes("photo") || colNameLower.includes("logo") || colNameLower.includes("cover")) extra += `\n            storage: {\n                storagePath: ${quote(`${tableName}/${col.column_name}`)}\n            },`;
+			else if (isUrl) extra += "\n            url: true,";
+			else if (colNameLower === "description" || colNameLower === "summary" || colNameLower === "excerpt") extra = withAdminOptions(extra, ["multiline: true"], emitAdmin);
+			else if (colNameLower === "content" || colNameLower === "body") extra = withAdminOptions(extra, ["multiline: true", "markdown: true"], emitAdmin);
+			else if (col.data_type === "text") extra = withAdminOptions(extra, ["multiline: true"], emitAdmin);
+		}
+		if (inferenceExtra) {
+			extra += inferenceExtra;
+			if (!extra.endsWith(",")) extra += ",";
+		}
+		const declaredValidation = [];
+		if (finalPropType === "string" && typeof col.character_maximum_length === "number" && col.character_maximum_length > 0 && !hasGeneratedKey(extra, "max")) declaredValidation.push(`max: ${col.character_maximum_length}`);
+		if (columnChecks) {
+			if (finalPropType === "number") {
+				if (columnChecks.min !== void 0 && !hasGeneratedKey(extra, "min")) declaredValidation.push(`min: ${columnChecks.min}`);
+				if (columnChecks.max !== void 0 && !hasGeneratedKey(extra, "max")) declaredValidation.push(`max: ${columnChecks.max}`);
+				if (columnChecks.moreThan !== void 0) declaredValidation.push(`moreThan: ${columnChecks.moreThan}`);
+				if (columnChecks.lessThan !== void 0) declaredValidation.push(`lessThan: ${columnChecks.lessThan}`);
+			}
+			if (finalPropType === "string") {
+				if (columnChecks.lengthMin !== void 0 && !hasGeneratedKey(extra, "min")) declaredValidation.push(`min: ${columnChecks.lengthMin}`);
+				if (columnChecks.lengthMax !== void 0 && !declaredValidation.some((v) => v.startsWith("max:")) && !hasGeneratedKey(extra, "max")) declaredValidation.push(`max: ${columnChecks.lengthMax}`);
+			}
+		}
+		if (singleColumnUniques.has(col.column_name) && !meta.pks.includes(col.column_name)) declaredValidation.push("unique: true");
+		extra = withValidation(extra, declaredValidation);
+		if (isReadOnlyColumn(col) && !hasGeneratedKey(extra, "readOnly")) {
+			const options = ["readOnly: true"];
+			if (isDerivedIndexColumn(col) && !hasGeneratedKey(extra, "hideFromCollection")) {
+				options.push("hideFromCollection: true");
+				hiddenFromCollection.add(propertyKey);
+			}
+			extra = withAdminOptions(extra, options, emitAdmin);
+		}
+		const columnComment = columnComments.get(col.column_name);
+		if (columnComment) extra = `\n            description: ${quote(columnComment)},${extra}`;
+		if (meta.pks.includes(col.column_name)) {
+			if (isCompositePk) extra += `\n            // Part of composite primary key (${commentText(meta.pks.join(", "))})`;
+			else if (finalPropType === "number" && !inferenceExtra.includes("isId:")) extra += "\n            isId: \"increment\",";
+			else if (col.data_type.toLowerCase() === "uuid" && !inferenceExtra.includes("isId:")) extra += "\n            isId: \"uuid\",";
+			else if (!inferenceExtra.includes("isId:")) extra += "\n            isId: \"uuid\", // Verify if this is a UUID or CUID";
+		}
+		if (finalPropType === "vector") {
+			const dims = col.atttypmod && col.atttypmod > 0 ? col.atttypmod : 1536;
+			extra += `\n            dimensions: ${dims},`;
+		}
+		if (col.is_nullable === "NO" && !meta.pks.includes(col.column_name) && !col.column_default && !isReadOnlyColumn(col)) if (extra.includes("validation: {")) extra = extra.replace("validation: {", "validation: {\n                required: true,");
+		else extra += "\n            validation: {\n                required: true\n            },";
+		const humanName = humanize(col.column_name);
+		orderEntries.push({
+			key: propertyKey,
+			ctx: {
+				propType: finalPropType,
+				isPk: meta.pks.includes(col.column_name),
+				isEnum: isEnumColumn,
+				isStorage: extra.includes("storage: {") || inferenceExtra.includes("storage: {"),
+				pgDataType: col.data_type,
+				originalIndex: currentIndex
+			}
+		});
+		propertyBlocks.set(propertyKey, `
+        ${propKey(propertyKey)}: {
+            name: ${quote(humanName)},
+            columnName: ${quote(col.column_name)},
+            type: ${quote(finalPropType)},${extra}
+        },`);
+	}
+	for (const fk of meta.fks) {
+		const targetTableName = fk.foreign_table_name;
+		if (!joinTables.has(targetTableName)) {
+			const stripped = toWireKey(fk.column_name.replace(/_id$/, ""));
+			const relName = firstFreeKey([
+				stripped,
+				toWireKey(targetTableName),
+				`${stripped}Relation`
+			], propertyBlocks);
+			orderEntries.push({
+				key: relName,
+				ctx: {
+					propType: "relation",
+					isPk: false,
+					isEnum: false,
+					isStorage: false,
+					pgDataType: "",
+					originalIndex: columnIndex++
+				}
+			});
+			const targetCollectionCamel = importCollection(targetTableName);
+			const relHumanName = humanize(relName);
+			propertyBlocks.set(relName, `
+        ${propKey(relName)}: {
+            name: ${quote(relHumanName)},
+            type: "relation",
+            // mapped from foreign key: ${commentText(fk.column_name)} -> ${commentText(targetTableName)}(${commentText(fk.foreign_column_name)})
+            relation: {
+                kind: "belongsTo",
+                target: ${relationTarget(targetCollectionCamel)},
+                localKey: ${quote(fk.column_name)}
+            }
+        },`);
+		}
+	}
+	const inverseFks = allFks.filter((fk) => fk.foreign_table_name === tableName && !joinTables.has(fk.table_name));
+	for (const fk of inverseFks) {
+		const sourceTableName = fk.table_name;
+		const targetCollectionCamel = importCollection(sourceTableName);
+		relationsOutput += `
+        {
+            kind: "hasMany",
+            relationName: ${quote(sourceTableName)},
+            target: ${relationTarget(targetCollectionCamel)},
+            // the ${commentText(sourceTableName)}.${commentText(fk.column_name)} FK points back here
+            foreignKeyOnTarget: ${quote(fk.column_name)}
+        },`;
+	}
+	const relatedJoinTables = Array.from(joinTables).filter((jt) => {
+		const jtMeta = tablesMap.get(jt);
+		return jtMeta ? jtMeta.fks.some((fk) => fk.foreign_table_name === tableName) : false;
+	});
+	for (const jt of relatedJoinTables) {
+		const jtMeta = tablesMap.get(jt);
+		if (!jtMeta) continue;
+		const joinFks = jtMeta.fks;
+		const selfRefFks = joinFks.filter((fk) => fk.foreign_table_name === tableName);
+		if (selfRefFks.length === 2) {
+			const thisFk = selfRefFks[0];
+			const otherFk = selfRefFks[1];
+			const relPropName = `${tableName}_via_${otherFk.column_name.replace(/_id$/, "")}`;
+			relationsOutput += `
+        {
+            kind: "manyToMany",
+            relationName: ${quote(relPropName)},
+            target: ${relationTarget(toCollectionVarName(tableName))},
+            through: {
+                table: ${quote(jt)},
+                sourceColumn: ${quote(thisFk.column_name)},
+                targetColumn: ${quote(otherFk.column_name)}
+            }
+        },`;
+			continue;
+		}
+		const otherFk = joinFks.find((fk) => fk.foreign_table_name !== tableName);
+		if (otherFk) {
+			const targetTableName = otherFk.foreign_table_name;
+			const targetCollectionCamel = importCollection(targetTableName);
+			const thisFk = joinFks.find((fk) => fk.foreign_table_name === tableName);
+			const throughCode = thisFk ? `\n            through: {\n                table: ${quote(jt)},\n                sourceColumn: ${quote(thisFk.column_name)},\n                targetColumn: ${quote(otherFk.column_name)}\n            }` : "";
+			relationsOutput += `
+        {
+            kind: "manyToMany",
+            relationName: ${quote(targetTableName)},
+            target: ${relationTarget(targetCollectionCamel)},${throughCode}
+        },`;
+		}
+	}
+	const relationsBlock = relationsOutput ? `\n    relations: [${relationsOutput}\n    ],` : "";
+	const sortedPropertiesOrder = sortPropertiesOrder(orderEntries);
+	for (const key of sortedPropertiesOrder) propsOutput += propertyBlocks.get(key) || "";
+	const adminEntries = [`icon: ${quote(icon)}`];
+	if (classification) {
+		const derivedFacts = context.metadata ? buildColumnFacts(meta, context.metadata, enumMap, checkFacts) : void 0;
+		if (classification.role === "owned-child") adminEntries.push("hideFromNavigation: true");
+		else if (classification.role === "lookup") adminEntries.push("group: \"Reference\"");
+		if (derivedFacts) {
+			const asProperty = (column) => keyByColumn.get(column) ?? toWireKey(column);
+			const titleProperty = deriveTitleProperty(derivedFacts);
+			if (titleProperty) adminEntries.push(`display: { title: ${quote(asProperty(titleProperty))} }`);
+			const kanbanProperty = deriveKanbanProperty(derivedFacts);
+			if (kanbanProperty) adminEntries.push(`kanban: {\n            columnProperty: ${quote(asProperty(kanbanProperty))}\n        }`);
+			const sort = deriveSort(derivedFacts);
+			if (sort) adminEntries.push(`sort: [${quote(asProperty(sort[0]))}, "desc"]`);
+		}
+		const listProperties = deriveListProperties(sortedPropertiesOrder, hiddenFromCollection);
+		if (listProperties) adminEntries.push(`listProperties: ${formatKeyList(listProperties)}`);
+	}
+	adminEntries.push(`propertiesOrder: ${formatKeyList(sortedPropertiesOrder)}`);
+	const adminBlock = emitAdmin ? `\n    admin: {\n        ${adminEntries.join(",\n        ")}\n    }` : "";
+	const descriptionBlock = tableComment ? `\n    description: ${quote(tableComment)},` : "";
+	const classificationNote = classification && classification.role !== "entity" ? `\n// Introspected as a ${commentText(classification.role)}: ${commentText(classification.reason)}.\n` : "";
+	const collectionVarName = toCollectionVarName(tableName);
+	const [open, close] = builder === "annotation" ? [`const ${collectionVarName}: PostgresCollectionConfig = {`, "};"] : [`const ${collectionVarName} = defineCollection({`, "});"];
+	const importLines = Array.from(imports);
+	return `${[...importLines.filter((line) => !line.includes("from \"./")), ...importLines.filter((line) => line.includes("from \"./"))].join("\n")}
+${classificationNote}
+${open}
+    name: ${quote(collectionName)},
+    singularName: ${quote(singular)},
+    slug: ${quote(tableName)},
+    table: ${quote(tableName)},${descriptionBlock}
+    properties: {${propsOutput}
+    },${relationsBlock}${adminBlock}
+${close}
+
+export default ${collectionVarName};
+`;
+}
+/**
+* Generate the content for an index.ts file that re-exports all collections.
+*/
+function generateIndexContent(fileNames) {
+	const sorted = [...fileNames].sort();
+	let imports = "";
+	let arrayElements = "";
+	for (const f of sorted) {
+		const varName = toCollectionVarName(f);
+		imports += `import ${varName} from ${quote(`./${f}`)};\n`;
+		arrayElements += `    ${varName},\n`;
+	}
+	return `${imports}\nexport const collections = [\n${arrayElements}];\n`;
+}
+/**
+* Merge new exports into existing index.ts content.
+* Returns the merged content string.
+*/
+function mergeIndexContent(existingContent, newFileNames) {
+	const existingImports = new Set([...existingContent.matchAll(/import\s+([a-zA-Z0-9_]+)\s+from\s+"\.\/([^"]+)"/g)].map((m) => m[2]));
+	const sorted = [...newFileNames].sort();
+	let newImports = "";
+	let newElements = "";
+	for (const f of sorted) if (!existingImports.has(f)) {
+		const varName = toCollectionVarName(f);
+		newImports += `import ${varName} from ${quote(`./${f}`)};\n`;
+		newElements += `    ${varName},\n`;
+	}
+	if (!newImports) return existingContent;
+	const importRegex = /import\s+.*?;/g;
+	let lastImportMatch;
+	let match;
+	while ((match = importRegex.exec(existingContent)) !== null) lastImportMatch = match;
+	let contentWithImports = existingContent;
+	if (lastImportMatch) {
+		const pos = lastImportMatch.index + lastImportMatch[0].length;
+		contentWithImports = existingContent.slice(0, pos) + "\n" + newImports.trimEnd() + existingContent.slice(pos);
+	} else contentWithImports = newImports + "\n" + existingContent;
+	return contentWithImports.replace(/export\s+const\s+collections\s*=\s*\[([\s\S]*?)\];/, (fullMatch, arrayContent) => {
+		let mergedArray = arrayContent.trimEnd();
+		if (mergedArray && !mergedArray.endsWith(",")) mergedArray += ",";
+		if (mergedArray) mergedArray += "\n";
+		mergedArray += newElements.trimEnd();
+		return `export const collections = [\n    ${mergedArray.trim()}\n];`;
+	});
+}
+/**
+* Safely extract the host portion of a database URL for logging.
+*/
+function safeHostFromUrl(url) {
+	return url.includes("@") ? url.split("@")[1] : "(local connection)";
+}
+//#endregion
+export { generateCollectionFile as a, identifyJoinTables as c, singularize as d, classifyTables as f, humanize as h, buildTablesMap as i, mergeIndexContent as l, mapPgType as m, COMMON_PACKAGE as n, generateIndexContent as o, lookupCandidates as p, buildEnumMap as r, getIconForTable as s, ADMIN_TYPES_PACKAGE as t, safeHostFromUrl as u };
+
+//# sourceMappingURL=introspect-db-logic-C6LQdTxj.js.map