@rebasepro/server-postgres 0.22.0 → 0.24.0

package/dist/{introspect-db-logic-C6LQdTxj.js → introspect-db-logic-kCETE8TY.js}

@@ -1,6 +1,8 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { firstFreeKey, toWireKey } from "@rebasepro/utils";
+import { a as buildSearchColumnSpec, u as searchColumnStamps } from "./search-column-BM-GV6vH.js";
+import { DEFAULT_SEARCH_COLUMN, DEFAULT_SEARCH_LANGUAGE } from "@rebasepro/types";
+import { firstFreeKey, toPostgresIdentifier, toWireKey } from "@rebasepro/utils";
 //#region src/schema/introspect-db-naming.ts
 /**
 * Naming helpers shared by the introspection modules. These live apart from
@@ -184,6 +186,359 @@ function mapPgType(dataType) {
 	if (dt === "uuid") return "string";
 	return "string";
 }
+//#endregion
+//#region src/schema/introspect-db-storage.ts
+var literal = (value) => JSON.stringify(value);
+/** `character varying` → `varchar`, the spellings the planner's `columnType` uses. */
+var NUMBER_COLUMN_TYPE = {
+	"integer": "integer",
+	"bigint": "bigint",
+	"real": "real",
+	"double precision": "double precision"
+};
+/** A sequence default — `nextval('orders_id_seq'::regclass)`. */
+var SEQUENCE_DEFAULT = /^nextval\('([^']+)'::regclass\)$/;
+/**
+* Whether a `nextval` default names the sequence `SERIAL` would have made for
+* this column — the only one the planner can declare, because it declares the
+* column as `SERIAL` and lets Postgres name the sequence.
+*/
+var isConventionalSequence = (col, sequence) => {
+	return sequence.replace(/^.*\./, "").replace(/^"|"$/g, "") === serialSequenceName(col.table_name, col.column_name);
+};
+/**
+* The name Postgres gives a `SERIAL` column's sequence — `ChooseRelationName`
+* with the `seq` label: `<table>_<column>_seq`, and when that is over 63 bytes
+* the longer of the two names is shortened, one character at a time, until it
+* fits.
+*/
+function serialSequenceName(table, column) {
+	const available = 58;
+	let tableChars = table.length;
+	let columnChars = column.length;
+	while (tableChars + columnChars > available) if (tableChars > columnChars) tableChars--;
+	else columnChars--;
+	return `${table.slice(0, tableChars)}_${column.slice(0, columnChars)}_seq`;
+}
+/**
+* The `isId` (and `columnType`) a single-column primary key needs.
+*
+* `isId: "increment"` is an identity column, and only an INTEGER one. A serial
+* key — an integer with a `nextval` default — is `SERIAL`/`BIGSERIAL`, declared
+* through `columnType` beside `isId: "manual"`. A uuid key is `"uuid"` only when
+* the database generates it; a key with no default is `"manual"`, which keeps
+* the planner from inventing one.
+*/
+function primaryKeyStorage(col, propType) {
+	const dataType = col.data_type.toLowerCase();
+	const fallback = col.column_default?.trim();
+	if (propType === "number") {
+		if (col.is_identity === "YES") {
+			if (dataType === "integer") return { keys: [`isId: ${literal("increment")}`] };
+			return {
+				keys: [`isId: ${literal("increment")}`],
+				note: `"${col.column_name}" is a ${dataType} identity key; \`isId: "increment"\` is always INTEGER, so a push would plan a narrowing type change (and ask before applying it).`
+			};
+		}
+		const sequence = fallback ? SEQUENCE_DEFAULT.exec(fallback) : null;
+		if (sequence) {
+			const serial = dataType === "bigint" ? "bigserial" : dataType === "integer" ? "serial" : void 0;
+			if (serial && isConventionalSequence(col, sequence[1])) return { keys: [`isId: ${literal("manual")}`, `columnType: ${literal(serial)}`] };
+			return {
+				keys: [`isId: ${literal("manual")}`, ...numberColumnType(dataType)],
+				note: `"${col.column_name}" takes its value from the sequence ${sequence[1]}, which no property can declare; a push would plan dropping that default.`
+			};
+		}
+		if (fallback) return { keys: [`isId: ${literal(`sql\`${fallback}\``)}`, ...numberColumnType(dataType)] };
+		return { keys: [`isId: ${literal("manual")}`, ...numberColumnType(dataType)] };
+	}
+	if (dataType === "uuid") {
+		if (fallback === "gen_random_uuid()") return { keys: [`isId: ${literal("uuid")}`] };
+		if (fallback) return { keys: [`isId: ${literal(`sql\`${fallback}\``)}`, `columnType: ${literal("uuid")}`] };
+		return { keys: [`isId: ${literal("manual")}`, `columnType: ${literal("uuid")}`] };
+	}
+	const strategy = fallback ? `sql\`${fallback}\`` : "manual";
+	const stored = stringStorage(col);
+	return {
+		keys: [`isId: ${literal(strategy)}`, ...stored.keys],
+		note: stored.note
+	};
+}
+/** `columnType` for a number column the planner would otherwise make NUMERIC. */
+function numberColumnType(dataType) {
+	const mapped = NUMBER_COLUMN_TYPE[dataType];
+	return mapped ? [`columnType: ${literal(mapped)}`] : [];
+}
+/** The keys a `string` column needs; the bound itself is emitted as `validation.max`. */
+function stringStorage(col) {
+	switch (col.data_type.toLowerCase()) {
+		case "text": return { keys: [] };
+		case "character varying":
+			if (typeof col.character_maximum_length === "number" && col.character_maximum_length > 0) return { keys: [`columnType: ${literal("varchar")}`] };
+			return {
+				keys: [`columnType: ${literal("varchar")}`],
+				note: `"${col.column_name}" is a varchar with no length; the planner always writes one (255 unless \`validation.max\` says otherwise), so a push would plan a narrowing type change.`
+			};
+		case "character": return { keys: [`columnType: ${literal("char")}`] };
+		case "uuid": return { keys: [`columnType: ${literal("uuid")}`] };
+		default: return {
+			keys: [],
+			note: `"${col.column_name}" is ${col.data_type === "USER-DEFINED" ? col.udt_name : col.data_type}, which no property type stores; it is read as text, and a push would plan converting the column to text.`
+		};
+	}
+}
+/**
+* The keys a non-key column needs, for the property type introspection chose.
+*
+* `enumTypeName` is the type the planner would name for this column
+* (`<table>_<column>`, cut to 63 bytes); an enum column whose type is called
+* anything else cannot be declared, and the note says how to rename it.
+*/
+function columnStorage(col, propType, context) {
+	const dataType = col.data_type.toLowerCase();
+	if (context.isEnumColumn) {
+		if (col.udt_name === context.enumTypeName) return { keys: [] };
+		return {
+			keys: [],
+			note: context.enumTypeShared ? `"${col.column_name}" uses the enum type "${col.udt_name}", which other columns share; Rebase gives each column its own type (<table>_<column>), so a push would plan "${context.enumTypeName}" and a conversion Postgres cannot cast.` : `"${col.column_name}" uses the enum type "${col.udt_name}", and Rebase names a column's enum type <table>_<column>. Rename it before pushing: ALTER TYPE "${col.udt_name}" RENAME TO "${context.enumTypeName}";`
+		};
+	}
+	switch (propType) {
+		case "number": {
+			if (dataType === "numeric") {
+				const keys = [];
+				if (typeof col.numeric_precision === "number") keys.push(`precision: ${col.numeric_precision}`);
+				if (typeof col.numeric_precision === "number" && typeof col.numeric_scale === "number") keys.push(`scale: ${col.numeric_scale}`);
+				return { keys };
+			}
+			if (dataType === "smallint") return {
+				keys: [`columnType: ${literal("integer")}`],
+				note: `"${col.column_name}" is smallint, which no \`columnType\` names; it is declared integer, so a push widens it (every value survives).`
+			};
+			const mapped = numberColumnType(dataType);
+			if (mapped.length > 0) return { keys: mapped };
+			return {
+				keys: [],
+				note: `"${col.column_name}" is ${col.data_type}, which no \`columnType\` names; it is declared numeric, and a push would plan converting it.`
+			};
+		}
+		case "string": return stringStorage(col);
+		case "date": switch (dataType) {
+			case "timestamp with time zone": return { keys: [] };
+			case "date": return { keys: [`columnType: ${literal("date")}`] };
+			case "time without time zone": return { keys: [`columnType: ${literal("time")}`] };
+			default: return {
+				keys: [],
+				note: `"${col.column_name}" is ${col.data_type}; a date property stores timestamptz, date or time, so a push would plan converting it to timestamptz (and ask before applying it).`
+			};
+		}
+		case "map": return dataType === "json" ? { keys: [`columnType: ${literal("json")}`] } : { keys: [] };
+		default: return { keys: [] };
+	}
+}
+/**
+* The `columnType` an array column needs, or a note when its element type is
+* not one the planner stores natively.
+*
+* Only `text[]`, `integer[]`, `boolean[]` and `numeric[]` are. Reading
+* `bigint[]` as `integer[]` — what this used to do — planned a narrowing.
+*/
+function arrayStorage(col) {
+	switch (col.udt_name) {
+		case "_text": return {
+			columnType: "text[]",
+			innerType: "string"
+		};
+		case "_int4": return {
+			columnType: "integer[]",
+			innerType: "number"
+		};
+		case "_bool": return {
+			columnType: "boolean[]",
+			innerType: "boolean"
+		};
+		case "_numeric": return {
+			columnType: "numeric[]",
+			innerType: "number"
+		};
+		default: {
+			const element = col.udt_name.replace(/^_/, "");
+			return {
+				innerType: "string",
+				note: `"${col.column_name}" is an array of ${element}; arrays are stored as text[], integer[], boolean[] or numeric[] (anything else as jsonb), so a push would plan converting it.`
+			};
+		}
+	}
+}
+/**
+* A column default as a `defaultValue`, when it is a literal a property can carry.
+*
+* `undefined` when there is no default to carry, or when the default is one the
+* generator expresses another way (`now()` is `autoValue`, a key's default is
+* its `isId`). `{ note }` when there is a default and no property can say it —
+* a push would plan dropping it.
+*/
+function literalDefaultOf(col, propType) {
+	const raw = col.column_default?.trim();
+	if (!raw) return void 0;
+	if (/^(now\(\)|CURRENT_TIMESTAMP)$/i.test(raw)) return void 0;
+	const quoted = /^'((?:[^']|'')*)'(?:::[\w\s."[\]]+)?$/.exec(raw);
+	const unquoted = quoted ? quoted[1].replace(/''/g, "'") : void 0;
+	switch (propType) {
+		case "string":
+			if (unquoted !== void 0) return { source: literal(unquoted) };
+			break;
+		case "number": {
+			const text = unquoted ?? raw.replace(/^\((.*)\)$/, "$1").replace(/::[\w\s]+$/, "");
+			if (/^-?\d+(\.\d+)?$/.test(text) && Number.isFinite(Number(text))) return { source: String(Number(text)) };
+			break;
+		}
+		case "boolean":
+			if (/^true$/i.test(raw)) return { source: "true" };
+			if (/^false$/i.test(raw)) return { source: "false" };
+			break;
+		case "map":
+			if (unquoted !== void 0) try {
+				const parsed = JSON.parse(unquoted);
+				if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) return { source: JSON.stringify(parsed) };
+			} catch {}
+			break;
+		default: break;
+	}
+	return { note: `"${col.column_name}" defaults to ${raw}, which no \`defaultValue\` can express; a push would plan dropping that default.` };
+}
+/** `ON DELETE` as the relation's `onDelete`, when it is not the default the planner would choose. */
+function onDeleteOf(fk, required) {
+	const rule = fk.delete_rule?.toUpperCase();
+	if (!rule) return void 0;
+	if (rule === (required ? "RESTRICT" : "SET NULL")) return void 0;
+	return rule.toLowerCase();
+}
+//#endregion
+//#region src/schema/introspect-db-search.ts
+/**
+* A collection's `search` block, read back out of the column it built.
+*
+* A Rebase search column is `tsvector GENERATED ALWAYS AS (…) STORED`, stamped
+* with a fingerprint of the expression in its `COMMENT`. Introspection used to
+* emit it as an ordinary read-only string property, which the planner makes a
+* `text` column — so the first push after adopting a Rebase database planned
+* `ALTER COLUMN "search_vector" TYPE text … DROP EXPRESSION`, and search was
+* gone for whoever approved it.
+*
+* Reading the block back is a guess checked by the stamp: the deparsed
+* expression names each field's column, weight and language, which is enough
+* to write a candidate block; the candidate is then compiled by the very code
+* that built the column, and kept only if its fingerprint is the one the column
+* carries. A block that does not reproduce the stamp is not emitted at all —
+* the note says so — because a wrong one would rebuild the column differently.
+*
+* `mode` and `fuzzyThreshold` act at query time and are stored nowhere, so they
+* come back as their defaults.
+*/
+/** One `setweight(to_tsvector('<lang>'::regconfig, <text>), '<W>'::"char")`, deparsed. */
+var SEGMENT = /setweight\(to_tsvector\('((?:[^']|'')+)'::regconfig, ([\s\S]+?)\), '([A-D])'::"char"\)/g;
+/** A property with the column's shape, for the candidate block to resolve against. */
+function propertyFor(col) {
+	if (col.data_type === "text" || col.data_type === "character varying" || col.data_type === "character") return {
+		name: col.column_name,
+		type: "string",
+		columnName: col.column_name
+	};
+	if (col.udt_name === "_text") return {
+		name: col.column_name,
+		type: "array",
+		columnName: col.column_name,
+		of: {
+			name: col.column_name,
+			type: "string"
+		}
+	};
+	if (col.data_type === "jsonb") return {
+		name: col.column_name,
+		type: "map",
+		columnName: col.column_name,
+		keyValue: true
+	};
+}
+/**
+* The search block a table's stamped generated columns were built from, or a
+* note saying why it could not be read back.
+*/
+function reconstructSearchBlock(input) {
+	const stamped = input.columns.filter((col) => col.is_generated === "ALWAYS" && (input.comments.get(col.column_name) ?? "").startsWith("rebase:search:v1:"));
+	const main = stamped.find((col) => col.udt_name === "tsvector");
+	if (!main) return { columns: /* @__PURE__ */ new Set() };
+	const fuzzy = stamped.find((col) => col.column_name === `${main.column_name}_text`);
+	const columns = new Set(stamped.map((col) => col.column_name));
+	const unreadable = (why) => ({
+		columns,
+		note: `"${main.column_name}" is a Rebase search column whose \`search\` block could not be read back (${why}). Declare the block again before pushing — without it a push plans dropping the column.`
+	});
+	const expression = main.generation_expression ?? "";
+	const byColumn = new Map(input.columns.map((col) => [col.column_name, col]));
+	const fields = [];
+	let language;
+	let unaccent = false;
+	for (const [, lang, inner, weight] of expression.matchAll(SEGMENT)) {
+		language ??= lang.replace(/''/g, "'");
+		if (lang.replace(/''/g, "'") !== language) return unreadable("its fields use different languages");
+		if (inner.includes("rebase_search_unaccent")) unaccent = true;
+		const column = [...inner.matchAll(/"?([A-Za-z_][A-Za-z0-9_$]*)"?/g)].map((m) => m[1]).find((name) => byColumn.has(name) && !columns.has(name));
+		if (!column) return unreadable("a field reads no column of this table");
+		const key = input.keyByColumn.get(column);
+		if (!key) return unreadable(`the column "${column}" is not a property`);
+		const jsonPath = [...inner.matchAll(/(?:->|#>)\s*'([^']+)'/g)].flatMap((m) => m[1].replace(/^\{|\}$/g, "").split(","));
+		fields.push({
+			path: [key, ...jsonPath].join("."),
+			weight
+		});
+	}
+	if (fields.length === 0 || !language) return unreadable("its expression is not one Rebase writes");
+	const search = {
+		...main.column_name !== DEFAULT_SEARCH_COLUMN ? { column: main.column_name } : {},
+		...language !== DEFAULT_SEARCH_LANGUAGE ? { language } : {},
+		...unaccent ? { unaccent: true } : {},
+		...fuzzy ? { fuzzy: true } : {},
+		fields: fields.map((f) => ({
+			path: f.path,
+			weight: f.weight
+		}))
+	};
+	const properties = {};
+	for (const [column, key] of input.keyByColumn) {
+		const col = byColumn.get(column);
+		const prop = col ? propertyFor(col) : void 0;
+		if (prop) properties[key] = prop;
+	}
+	const candidate = {
+		slug: input.table,
+		name: input.table,
+		table: input.table,
+		...input.schema !== "public" ? { schema: input.schema } : {},
+		properties,
+		search
+	};
+	let fingerprints;
+	try {
+		const spec = buildSearchColumnSpec(candidate);
+		if (!spec) return unreadable("no block compiles from it");
+		fingerprints = new Map(searchColumnStamps(spec).map((stamp) => [stamp.column, stamp.fingerprint]));
+	} catch (err) {
+		return unreadable(err instanceof Error ? err.message : String(err));
+	}
+	for (const col of stamped) if (fingerprints.get(col.column_name) !== input.comments.get(col.column_name)) return unreadable("the block read from its expression does not reproduce the column's stamp");
+	return {
+		columns,
+		block: `\n    search: {\n        ${[
+			...search.column ? [`column: ${JSON.stringify(search.column)}`] : [],
+			...search.language ? [`language: ${JSON.stringify(search.language)}`] : [],
+			...search.unaccent ? ["unaccent: true"] : [],
+			...search.fuzzy ? ["fuzzy: true"] : [],
+			`fields: [\n${fields.map((f) => `            { path: ${JSON.stringify(f.path)}, weight: ${JSON.stringify(f.weight)} }`).join(",\n")}\n        ]`
+		].join(",\n        ")}\n    },`
+	};
+}
 /**
 * A timestamp the database maintains: a temporal column defaulting to the
 * transaction clock.
@@ -300,6 +655,7 @@ function buildContext(metadata, tables) {
 		inboundByTable.set(constraint.foreignTable, inbound);
 	}
 	return {
+		schema: metadata.schema,
 		tables,
 		constraintsByTable,
 		inboundByTable,
@@ -319,9 +675,14 @@ function buildContext(metadata, tables) {
 *   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.
+*   point *at*, so it needs an identity of its own;
+* - it is in `public`. That is the only schema Rebase reads and creates
+*   junction tables in (`resolveJunctionSpecs`), so a `manyToMany` folded from
+*   `crm.contacts_tags` would read and write an empty `public.contacts_tags`
+*   instead. Kept as a table, its rows stay where they are and are served.
 */
 function classifyJunction(table, context) {
+	if (context.schema !== "public") return null;
 	const meta = context.tables.get(table);
 	if (!meta) return null;
 	const constraints = context.constraintsByTable.get(table) ?? [];
@@ -591,6 +952,34 @@ function deriveListProperties(propertiesOrder, hidden = /* @__PURE__ */ new Set(
 * no process.exit.  It is imported by introspect-db.ts (the CLI entry-point)
 * and consumed directly by tests.
 */
+/**
+* Why a table keyed on several columns is not generated as a collection, or
+* `undefined` when it is.
+*
+* Several `isId` properties are one composite key, and the planner builds that
+* table under the same `PRIMARY KEY (a, b)` — so such a table round-trips when
+* two things hold:
+*
+* - **Every key column can carry `isId`,** which exists on string and number
+*   properties only. Read from the column's SQL type, not a data sample: a
+*   `line_no` holding only 1s is not a boolean. A key with a column of another
+*   type — pagila's `payment` is keyed on a timestamp too — can be marked on
+*   some of its columns only, and those would be read as the whole key.
+* - **Nothing points at it.** A foreign key into it, or a junction, is a link
+*   into a composite key, which the planner refuses: the relation has one
+*   column to point with.
+*/
+function compositeKeySkipReason(meta, allFks) {
+	if (meta.pks.length < 2) return void 0;
+	const unmarkable = meta.pks.filter((pk) => {
+		const column = meta.columns.find((c) => c.column_name === pk);
+		const type = column ? mapPgType(column.data_type) : void 0;
+		return type !== "string" && type !== "number";
+	});
+	if (unmarkable.length > 0) return `its key column${unmarkable.length > 1 ? "s" : ""} ${unmarkable.map((c) => `"${c}"`).join(", ")} cannot carry \`isId\`, which a string or number property takes`;
+	const referencing = [...new Set(allFks.filter((fk) => fk.foreign_table_name === meta.name && fk.table_name !== meta.name).map((fk) => fk.table_name))];
+	if (referencing.length > 0) return `${referencing.map((t) => `"${t}"`).join(", ")} point${referencing.length > 1 ? "" : "s"} at it, and a link cannot point at a composite key`;
+}
 var IRREGULAR_SINGULARS = {
 	people: "person",
 	children: "child",
@@ -948,6 +1337,8 @@ function withAdminOptions(extra, entries, emitAdmin = true) {
 	if (extra.includes("admin: {")) return extra.replace("admin: {", `admin: {\n${block},`);
 	return `${extra}\n            admin: {\n${block}\n            },`;
 }
+/** A SQL string literal. */
+var quoteSqlString = (value) => `'${value.replace(/'/g, "''")}'`;
 /** A TypeScript string literal, escaped. */
 function quote(value) {
 	return JSON.stringify(value);
@@ -1052,6 +1443,9 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 	};
 	let propsOutput = "";
 	let relationsOutput = "";
+	/** What the planner will not reproduce exactly, column by column. */
+	const fileNotes = [];
+	const skippedTables = context.skippedTables ?? /* @__PURE__ */ new Set();
 	const orderEntries = [];
 	const propertyBlocks = /* @__PURE__ */ new Map();
 	/**
@@ -1069,25 +1463,45 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 	const hiddenFromCollection = /* @__PURE__ */ new Set();
 	let columnIndex = 0;
 	const isCompositePk = meta.pks.length > 1;
+	/**
+	* The property type a column is generated as, with what the data sample
+	* adds to it. A column of a composite key keeps its SQL type's reading:
+	* it carries `isId`, which only a string or number property takes, and a
+	* key column holding only 1s and 0s is still a key, not a boolean.
+	*/
+	const propertyTypeOf = (col) => {
+		const isEnumColumn = col.data_type === "USER-DEFINED" && enumMap.get(col.udt_name) !== void 0;
+		const propType = isEnumColumn ? "string" : col.udt_name === "vector" ? "vector" : mapPgType(col.data_type);
+		if (isEnumColumn || !sampleData || sampleData.length === 0 || isCompositePk && meta.pks.includes(col.column_name)) return {
+			propType,
+			finalPropType: propType,
+			inferenceExtra: ""
+		};
+		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);
+		return {
+			propType,
+			finalPropType: inferred.propType || propType,
+			inferenceExtra: inferred.extra || ""
+		};
+	};
+	const compositeKeyMarkable = isCompositePk && meta.pks.every((pk) => {
+		const keyColumn = meta.columns.find((c) => c.column_name === pk);
+		if (!keyColumn) return false;
+		const { finalPropType } = propertyTypeOf(keyColumn);
+		return finalPropType === "string" || finalPropType === "number";
+	});
 	for (const col of meta.columns) {
+		if (col.is_generated === "ALWAYS" && (columnComments.get(col.column_name) ?? "").startsWith("rebase:search:v1:")) continue;
 		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 { propType, finalPropType, inferenceExtra } = propertyTypeOf(col);
 		const columnChecks = tableChecks?.get(col.column_name);
 		if (isEnumColumn && colEnumValues) {
 			const enumEntries = colEnumValues.map((v) => `{ id: ${quote(v)}, label: ${quote(humanize(v))} }`).join(", ");
@@ -1095,6 +1509,13 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 		} 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}],`;
+			const enumType = toPostgresIdentifier(`${tableName}_${col.column_name}`);
+			const labels = columnChecks.enumValues.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
+			const check = (context.metadata?.checks ?? []).find((c) => c.table_name === tableName && c.definition.includes(col.column_name));
+			const table = `"${tableName}"`;
+			const column = `"${col.column_name}"`;
+			const restoreDefault = literalDefaultOf(col, "string");
+			fileNotes.push(`"${col.column_name}" is text with CHECK (… IN …), declared here as an \`enum\`, which Rebase stores as the enum type "${enumType}". Convert the column before pushing: CREATE TYPE "${enumType}" AS ENUM (${labels}); ALTER TABLE ${table} ${check ? `DROP CONSTRAINT "${check.constraint_name}", ` : ""}ALTER COLUMN ${column} DROP DEFAULT, ALTER COLUMN ${column} TYPE "${enumType}" USING ${column}::"${enumType}"` + (restoreDefault && "source" in restoreDefault ? `, ALTER COLUMN ${column} SET DEFAULT ${quoteSqlString(JSON.parse(restoreDefault.source))}` : "") + "; — or delete the `enum` to keep the column as it is.");
 		}
 		if (finalPropType === "date") {
 			if (colNameLower === "created_at" || colNameLower === "createdat") {
@@ -1111,16 +1532,10 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 			}
 		}
 		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)} },`;
+			const stored = arrayStorage(col);
+			if (stored.columnType) extra += `\n            columnType: ${quote(stored.columnType)},`;
+			if (stored.note) fileNotes.push(stored.note);
+			extra += `\n            of: { name: ${quote(`${humanize(col.column_name)} Item`)}, type: ${quote(stored.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");
@@ -1134,6 +1549,25 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 			extra += inferenceExtra;
 			if (!extra.endsWith(",")) extra += ",";
 		}
+		if (!meta.pks.includes(col.column_name) && !isReadOnlyColumn(col)) {
+			const enumTypeName = toPostgresIdentifier(`${tableName}_${col.column_name}`);
+			const enumTypeShared = isEnumColumn && (context.metadata?.columns ?? meta.columns).filter((other) => other.udt_name === col.udt_name && other.data_type === "USER-DEFINED").length > 1;
+			const stored = finalPropType === "array" ? { keys: [] } : columnStorage(col, finalPropType, {
+				isEnumColumn,
+				enumTypeName,
+				enumTypeShared
+			});
+			for (const key of stored.keys) {
+				const name = key.slice(0, key.indexOf(":"));
+				if (!hasGeneratedKey(extra, name) && !hasGeneratedKey(inferenceExtra, name)) extra += `\n            ${key},`;
+			}
+			if (stored.note) fileNotes.push(stored.note);
+			if (!hasGeneratedKey(extra, "autoValue") && !hasGeneratedKey(extra, "defaultValue")) {
+				const fallback = literalDefaultOf(col, finalPropType);
+				if (fallback && "source" in fallback) extra += `\n            defaultValue: ${fallback.source},`;
+				else if (fallback) fileNotes.push(fallback.note);
+			}
+		}
 		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) {
@@ -1161,16 +1595,30 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 		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 (isCompositePk) {
+				extra += `\n            // Part of composite primary key (${commentText(meta.pks.join(", "))})`;
+				if (compositeKeyMarkable && !inferenceExtra.includes("isId:")) {
+					const stored = primaryKeyStorage(col, finalPropType);
+					for (const key of stored.keys) {
+						const name = key.slice(0, key.indexOf(":"));
+						if (!hasGeneratedKey(extra, name)) extra += `\n            ${key},`;
+					}
+					if (stored.note) fileNotes.push(stored.note);
+				}
+			} else if (!inferenceExtra.includes("isId:")) {
+				const stored = primaryKeyStorage(col, finalPropType);
+				for (const key of stored.keys) {
+					const name = key.slice(0, key.indexOf(":"));
+					if (!hasGeneratedKey(extra, name)) extra += `\n            ${key},`;
+				}
+				if (stored.note) fileNotes.push(stored.note);
+			}
 		}
 		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,");
+		if (col.is_nullable === "NO" && !meta.pks.includes(col.column_name) && !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({
@@ -1193,6 +1641,7 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 	}
 	for (const fk of meta.fks) {
 		const targetTableName = fk.foreign_table_name;
+		if (skippedTables.has(targetTableName)) continue;
 		if (!joinTables.has(targetTableName)) {
 			const stripped = toWireKey(fk.column_name.replace(/_id$/, ""));
 			const relName = firstFreeKey([
@@ -1213,27 +1662,47 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 			});
 			const targetCollectionCamel = importCollection(targetTableName);
 			const relHumanName = humanize(relName);
+			const required = meta.columns.find((c) => c.column_name === fk.column_name)?.is_nullable === "NO";
+			const onDelete = onDeleteOf(fk, required);
+			const requiredLine = required ? "\n            validation: { required: true }," : "";
+			const onDeleteLine = onDelete ? `,\n                onDelete: ${quote(onDelete)}` : "";
 			propertyBlocks.set(relName, `
         ${propKey(relName)}: {
             name: ${quote(relHumanName)},
-            type: "relation",
+            type: "relation",${requiredLine}
             // 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)}
+                localKey: ${quote(fk.column_name)}${onDeleteLine}
             }
         },`);
 		}
 	}
-	const inverseFks = allFks.filter((fk) => fk.foreign_table_name === tableName && !joinTables.has(fk.table_name));
+	/**
+	* A name for an entry in the `relations` array that no property and no
+	* earlier entry has taken.
+	*
+	* Relations and properties share one namespace — a relation is found by
+	* name — so a `belongsTo` property called `series` beside a many-to-many
+	* also called `series` left one of them unreachable: the planner resolved
+	* the property's name to the many-to-many, planned no `series_id` column,
+	* and the first push dropped it.
+	*/
+	const usedRelationNames = /* @__PURE__ */ new Set();
+	const relationNameFor = (preferred, fallback) => {
+		const name = firstFreeKey([preferred, fallback], { has: (key) => propertyBlocks.has(key) || usedRelationNames.has(key) });
+		usedRelationNames.add(name);
+		return name;
+	};
+	const inverseFks = allFks.filter((fk) => fk.foreign_table_name === tableName && !joinTables.has(fk.table_name) && !skippedTables.has(fk.table_name));
 	for (const fk of inverseFks) {
 		const sourceTableName = fk.table_name;
 		const targetCollectionCamel = importCollection(sourceTableName);
 		relationsOutput += `
         {
             kind: "hasMany",
-            relationName: ${quote(sourceTableName)},
+            relationName: ${quote(relationNameFor(sourceTableName, `${sourceTableName}_by_${fk.column_name}`))},
             target: ${relationTarget(targetCollectionCamel)},
             // the ${commentText(sourceTableName)}.${commentText(fk.column_name)} FK points back here
             foreignKeyOnTarget: ${quote(fk.column_name)}
@@ -1247,7 +1716,11 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 		const jtMeta = tablesMap.get(jt);
 		if (!jtMeta) continue;
 		const joinFks = jtMeta.fks;
-		const selfRefFks = joinFks.filter((fk) => fk.foreign_table_name === tableName);
+		const keyPosition = (fk) => {
+			const position = jtMeta.pks.indexOf(fk.column_name);
+			return position === -1 ? Number.MAX_SAFE_INTEGER : position;
+		};
+		const selfRefFks = joinFks.filter((fk) => fk.foreign_table_name === tableName).sort((a, b) => keyPosition(a) - keyPosition(b));
 		if (selfRefFks.length === 2) {
 			const thisFk = selfRefFks[0];
 			const otherFk = selfRefFks[1];
@@ -1255,7 +1728,7 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 			relationsOutput += `
         {
             kind: "manyToMany",
-            relationName: ${quote(relPropName)},
+            relationName: ${quote(relationNameFor(relPropName, `${relPropName}_${jt}`))},
             target: ${relationTarget(toCollectionVarName(tableName))},
             through: {
                 table: ${quote(jt)},
@@ -1266,7 +1739,14 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 			continue;
 		}
 		const otherFk = joinFks.find((fk) => fk.foreign_table_name !== tableName);
-		if (otherFk) {
+		const leadingTable = joinFks.find((fk) => fk.column_name === jtMeta.pks[0])?.foreign_table_name;
+		const sortsFirst = otherFk ? [tableName, otherFk.foreign_table_name].sort()[0] : tableName;
+		const declareHere = !leadingTable || leadingTable === sortsFirst || leadingTable === tableName;
+		if (otherFk && !declareHere) relationsOutput += `
+        // The many-to-many with ${commentText(otherFk.foreign_table_name)} through ${commentText(jt)} is declared on
+        // ${commentText(otherFk.foreign_table_name)} only: declaring it here too would re-key ${commentText(jt)}
+        // from (${commentText(jtMeta.pks.join(", "))}) on the next push.`;
+		if (otherFk && declareHere && !skippedTables.has(otherFk.foreign_table_name)) {
 			const targetTableName = otherFk.foreign_table_name;
 			const targetCollectionCamel = importCollection(targetTableName);
 			const thisFk = joinFks.find((fk) => fk.foreign_table_name === tableName);
@@ -1274,11 +1754,20 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 			relationsOutput += `
         {
             kind: "manyToMany",
-            relationName: ${quote(targetTableName)},
+            relationName: ${quote(relationNameFor(targetTableName, `${targetTableName}_via_${jt}`))},
             target: ${relationTarget(targetCollectionCamel)},${throughCode}
         },`;
 		}
 	}
+	const search = reconstructSearchBlock({
+		schema: context.metadata?.schema ?? "public",
+		table: tableName,
+		columns: meta.columns,
+		comments: columnComments,
+		keyByColumn
+	});
+	if (search.note) fileNotes.push(search.note);
+	const searchBlock = search.block ?? "";
 	const relationsBlock = relationsOutput ? `\n    relations: [${relationsOutput}\n    ],` : "";
 	const sortedPropertiesOrder = sortPropertiesOrder(orderEntries);
 	for (const key of sortedPropertiesOrder) propsOutput += propertyBlocks.get(key) || "";
@@ -1302,17 +1791,21 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 	adminEntries.push(`propertiesOrder: ${formatKeyList(sortedPropertiesOrder)}`);
 	const adminBlock = emitAdmin ? `\n    admin: {\n        ${adminEntries.join(",\n        ")}\n    }` : "";
 	const descriptionBlock = tableComment ? `\n    description: ${quote(tableComment)},` : "";
+	const pgSchema = context.metadata?.schema;
+	const schemaBlock = pgSchema && pgSchema !== "public" ? `\n    schema: ${quote(pgSchema)},` : "";
 	const classificationNote = classification && classification.role !== "entity" ? `\n// Introspected as a ${commentText(classification.role)}: ${commentText(classification.reason)}.\n` : "";
+	for (const note of fileNotes) context.notes?.push(`${tableName}: ${note}`);
+	const storageNote = fileNotes.length > 0 ? `\n// ⚠ Not reproduced exactly by \`rebase db push\` — read before pushing:\n${fileNotes.map((n) => `//   - ${commentText(n)}`).join("\n")}\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}
+${classificationNote}${storageNote}
 ${open}
     name: ${quote(collectionName)},
     singularName: ${quote(singular)},
     slug: ${quote(tableName)},
-    table: ${quote(tableName)},${descriptionBlock}
+    table: ${quote(tableName)},${schemaBlock}${descriptionBlock}${searchBlock}
     properties: {${propsOutput}
     },${relationsBlock}${adminBlock}
 ${close}
@@ -1373,6 +1866,6 @@ 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 };
+export { compositeKeySkipReason as a, getIconForTable as c, safeHostFromUrl as d, singularize as f, humanize as g, mapPgType as h, buildTablesMap as i, identifyJoinTables as l, lookupCandidates as m, COMMON_PACKAGE as n, generateCollectionFile as o, classifyTables as p, buildEnumMap as r, generateIndexContent as s, ADMIN_TYPES_PACKAGE as t, mergeIndexContent as u };
 
-//# sourceMappingURL=introspect-db-logic-C6LQdTxj.js.map
+//# sourceMappingURL=introspect-db-logic-kCETE8TY.js.map