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

package/dist/ensure-collection-tables-BEEjn5cn.js

@@ -1,857 +0,0 @@
-import { createRequire as __createRequire } from "module";
-__createRequire(import.meta.url);
-import { r as __exportAll } from "./__vite-browser-external-BnuHet1e.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-C0fxM8dY.js";
-import { d as extractPgError, u as extractCauseMessage } from "./cli-errors-B8qHg02P.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-Bt2d2mRH.js";
-import { v as quoteRelation } from "./introspect-db-logic-WMuAfxvw.js";
-import { isConcurrentDdlRace, isDuplicateObjectRace, logger } from "@rebasepro/server";
-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.
-*
-* Keyed by every spelling either side can produce: `information_schema` reports
-* `udt_name` (`int4`, `_numeric`, `bpchar`), while the generators emit SQL
-* (`INTEGER`, `NUMERIC[]`, `CHAR(3)`). Both are normalised through here.
-*/
-var FAMILIES = {
-	int2: "number",
-	smallint: "number",
-	int4: "number",
-	int: "number",
-	integer: "number",
-	int8: "number",
-	bigint: "number",
-	numeric: "number",
-	decimal: "number",
-	float4: "number",
-	real: "number",
-	float8: "number",
-	"double precision": "number",
-	money: "number",
-	text: "text",
-	varchar: "text",
-	"character varying": "text",
-	bpchar: "text",
-	char: "text",
-	character: "text",
-	citext: "text",
-	bool: "boolean",
-	boolean: "boolean",
-	json: "json",
-	jsonb: "jsonb",
-	uuid: "uuid",
-	bytea: "bytea",
-	date: "date",
-	time: "time",
-	"time without time zone": "time",
-	timetz: "time",
-	"time with time zone": "time",
-	timestamp: "timestamp",
-	"timestamp without time zone": "timestamp",
-	timestamptz: "timestamptz",
-	"timestamp with time zone": "timestamptz",
-	interval: "interval",
-	tsvector: "tsvector",
-	vector: "vector",
-	halfvec: "halfvec",
-	sparsevec: "sparsevec"
-};
-/**
-* One SQL or `udt_name` spelling reduced to its family, or `null` when this
-* module has no opinion about it.
-*
-* `null` is not a failure. It is the answer for an enum type, a domain, a
-* PostGIS column, a quoted qualified name — everything whose identity is a
-* *name* rather than a shape, where two spellings being different says nothing
-* about whether the values are compatible.
-*/
-function typeFamily(raw) {
-	if (!raw) return null;
-	let type = raw.trim().toLowerCase();
-	if (!type) return null;
-	if (type.startsWith("\"")) return null;
-	const generated = type.indexOf(" generated ");
-	if (generated > 0) type = type.slice(0, generated).trim();
-	if (type.endsWith("[]")) {
-		const element = typeFamily(type.slice(0, -2));
-		return element && `array:${element}`;
-	}
-	if (type.startsWith("_")) {
-		const element = typeFamily(type.slice(1));
-		return element && `array:${element}`;
-	}
-	const paren = type.indexOf("(");
-	if (paren > 0) type = type.slice(0, paren).trim();
-	return FAMILIES[type] ?? null;
-}
-/**
-* Do these two spellings describe columns that hold the same kind of value?
-*
-* `true` whenever the answer is not confidently "no" — an unrecognised type on
-* either side agrees with everything, because a report needs evidence and an
-* unknown type is the absence of it.
-*/
-function typesAgree(declared, actual) {
-	const a = typeFamily(declared);
-	const b = typeFamily(actual);
-	if (a === null || b === null) return true;
-	if (a !== b) return false;
-	if (!isNumeric(declared) || !isNumeric(actual)) return true;
-	const declaredModifier = numericModifier(declared);
-	if (declaredModifier === null) return true;
-	return declaredModifier === numericModifier(actual);
-}
-/** `NUMERIC`, `numeric(10,2)`, `DECIMAL(10, 2)` — the arbitrary-precision type itself. */
-function isNumeric(raw) {
-	return /^\s*(?:numeric|decimal)\s*(?:\(|$)/i.test(raw);
-}
-/**
-* `numeric(10,2)` / `NUMERIC(10, 2)` → `10,2`; a bare `numeric` → `null`. A
-* precision alone means a scale of 0, which is how the catalogue reports it:
-* `NUMERIC(10)` → `10,0`.
-*/
-function numericModifier(raw) {
-	const match = raw.match(/\(([^)]*)\)/);
-	if (!match) return null;
-	const [precision, scale = "0"] = match[1].split(",").map((part) => part.trim());
-	return `${precision},${scale}`;
-}
-/**
-* The sentence a boot log says about one drifted column.
-*
-* Written to be actionable in the place it is read, which is a runtime log with
-* no way to run a migration from it: it names both types, says which surface
-* will break first, and gives the statement that resolves it.
-*/
-function columnTypeDriftMessage(drift) {
-	const [schema, table] = drift.table.split(".");
-	return `Column "${drift.table}"."${drift.column}" is ${drift.actual} in the database, but this collection declares ${drift.declared}. Boot does not change an existing column's type, so the database keeps what it has and writes that match the declaration will be rejected by Postgres. Change it deliberately, when you can watch it:
-    ALTER TABLE "${schema}"."${table}" ALTER COLUMN "${drift.column}" TYPE ${drift.declared} USING "${drift.column}"::${drift.declared};`;
-}
-//#endregion
-//#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_$]*$/;
-/**
-* 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
-* concatenated on trust, and quoting is not escaping. A table named
-* `x" (id int); DROP TABLE users; --` closes the quote and the statement, and
-* the whole thing runs on the owner connection, which is the one connection in
-* the system that is exempt from every RLS policy.
-*
-* That is only a config file on a self-hosted project, where the person writing
-* it could run the SQL directly anyway. It is not only a config file where a
-* collection can be defined over the wire — the live-schema and source editors
-* both do that — and there the caller is an admin on the app, not an operator
-* of the database.
-*/
-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;
-}
-/** 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 = [];
-	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: `${enumPlan.qualified}.${value}`,
-					sql: `ALTER TYPE "${enumPlan.schema}"."${enumPlan.name}" ADD VALUE IF NOT EXISTS ${quoteSqlLiteral(value)};`
-				});
-			}
-			continue;
-		}
-		actions.push({
-			kind: "create-enum",
-			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 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: table.qualified,
-			sql: `CREATE TABLE IF NOT EXISTS "${schema}"."${name}" (${definition});`
-		});
-	}
-	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: table.qualified,
-			sql: `CREATE TABLE IF NOT EXISTS "${table.schema}"."${table.table}" (${columns}, PRIMARY KEY (${table.primaryKey.map((c) => `"${c}"`).join(", ")}));`
-		});
-	}
-	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 column that is only missing because it was renamed.
-	*
-	* Returns true when it handled the column, so the caller skips the ordinary
-	* 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.
-	*/
-	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: table.qualified,
-			expected: column.column,
-			legacy: column.legacyColumn
-		});
-		actions.push({
-			kind: "rename-column",
-			target: `${table.qualified}.${column.column}`,
-			sql: `ALTER TABLE "${table.schema}"."${table.table}" RENAME COLUMN "${column.legacyColumn}" TO "${column.column}";`
-		});
-		return true;
-	};
-	/**
-	* 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);
-	/**
-	* The column is there and holds a different kind of value than the
-	* collection says it does. Reported, never altered: an unattended `ALTER
-	* COLUMN … TYPE` over customer data is not a thing to do quietly, and the
-	* *quiet* is what this fixes. A deploy that changed a `columnType` used to
-	* report success while the column stayed as it was, and the divergence
-	* surfaced later as every write failing. A column whose definition is owned
-	* elsewhere (auth, or a generated search column) is not compared: the
-	* declaration there is a rendered string rather than a type, and auth's own
-	* reconcile owns it.
-	*/
-	const reportTypeDrift = (table, column) => {
-		const key = `${table.qualified}.${column.column}`;
-		if (existing.tables.get(table.qualified)?.has(column.column) !== true || column.sqlDefinition) return;
-		const declaredType = renderPgType(column.type);
-		const actualType = existing.columnTypes?.get(key);
-		if (actualType && !typesAgree(declaredType, actualType)) columnTypeDrift.push({
-			table: table.qualified,
-			column: column.column,
-			declared: declaredType,
-			actual: actualType
-		});
-	};
-	/**
-	* 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;
-		reportTypeDrift(table, column);
-		const notNullIsSafe = fresh || empty || hasDefault;
-		const uniqueIsSafe = fresh || empty || !hasDefault;
-		const applicable = {
-			...column,
-			unique: column.unique && !columnExists && uniqueIsSafe,
-			nullable: column.nullable || !(notNullIsSafe || columnExists)
-		};
-		if (column.unique && !columnExists && !uniqueIsSafe) withheldConstraints.push({
-			target: key,
-			kind: "unique",
-			reason: `"${column.column}" is unique, but "${table.qualified}" ` + (existing.populatedTables === void 0 ? "may already hold rows" : "already holds rows") + " and the column's default would give every one of them the same value, so UNIQUE would fail as it was added.",
-			remedy: `Give each existing row its own value, then add the constraint — \`ALTER TABLE "${table.schema}"."${table.table}" ADD UNIQUE ("${column.column}")\` — or drop the property's default.`
-		});
-		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};`
-			});
-		}
-		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));
-		}
-	}
-	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: table.qualified,
-					column: stamp.column,
-					found: recorded,
-					expected: stamp.fingerprint,
-					rebuild: [
-						`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(table, stamp.column, definition);
-			if (exists && recorded === void 0) searchAdopted.push({
-				table: table.qualified,
-				column: stamp.column
-			});
-			if (recorded !== stamp.fingerprint) actions.push({
-				kind: "comment-column",
-				target: `${table.qualified}.${stamp.column}`,
-				sql: stamp.sql
-			});
-		}
-	}
-	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;
-			}
-			reportTypeDrift(table, column);
-			addColumn(table, column.column, renderPgType(column.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();
-	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: 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 vectorIndexSkipped = [];
-	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: concurrent(spec.schema, spec.table) ? vectorIndexStatement(spec).replace("CREATE INDEX IF NOT EXISTS", "CREATE INDEX CONCURRENTLY IF NOT EXISTS") : vectorIndexStatement(spec)
-		});
-		vectorIndexSkipped.push(...table.vector.skipped);
-	}
-	for (const spec of sortIndexSpecs(collectionTables.flatMap((t) => t.indexes))) actions.push({
-		kind: "create-index",
-		target: `${spec.schema}.${spec.table}`,
-		sql: collectionIndexStatement(spec, {
-			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 table of collectionTables) {
-		const live = existing.tables.get(table.qualified);
-		if (!live || created.has(table.qualified)) continue;
-		const declared = /* @__PURE__ */ new Set();
-		for (const column of table.columns) {
-			declared.add(column.column);
-			if (column.legacyColumn) declared.add(column.legacyColumn);
-		}
-		for (const column of live) {
-			const key = `${table.qualified}.${column}`;
-			if (declared.has(column)) continue;
-			if (!existing.notNullColumns.has(key)) continue;
-			if (existing.columnDefaults.has(key)) continue;
-			orphanedRequiredColumns.push({
-				table: table.qualified,
-				column,
-				slug: table.slug
-			});
-		}
-	}
-	return {
-		actions,
-		statements: actions.map((a) => a.sql),
-		legacyForeignKeys,
-		searchDrift,
-		searchAdopted,
-		vectorIndexSkipped,
-		withheldConstraints,
-		columnTypeDrift,
-		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();
-	const enums = /* @__PURE__ */ new Set();
-	if (schemas.length === 0) return {
-		tables,
-		enums
-	};
-	const inList = schemas.map((schema) => `'${assertSafeIdentifier(schema, "schema name")}'`).join(", ");
-	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,
-                numeric_precision, numeric_scale
-         FROM information_schema.columns
-         WHERE table_schema IN (${inList})`);
-	for (const row of columns) {
-		const key = `${row.table_schema}.${row.table_name}`;
-		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) {
-			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
-         JOIN pg_namespace n ON c.relnamespace = n.oid
-         WHERE c.relkind IN ('r', 'p') AND n.nspname IN (${inList})`);
-	if (realTables.length > 0) {
-		const probes = realTables.map((row) => `SELECT ${quoteSqlLiteral(`${row.schema}.${row.name}`)} AS key, EXISTS(SELECT 1 FROM ${quoteRelation(row.schema, row.name)} LIMIT 1) AS populated`);
-		const { rows: populationRows } = await client.query(probes.join(" UNION ALL "));
-		for (const row of populationRows) if (row.populated) populatedTables.add(row.key);
-	}
-	const enumValues = /* @__PURE__ */ new Map();
-	const { rows: enumValueRows } = await client.query(`SELECT n.nspname AS schema, t.typname AS name, e.enumlabel AS value
-         FROM pg_enum e
-         JOIN pg_type t ON e.enumtypid = t.oid
-         JOIN pg_namespace n ON t.typnamespace = n.oid
-         WHERE n.nspname IN (${inList})
-         ORDER BY t.typname, e.enumsortorder`);
-	for (const row of enumValueRows) {
-		const key = `${row.schema}.${row.name}`;
-		if (!enumValues.has(key)) enumValues.set(key, []);
-		enumValues.get(key).push(row.value);
-	}
-	const { rows: enumRows } = await client.query(`SELECT n.nspname AS schema, t.typname AS name
-         FROM pg_type t
-         JOIN pg_namespace n ON t.typnamespace = n.oid
-         WHERE t.typtype = 'e' AND n.nspname IN (${inList})`);
-	for (const row of enumRows) enums.add(`${row.schema}.${row.name}`);
-	const constraints = /* @__PURE__ */ new Set();
-	const { rows: constraintRows } = await client.query(`SELECT n.nspname AS schema, c.relname AS table, con.conname AS name
-         FROM pg_constraint con
-         JOIN pg_class c ON con.conrelid = c.oid
-         JOIN pg_namespace n ON c.relnamespace = n.oid
-         WHERE n.nspname IN (${inList})`);
-	for (const row of constraintRows) constraints.add(`${row.schema}.${row.table}.${row.name}`);
-	const columnComments = /* @__PURE__ */ new Map();
-	const { rows: commentRows } = await client.query(`SELECT n.nspname AS schema, c.relname AS table, a.attname AS column, d.description AS comment
-         FROM pg_description d
-         JOIN pg_class c ON d.objoid = c.oid
-         JOIN pg_namespace n ON c.relnamespace = n.oid
-         JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = d.objsubid
-         WHERE d.objsubid > 0 AND n.nspname IN (${inList})`);
-	for (const row of commentRows) {
-		if (row.comment == null) continue;
-		columnComments.set(`${row.schema}.${row.table}.${row.column}`, row.comment);
-	}
-	return {
-		tables,
-		enums,
-		constraints,
-		columnComments,
-		enumValues,
-		notNullColumns,
-		populatedTables,
-		columnTypes,
-		columnDefaults,
-		triggers
-	};
-}
-/**
-* What to tell an operator whose `search` block no longer matches its column.
-*
-* Every line here is doing work: naming the collection is not enough, because
-* the symptom (a search that finds nothing) points at the data, not the schema;
-* and the remediation has to be exact, because it is a table rewrite the
-* operator is being asked to schedule rather than discover.
-*/
-function searchDriftMessage(drift) {
-	return "The `search` block changed after its generated column was created, and Postgres cannot alter a generated expression in place.\nRebase will not rebuild it for you: dropping and re-adding a STORED generated column rewrites the whole table under an ACCESS EXCLUSIVE lock and rebuilds its GIN index, which is an outage this unattended path may not schedule on your behalf.\nUntil it is rebuilt the column keeps indexing the previous fields, weights and language — searches for anything added since return nothing, which reads from outside as \"no such row\".\nRun these (or revert the block to what the column was built from), then boot again:\n" + drift.map((d) => `  "${d.table}"."${d.column}" was generated from a different \`search\` block (recorded ${d.found}, current ${d.expected}).\n` + d.rebuild.map((s) => `      ${s}`).join("\n")).join("\n") + "\n  The GIN index is dropped with the column and recreated concurrently on the next boot.";
-}
-/**
-* Read what the database looks like, for the schemas a set of collections
-* lives in.
-*
-* The same read `ensureCollectionTables` does at boot, exposed on its own for
-* the callers that want to *plan* against a real database without changing it —
-* the live schema editor, which has to tell somebody what a change would do
-* before they agree to it.
-*/
-async function readSchemaFactsFor(client, collections) {
-	const relational = relationalCollections(collections);
-	return readExistingSchema(client, Array.from(/* @__PURE__ */ new Set([...relational.map(schemaOf), ...planJunctionTables(relational).map((junction) => junction.schema)])));
-}
-/**
-* Bring the database up to date. Returns what it did.
-*
-* Each statement runs on its own rather than in one transaction: they are all
-* independently safe and idempotent, and a single failure (an enum label that
-* cannot be added, say) should not roll back the tables that were created fine.
-* The error is surfaced with the statement that caused it.
-*/
-async function ensureCollectionTables(client, collections, log, options = {}) {
-	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}";`);
-	}
-	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.`;
-		logger.info(`[schema] ${message}`);
-		log?.(message);
-	}
-	if (plan.searchDrift.length > 0) throw new Error(searchDriftMessage(plan.searchDrift));
-	for (const adopted of plan.searchAdopted) {
-		const message = `Adopting the existing generated column "${adopted.table}"."${adopted.column}" and recording what the current \`search\` block would generate. Any later change to that block will be detected and refused; a change made *before* this version was deployed cannot be, so if search has been missing content, rebuild the column once: ALTER TABLE "${adopted.table.split(".").join("\".\"")}" DROP COLUMN "${adopted.column}"; and boot again.`;
-		logger.info(`[schema] ${message}`);
-		log?.(message);
-	}
-	for (const skip of plan.vectorIndexSkipped) {
-		const message = `No ANN index on "${skip.table}"."${skip.column}": ${skip.reason}`;
-		logger.warn(`[schema] ${message}`);
-		log?.(message);
-	}
-	for (const withheld of plan.withheldConstraints) {
-		const message = `No ${withheld.kind === "unique" ? "UNIQUE" : "NOT NULL"} on "${withheld.target}": ${withheld.reason} ${withheld.remedy}`;
-		logger.warn(`[schema] ${message}`);
-		log?.(message);
-	}
-	for (const drift of plan.columnTypeDrift) {
-		const message = columnTypeDriftMessage(drift);
-		logger.warn(`[schema] ${message}`);
-		log?.(message);
-	}
-	for (const orphan of plan.orphanedRequiredColumns) {
-		const [schema, table] = orphan.table.split(".");
-		const message = `"${orphan.table}"."${orphan.column}" is NOT NULL with no default, and the "${orphan.slug}" collection no longer declares it. Every insert will be rejected for a field you cannot set (PG_23502, naming "${orphan.column}"). This is what a renamed property looks like: the new column was added, and the old one cannot be dropped unattended. Fix it with ONE of:
-      ALTER TABLE "${schema}"."${table}" DROP COLUMN "${orphan.column}";               -- the rename is complete\n      ALTER TABLE "${schema}"."${table}" ALTER COLUMN "${orphan.column}" DROP NOT NULL; -- keep the data, stop requiring it\n      ...or declare the property again, if the column is still wanted.`;
-		logger.warn(`[schema] ${message}`);
-		log?.(message);
-	}
-	if (plan.actions.length === 0) {
-		log?.("Schema is up to date; nothing to create.");
-		return {
-			...plan,
-			failures
-		};
-	}
-	for (const action of plan.actions) try {
-		if (await applyAction(client, action)) log?.(`${action.kind}: ${action.target}`);
-		else log?.(`${action.kind}: ${action.target} (already created by a peer)`);
-	} catch (err) {
-		const message = describeDriverError(err);
-		if (action.kind === "add-constraint" || action.kind === "comment-column" || action.kind === "create-index" && !/CREATE\s+UNIQUE\s+INDEX/i.test(action.sql)) {
-			failures.push({
-				kind: action.kind,
-				target: action.target,
-				error: message
-			});
-			continue;
-		}
-		throw new Error(`Failed to ${action.kind} ${action.target}: ${message}${vectorExtensionHint(message)}\n  ${action.sql}`);
-	}
-	return {
-		...plan,
-		failures
-	};
-}
-/**
-* What actually went wrong, rather than what the ORM said about it.
-*
-* Drizzle wraps every driver error, and its `message` is literally
-* ``Failed query: ${sql}\nparams: ${params}`` — the statement we already know,
-* and not one word of Postgres's answer. Reporting `err.message` therefore
-* produced a failure that named the statement twice and the *reason* zero
-* times, so four unrelated boot failures — a missing extension, a wrong
-* privilege, a bad index method, a constraint the rows violate — all read
-* identically to whoever had to fix them.
-*
-* Two consequences, both observed in the field before this existed:
-*
-*  1. On a managed deployment the reason never reaches anybody. Boot dies, the
-*     pod never goes ready, and the deploy reports a readiness timeout — so the
-*     one line that says why is the one line that was thrown away here.
-*  2. {@link vectorExtensionHint} matches on the error text. Against the
-*     wrapper it matched nothing, so the hint written specifically to explain a
-*     missing pgvector never fired on the path that raises it.
-*
-* `detail` and `hint` come along because they are the fields Postgres uses to
-* say which object it meant and what to do about it — `CREATE EXTENSION` names
-* the missing library there, and a rejected constraint names the row. This
-* writes into the tenant's own boot log, about the tenant's own database.
-*/
-function describeDriverError(err) {
-	const pg = extractPgError(err);
-	if (pg) {
-		const parts = [pg.code ? `${pg.message} [${pg.code}]` : pg.message];
-		if (pg.detail) parts.push(`  detail: ${pg.detail}`);
-		if (pg.hint) parts.push(`  hint: ${pg.hint}`);
-		return parts.join("\n");
-	}
-	const cause = extractCauseMessage(err);
-	if (cause) return cause;
-	return err instanceof Error ? err.message : String(err);
-}
-/** ` CONCURRENTLY ` as it appears in a rendered `CREATE [UNIQUE] INDEX`. */
-var CONCURRENTLY_RE = /\sCONCURRENTLY\s/i;
-/**
-* `25001 active_sql_transaction` — "cannot run inside a transaction block".
-*
-* Only ever raised here by `CREATE INDEX CONCURRENTLY`, and only when the
-* connection we were handed is inside a transaction. Deliberately narrow: it
-* decides to retry a *different* statement, so it must not fire on anything it
-* has not been reasoned about.
-*/
-function isTransactionBlockRefusal(err) {
-	return extractPgError(err)?.code === "25001";
-}
-/** Attempts per action, including the first. Matches the server's bootstraps. */
-var DDL_ATTEMPTS = 4;
-/**
-* Run one planned statement, surviving a simultaneous boot.
-*
-* Every statement in a plan is written to be idempotent, and that is not the
-* same as being safe to run concurrently: `CREATE … IF NOT EXISTS` reads the
-* catalog and then writes to it as two steps, so peers starting together both
-* see "absent" and the loser gets a duplicate key on a *catalog* index. Measured
-* against Postgres 18: five instances, 8 of 10 calls lost. `CREATE TYPE` is
-* worse, because Postgres has no `IF NOT EXISTS` for it at all.
-*
-* What made that fatal here rather than merely noisy is the loop this sits in.
-* A losing statement threw, and the throw abandoned **every remaining action in
-* the plan** — so a replica that lost one race came up missing tables it never
-* attempted, and the boot log blamed the one statement that failed.
-*
-* @returns `true` if this process applied the statement, `false` if a peer had
-*   already created the object. The distinction is only for the log; both mean
-*   the object is now there.
-* @throws the original error for anything that is not a race — a syntax error, a
-*   permission failure, a unique constraint the customer's own rows violate.
-*/
-async function applyAction(client, action) {
-	let sqlText = action.sql;
-	for (let attempt = 1;; attempt++) try {
-		await client.query(sqlText);
-		return true;
-	} catch (err) {
-		if (isTransactionBlockRefusal(err) && CONCURRENTLY_RE.test(sqlText)) {
-			sqlText = sqlText.replace(CONCURRENTLY_RE, " ");
-			logger.warn(`[schema] ${action.kind} ${action.target}: this connection is inside a transaction, so the index is being built with a write lock rather than concurrently. Writes to this table block until it finishes.`);
-			continue;
-		}
-		if (isDuplicateObjectRace(err)) {
-			logger.debug(`[schema] ${action.kind} ${action.target}: already created by another instance`);
-			return false;
-		}
-		if (isConcurrentDdlRace(err) && attempt < DDL_ATTEMPTS) {
-			logger.debug(`[schema] ${action.kind} ${action.target}: lost a race with another instance (attempt ${attempt}/${DDL_ATTEMPTS}) — retrying`);
-			await new Promise((resolve) => setTimeout(resolve, 40 * attempt * (1 + Math.random())));
-			continue;
-		}
-		throw err;
-	}
-}
-//#endregion
-export { readSchemaFactsFor as a, readExistingSchema as i, ensure_collection_tables_exports as n, planCollectionSchemaEnsure as r, describeDriverError as t };
-
-//# sourceMappingURL=ensure-collection-tables-BEEjn5cn.js.map