@rebasepro/server-postgres 0.23.0 → 0.24.1-canary.g56af4a4

package/dist/{plan-schema-C0fxM8dY.js → plan-schema-B1YF_tYq.js}

@@ -1,446 +1,13 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { a as getPrimaryKeyColumn, c as idColumnDefault, i as enumLabelsOf, l as isIdProperty, o as getPrimaryKeyName, r as declaresEnumType, s as getPrimaryKeyProp, t as assertSinglePrimaryKey, u as resolveColumnName } from "./column-plan-helpers-DF-8dTVa.js";
-import { i as isAuthCollection, n as authUsersColumnDefinition, r as authUsersColumnSql, t as AUTH_USERS_COLUMNS } from "./auth-users-columns-D2LBFrMH.js";
+import { a as buildSearchColumnSpec, d as searchColumnTypeSql, f as searchExtensionStatements, i as assertSearchIsPostgresOnly, p as searchHelperFunctions } from "./search-column-BM-GV6vH.js";
+import { a as getPrimaryKeyName, c as isIdProperty, d as sqlExpressionText, i as getPrimaryKeyColumn, l as primaryKeyPropertyNames, n as declaresEnumType, o as getPrimaryKeyProp, r as enumLabelsOf, s as idColumnDefault, u as resolveColumnName } from "./column-plan-helpers-drZIsSNf.js";
+import { i as isAuthCollection, n as authUsersColumnDefinition, r as authUsersColumnSql, t as AUTH_USERS_COLUMNS } from "./auth-users-columns-C72EMoDJ.js";
 import { c as vectorExtensionStatement, n as buildVectorColumnSpecs, o as vectorExtensionDeclared, r as buildVectorIndexPlan } from "./vector-index-CMJKb3C9.js";
