@rebasepro/server-postgres 0.19.1 → 0.19.2-canary.g08eed46

package/dist/{ensure-collection-tables-D4wJzM4y.js → ensure-collection-tables-Bkvehxdm.js}

@@ -1,14 +1,14 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
 import { r as __exportAll } from "./__vite-browser-external-BnuHet1e.js";
-import { C as searchIndexStatements, S as searchHelperFunctions, _ as assertSearchIsPostgresOnly, b as searchColumnStamps, c as isIdProperty, d as planRelationalColumns, f as quoteSqlLiteral, g as SEARCH_UNACCENT_FN, h as SEARCH_TEXT_FN, p as resolveColumnName, s as getSqlColumnType, u as planJunctionTables, v as buildSearchColumnSpec, x as searchExtensionStatements } from "./generate-postgres-ddl-logic-CtnpIBVv.js";
-import { l as extractCauseMessage, u as extractPgError } from "./cli-errors-DxN4yzdH.js";
-import { i as isAuthCollection, n as authUsersColumnDefinition, r as authUsersColumnSql, t as AUTH_USERS_COLUMNS } from "./auth-users-columns-D2LBFrMH.js";
-import { c as vectorExtensionStatement, l as vectorIndexStatement, n as buildVectorColumnSpecs, o as vectorExtensionDeclared, r as buildVectorIndexPlan, s as vectorExtensionHint } from "./vector-index-DkWxm2de.js";
-import { r as collectionIndexStatement, t as buildCollectionIndexPlan } from "./collection-index-BHgT_TKd.js";
+import { a as triggerStatements, c as SEARCH_TEXT_FN, h as searchColumnStamps, i as SET_UPDATED_AT_FN, l as SEARCH_UNACCENT_FN, n as planSchema, r as quoteSqlLiteral, y as searchIndexStatements } from "./plan-schema-Hgl62S-w.js";
+import { d as extractPgError, u as extractCauseMessage } from "./cli-errors-C3g_kHBw.js";
+import { s as vectorExtensionHint, u as vectorIndexStatement } from "./vector-index-CMJKb3C9.js";
+import { c as sortIndexSpecs, n as collectionIndexStatement } from "./collection-index-DdnsxiJ_.js";
+import { c as planJunctionTables, l as renderColumnDefinition, u as renderPgType } from "./generate-postgres-ddl-logic-CR2xcS7e.js";
 import { isConcurrentDdlRace, isDuplicateObjectRace, logger } from "@rebasepro/server";
-import { declaredDatabaseExtensions, isPostgresCollectionConfig } from "@rebasepro/types";
-import { getTableName, relationalCollections } from "@rebasepro/common";
+import { REBASE_SCHEMA, declaredDatabaseExtensions } from "@rebasepro/types";
+import { relationalCollections } from "@rebasepro/common";
 //#region src/schema/column-type-drift.ts
 /**
 * Types that mean the same thing to everything above the driver.
@@ -99,7 +99,16 @@ function typesAgree(declared, actual) {
 	const a = typeFamily(declared);
 	const b = typeFamily(actual);
 	if (a === null || b === null) return true;
-	return a === b;
+	if (a !== b) return false;
+	if (a !== "numeric") return true;
+	const declaredModifier = numericModifier(declared);
+	if (declaredModifier === null) return true;
+	return declaredModifier === numericModifier(actual);
+}
+/** `numeric(10,2)` / `NUMERIC(10, 2)` → `10,2`; a bare `numeric` → `null`. */
+function numericModifier(raw) {
+	const match = raw.match(/\(([^)]*)\)/);
+	return match ? match[1].replace(/\s+/g, "") : null;
 }
 /**
 * The sentence a boot log says about one drifted column.
@@ -114,51 +123,10 @@ function columnTypeDriftMessage(drift) {
     ALTER TABLE "${schema}"."${table}" ALTER COLUMN "${drift.column}" TYPE ${drift.declared} USING "${drift.column}"::${drift.declared};`;
 }
 //#endregion
-//#region src/schema/ensure-collection-tables.ts
-/**
-* Bringing a database up to date with a bundle's collections, additively.
-*
-* ## Why this exists
-*
-* A managed runtime boots someone else's compiled project against a database it
-* has never seen. Auth tables are ensured at boot already, but collection tables
-* were not created by anything: the platform ran the app and every `/api/data/*`
-* request answered 500 on a missing relation. `rebase db push` cannot help — it
-* is an Atlas-driven CLI command, and the runtime image ships no CLI.
-*
-* ## Why additive-only, forever
-*
-* This runs unattended, against a database with customers' data in it, with no
-* human reading a diff. So it may only ever do things that cannot lose data:
-* create a missing table, add a missing column, create a missing enum type.
-*
-* It will **never** drop a table or a column, narrow a type, or alter a
-* constraint. A removed field leaves its column behind; a renamed field looks
-* like an addition and the old column stays. That is the correct trade for an
-* automated path — the alternative is an unattended process that can silently
-* destroy a column, which is precisely the failure `db push` was hardened
-* against. Destructive changes stay a deliberate, human-reviewed migration.
-*
-* Because of that, this is safe to run on every boot, and re-running it is a
-* no-op.
-*/
-var ensure_collection_tables_exports = /* @__PURE__ */ __exportAll({
-	describeDriverError: () => describeDriverError,
-	ensureCollectionTables: () => ensureCollectionTables,
-	planCollectionSchemaEnsure: () => planCollectionSchemaEnsure,
-	readExistingSchema: () => readExistingSchema,
-	readSchemaFactsFor: () => readSchemaFactsFor
-});
+//#region src/schema/plan/diff-plan.ts
 /** Postgres identifiers this module is willing to interpolate. */
 var SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_$]*$/;