-import { a as deriveIndexName, t as buildCollectionIndexSpecs } from "./collection-index-DdnsxiJ_.js";
-import { DEFAULT_FUZZY_THRESHOLD, DEFAULT_SEARCH_COLUMN, DEFAULT_SEARCH_LANGUAGE, DEFAULT_SEARCH_MODE, DEFAULT_SEARCH_WEIGHT, REBASE_SCHEMA, hasForeignKeyOnTarget, isManyToMany, isPostgresCollectionConfig } from "@rebasepro/types";
-import { TENANT_INDEX_REASON, assertBeforeQueryIsPostgresOnly, fieldKeyForColumn, findRelation, getEffectiveSecurityRules, getEnumVarName, getInjectedSecurityRules, getJunctionCollectionConfig, getJunctionSecurityRules, getTableName, getTableVarName, getTenantConfig, policyToPostgres, relationalCollections, resolveCollectionRelations, resolveJunctionSpecs, resolveStringColumnLength, securityRuleToConditions } from "@rebasepro/common";
-import { generateForeignKeyName, getPolicyNamesForRule, legacyForeignKeyName, toPostgresIdentifier, toSnakeCase } from "@rebasepro/utils";
-import { createHash } from "node:crypto";
-//#region src/schema/search-column.ts
-/**
-* The one place a collection's `search` block becomes SQL.
-*
-* Four things describe a Postgres table in this codebase — the DDL generator,
-* the Drizzle schema generator, the runtime table builder for BaaS mode, and
-* the boot-time schema ensure — and each of them has, at some point, described
-* a column differently from the others. The `varchar(255)` note in
-* `generate-postgres-ddl-logic` is one such scar: the same property produced a
-* capped column down one path and an uncapped one down the other, and nothing
-* failed until a user hit the cap.
-*
-* So the search column is not implemented four times. It is computed once,
-* here, and every generator renders the same {@link SearchColumnSpec}. There is
-* a test asserting exactly that (`search-column-contract.test.ts`); the point of
-* this module is that the test has something to assert *about*.
-*
-* ## Why the expressions look the way they do
-*
-* A `GENERATED ALWAYS AS … STORED` expression must be strictly IMMUTABLE, and
-* Postgres is stricter here than intuition. Verified against PostgreSQL 18:
-*
-* | expression                              | immutable |
-* |-----------------------------------------|-----------|
-* | `to_tsvector('spanish', col)`           | yes       |
-* | `to_tsvector(col)` (1-arg)              | **no** — depends on `default_text_search_config` |
-* | `array_to_string(col, ' ')`             | **no**    |
-* | `col::text` on `text[]`                 | **no**    |
-* | `to_jsonb(col)`                         | **no**    |
-* | `unaccent(col)`                         | **no** — dictionary lookup is STABLE |
-* | `jsonb_to_tsvector('spanish', j, '["string"]')` | yes |
-* | `setweight(...) || setweight(...)`      | yes       |
-*
-* Three of the four things a real search column needs are therefore unavailable
-* directly, which is why {@link searchHelperFunctions} exists: each wraps a
-* stable built-in in an SQL function declared IMMUTABLE. That declaration is a
-* promise, and it is a true one for these three — array joining, JSON string
-* extraction and accent folding are all deterministic for a given input; the
-* built-ins are marked stable only because they must account for element types
-* and dictionaries in general.
-*
-* The alternative was to skip `unaccent` and text arrays entirely. That is not
-* a real option in an accented language: Postgres stems `auditoría` to
-* `auditor` and `auditoria` to `auditori` — *different lexemes* — so a query
-* typed without accents misses every row that carries them.
-*/
-/** Schema-qualified so a collection outside `public` still resolves them. */
-var HELPER_SCHEMA = "public";
-/**
-* Names of the helper functions. Frozen: they are recorded in the stored
-* generation expression of every search column ever created, so renaming one
-* orphans every table that already has a search column.
-*/
-var SEARCH_TEXT_FN = `${HELPER_SCHEMA}.rebase_search_text`;
-var SEARCH_UNACCENT_FN = `${HELPER_SCHEMA}.rebase_search_unaccent`;
-/** Raised when a `search` block names something that cannot be searched. */
-var SearchConfigError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "SearchConfigError";
-	}
-};
-/** The `search` block of a collection, or undefined when it has none. */
-var getSearchConfig = (collection) => isPostgresCollectionConfig(collection) ? collection.search : void 0;
-/**
-* Refuse a `search` block on a collection this engine does not store.
-*
-* The type only permits one on a `PostgresCollectionConfig`, so TypeScript
-* already stops the ordinary case. This catches the rest — a JS config, a cast,
-* a collection whose `engine` was changed after the block was written — because
-* the alternative is the exact failure the block exists to prevent: a developer
-* who declared what to index, saw no error, and got the substring fallback.
-*
-* Called with *every* collection, before the Postgres ones are filtered out.
-*/
-var assertSearchIsPostgresOnly = (collections) => {
-	for (const collection of collections) {
-		if (isPostgresCollectionConfig(collection)) continue;
-		if (!collection.search) continue;
-		const engine = collection.engine ?? "non-postgres";
-		throw new SearchConfigError(`${collection.slug}.search: full-text search is a Postgres feature, and this collection is served by \`${engine}\`. Remove the block — it would otherwise look configured while \`.search()\` kept using the default substring match.`);
-	}
-};
-var columnNameOf = (propName, prop) => prop && "columnName" in prop && typeof prop.columnName === "string" ? prop.columnName : toSnakeCase(propName);
-/**
-* Classify a property for search purposes.
-*
-* Deliberately narrower than the schema plan's `PgType`: search only cares
-* whether a value reaches text, and the mapping from property to *physical*
-* type is asserted against the plan in the contract test rather than duplicated
-* here.
-*
-* Returns null for anything that is not text-bearing, which the caller turns
-* into a boot error naming the property.
-*/
-var classify = (prop) => {
-	switch (prop.type) {
-		case "string": {
-			const sp = prop;
-			if (sp.enum) return {
-				kind: "text",
-				reason: "enum"
-			};
-			if (sp.isId === "uuid" || sp.columnType === "uuid") return {
-				kind: "text",
-				reason: "uuid"
-			};
-			return { kind: "text" };
-		}
-		case "map":
-			if (prop.columnType === "json") return {
-				kind: "jsonb",
-				reason: "json"
-			};
-			return { kind: "jsonb" };
-		case "array": {
-			const ap = prop;
-			let colType = ap.columnType;
-			if (!colType && ap.of && !Array.isArray(ap.of)) {
-				const of = ap.of;
-				if (of.type === "string") colType = "text[]";
-				else if (of.type === "number") colType = of.validation?.integer ? "integer[]" : "numeric[]";
-				else if (of.type === "boolean") colType = "boolean[]";
-			}
-			if (colType === "text[]") return { kind: "text_array" };
-			if (colType === "json") return {
-				kind: "jsonb",
-				reason: "json"
-			};
-			if (colType === "integer[]" || colType === "boolean[]" || colType === "numeric[]") return {
-				kind: "text_array",
-				reason: "non_text_array"
-			};
-			return { kind: "jsonb" };
-		}
-		default: return null;
-	}
-};
-var normalize = (inner, unaccent) => unaccent ? `${SEARCH_UNACCENT_FN}(${inner})` : inner;
-/** SQL reading one field as plain text, before normalization. */
-var rawTextSql = (field) => {
-	const col = `"${field.column}"`;
-	if (field.kind === "text") return `coalesce(${col}, '')`;
-	if (field.kind === "text_array") return `${SEARCH_TEXT_FN}(coalesce(${col}, '{}'::text[]))`;
-	return `${SEARCH_TEXT_FN}(coalesce(${field.jsonPath.length === 0 ? col : field.jsonPath.length === 1 ? `${col} -> ${quote(field.jsonPath[0])}` : `${col} #> ${quote(`{${field.jsonPath.join(",")}}`)}`}, '{}'::jsonb))`;
-};
-var quote = (v) => `'${v.replace(/'/g, "''")}'`;
-/**
-* Resolve and validate one declared field path.
-*
-* A path that does not resolve throws. The whole point of an explicit block is
-* that the author knows what is indexed; a silently dropped field would make it
-* a guess again, and the failure — a search that returns nothing for content
-* that is plainly in the row — is invisible from the outside.
-*/
-var resolveField = (entry, collection, cfg) => {
-	const path = typeof entry === "string" ? entry : entry.path;
-	const weight = (typeof entry === "string" ? void 0 : entry.weight) ?? DEFAULT_SEARCH_WEIGHT;
-	const where = `${collection.slug}.search`;
-	if (!path || typeof path !== "string") throw new SearchConfigError(`${where}: every entry in \`fields\` needs a property path.`);
-	const [head, ...rest] = path.split(".");
-	const prop = collection.properties?.[head];
-	if (!prop) throw new SearchConfigError(`${where}: "${path}" starts at property "${head}", which this collection does not declare. Known properties: ${Object.keys(collection.properties ?? {}).join(", ")}.`);
-	const classified = classify(prop);
-	if (!classified) throw new SearchConfigError(`${where}: "${path}" is a \`${prop.type}\` property, which holds no text to search. Searchable kinds are \`string\`, \`string[]\` and \`map\` (or a path inside one).`);
-	if (classified.reason === "enum") throw new SearchConfigError(`${where}: "${path}" is an enum. Enums are a fixed vocabulary — filter on them with \`where\` instead, which is exact and uses an index.`);
-	if (classified.reason === "uuid") throw new SearchConfigError(`${where}: "${path}" is a UUID column. Look it up by id rather than searching it.`);
-	if (classified.reason === "json") throw new SearchConfigError(`${where}: "${path}" is a \`json\` column, and the cast from \`json\` to \`jsonb\` is not immutable, so it cannot feed a generated column. Declare the property as \`jsonb\` (the default) to search it.`);
-	if (classified.reason === "non_text_array") throw new SearchConfigError(`${where}: "${path}" is an array of numbers or booleans. Only \`string[]\` carries text to search.`);
-	if (rest.length > 0 && classified.kind !== "jsonb") throw new SearchConfigError(`${where}: "${path}" addresses a path inside "${head}", but "${head}" is a \`${prop.type}\` property, not a \`map\`. Only map properties have paths inside them.`);
-	const column = columnNameOf(head, prop);
-	const raw = rawTextSql({
-		column,
-		jsonPath: rest,
-		kind: classified.kind
-	});
-	const textSql = normalize(raw, cfg.unaccent === true);
-	const language = cfg.language ?? DEFAULT_SEARCH_LANGUAGE;
-	return {
-		path,
-		column,
-		jsonPath: rest,
-		kind: classified.kind,
-		weight,
-		sql: `setweight(to_tsvector(${quote(language)}, ${textSql}), ${quote(weight)})`,
-		textSql,
-		foldedTextSql: normalize(raw, true)
-	};
-};
-/**
-* Build the full spec for a collection, or undefined when it has not opted in.
-*
-* Throws {@link SearchConfigError} on a config that cannot be honoured. Callers
-* at boot surface that as a startup failure — a search block that half-works is
-* worse than one that refuses.
-*/
-var buildSearchColumnSpec = (collection) => {
-	const cfg = getSearchConfig(collection);
-	if (!cfg) return void 0;
-	if (!Array.isArray(cfg.fields) || cfg.fields.length === 0) throw new SearchConfigError(`${collection.slug}.search: \`fields\` is empty. Name the properties to index, or remove the \`search\` block to keep the default ILIKE behaviour.`);
-	const table = getTableName(collection);
-	const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
-	const column = cfg.column ?? DEFAULT_SEARCH_COLUMN;
-	if (collection.properties?.[column]) throw new SearchConfigError(`${collection.slug}.search: the generated column "${column}" collides with a declared property of the same name. Set \`search.column\` to something else.`);
-	const fields = cfg.fields.map((entry) => resolveField(entry, collection, cfg));
-	const seen = /* @__PURE__ */ new Set();
-	for (const f of fields) {
-		if (seen.has(f.path)) throw new SearchConfigError(`${collection.slug}.search: "${f.path}" is listed twice.`);
-		seen.add(f.path);
-	}
-	const mode = cfg.mode ?? DEFAULT_SEARCH_MODE;
-	const extensions = [];
-	if (cfg.unaccent || mode === "hybrid") extensions.push("unaccent");
-	if (cfg.fuzzy) extensions.push("pg_trgm");
-	const spec = {
-		schema,
-		table,
-		column,
-		language: cfg.language ?? DEFAULT_SEARCH_LANGUAGE,
-		unaccent: cfg.unaccent === true,
-		mode,
-		fields,
-		expression: fields.map((f) => f.sql).join(" || "),
-		indexName: toPostgresIdentifier(`${table}_${column}_gin`),
-		extensions
-	};
-	if (cfg.fuzzy) {
-		const fuzzyColumn = `${column}_text`;
-		if (collection.properties?.[fuzzyColumn]) throw new SearchConfigError(`${collection.slug}.search: \`fuzzy\` needs the column "${fuzzyColumn}", which collides with a declared property. Set \`search.column\` to something else.`);
-		spec.fuzzy = {
-			column: fuzzyColumn,
-			expression: fields.map((f) => f.textSql).join(" || ' ' || "),
-			indexName: toPostgresIdentifier(`${table}_${fuzzyColumn}_trgm`),
-			threshold: cfg.fuzzyThreshold ?? DEFAULT_FUZZY_THRESHOLD
-		};
-	}
-	return spec;
-};
-/**
-* The IMMUTABLE wrappers the generated expressions call.
-*
-* `CREATE OR REPLACE` so a boot against an existing database is a no-op rather
-* than an error, and idempotent for the same reason every other boot-time DDL
-* statement here is.
-*
-* The bodies are stable built-ins wrapped in an immutable promise — see the
-* module comment for why that promise is sound. `STRICT` matters: it makes NULL
-* in mean NULL out without executing the body, which is what the `coalesce` at
-* each call site then absorbs.
-*/
-var searchHelperFunctions = (spec) => {
-	const statements = [`CREATE OR REPLACE FUNCTION ${SEARCH_TEXT_FN}(text[]) RETURNS text\n    LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS\n    $$ SELECT array_to_string($1, ' ') $$;`, `CREATE OR REPLACE FUNCTION ${SEARCH_TEXT_FN}(jsonb) RETURNS text\n    LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS\n    $$ SELECT coalesce(string_agg(v, ' '), '')\n       FROM jsonb_array_elements_text(jsonb_path_query_array($1, 'strict $.**?(@.type() == "string")')) AS v $$;`];
-	if (spec.unaccent || spec.mode === "hybrid") statements.push(`CREATE OR REPLACE FUNCTION ${SEARCH_UNACCENT_FN}(text) RETURNS text\n    LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS\n    $$ SELECT ${HELPER_SCHEMA}.unaccent('${HELPER_SCHEMA}.unaccent'::regdictionary, $1) $$;`);
-	return statements;
-};
-/**
-* `CREATE EXTENSION` statements the spec's expressions depend on.
-*
-* `WITH SCHEMA public` is load-bearing, not tidiness. An unqualified
-* `CREATE EXTENSION` installs into the first schema on `search_path`, which
-* defaults to `"$user", public` — and the scaffold's database role is named
-* `rebase`, the same as the schema the generator creates one statement earlier.
-* So the moment that schema exists, `CREATE EXTENSION unaccent` puts the
-* dictionary in `rebase`, and every reference to `public.unaccent` below fails
-* with "text search dictionary does not exist". Observed, not theorised.
-*/
-var searchExtensionStatements = (spec) => spec.extensions.map((e) => `CREATE EXTENSION IF NOT EXISTS ${e} WITH SCHEMA ${HELPER_SCHEMA};`);
-/**
-* Everything after the column name — the type and the generation expression.
-*
-* Split out because four emitters need it and only two of them have a place to
-* put the name: `CREATE TABLE` and `ADD COLUMN` write `"col" <this>`, while the
-* schema plan carries it as the column's SQL definition and the boot-time
-* rebuild statement interpolates it on its own.
-*/
-var searchColumnTypeSql = (expression, kind) => `${kind} GENERATED ALWAYS AS (${expression}) STORED`;
-/** The column definition as it appears inside `CREATE TABLE`. */
-var searchColumnDefinition = (spec) => `"${spec.column}" ${searchColumnTypeSql(spec.expression, "tsvector")}`;
-/** The fuzzy column definition, when the spec asks for one. */
-var fuzzyColumnDefinition = (spec) => spec.fuzzy ? `"${spec.fuzzy.column}" ${searchColumnTypeSql(spec.fuzzy.expression, "text")}` : void 0;
-/**
-* Index statements for the spec.
-*
-* `CONCURRENTLY` is deliberately *not* used here. This form is emitted into a
-* SQL file replayed as one unit — a migration, or `search.sql` — where a
-* concurrent build is not allowed. The boot-time ensure path runs statement by
-* statement against tables that are live and populated, and uses the
-* concurrent form instead; see `ensureSearchColumns`.
-*/
-var searchIndexStatements = (spec) => {
-	const statements = [`CREATE INDEX IF NOT EXISTS "${spec.indexName}" ON "${spec.schema}"."${spec.table}" USING GIN ("${spec.column}");`];
-	if (spec.fuzzy) statements.push(`CREATE INDEX IF NOT EXISTS "${spec.fuzzy.indexName}" ON "${spec.schema}"."${spec.table}" USING GIN ("${spec.fuzzy.column}" ${HELPER_SCHEMA}.gin_trgm_ops);`);
-	return statements;
-};
-/**
-* Marker on the comment of every generated search column this module creates.
-*
-* Versioned because the fingerprint below is only comparable against itself: a
-* future change to how it is computed has to read as "not stamped by this
-* version" rather than as drift on every existing column.
-*/
-var SEARCH_STAMP_PREFIX = "rebase:search:v1:";
-/**
-* A stable fingerprint of one generated column's expression.
-*
-* Why a stamp rather than reading the expression back: Postgres stores a
-* generated column's expression *parsed*, and hands it back deparsed — casts
-* made explicit, identifiers requoted, schema qualifications added or dropped
-* according to `search_path`. Comparing that text to the text we generated
-* would report drift on wording, and this comparison decides whether a boot
-* refuses, so a false positive is an outage. The stamp is written by the same
-* code that writes the column, so equality means what it says.
-*/
-var searchExpressionFingerprint = (expression) => `${SEARCH_STAMP_PREFIX}${createHash("sha256").update(expression).digest("hex").slice(0, 16)}`;
-/**
-* The stamps for a spec's generated columns — one per column, never shared.
-*
-* Per column on purpose: turning `fuzzy` on adds a second column and changes
-* nothing about the first, and a spec-wide fingerprint would report the
-* untouched `tsvector` column as drifted and refuse a boot over a change that
-* is purely additive.
-*/
-var searchColumnStamps = (spec) => {
-	const stamp = (column, expression) => {
-		const fingerprint = searchExpressionFingerprint(expression);
-		return {
-			column,
-			expression,
-			fingerprint,
-			sql: `COMMENT ON COLUMN "${spec.schema}"."${spec.table}"."${column}" IS ${quote(fingerprint)};`
-		};
-	};
-	const stamps = [stamp(spec.column, spec.expression)];
-	if (spec.fuzzy) stamps.push(stamp(spec.fuzzy.column, spec.fuzzy.expression));
-	return stamps;
-};
-/**
-* The same drift check as the boot ensure, for the SQL file.
-*
-* Needed because {@link searchColumnStamps} would otherwise *launder* drift on
-* the migration path: `ADD COLUMN IF NOT EXISTS` does nothing to a column that
-* exists, so a re-generated `search.sql` would stamp a stale column with the
-* new block's fingerprint and the next boot would find them in agreement.
-* Guarding first means the file refuses instead — `rebase db push` is attended,
-* and the operator reading the failure is the person who changed the block.
-*/
-var searchStampGuards = (spec) => searchColumnStamps(spec).map((stamp) => {
-	const relation = quote(`"${spec.schema}"."${spec.table}"`);
-	return `DO $rebase_search$
-DECLARE recorded text;
-BEGIN
-    SELECT col_description(a.attrelid, a.attnum) INTO recorded
-    FROM pg_attribute a
-    WHERE a.attrelid = ${relation}::regclass AND a.attname = ${quote(stamp.column)} AND NOT a.attisdropped;
-    IF recorded LIKE ${quote(`${SEARCH_STAMP_PREFIX}%`)} AND recorded <> ${quote(stamp.fingerprint)} THEN
-        RAISE EXCEPTION 'Rebase: the search block for ${spec.schema}.${spec.table} changed after the generated column "${stamp.column}" was built (recorded %, expected ${stamp.fingerprint}). Postgres cannot alter a generated expression in place. Drop the column and re-apply this file — it rewrites the table and rebuilds the index: ALTER TABLE ${relation.slice(1, -1)} DROP COLUMN "${stamp.column}";', recorded;
-    END IF;
-END
-$rebase_search$;`;
-});
-/**
-* The index names the spec creates.
-*
-* Needed by name, not just by statement, so Atlas can be told to exclude them
-* from its diff — see `searchExcludePatterns`.
-*/
-var searchIndexNames = (spec) => spec.fuzzy ? [spec.indexName, spec.fuzzy.indexName] : [spec.indexName];
-/**
-* The generated column names a collection's search block adds, if any.
-*
-* These are physical columns on the table, so `SELECT *` returns them. They are
-* an index in column form — a list of lexeme positions, or a concatenation of
-* every searchable field on the row — and nothing outside the query planner has
-* any use for them. Left in, every list response carries a second, larger copy
-* of the row's text.
-*/
-var searchColumnNames = (collection) => {
-	let spec;
-	try {
-		spec = buildSearchColumnSpec(collection);
-	} catch {
-		return [];
-	}
-	if (!spec) return [];
-	return spec.fuzzy ? [spec.column, spec.fuzzy.column] : [spec.column];
-};
-/**
-* True for a column whose type only ever holds a search index.
-*
-* Independent of any collection config on purpose: an introspected database
-* (BaaS mode) can carry a `tsvector` column this framework never created —
-* Pagila's `film.fulltext` is the canonical one — and it should not be returned
-* to callers either. `isDerivedIndexColumn` already keeps such a column out of
-* the *properties*; this keeps it out of the *rows*.
-*/
-var isSearchIndexColumn = (column) => {
-	const sqlType = typeof column?.getSQLType === "function" ? column.getSQLType().toLowerCase() : "";
-	return sqlType === "tsvector" || sqlType === "tsquery";
-};
-/**
-* A drizzle select projection over `table` with the search columns dropped.
-*
-* Returns undefined when nothing needs dropping, so the common case keeps using
-* a plain `select()` and this stays invisible in the generated SQL.
-*/
-var visibleColumnProjection = (tableColumns, collection) => {
-	const excluded = excludedColumnNames(tableColumns, collection);
-	if (!tableColumns || excluded.length === 0) return void 0;
-	const projection = {};
-	for (const [name, column] of Object.entries(tableColumns)) if (!excluded.includes(name)) projection[name] = column;
-	return projection;
-};
-/** The same exclusion as a drizzle `db.query` `columns` denylist. */
-var hiddenColumnsOption = (tableColumns, collection) => {
-	const excluded = excludedColumnNames(tableColumns, collection);
-	if (excluded.length === 0) return void 0;
-	return Object.fromEntries(excluded.map((name) => [name, false]));
-};
-/**
-* The columns to keep out of a response, by name.
-*
-* `tableColumns` is whatever `getTableColumns` returned, which is `undefined`
-* for anything that is not a real drizzle table — a stub in a test, a derived
-* or nested path with no table behind it. Nothing to exclude is the right
-* answer there, and it has to be an answer rather than a throw: this runs on
-* the read path of every collection, opted in or not.
-*/
-var excludedColumnNames = (tableColumns, collection) => {
-	if (!tableColumns || typeof tableColumns !== "object") return [];
-	const byName = new Set(collection ? searchColumnNames(collection) : []);
-	return Object.keys(tableColumns).filter((name) => byName.has(name) || isSearchIndexColumn(tableColumns[name]));
-};
-//#endregion
+import { d as foreignKeyIndexSpec, o as buildCollectionIndexSpecs, p as leadsWithColumn, u as deriveIndexName } from "./source-DBDbBTL4.js";
+import { REBASE_SCHEMA, hasForeignKeyOnTarget, isManyToMany, isPostgresCollectionConfig } from "@rebasepro/types";
+import { TENANT_INDEX_REASON, assertBeforeQueryIsPostgresOnly, compileRulePolicies, fieldKeyForColumn, findRelation, getEffectiveSecurityRules, getEnumVarName, getInjectedSecurityRules, getJunctionCollectionConfig, getJunctionSecurityRules, getTableName, getTableVarName, getTenantConfig, relationalCollections, resolveCollectionRelations, resolveJunctionSpecs, resolveStringColumnLength } from "@rebasepro/common";
+import { generateForeignKeyName, getPolicySupersededNames, legacyForeignKeyName, toPostgresIdentifier, toSnakeCase } from "@rebasepro/utils";
 //#region src/schema/relation-names.ts
 /**
 * The `relationName` both sides of a link must agree on.
@@ -571,7 +138,7 @@ var triggerStatements = (plan) => [dropTriggerStatement(plan), createTriggerStat
 * imported would not be comparable with itself.
 *
 * It **throws** rather than guessing. A configuration no renderer can honour —
-* an empty enum, two `isId` properties, `isId: "cuid"`, an unknown
+* an empty enum, `isId: "cuid"`, a foreign key into a composite key, an unknown
 * `columnType`, a relation to a collection that is not in the bundle, a
 * `search` block on a collection Postgres does not store — used to fail
 * differently in each of the three emitters, or not at all, and the failure
@@ -588,6 +155,8 @@ var quoteSqlLiteral = (value) => `'${value.replace(/'/g, "''")}'`;
 var schemaOf = (collection) => isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
 var bareTableName = (name) => name.includes(".") ? name.split(".").pop() : name;
 var describe = (collection) => collection.slug ?? collection.name ?? "(unnamed)";
+/** A link, as a refusal names it: `relation "posts.author"`. */
+var linkLabel = (kind, collection, key) => `${kind} "${describe(collection)}.${key}"`;
 /**
 * The `ON DELETE` a foreign key gets when the author did not say.
 *
@@ -632,13 +201,22 @@ var foreignKeyPlan = (args) => {
 * One exception: a `serial` key owns a sequence, and a column pointing at it is
 * the plain integer of the same width — `SERIAL` there would give every
 * referencing column a sequence of its own.
+*
+* @param via the link asking, named if the collection's key is composite and so
+*   cannot be pointed at — see `getPrimaryKeyProp`.
 */
-var primaryKeyPgType = (collection) => {
-	const { name, prop } = getPrimaryKeyProp(collection);
+var primaryKeyPgType = (collection, via) => {
+	const { name, prop } = getPrimaryKeyProp(collection, via);
 	if (prop?.type === "number") return withoutSequence(numberType(name, prop, collection, true));
 	if (prop?.type === "string") return stringType(name, prop, collection);
 	return { kind: "text" };
 };
+/**
+* The DEFAULT of the implicit `id TEXT PRIMARY KEY` a collection that declares
+* no key gets: a uuid, as text. The same generator `isId: "uuid"` uses, cast to
+* the column the key has always been.
+*/
+var IMPLICIT_ID_DEFAULT = "gen_random_uuid()::text";
 var withoutSequence = (type) => {
 	switch (type.kind) {
 		case "smallserial": return { kind: "smallint" };
@@ -762,7 +340,7 @@ var columnPgType = (propName, prop, collection, resolveCollection) => {
 		case "relation":
 		case "reference": {
 			const target = linkTarget(propName, prop, collection, resolveCollection);
-			return target ? primaryKeyPgType(target) : { kind: "text" };
+			return target ? primaryKeyPgType(target, linkLabel(prop.type, collection, propName)) : { kind: "text" };
 		}
 		default: throw new Error(`No Postgres column type for property "${propName}" of type "${prop.type}" in collection "${describe(collection)}". Add a case to \`columnPgType\` in schema/plan/plan-schema.ts.`);
 	}
@@ -870,7 +448,10 @@ var literalDefault = (prop, type) => {
 		default: return;
 	}
 };
-/** The DEFAULT a column carries: id strategy, then `autoValue`, then `defaultValue`. */
+/**
+* The DEFAULT a column carries: id strategy, then `autoValue`, then a
+* `databaseDefault` given as SQL, then `defaultValue`.
+*/
 var columnDefault = (propName, prop, collection, type) => {
 	const idDefault = idColumnDefault(propName, prop, collection);
 	if (idDefault) {
@@ -891,48 +472,62 @@ var columnDefault = (propName, prop, collection, type) => {
 			expression: "now()"
 		};
 	}
+	if (typeof prop.databaseDefault === "string") {
+		const expression = sqlExpressionText(prop.databaseDefault).trim();
+		if (expression) return {
+			kind: "sql",
+			expression
+		};
+	}
 	return literalDefault(prop, type);
 };
 /**
 * One security rule, compiled to the clauses a policy is made of.
 *
-* The desugaring (`access` / `ownerField` / `roles` / structured condition /
-* raw SQL → `PolicyExpression`) and the SQL compilation are `@rebasepro/common`'s,
-* which is what the client-side evaluator uses too — so the UI, the DDL and the
-* database agree about who can read a row. What lives here is only the shape:
-* which operations a rule expands to, which clauses each operation takes, and
-* the deny-all fallback for a clause that compiled to nothing.
+* The compilation is `compileRulePolicies` in `@rebasepro/common`, which the
+* Studio's RLS editor also compares the live database against — so the UI, the
+* DDL and the database agree about who can read a row. What this adds is only
+* the planner's bookkeeping: which rule a policy came from, and whether Rebase
+* injected it.
 */
 var compileSecurityRule = (collection, rule, resolveCollection, injected, ruleKey = rule.name ?? "(unnamed)") => {
-	const tableName = getTableName(collection);
-	const ops = rule.operations && rule.operations.length > 0 ? rule.operations : [rule.operation ?? "all"];
-	const policyNames = getPolicyNamesForRule(rule, tableName);
-	const { usingExpr, withCheckExpr } = securityRuleToConditions(rule);
-	return ops.map((operation, index) => {
-		const needsUsing = operation !== "insert";
-		const needsWithCheck = operation !== "select" && operation !== "delete";
-		let using = needsUsing && usingExpr ? policyToPostgres(usingExpr, collection, { resolveCollection }) : null;
-		let withCheck = needsWithCheck && withCheckExpr ? policyToPostgres(withCheckExpr, collection, { resolveCollection }) : null;
-		if (!using && needsUsing) using = "false";
-		if (!withCheck && needsWithCheck) withCheck = "false";
-		return {
-			name: policyNames[index],
-			ruleKey,
-			operation,
-			mode: rule.mode ?? "permissive",
-			roles: rule.pgRoles ? [...rule.pgRoles].sort() : ["public"],
-			using,
-			withCheck,
-			injected
-		};
+	const supersedes = getPolicySupersededNames(rule, getTableName(collection));
+	return compileRulePolicies(collection, rule, { resolveCollection }).map((policy, index) => ({
+		...policy,
+		ruleKey,
+		injected,
+		...index === 0 && supersedes.length > 0 ? { supersedes } : {}
+	}));
+};
+/**
+* A table's policies, minus any superseded name Postgres would store one of
+* them under.
+*
+* A superseded name is a 63-byte cut, and another rule's over-long name can
+* cut to the very same bytes — `<table>_default_admin_read` and the old
+* `<table>_default_admin_write_<op>` both do on a 50-byte table. Dropping it
+* then would drop that policy right after its own `CREATE`. Its own `DROP
+* POLICY IF EXISTS` already removes the old policy, so nothing is lost.
+*/
+var withoutLiveSupersededNames = (policies) => {
+	const stored = new Set(policies.map((policy) => toPostgresIdentifier(policy.name)));
+	return policies.map((policy) => {
+		if (!policy.supersedes) return policy;
+		const supersedes = policy.supersedes.filter((name) => !stored.has(name));
+		if (supersedes.length === policy.supersedes.length) return policy;
+		const kept = { ...policy };
+		if (supersedes.length > 0) kept.supersedes = supersedes;
+		else delete kept.supersedes;
+		return kept;
 	});
 };
 function planSchema(allCollections, options = {}) {
 	assertSearchIsPostgresOnly(allCollections);
 	assertBeforeQueryIsPostgresOnly(allCollections);
 	const collections = relationalCollections(allCollections);
-	collections.forEach(assertSinglePrimaryKey);
-	const resolveCollection = (slug) => collections.find((c) => c.slug === slug || getTableName(c) === slug);
+	const firstBySlugOrTable = /* @__PURE__ */ new Map();
+	for (const c of collections) for (const key of [c.slug, getTableName(c)]) if (!firstBySlugOrTable.has(key)) firstBySlugOrTable.set(key, c);
+	const resolveCollection = (slug) => firstBySlugOrTable.get(slug);
 	const declaredSchemas = Array.from(new Set(collections.map((c) => isPostgresCollectionConfig(c) ? c.schema : void 0).filter(Boolean)));
 	const schemas = Array.from(/* @__PURE__ */ new Set([REBASE_SCHEMA, ...declaredSchemas]));
 	const enums = [];
@@ -1010,6 +605,7 @@ function planSchema(allCollections, options = {}) {
 	const triggerFunctionNeeded = { value: false };
 	const tables = [];
 	for (const [tableName, entry] of tableEntries) tables.push(entry.junction ? planJunctionTable(tableName, entry.junction.relation, entry.junction.source, junctionSpecs, resolveCollection, triggerFunctionNeeded) : planCollectionTable(entry.collection, resolveCollection, triggerFunctionNeeded));
+	assertNoTruncationCollisions(tables, enums);
 	const extensions = [];
 	const functions = [];
 	const seenStatements = /* @__PURE__ */ new Set();
@@ -1041,6 +637,31 @@ function planSchema(allCollections, options = {}) {
 	};
 }
 /**
+* Refuse two relations — tables, junctions and enum types share one namespace
+* per schema, because every table owns a row type of its own name — that are
+* distinct in full but one name after Postgres keeps the first 63 bytes.
+*
+* `a_table_with_a_really_long_name_that_goes_on_and_on_and_on_forever` with an
+* enum column and a many-to-many truncated its table, its enum type and its
+* junction to the same identifier: the push failed with `type "…" already
+* exists` and no validator mentioned the length. A name that already works is
+* never touched — only a collision that cannot be created refuses.
+*/
+function assertNoTruncationCollisions(tables, enums) {
+	const owners = /* @__PURE__ */ new Map();
+	const claim = (schema, name, what) => {
+		const key = `${schema}.${toPostgresIdentifier(name)}`;
+		const first = owners.get(key);
+		if (first === void 0) {
+			owners.set(key, what);
+			return;
+		}
+		throw new Error(`The ${what} and the ${first} both become "${schema}"."${toPostgresIdentifier(name)}" in Postgres, which keeps only the first 63 bytes of an identifier — and a table, a junction table and an enum type share one namespace (every table owns a row type of its name). The push would fail with "already exists". Give the collection a shorter \`table\`, or the enum's property a shorter \`columnName\` (an enum type is named <table>_<column>).`);
+	};
+	for (const table of tables) claim(table.schema, table.table, table.kind === "junction" ? `junction table "${table.table}"` : `table "${table.table}"`);
+	for (const e of enums) claim(e.schema, e.name, `enum type "${e.name}"`);
+}
+/**
 * Refuse two many-to-many relations that resolve to one junction table with
 * different key columns.
 *
@@ -1156,22 +777,18 @@ function planCollectionTable(collection, resolveCollection, triggerFunctionNeede
 			}
 		});
 	}
-	if (!columns.some((c) => c.primaryKey)) columns.unshift({
-		key: "id",
-		column: "id",
-		type: { kind: "text" },
-		nullable: false,
-		primaryKey: true,
-		unique: false,
-		source: {
-			kind: "implicit-id",
-			slug: collection.slug
-		}
-	});
+	const primaryKey = planPrimaryKey(collection, columns);
 	const injected = new Set(getInjectedSecurityRules(collection).map((rule) => rule.name));
-	const policies = getEffectiveSecurityRules(collection).flatMap((rule, index) => compileSecurityRule(collection, rule, resolveCollection, Boolean(rule.name && injected.has(rule.name)), rule.name ?? `#${index}`));
-	const tenantIndexes = applyTenantColumnEffects(collection, columns, schema, table);
+	const policies = withoutLiveSupersededNames(getEffectiveSecurityRules(collection).flatMap((rule, index) => compileSecurityRule(collection, rule, resolveCollection, Boolean(rule.name && injected.has(rule.name)), rule.name ?? `#${index}`)));
+	const tenantIndexes = applyTenantColumnEffects(collection, columns, primaryKey, schema, table);
 	settleDefaultOnDelete(collection, columns, relations);
+	const indexes = [...buildCollectionIndexSpecs(collection, resolveColumnName), ...tenantIndexes];
+	indexes.push(...planForeignKeyIndexes(schema, table, columns, primaryKey, indexes, (column) => {
+		if (column.source.kind !== "relation" || !column.source.propName) return false;
+		const prop = collection.properties?.[column.source.propName];
+		const relation = findRelation(relations, prop?.relation?.relationName ?? column.source.propName);
+		return relation?.kind === "belongsTo" && relation.index;
+	}));
 	return {
 		schema,
 		table,
@@ -1181,8 +798,8 @@ function planCollectionTable(collection, resolveCollection, triggerFunctionNeede
 		kind: "collection",
 		slug: collection.slug,
 		columns,
-		primaryKey: columns.filter((c) => c.primaryKey).map((c) => c.column),
-		indexes: [...buildCollectionIndexSpecs(collection, resolveColumnName), ...tenantIndexes],
+		primaryKey,
+		indexes,
 		search,
 		vector: buildVectorIndexPlan(collection, resolveColumnName),
 		vectorColumns: buildVectorColumnSpecs(collection, resolveColumnName),
@@ -1192,6 +809,50 @@ function planCollectionTable(collection, resolveCollection, triggerFunctionNeede
 	};
 }
 /**
+* The table's primary key, as the column names {@link TablePlan.primaryKey}
+* lists — and the columns adjusted to state it one way only.
+*
+* One `isId` property is a key column of its own, declared inline
+* (`"id" INTEGER PRIMARY KEY`, `.primaryKey()`), which is how
+* {@link planPropertyColumn} planned it. Several are one composite key, and a
+* composite key cannot be said column by column: two inline `PRIMARY KEY`
+* clauses are two primary keys, which Postgres refuses. So each member stops
+* being a key of its own, keeps NOT NULL (the constraint implies it, and every
+* emitter spells it on the column so the three read the same), and the table
+* gets one `PRIMARY KEY (a, b)` over the list returned here — the shape a
+* junction's key has always had.
+*
+* A collection that declares no key gets an implicit `id TEXT PRIMARY KEY`,
+* which is what `getPrimaryKeys` reads back.
+*/
+function planPrimaryKey(collection, columns) {
+	const keyNames = primaryKeyPropertyNames(collection);
+	if (keyNames.length > 1) return keyNames.map((name) => {
+		const column = columns.find((c) => c.source.propName === name && !c.columnOwnedByProperty);
+		if (!column) throw new Error(`Property "${name}" of collection "${describe(collection)}" is marked \`isId\`, and it puts no column on this table, so it cannot be part of the table's primary key. Mark the property that holds the column instead.`);
+		column.primaryKey = false;
+		column.nullable = false;
+		return column.column;
+	});
+	if (!columns.some((c) => c.primaryKey)) columns.unshift({
+		key: "id",
+		column: "id",
+		type: { kind: "text" },
+		nullable: false,
+		primaryKey: true,
+		unique: false,
+		default: {
+			kind: "sql",
+			expression: IMPLICIT_ID_DEFAULT
+		},
+		source: {
+			kind: "implicit-id",
+			slug: collection.slug
+		}
+	});
+	return columns.filter((c) => c.primaryKey).map((c) => c.column);
+}
+/**
 * One declared, non-linking property, as a column.
 *
 * Extracted from {@link planCollectionTable} the moment a second table needed
@@ -1274,12 +935,12 @@ function planPropertyColumn(propName, prop, ctx) {
 * column that does not exist: `CREATE POLICY` fails, RLS stays enabled, and the
 * collection denies every row.
 */
-function applyTenantColumnEffects(collection, columns, schema, table) {
+function applyTenantColumnEffects(collection, columns, primaryKey, schema, table) {
 	const tenant = getTenantConfig(collection);
 	if (!tenant) return [];
 	const column = findTenantColumn(collection, columns, tenant.field);
 	if (!column) throw new Error(`Collection "${describe(collection)}" declares \`tenant: { field: "${tenant.field}" }\`, and no property of that name reaches a column. \`tenant\` says what a column means; it does not create one. Declare the property, or name the one that holds the tenant id.`);
-	if (column.primaryKey) return [];
+	if (primaryKey[0] === column.column) return [];
 	column.nullable = false;
 	const withoutName = {
 		schema,
@@ -1301,6 +962,39 @@ function applyTenantColumnEffects(collection, columns, schema, table) {
 	}];
 }
 /**
+* A btree on each foreign-key column of one table, where nothing already
+* serves the lookup — see `foreignKeyIndexSpec` for why the column needs one.
+*
+* Skipped, so that no table ever carries two indexes doing one job, when the
+* column already leads:
+*
+* - the primary key — `<table>_pkey` is a btree over the key in key order, so
+*   its first column is indexed and the rest are not (a junction's
+*   `(post_id, tag_id)` key serves `post_id`, and `tag_id` gets an index);
+* - a UNIQUE on the column (`validation.unique`, on the relation or on the
+*   property that owns the column) — Postgres backs it with a btree;
+* - another planned index that leads with it ({@link leadsWithColumn}) — one
+*   the collection declares in `indexes:`, or the tenant index.
+*
+* Only the plan is consulted, never the catalogue: `db push` renders this from
+* the collections alone, and boot has to reach the same set with the same
+* names, or Atlas would plan to drop what boot built.
+*/
+function planForeignKeyIndexes(schema, table, columns, primaryKey, planned, wantsIndex) {
+	const created = columns.filter((c) => !c.columnOwnedByProperty);
+	const derived = [];
+	for (const column of columns) {
+		const fk = column.foreignKey;
+		if (!fk || !wantsIndex(column)) continue;
+		const name = fk.column;
+		if (primaryKey[0] === name) continue;
+		if (created.some((c) => c.column === name && c.unique)) continue;
+		if ([...planned, ...derived].some((spec) => leadsWithColumn(spec, name))) continue;
+		derived.push(foreignKeyIndexSpec(schema, table, name));
+	}
+	return derived;
+}
+/**
 * The planned column a `tenant.field` names.
 *
 * Not simply `columns.find(c => c.key === field)`: a `belongsTo` relation
@@ -1384,10 +1078,11 @@ function planRelationColumn(propName, prop, collection, relations, schema, table
 	const relationName = prop.relation?.relationName ?? propName;
 	const legacyKey = legacyForeignKeyName(relationName);
 	const derived = relation.localKey === generateForeignKeyName(relationName);
+	const via = linkLabel("relation", collection, propName);
 	return {
 		key: fkFieldKey,
 		column: relation.localKey,
-		type: primaryKeyPgType(target),
+		type: primaryKeyPgType(target, via),
 		nullable: !required,
 		primaryKey: false,
 		unique: prop.validation?.unique === true,
@@ -1399,7 +1094,7 @@ function planRelationColumn(propName, prop, collection, relations, schema, table
 			column: relation.localKey,
 			targetSchema: schemaOf(target),
 			targetTable: bareTableName(getTableName(target)),
-			targetColumn: getPrimaryKeyColumn(target),
+			targetColumn: getPrimaryKeyColumn(target, via),
 			onDelete: relation.onDelete ?? defaultBelongsToOnDelete(required),
 			onUpdate: relation.onUpdate
 		}),
@@ -1415,10 +1110,11 @@ function planReferenceColumn(propName, prop, collection, resolveCollection, sche
 	const target = prop.path ? resolveCollection(prop.path) : void 0;
 	const column = resolveColumnName(propName, prop);
 	const required = prop.validation?.required === true;
+	const via = linkLabel("reference", collection, propName);
 	return {
 		key: propName,
 		column,
-		type: target ? primaryKeyPgType(target) : { kind: "text" },
+		type: target ? primaryKeyPgType(target, via) : { kind: "text" },
 		nullable: !required,
 		primaryKey: false,
 		unique: prop.validation?.unique === true,
@@ -1428,7 +1124,7 @@ function planReferenceColumn(propName, prop, collection, resolveCollection, sche
 			column,
 			targetSchema: schemaOf(target),
 			targetTable: bareTableName(getTableName(target)),
-			targetColumn: getPrimaryKeyColumn(target),
+			targetColumn: getPrimaryKeyColumn(target, via),
 			onDelete: defaultBelongsToOnDelete(required)
 		}) : void 0,
 		source: {
@@ -1462,7 +1158,44 @@ var authColumnType = (sqlType) => {
 	if (!mapped) throw new Error(`\`auth-users-columns\` declares a column of type "${sqlType}", which the schema plan has no tag for. Add it to \`AUTH_COLUMN_TYPES\` in schema/plan/plan-schema.ts.`);
 	return mapped;
 };
-function planJunctionTable(tableName, relation, source, junctionSpecs, resolveCollection, triggerFunctionNeeded) {
+/**
+* Which declaring side a junction is planned from.
+*
+* With one side, that side — as it always was, so a junction only one end
+* declares keeps the key every database already has. With both ends declaring
+* it, the planner used to take whichever it reached first, and the two doors
+* reach them in different orders: `db push` loads files by name, boot walks the
+* bundle's array. The same junction was keyed `(a_id, b_id)` by one and
+* `(b_id, a_id)` by the other, and a push against a boot-built database rebuilt
+* the key. Now the side whose table sorts first, which is the order `db push`
+* already used wherever a file is named after its table.
+*/
+function canonicalJunctionSide(table, relation, source, spec) {
+	if (!spec || spec.declaringSides.length < 2) return {
+		relation,
+		source
+	};
+	const chosen = [...spec.declaringSides].sort((a, b) => {
+		const left = bareTableName(getTableName(a.collection));
+		const right = bareTableName(getTableName(b.collection));
+		if (left !== right) return left < right ? -1 : 1;
+		return a.junctionColumn < b.junctionColumn ? -1 : a.junctionColumn > b.junctionColumn ? 1 : 0;
+	})[0].collection;
+	if (chosen === source) return {
+		relation,
+		source
+	};
+	const resolved = Object.values(resolveCollectionRelations(chosen)).find((r) => isManyToMany(r) && bareTableName(r.through.table) === table);
+	return resolved ? {
+		relation: resolved,
+		source: chosen
+	} : {
+		relation,
+		source
+	};
+}
+function planJunctionTable(tableName, reachedRelation, reachedSource, junctionSpecs, resolveCollection, triggerFunctionNeeded) {
+	const { relation, source } = canonicalJunctionSide(bareTableName(tableName), reachedRelation, reachedSource, junctionSpecs.get(bareTableName(tableName)));
 	if (!isManyToMany(relation)) throw new Error(`Internal: junction table "${tableName}" was reached from a ${relation.kind} relation.`);
 	const table = bareTableName(tableName);
 	const schema = "public";
@@ -1475,10 +1208,11 @@ function planJunctionTable(tableName, relation, source, junctionSpecs, resolveCo
 		const legacy = legacyForeignKeyName(slug);
 		return column === generateForeignKeyName(slug) && legacy !== column ? legacy : void 0;
 	};
+	const via = linkLabel("relation", source, relation.relationName);
 	const endpoint = (collection, column) => ({
 		key: column,
 		column,
-		type: primaryKeyPgType(collection),
+		type: primaryKeyPgType(collection, via),
 		nullable: false,
 		primaryKey: false,
 		unique: false,
@@ -1489,7 +1223,7 @@ function planJunctionTable(tableName, relation, source, junctionSpecs, resolveCo
 			column,
 			targetSchema: schemaOf(collection),
 			targetTable: bareTableName(getTableName(collection)),
-			targetColumn: getPrimaryKeyColumn(collection),
+			targetColumn: getPrimaryKeyColumn(collection, via),
 			onDelete
 		}),
 		source: { kind: "junction-key" }
@@ -1513,7 +1247,7 @@ function planJunctionTable(tableName, relation, source, junctionSpecs, resolveCo
 			columns.push(plan);
 		}
 	}
-	const policies = spec ? getJunctionSecurityRules(spec).flatMap((rule, index) => compileSecurityRule(getJunctionCollectionConfig(spec), rule, resolveCollection, false, rule.name ?? `#${index}`)) : [];
+	const policies = spec ? withoutLiveSupersededNames(getJunctionSecurityRules(spec).flatMap((rule, index) => compileSecurityRule(getJunctionCollectionConfig(spec), rule, resolveCollection, false, rule.name ?? `#${index}`))) : [];
 	return {
 		schema,
 		table,
@@ -1523,7 +1257,7 @@ function planJunctionTable(tableName, relation, source, junctionSpecs, resolveCo
 		declaringSlugs: spec?.declaringSides.map((side) => side.collection.slug) ?? [],
 		columns,
 		primaryKey: [sourceColumn, targetColumn],
-		indexes: [],
+		indexes: planForeignKeyIndexes(schema, table, columns, [sourceColumn, targetColumn], [], (column) => column.source.kind === "junction-key"),
 		vectorColumns: [],
 		policies,
 		triggers,
@@ -1538,12 +1272,29 @@ function planJunctionTable(tableName, relation, source, junctionSpecs, resolveCo
 */
 function planRelations(collections, tableEntries) {
 	const plans = [];
+	const fkOnTargetBySlug = /* @__PURE__ */ new Map();
+	for (const other of collections) for (const otherRel of Object.values(resolveCollectionRelations(other))) {
+		if (!hasForeignKeyOnTarget(otherRel)) continue;
+		let otherTarget;
+		try {
+			otherTarget = otherRel.target();
+		} catch {
+			continue;
+		}
+		const list = fkOnTargetBySlug.get(otherTarget.slug) ?? [];
+		list.push({
+			other,
+			otherRel
+		});
+		fkOnTargetBySlug.set(otherTarget.slug, list);
+	}
 	for (const [tableName, entry] of tableEntries) {
 		const tableVar = getTableVarName(tableName);
 		if (entry.junction) {
 			const { relation, source } = entry.junction;
 			if (!isManyToMany(relation)) continue;
 			const target = relation.target();
+			const via = linkLabel("relation", source, relation.relationName);
 			const owningRelationName = sharedRelationName(relation, source);
 			let inverse;
 			try {
@@ -1557,7 +1308,7 @@ function planRelations(collections, tableEntries) {
 				targetVar: getTableVarName(getTableName(source)),
 				relationName: owningRelationName,
 				fields: [relation.through.sourceColumn],
-				references: [getPrimaryKeyName(source)]
+				references: [getPrimaryKeyName(source, via)]
 			});
 			if (inverseRelationName === owningRelationName) continue;
 			plans.push({
@@ -1567,7 +1318,7 @@ function planRelations(collections, tableEntries) {
 				targetVar: getTableVarName(getTableName(target)),
 				relationName: inverseRelationName,
 				fields: [relation.through.targetColumn],
-				references: [getPrimaryKeyName(target)]
+				references: [getPrimaryKeyName(target, via)]
 			});
 			continue;
 		}
@@ -1594,7 +1345,7 @@ function planRelations(collections, tableEntries) {
 						targetVar,
 						relationName,
 						fields: [fieldKeyForColumn(collection, relation.localKey)],
-						references: [getPrimaryKeyName(target)]
+						references: [getPrimaryKeyName(target, linkLabel("relation", collection, key))]
 					});
 					break;
 				case "hasOne":
@@ -1602,7 +1353,11 @@ function planRelations(collections, tableEntries) {
 						tableVar,
 						key,
 						kind: "one",
-						targetVar
+						targetVar,
+						relationName,
+						fields: [relation.sourceKey ? fieldKeyForColumn(collection, relation.sourceKey) : getPrimaryKeyName(collection, linkLabel("relation", collection, key))],
+						references: [fieldKeyForColumn(target, relation.foreignKeyOnTarget)],
+						nullable: true
 					});
 					break;
 				case "hasMany":
@@ -1626,38 +1381,28 @@ function planRelations(collections, tableEntries) {
 				case "via": break;
 			}
 		}
-		for (const other of collections) {
+		for (const { other, otherRel } of fkOnTargetBySlug.get(collection.slug) ?? []) {
 			if (other.slug === collection.slug) continue;
-			for (const otherRel of Object.values(resolveCollectionRelations(other))) {
-				if (!hasForeignKeyOnTarget(otherRel)) continue;
-				let otherTarget;
-				try {
-					otherTarget = otherRel.target();
-				} catch {
-					continue;
-				}
-				if (otherTarget.slug !== collection.slug) continue;
-				const relationName = sharedRelationName(otherRel, other);
-				const dedupe = `${relationName}::belongsTo`;
-				if (emitted.has(dedupe)) continue;
-				emitted.add(dedupe);
-				const otherVar = getTableVarName(getTableName(other));
-				const fieldKey = fieldKeyForColumn(collection, otherRel.foreignKeyOnTarget);
-				plans.push({
-					tableVar,
-					key: `_synth_${otherVar}_${fieldKey}`,
-					kind: "one",
-					targetVar: otherVar,
-					relationName,
-					fields: [fieldKey],
-					references: [otherRel.sourceKey ? fieldKeyForColumn(other, otherRel.sourceKey) : getPrimaryKeyName(other)]
-				});
-			}
+			const relationName = sharedRelationName(otherRel, other);
+			const dedupe = `${relationName}::belongsTo`;
+			if (emitted.has(dedupe)) continue;
+			emitted.add(dedupe);
+			const otherVar = getTableVarName(getTableName(other));
+			const fieldKey = fieldKeyForColumn(collection, otherRel.foreignKeyOnTarget);
+			plans.push({
+				tableVar,
+				key: `_synth_${otherVar}_${fieldKey}`,
+				kind: "one",
+				targetVar: otherVar,
+				relationName,
+				fields: [fieldKey],
+				references: [otherRel.sourceKey ? fieldKeyForColumn(other, otherRel.sourceKey) : getPrimaryKeyName(other, linkLabel("relation", other, otherRel.relationName))]
+			});
 		}
 	}
 	return plans;
 }
 //#endregion
-export { searchHelperFunctions as _, triggerStatements as a, searchStampGuards as b, SEARCH_TEXT_FN as c, fuzzyColumnDefinition as d, hiddenColumnsOption as f, searchExtensionStatements as g, searchColumnStamps as h, SET_UPDATED_AT_FN as i, SEARCH_UNACCENT_FN as l, searchColumnNames as m, planSchema as n, sharedRelationName as o, searchColumnDefinition as p, quoteSqlLiteral as r, SEARCH_STAMP_PREFIX as s, columnPgType as t, buildSearchColumnSpec as u, searchIndexNames as v, visibleColumnProjection as x, searchIndexStatements as y };
+export { triggerStatements as a, SET_UPDATED_AT_FN as i, planSchema as n, sharedRelationName as o, quoteSqlLiteral as r, columnPgType as t };
 
-//# sourceMappingURL=plan-schema-C0fxM8dY.js.map
+//# sourceMappingURL=plan-schema-B1YF_tYq.js.map