-function assertSafeIdentifier(value, what) {
-	if (!SAFE_IDENTIFIER.test(value)) throw new Error(`Refusing to build SQL with an unsafe ${what}: ${JSON.stringify(value)}`);
-	return value;
-}
 /**
-* The schema a collection lives in — validated, because it is about to be
-* interpolated into DDL.
-*
 * Validation used to run only on the names read back OUT of the catalogue,
 * which is the direction that cannot hurt anyone: those came from Postgres. The
 * names going IN — the schema and table a collection declares — were quoted and
@@ -173,349 +141,320 @@ function assertSafeIdentifier(value, what) {
 * both do that — and there the caller is an admin on the app, not an operator
 * of the database.
 */
-function schemaOf(collection) {
-	return assertSafeIdentifier(isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public", "schema name");
-}
-/** A collection's table name, validated for the same reason as {@link schemaOf}. */
-function tableOf(collection) {
-	return assertSafeIdentifier(getTableName(collection), "table name");
-}
-function qualified(collection) {
-	return `${schemaOf(collection)}.${tableOf(collection)}`;
-}
-/**
-* Enum types a collection's properties require, as `schema.typename`.
-*
-* Named exactly as the DDL generator names them (`<table>_<column>`), because
-* a column added here has to reference the same type the generator would have
-* created — a second, differently-named type for the same field would be a
-* silent schema fork.
-*/
-function requiredEnums(collection) {
-	const table = tableOf(collection);
-	const schema = schemaOf(collection);
-	const out = [];
-	for (const [propName, prop] of Object.entries(collection.properties ?? {})) {
-		const p = prop;
-		if (!("enum" in p) || !p.enum) continue;
-		if (p.type !== "string" && p.type !== "number") continue;
-		const values = p.enum.map((entry) => entry && typeof entry === "object" && "id" in entry ? String(entry.id) : String(entry)).filter((v) => v.length > 0);
-		if (values.length === 0) continue;
-		out.push({
-			name: `${schema}.${table}_${resolveColumnName(propName, p)}`,
-			values
-		});
-	}
-	return out;
+function assertSafeIdentifier(value, what) {
+	if (!SAFE_IDENTIFIER.test(value)) throw new Error(`Refusing to build SQL with an unsafe ${what}: ${JSON.stringify(value)}`);
+	return value;
 }
-/**
-* Decide what to add. Pure — the caller supplies what exists and runs the result.
-*
-* Ordering matters and is deliberate: enum types before the tables and columns
-* that reference them, tables before the columns added to other tables (a new
-* table may be the target of a relation), and nothing is emitted twice.
-*/
-function planCollectionSchemaEnsure(allCollections, existing, options = {}) {
+/** Which pass a column belongs to. The order below is the order they run in. */
+var isScalarProperty = (column) => (column.source.kind === "property" || column.source.kind === "implicit-id") && !column.primaryKey;
+function diffPlanAgainstCatalogue(plan, existing, options = {}) {
 	const constraintPolicy = options.constraints ?? "additive";
+	const actions = [];
 	const withheldConstraints = [];
 	const columnTypeDrift = [];
-	assertSearchIsPostgresOnly(allCollections);
-	const collections = relationalCollections(allCollections);
-	const actions = [];
-	const plannedEnums = /* @__PURE__ */ new Set();
-	for (const collection of collections) for (const { name, values } of requiredEnums(collection)) {
-		if (existing.enums.has(name) || plannedEnums.has(name)) {
-			const current = existing.enumValues?.get(name);
-			if (!current || plannedEnums.has(name)) continue;
-			const [schema, typeName] = name.split(".");
-			for (const value of values) {
+	const legacyForeignKeys = [];
+	const searchDrift = [];
+	const searchAdopted = [];
+	const collectionTables = plan.tables.filter((t) => t.kind === "collection");
+	const junctionTables = plan.tables.filter((t) => t.kind === "junction");
+	for (const enumPlan of plan.enums) {
+		assertSafeIdentifier(enumPlan.schema, "schema name");
+		if (existing.enums.has(enumPlan.qualified)) {
+			const current = existing.enumValues?.get(enumPlan.qualified);
+			if (!current) continue;
+			for (const value of enumPlan.labels) {
 				if (current.includes(value)) continue;
 				actions.push({
 					kind: "add-enum-value",
-					target: `${name}.${value}`,
-					sql: `ALTER TYPE "${schema}"."${typeName}" ADD VALUE IF NOT EXISTS ${quoteSqlLiteral(value)};`
+					target: `${enumPlan.qualified}.${value}`,
+					sql: `ALTER TYPE "${enumPlan.schema}"."${enumPlan.name}" ADD VALUE IF NOT EXISTS ${quoteSqlLiteral(value)};`
 				});
 			}
 			continue;
 		}
-		plannedEnums.add(name);
-		const [schema, typeName] = name.split(".");
 		actions.push({
 			kind: "create-enum",
-			target: name,
-			sql: `CREATE TYPE "${schema}"."${typeName}" AS ENUM (${values.map(quoteSqlLiteral).join(", ")});`
-		});
-	}
-	const searchSpecs = collections.map((c) => buildSearchColumnSpec(c)).filter((spec) => spec !== void 0);
-	const plannedExtensions = /* @__PURE__ */ new Set();
-	const planExtension = (statement) => {
-		if (plannedExtensions.has(statement)) return;
-		plannedExtensions.add(statement);
-		actions.push({
-			kind: "create-extension",
-			target: statement.replace(/^CREATE EXTENSION IF NOT EXISTS |;$/g, ""),
-			sql: statement
-		});
-	};
-	for (const spec of searchSpecs) for (const statement of searchExtensionStatements(spec)) planExtension(statement);
-	if (vectorExtensionDeclared(options.databaseExtensions) && collections.some((c) => buildVectorColumnSpecs(c, resolveColumnName).length > 0)) planExtension(vectorExtensionStatement());
-	const plannedFunctions = /* @__PURE__ */ new Set();
-	for (const spec of searchSpecs) for (const statement of searchHelperFunctions(spec)) {
-		if (plannedFunctions.has(statement)) continue;
-		plannedFunctions.add(statement);
-		actions.push({
-			kind: "create-function",
-			target: statement.includes("unaccent") ? SEARCH_UNACCENT_FN : SEARCH_TEXT_FN,
-			sql: statement
+			target: enumPlan.qualified,
+			sql: `CREATE TYPE "${enumPlan.schema}"."${enumPlan.name}" AS ENUM (${enumPlan.labels.map(quoteSqlLiteral).join(", ")});`
 		});
 	}
+	for (const statement of plan.extensions) actions.push({
+		kind: "create-extension",
+		target: statement.replace(/^CREATE EXTENSION IF NOT EXISTS |;$/g, ""),
+		sql: statement
+	});
+	for (const statement of plan.functions) actions.push({
+		kind: "create-function",
+		target: functionTarget(statement),
+		sql: statement
+	});
 	const created = /* @__PURE__ */ new Set();
-	for (const collection of collections) {
-		const key = qualified(collection);
-		if (existing.tables.has(key) || created.has(key)) continue;
-		created.add(key);
-		const schema = schemaOf(collection);
-		const table = tableOf(collection);
-		const idEntry = Object.entries(collection.properties ?? {}).find(([n, p]) => isIdProperty(n, p, collection));
-		const idName = idEntry ? resolveColumnName(idEntry[0], idEntry[1]) : "id";
-		const idProp = idEntry?.[1];
-		const idType = idProp ? getSqlColumnType(idEntry[0], idProp, collection, collections) : "TEXT";
-		let idDef = `"${assertSafeIdentifier(idName, "column name")}" ${idType} PRIMARY KEY`;
-		if (idProp?.type === "string" && idProp.isId === "uuid") idDef += " DEFAULT gen_random_uuid()";
+	for (const table of collectionTables) {
+		if (existing.tables.has(table.qualified) || created.has(table.qualified)) continue;
+		created.add(table.qualified);
+		const schema = assertSafeIdentifier(table.schema, "schema name");
+		const name = assertSafeIdentifier(table.table, "table name");
+		const id = table.columns.find((c) => c.primaryKey);
+		const definition = id ? `"${assertSafeIdentifier(id.column, "column name")}" ${renderColumnDefinition(id)}` : "\"id\" TEXT PRIMARY KEY";
 		actions.push({
 			kind: "create-table",
-			target: key,
-			sql: `CREATE TABLE IF NOT EXISTS "${schema}"."${table}" (${idDef});`
+			target: table.qualified,
+			sql: `CREATE TABLE IF NOT EXISTS "${schema}"."${name}" (${definition});`
 		});
 	}
-	const junctions = planJunctionTables(collections);
-	for (const junction of junctions) {
-		const key = `${junction.schema}.${junction.table}`;
-		if (existing.tables.has(key) || created.has(key)) continue;
-		created.add(key);
+	for (const table of junctionTables) {
+		if (existing.tables.has(table.qualified) || created.has(table.qualified)) continue;
+		created.add(table.qualified);
+		const columns = table.columns.map((c) => `"${c.column}" ${renderColumnDefinition(c)}`).join(", ");
 		actions.push({
 			kind: "create-table",
-			target: key,
-			sql: junction.createTable
+			target: table.qualified,
+			sql: `CREATE TABLE IF NOT EXISTS "${table.schema}"."${table.table}" (${columns}, PRIMARY KEY (${table.primaryKey.map((c) => `"${c}"`).join(", ")}));`
 		});
 	}
-	const legacyForeignKeys = [];
+	const addColumn = (table, column, definition) => {
+		if (existing.tables.get(table.qualified)?.has(column)) return;
+		assertSafeIdentifier(column, "column name");
+		actions.push({
+			kind: "add-column",
+			target: `${table.qualified}.${column}`,
+			sql: `ALTER TABLE "${table.schema}"."${table.table}" ADD COLUMN IF NOT EXISTS "${column}" ${definition};`
+		});
+	};
 	/**
-	* Move a relation column that is only missing because it was renamed.
+	* Move a column that is only missing because it was renamed.
 	*
 	* Returns true when it handled the column, so the caller skips the ordinary
-	* ADD. Adding here would be the wrong move and a quiet one: the data is in
-	* the old column, `ADD COLUMN` creates the new one empty beside it, every
+	* ADD. Adding would be the wrong move and a quiet one: the data is in the
+	* old column, `ADD COLUMN` creates the new one empty beside it, every
 	* statement succeeds, and the relation reads the empty one. A rename is
 	* metadata-only in Postgres, keeps the values, and carries the column's
 	* indexes and constraints with it.
-	*
-	* Only ever reached when the new name is absent and the old name is
-	* present, so there is nothing to overwrite and nothing to choose between.
 	*/
-	const renameLegacyColumn = (key, schema, table, column, legacyName) => {
-		const present = existing.tables.get(key);
-		if (!legacyName || !present) return false;
-		if (present.has(column) || !present.has(legacyName)) return false;
+	const renameLegacyColumn = (table, column) => {
+		const present = existing.tables.get(table.qualified);
+		if (!column.legacyColumn || !present) return false;
+		if (present.has(column.column) || !present.has(column.legacyColumn)) return false;
 		legacyForeignKeys.push({
-			table: key,
-			expected: column,
-			legacy: legacyName
+			table: table.qualified,
+			expected: column.column,
+			legacy: column.legacyColumn
 		});
 		actions.push({
 			kind: "rename-column",
-			target: `${key}.${column}`,
-			sql: `ALTER TABLE "${schema}"."${table}" RENAME COLUMN "${legacyName}" TO "${column}";`
+			target: `${table.qualified}.${column.column}`,
+			sql: `ALTER TABLE "${table.schema}"."${table.table}" RENAME COLUMN "${column.legacyColumn}" TO "${column.column}";`
 		});
 		return true;
 	};
-	const addColumn = (key, schema, table, column, definition) => {
-		if (existing.tables.get(key)?.has(column)) return;
-		assertSafeIdentifier(column, "column name");
-		actions.push({
-			kind: "add-column",
-			target: `${key}.${column}`,
-			sql: `ALTER TABLE "${schema}"."${table}" ADD COLUMN IF NOT EXISTS "${column}" ${definition};`
+	/**
+	* A `NOT NULL` is safe exactly when it cannot fail against rows that are
+	* already there, and there are three ways to know that:
+	*
+	*  - the table is being created by this plan (no rows yet);
+	*  - the table exists and is empty;
+	*  - the column arrives with a DEFAULT, which Postgres backfills into every
+	*    existing row as part of ADD COLUMN.
+	*
+	* `populatedTables` absent means the caller does not know, and not knowing
+	* has to read as "assume rows" — the other direction emits a NOT NULL that
+	* is checked against live data and aborts the boot. Written as an explicit
+	* `!== undefined` because the optional-chain form quietly says *empty* when
+	* the fact is missing, which is the wrong way to be wrong.
+	*/
+	const tableIsEmpty = (table) => existing.populatedTables !== void 0 && existing.tables.has(table.qualified) && !existing.populatedTables.has(table.qualified);
+	/**
+	* Plan one column, with the constraints this database can safely take.
+	*
+	* The definition comes from the same renderer `schema.sql` uses, minus the
+	* constraints that are checked against live rows. That subtraction is the
+	* whole of what this path is allowed to decide for itself.
+	*/
+	const planColumn = (table, column) => {
+		const key = `${table.qualified}.${column.column}`;
+		const columnExists = existing.tables.get(table.qualified)?.has(column.column) === true;
+		const fresh = created.has(table.qualified);
+		const empty = tableIsEmpty(table);
+		const required = !column.nullable;
+		const hasDefault = column.default !== void 0;
+		const declaredType = renderPgType(column.type);
+		const actualType = existing.columnTypes?.get(key);
+		if (columnExists && !column.sqlDefinition && actualType && !typesAgree(declaredType, actualType)) columnTypeDrift.push({
+			table: table.qualified,
+			column: column.column,
+			declared: declaredType,
+			actual: actualType
 		});
-	};
-	for (const collection of collections) {
-		const key = qualified(collection);
-		const schema = schemaOf(collection);
-		const table = tableOf(collection);
-		const fresh = created.has(key);
-		const auth = isAuthCollection(collection);
-		for (const [propName, prop] of Object.entries(collection.properties ?? {})) {
-			const p = prop;
-			if (isIdProperty(propName, p, collection)) continue;
-			if (p.type === "reference" || p.type === "relation") continue;
-			const column = resolveColumnName(propName, p);
-			const authDefinition = auth ? authUsersColumnDefinition(column) : void 0;
-			if (authDefinition) {
-				addColumn(key, schema, table, column, authDefinition);
-				continue;
-			}
-			const declaredType = getSqlColumnType(propName, p, collection, collections);
-			let definition = declaredType;
-			if (fresh && p.validation?.unique) definition += " UNIQUE";
-			const autoValue = p.autoValue;
-			const hasDefault = p.type === "date" && (autoValue === "on_create" || autoValue === "on_update");
-			if (hasDefault) definition += " DEFAULT now()";
-			const required = p.validation?.required === true;
-			const columnKey = `${key}.${column}`;
-			const columnExists = existing.tables.get(key)?.has(column) === true;
-			const actualType = existing.columnTypes?.get(columnKey);
-			if (columnExists && actualType && !typesAgree(declaredType, actualType)) columnTypeDrift.push({
-				table: key,
-				column,
-				declared: declaredType,
-				actual: actualType
-			});
-			const tableIsEmpty = existing.populatedTables !== void 0 && existing.tables.has(key) && !existing.populatedTables.has(key);
-			const notNullIsSafe = fresh || tableIsEmpty || hasDefault;
-			if (required && !columnExists) if (notNullIsSafe) definition += " NOT NULL";
-			else withheldConstraints.push({
-				target: columnKey,
-				kind: "not-null",
-				reason: `"${column}" is required, but "${key}" already holds rows and the column has no default to backfill them with, so NOT NULL would be checked against data that does not have a value yet.`,
-				remedy: "Backfill the column, then add the constraint — or give the property a default so every existing row gets one."
+		const notNullIsSafe = fresh || empty || hasDefault;
+		const applicable = {
+			...column,
+			unique: column.unique && fresh,
+			nullable: column.nullable || !(notNullIsSafe || columnExists)
+		};
+		if (required && !columnExists && !notNullIsSafe) withheldConstraints.push({
+			target: key,
+			kind: "not-null",
+			reason: column.source.kind === "relation" || column.source.kind === "reference" ? `"${column.column}" is a required link, but "${table.qualified}" already holds rows and the column has no default to backfill them with, so NOT NULL would be checked against data that does not have a value yet.` : `"${column.column}" is required, but "${table.qualified}" already holds rows and the column has no default to backfill them with, so NOT NULL would be checked against data that does not have a value yet.`,
+			remedy: column.source.kind === "relation" || column.source.kind === "reference" ? "Backfill the column, then add the constraint — or make the relation optional." : "Backfill the column, then add the constraint — or give the property a default so every existing row gets one."
+		});
+		addColumn(table, column.column, renderColumnDefinition(applicable));
+		if (!columnExists) return;
+		if (column.default && column.default.kind !== "identity" && !column.generated) {
+			const expression = column.default.kind === "sql" ? column.default.expression : column.default.sql;
+			if (!existing.columnDefaults?.has(key)) actions.push({
+				kind: "set-default",
+				target: key,
+				sql: `ALTER TABLE "${table.schema}"."${table.table}" ALTER COLUMN "${column.column}" SET DEFAULT ${expression};`
 			});
-			addColumn(key, schema, table, column, definition);
-			if (columnExists && constraintPolicy === "converge") {
-				const isNotNull = existing.notNullColumns?.has(columnKey) === true;
-				if (required && !isNotNull) if (tableIsEmpty) actions.push({
-					kind: "set-not-null",
-					target: columnKey,
-					sql: `ALTER TABLE "${schema}"."${table}" ALTER COLUMN "${column}" SET NOT NULL;`
-				});
-				else withheldConstraints.push({
-					target: columnKey,
-					kind: "not-null",
-					reason: `"${column}" became required, but "${key}" holds rows and any of them with no value would make SET NOT NULL fail.`,
-					remedy: "Backfill the column first — `UPDATE … SET \"" + column + "\" = … WHERE \"" + column + "\" IS NULL` — then apply this again."
-				});
-				if (!required && isNotNull) actions.push({
-					kind: "drop-not-null",
-					target: columnKey,
-					sql: `ALTER TABLE "${schema}"."${table}" ALTER COLUMN "${column}" DROP NOT NULL;`
-				});
-			}
 		}
-		if (auth) {
-			const declared = new Set(Object.entries(collection.properties ?? {}).map(([name, prop]) => resolveColumnName(name, prop)));
-			for (const spec of AUTH_USERS_COLUMNS) {
-				if (declared.has(spec.column)) continue;
-				addColumn(key, schema, table, spec.column, authUsersColumnSql(spec));
-			}
+		if (constraintPolicy !== "converge") return;
+		const isNotNull = existing.notNullColumns?.has(key) === true;
+		if (required && !isNotNull) if (empty) actions.push({
+			kind: "set-not-null",
+			target: key,
+			sql: `ALTER TABLE "${table.schema}"."${table.table}" ALTER COLUMN "${column.column}" SET NOT NULL;`
+		});
+		else withheldConstraints.push({
+			target: key,
+			kind: "not-null",
+			reason: `"${column.column}" became required, but "${table.qualified}" holds rows and any of them with no value would make SET NOT NULL fail.`,
+			remedy: "Backfill the column first — `UPDATE … SET \"" + column.column + "\" = … WHERE \"" + column.column + "\" IS NULL` — then apply this again."
+		});
+		if (!required && isNotNull) actions.push({
+			kind: "drop-not-null",
+			target: key,
+			sql: `ALTER TABLE "${table.schema}"."${table.table}" ALTER COLUMN "${column.column}" DROP NOT NULL;`
+		});
+	};
+	for (const table of collectionTables) {
+		assertSafeIdentifier(table.schema, "schema name");
+		assertSafeIdentifier(table.table, "table name");
+		for (const column of table.columns) {
+			if (!isScalarProperty(column)) continue;
+			planColumn(table, column);
+		}
+		for (const column of table.columns) {
+			if (column.source.kind !== "auth") continue;
+			addColumn(table, column.column, renderColumnDefinition(column));
 		}
 	}
-	const searchDrift = [];
-	const searchAdopted = [];
-	for (const spec of searchSpecs) {
-		const key = `${spec.schema}.${spec.table}`;
-		const definitions = { [spec.column]: `tsvector GENERATED ALWAYS AS (${spec.expression}) STORED` };
-		if (spec.fuzzy) definitions[spec.fuzzy.column] = `text GENERATED ALWAYS AS (${spec.fuzzy.expression}) STORED`;
-		for (const stamp of searchColumnStamps(spec)) {
-			const definition = definitions[stamp.column];
-			const exists = existing.tables.get(key)?.has(stamp.column) === true;
-			const recorded = existing.columnComments?.get(`${key}.${stamp.column}`);
+	for (const table of collectionTables) {
+		if (!table.search) continue;
+		const definitions = new Map(table.columns.filter((c) => c.source.kind === "search").map((c) => [c.column, renderColumnDefinition(c)]));
+		for (const stamp of searchColumnStamps(table.search)) {
+			const definition = definitions.get(stamp.column);
+			const exists = existing.tables.get(table.qualified)?.has(stamp.column) === true;
+			const recorded = existing.columnComments?.get(`${table.qualified}.${stamp.column}`);
 			if (exists && recorded?.startsWith("rebase:search:v1:") && recorded !== stamp.fingerprint) {
 				searchDrift.push({
-					table: key,
+					table: table.qualified,
 					column: stamp.column,
 					found: recorded,
 					expected: stamp.fingerprint,
 					rebuild: [
-						`ALTER TABLE "${spec.schema}"."${spec.table}" DROP COLUMN "${stamp.column}";`,
-						`ALTER TABLE "${spec.schema}"."${spec.table}" ADD COLUMN "${stamp.column}" ${definition};`,
+						`ALTER TABLE "${table.schema}"."${table.table}" DROP COLUMN "${stamp.column}";`,
+						`ALTER TABLE "${table.schema}"."${table.table}" ADD COLUMN "${stamp.column}" ${definition};`,
 						stamp.sql
 					]
 				});
 				continue;
 			}
-			addColumn(key, spec.schema, spec.table, stamp.column, definition);
+			addColumn(table, stamp.column, definition);
 			if (exists && recorded === void 0) searchAdopted.push({
-				table: key,
+				table: table.qualified,
 				column: stamp.column
 			});
 			if (recorded !== stamp.fingerprint) actions.push({
 				kind: "comment-column",
-				target: `${key}.${stamp.column}`,
+				target: `${table.qualified}.${stamp.column}`,
 				sql: stamp.sql
 			});
 		}
 	}
-	for (const junction of junctions) {
-		const key = `${junction.schema}.${junction.table}`;
-		if (created.has(key)) continue;
-		for (const column of junction.columns) {
-			if (renameLegacyColumn(key, junction.schema, junction.table, column.name, column.legacyName)) continue;
-			addColumn(key, junction.schema, junction.table, column.name, column.type);
+	for (const table of junctionTables) {
+		if (created.has(table.qualified)) continue;
+		for (const column of table.columns) {
+			if (renameLegacyColumn(table, column)) continue;
+			if (column.source.kind === "property") {
+				planColumn(table, column);
+				continue;
+			}
+			addColumn(table, column.column, renderPgType(column.type));
 		}
 	}
-	const plannedRelationColumns = /* @__PURE__ */ new Map();
-	for (const relational of planRelationalColumns(collections)) {
-		const relKey = `${relational.schema}.${relational.table}`;
-		if (!plannedRelationColumns.has(relKey)) plannedRelationColumns.set(relKey, /* @__PURE__ */ new Set());
-		plannedRelationColumns.get(relKey).add(relational.column);
-		if (relational.legacyColumn) plannedRelationColumns.get(relKey).add(relational.legacyColumn);
-		if (renameLegacyColumn(relKey, relational.schema, relational.table, relational.column, relational.legacyColumn)) continue;
-		addColumn(relKey, relational.schema, relational.table, relational.column, relational.type);
+	for (const table of collectionTables) for (const column of table.columns) {
+		if (column.source.kind !== "relation" && column.source.kind !== "reference") continue;
+		if (column.columnOwnedByProperty) continue;
+		if (renameLegacyColumn(table, column)) continue;
+		planColumn(table, column);
 	}
 	const knownConstraints = existing.constraints ?? /* @__PURE__ */ new Set();
 	const plannedConstraints = /* @__PURE__ */ new Set();
-	const foreignKeys = [...planRelationalColumns(collections).map((r) => r.foreignKey), ...junctions.flatMap((j) => j.foreignKeys)];
-	for (const fk of foreignKeys) {
+	for (const table of [...collectionTables, ...junctionTables]) for (const column of table.columns) {
+		const fk = column.foreignKey;
 		if (!fk) continue;
 		const name = `${fk.schema}.${fk.table}.${fk.constraintName}`;
 		if (knownConstraints.has(name) || plannedConstraints.has(name)) continue;
 		plannedConstraints.add(name);
 		actions.push({
 			kind: "add-constraint",
-			target: `${fk.schema}.${fk.table}.${fk.constraintName}`,
-			sql: fk.sql
+			target: name,
+			sql: `${fk.sql};`
+		});
+	}
+	const concurrent = (schema, table) => !created.has(`${schema}.${table}`);
+	for (const table of collectionTables) {
+		if (!table.search) continue;
+		for (const statement of searchIndexStatements(table.search)) actions.push({
+			kind: "create-index",
+			target: table.qualified,
+			sql: concurrent(table.schema, table.table) ? statement.replace("CREATE INDEX IF NOT EXISTS", "CREATE INDEX CONCURRENTLY IF NOT EXISTS") : statement
 		});
 	}
-	const concurrentIndexing = (schema, table) => !created.has(`${schema}.${table}`);
-	for (const spec of searchSpecs) for (const statement of searchIndexStatements(spec)) actions.push({
-		kind: "create-index",
-		target: `${spec.schema}.${spec.table}`,
-		sql: concurrentIndexing(spec.schema, spec.table) ? statement.replace("CREATE INDEX IF NOT EXISTS", "CREATE INDEX CONCURRENTLY IF NOT EXISTS") : statement
-	});
 	const vectorIndexSkipped = [];
-	for (const collection of collections) {
-		const plan = buildVectorIndexPlan(collection, resolveColumnName);
-		for (const spec of plan.specs) actions.push({
+	for (const table of collectionTables) {
+		if (!table.vector) continue;
+		for (const spec of table.vector.specs) actions.push({
 			kind: "create-index",
 			target: `${spec.schema}.${spec.table}`,
-			sql: concurrentIndexing(spec.schema, spec.table) ? vectorIndexStatement(spec).replace("CREATE INDEX IF NOT EXISTS", "CREATE INDEX CONCURRENTLY IF NOT EXISTS") : vectorIndexStatement(spec)
+			sql: concurrent(spec.schema, spec.table) ? vectorIndexStatement(spec).replace("CREATE INDEX IF NOT EXISTS", "CREATE INDEX CONCURRENTLY IF NOT EXISTS") : vectorIndexStatement(spec)
 		});
-		vectorIndexSkipped.push(...plan.skipped);
+		vectorIndexSkipped.push(...table.vector.skipped);
 	}
-	for (const spec of buildCollectionIndexPlan(collections, resolveColumnName)) actions.push({
+	for (const spec of sortIndexSpecs(collectionTables.flatMap((t) => t.indexes))) actions.push({
 		kind: "create-index",
 		target: `${spec.schema}.${spec.table}`,
 		sql: collectionIndexStatement(spec, {
-			concurrently: concurrentIndexing(spec.schema, spec.table),
+			concurrently: concurrent(spec.schema, spec.table),
 			ifNotExists: true
 		})
 	});
+	for (const table of collectionTables) for (const trigger of table.triggers) {
+		if (existing.triggers?.has(`${table.qualified}.${trigger.name}`)) continue;
+		for (const statement of triggerStatements(trigger)) actions.push({
+			kind: "create-trigger",
+			target: `${table.qualified}.${trigger.name}`,
+			sql: statement
+		});
+	}
 	const orphanedRequiredColumns = [];
-	if (existing.notNullColumns && existing.columnDefaults) for (const collection of collections) {
-		const key = qualified(collection);
-		const live = existing.tables.get(key);
-		if (!live || created.has(key)) continue;
+	if (existing.notNullColumns && existing.columnDefaults) for (const table of collectionTables) {
+		const live = existing.tables.get(table.qualified);
+		if (!live || created.has(table.qualified)) continue;
 		const declared = /* @__PURE__ */ new Set();
-		for (const [propName, prop] of Object.entries(collection.properties ?? {})) declared.add(resolveColumnName(propName, prop));
-		for (const column of plannedRelationColumns.get(key) ?? []) declared.add(column);
+		for (const column of table.columns) {
+			declared.add(column.column);
+			if (column.legacyColumn) declared.add(column.legacyColumn);
+		}
 		for (const column of live) {
-			const columnKey = `${key}.${column}`;
+			const key = `${table.qualified}.${column}`;
 			if (declared.has(column)) continue;
-			if (!existing.notNullColumns.has(columnKey)) continue;
-			if (existing.columnDefaults.has(columnKey)) continue;
+			if (!existing.notNullColumns.has(key)) continue;
+			if (existing.columnDefaults.has(key)) continue;
 			orphanedRequiredColumns.push({
-				table: key,
+				table: table.qualified,
 				column,
-				slug: collection.slug
+				slug: table.slug
 			});
 		}
 	}
@@ -531,6 +470,62 @@ function planCollectionSchemaEnsure(allCollections, existing, options = {}) {
 		orphanedRequiredColumns
 	};
 }
+/** What a `CREATE FUNCTION` statement is called, for the action log. */
+var functionTarget = (statement) => {
+	if (statement.includes("set_updated_at")) return SET_UPDATED_AT_FN;
+	return statement.includes("unaccent") ? SEARCH_UNACCENT_FN : SEARCH_TEXT_FN;
+};
+//#endregion
+//#region src/schema/ensure-collection-tables.ts
+/**
+* Applying a schema plan to a database that is already running.
+*
+* ## What this module is
+*
+* A managed runtime boots someone else's compiled project against a database it
+* has never seen. Auth tables are ensured at boot already, but collection tables
+* were not created by anything: the platform ran the app and every `/api/data/*`
+* request answered 500 on a missing relation. `rebase db push` cannot help — it
+* is an Atlas-driven CLI command, and the runtime image ships no CLI.
+*
+* Two halves, and only one of them is here. *What the collections ask for* is
+* `schema/plan/plan-schema.ts`, shared with `db push` and the generated Drizzle
+* file; *what the database already has, and which of those statements are safe
+* to run against it* is `schema/plan/diff-plan.ts`. This module reads the
+* catalogue, runs the statements, and reports what happened.
+*
+* ## Why additive-only, forever
+*
+* This runs unattended, against a database with customers' data in it, with no
+* human reading a diff. So it may only ever do things that cannot lose data.
+* See `diff-plan.ts` for the whole of that argument.
+*/
+var ensure_collection_tables_exports = /* @__PURE__ */ __exportAll({
+	describeDriverError: () => describeDriverError,
+	ensureCollectionTables: () => ensureCollectionTables,
+	planCollectionSchemaEnsure: () => planCollectionSchemaEnsure,
+	readExistingSchema: () => readExistingSchema,
+	readSchemaFactsFor: () => readSchemaFactsFor
+});
+/** The schema a collection lives in, validated before it reaches any DDL. */
+function schemaOf(collection) {
+	return assertSafeIdentifier(collection.schema || "public", "schema name");
+}
+/**
+* Decide what to add. Pure — the caller supplies what exists and runs the
+* result.
+*
+* A plan and a diff: the collections are read once, by `planSchema`, into the
+* same {@link SchemaPlan} `db push` renders `schema.sql` from, and the diff
+* subtracts what the database already has. Before that split this function had
+* its own reading of every `Property`, and the audit found twelve places where
+* it disagreed with the two generators — a required `author_id` that was
+* NOT NULL after a push and nullable after a boot among them, on the one path
+* with no developer in the loop.
+*/
+function planCollectionSchemaEnsure(allCollections, existing, options = {}) {
+	return diffPlanAgainstCatalogue(planSchema(allCollections, { databaseExtensions: options.databaseExtensions }), existing, { constraints: options.constraints });
+}
 /** Read what the database has, for the schemas the collections live in. */
 async function readExistingSchema(client, schemas) {
 	const tables = /* @__PURE__ */ new Map();
@@ -543,7 +538,8 @@ async function readExistingSchema(client, schemas) {
 	const notNullColumns = /* @__PURE__ */ new Set();
 	const columnTypes = /* @__PURE__ */ new Map();
 	const columnDefaults = /* @__PURE__ */ new Set();
-	const { rows: columns } = await client.query(`SELECT table_schema, table_name, column_name, is_nullable, udt_name, column_default
+	const { rows: columns } = await client.query(`SELECT table_schema, table_name, column_name, is_nullable, udt_name, column_default,
+                numeric_precision, numeric_scale
          FROM information_schema.columns
          WHERE table_schema IN (${inList})`);
 	for (const row of columns) {
@@ -551,9 +547,19 @@ async function readExistingSchema(client, schemas) {
 		if (!tables.has(key)) tables.set(key, /* @__PURE__ */ new Set());
 		tables.get(key).add(row.column_name);
 		if (row.is_nullable === "NO") notNullColumns.add(`${key}.${row.column_name}`);
-		if (row.udt_name) columnTypes.set(`${key}.${row.column_name}`, row.udt_name);
+		if (row.udt_name) {
+			const modifier = row.udt_name === "numeric" && row.numeric_precision !== null ? `(${row.numeric_precision},${row.numeric_scale ?? 0})` : "";
+			columnTypes.set(`${key}.${row.column_name}`, `${row.udt_name}${modifier}`);
+		}
 		if (row.column_default !== null) columnDefaults.add(`${key}.${row.column_name}`);
 	}
+	const triggers = /* @__PURE__ */ new Set();
+	const { rows: triggerRows } = await client.query(`SELECT n.nspname AS schema, c.relname AS table, t.tgname AS name
+         FROM pg_trigger t
+         JOIN pg_class c ON t.tgrelid = c.oid
+         JOIN pg_namespace n ON c.relnamespace = n.oid
+         WHERE NOT t.tgisinternal AND n.nspname IN (${inList})`);
+	for (const row of triggerRows) triggers.add(`${row.schema}.${row.table}.${row.name}`);
 	const populatedTables = /* @__PURE__ */ new Set();
 	const { rows: realTables } = await client.query(`SELECT n.nspname AS schema, c.relname AS name
          FROM pg_class c
@@ -612,7 +618,8 @@ async function readExistingSchema(client, schemas) {
 		notNullColumns,
 		populatedTables,
 		columnTypes,
-		columnDefaults
+		columnDefaults,
+		triggers
 	};
 }
 /**
@@ -648,15 +655,14 @@ async function readSchemaFactsFor(client, collections) {
 * The error is surfaced with the statement that caused it.
 */
 async function ensureCollectionTables(client, collections, log, options = {}) {
-	const schemas = Array.from(/* @__PURE__ */ new Set([...collections.map(schemaOf), ...planJunctionTables(collections).map((j) => j.schema)]));
-	for (const schema of schemas) {
-		assertSafeIdentifier(schema, "schema name");
-		if (schema !== "public") await client.query(`CREATE SCHEMA IF NOT EXISTS "${schema}";`);
+	const schema = planSchema(collections, { databaseExtensions: options.databaseExtensions ?? declaredDatabaseExtensions() });
+	const schemas = Array.from(new Set(schema.tables.map((table) => table.schema)));
+	for (const name of schemas) {
+		assertSafeIdentifier(name, "schema name");
+		if (name !== "public") await client.query(`CREATE SCHEMA IF NOT EXISTS "${name}";`);
 	}
-	const plan = planCollectionSchemaEnsure(collections, await readExistingSchema(client, schemas), {
-		...options,
-		databaseExtensions: options.databaseExtensions ?? declaredDatabaseExtensions()
-	});
+	if (schema.tables.some((table) => table.triggers.length > 0)) await client.query(`CREATE SCHEMA IF NOT EXISTS "${REBASE_SCHEMA}";`);
+	const plan = diffPlanAgainstCatalogue(schema, await readExistingSchema(client, schemas), { constraints: options.constraints });
 	const failures = [];
 	for (const legacy of plan.legacyForeignKeys) {
 		const message = `Renaming "${legacy.table}"."${legacy.legacy}" to "${legacy.expected}". The old name is the one Rebase derived for this relation before it singularized properly; the column keeps its data, indexes and constraints. To keep the old name instead, set \`localKey: "${legacy.legacy}"\` on the relation and this will stop.`;
@@ -817,4 +823,4 @@ async function applyAction(client, action) {
 //#endregion
 export { readSchemaFactsFor as a, readExistingSchema as i, ensure_collection_tables_exports as n, planCollectionSchemaEnsure as r, describeDriverError as t };
 
-//# sourceMappingURL=ensure-collection-tables-D4wJzM4y.js.map
+//# sourceMappingURL=ensure-collection-tables-Bkvehxdm.js.map