@rebasepro/server-postgres 0.22.0 → 0.23.0

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

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { a as getPrimaryKeyName, c as isIdProperty, i as enumLabelsOf, l as resolveColumnName, o as getPrimaryKeyProp, r as declaresEnumType, s as idColumnDefault, t as assertSinglePrimaryKey } from "./column-plan-helpers-CpILzHJS.js";
+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 { 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";
@@ -622,14 +622,30 @@ var foreignKeyPlan = (args) => {
 * The type a column pointing at this collection's primary key must have — a
 * junction endpoint, a `belongsTo` foreign key, a `reference`.
 *
-* One function because it was three: the ladder was spelled inline in
-* `generatePostgresDdl`, again in `planJunctionTables` and a third time in the
-* Drizzle generator.
+* The key's own column type, from the same functions that typed the key: a
+* foreign key only holds between compatible types, so any second reading of
+* the key is a constraint waiting to fail. This used to look at the id
+* strategy alone, so `id: { isId: true, columnType: "uuid" }` was referenced by
+* TEXT columns (42804 — the constraint was never created) and a `bigint` key by
+* INTEGER ones, which overflow at 2^31.
+*
+* 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.
 */
 var primaryKeyPgType = (collection) => {
-	const pk = getPrimaryKeyProp(collection);
-	if (pk.type === "number") return { kind: "integer" };
-	return pk.isUuid ? { kind: "uuid" } : { kind: "text" };
+	const { name, prop } = getPrimaryKeyProp(collection);
+	if (prop?.type === "number") return withoutSequence(numberType(name, prop, collection, true));
+	if (prop?.type === "string") return stringType(name, prop, collection);
+	return { kind: "text" };
+};
+var withoutSequence = (type) => {
+	switch (type.kind) {
+		case "smallserial": return { kind: "smallint" };
+		case "serial": return { kind: "integer" };
+		case "bigserial": return { kind: "bigint" };
+		default: return type;
+	}
 };
 /** The `columnType`s a `number` property may name, and what each one is. */
 var NUMBER_COLUMN_TYPES = {
@@ -766,6 +782,33 @@ var linkTarget = (propName, prop, collection, resolveCollection) => {
 		return;
 	}
 };
+/** A value already written as a day, or as a time of day. */
+var BARE_DATE = /^\d{4}-\d{2}-\d{2}$/;
+var BARE_TIME = /^\d{2}:\d{2}(:\d{2}(\.\d+)?)?$/;
+/**
+* A date default in the shape its column's type accepts: a day for `date`, a
+* time of day for `time`, an instant for a timestamp.
+*
+* Rendered as a full ISO timestamp whatever the column, a `time` column's
+* DEFAULT was `'2024-03-01T15:30:00.000Z'`, which Postgres refuses — "invalid
+* input syntax for type time" — so the schema would not apply. A value already
+* written in the column's shape (`"2024-12-25"`, `"09:00"`) is kept as written;
+* anything else is read as an instant and its UTC day or time of day taken, the
+* same zone the timestamp rendering has always used. A string that is no date
+* at all is no DEFAULT, rather than a schema that cannot be applied.
+*/
+var dateDefaultLiteral = (value, type) => {
+	if (typeof value === "string") {
+		if (type.kind === "date" && BARE_DATE.test(value)) return value;
+		if (type.kind === "time" && BARE_TIME.test(value)) return value;
+	}
+	const instant = value instanceof Date ? value : typeof value === "string" ? new Date(value) : void 0;
+	if (!instant || Number.isNaN(instant.getTime())) return void 0;
+	const iso = instant.toISOString();
+	if (type.kind === "date") return iso.slice(0, 10);
+	if (type.kind === "time") return iso.slice(11, 23);
+	return typeof value === "string" ? value : iso;
+};
 /**
 * A `defaultValue` as a database DEFAULT.
 *
@@ -800,11 +843,11 @@ var literalDefault = (prop, type) => {
 			sql: value ? "TRUE" : "FALSE"
 		} : void 0;
 		case "date": {
-			const iso = value instanceof Date ? Number.isNaN(value.getTime()) ? void 0 : value.toISOString() : typeof value === "string" ? value : void 0;
-			return iso === void 0 ? void 0 : {
+			const literal = dateDefaultLiteral(value, type);
+			return literal === void 0 ? void 0 : {
 				kind: "literal",
-				value: iso,
-				sql: quoteSqlLiteral(iso)
+				value: literal,
+				sql: quoteSqlLiteral(literal)
 			};
 		}
 		case "map":
@@ -893,7 +936,7 @@ function planSchema(allCollections, options = {}) {
 	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 = [];
-	const seenEnums = /* @__PURE__ */ new Set();
+	const enumOwners = /* @__PURE__ */ new Map();
 	/**
 	* Every enum type one table's properties declare, appended once.
 	*
@@ -911,10 +954,21 @@ function planSchema(allCollections, options = {}) {
 			const labels = enumLabelsOf(propName, prop, collection);
 			if (!declaresEnumType(prop)) continue;
 			const schema = schemaOf(collection);
-			const name = `${getTableName(collection)}_${resolveColumnName(propName, prop)}`;
-			const qualified = `${schema}.${name}`;
-			if (seenEnums.has(qualified)) continue;
-			seenEnums.add(qualified);
+			const table = getTableName(collection);
+			const column = resolveColumnName(propName, prop);
+			const name = `${table}_${column}`;
+			const qualified = `${schema}.${toPostgresIdentifier(name)}`;
+			const owner = `property "${propName}" of collection "${describe(collection)}"`;
+			const claimed = enumOwners.get(qualified);
+			if (claimed) {
+				if (claimed.table === table && claimed.column === column) continue;
+				throw new Error(`The enum ${owner} and the enum ${claimed.owner} both derive the Postgres type "${schema}"."${toPostgresIdentifier(name)}" (an enum type is named <table>_<column>, and Postgres keeps the first 63 bytes). One type cannot hold both columns' values, and a type's name cannot change once a database holds it. Give one of the two columns another name with \`columnName\`, or its collection another \`table\` or \`schema\`.`);
+			}
+			enumOwners.set(qualified, {
+				table,
+				column,
+				owner
+			});
 			enums.push({
 				schema,
 				name,
@@ -927,12 +981,14 @@ function planSchema(allCollections, options = {}) {
 	};
 	for (const collection of collections) collectEnumTypes(collection, collection.properties ?? {}, isPostgresCollectionConfig(collection) ? collection.schema : void 0);
 	const tableEntries = /* @__PURE__ */ new Map();
+	const junctionShapes = /* @__PURE__ */ new Map();
 	for (const collection of collections) {
 		const tableName = getTableName(collection);
 		if (tableName) tableEntries.set(tableName, { collection });
-		for (const relation of Object.values(resolveCollectionRelations(collection))) {
+		for (const [relationKey, relation] of Object.entries(resolveCollectionRelations(collection))) {
 			if (!isManyToMany(relation)) continue;
 			const junctionTable = relation.through.table;
+			assertOneJunctionShape(junctionShapes, junctionTable, collection, relation.relationName ?? relationKey, relation);
 			if (tableEntries.has(junctionTable)) continue;
 			tableEntries.set(junctionTable, {
 				collection: {
@@ -984,6 +1040,38 @@ function planSchema(allCollections, options = {}) {
 		options
 	};
 }
+/**
+* Refuse two many-to-many relations that resolve to one junction table with
+* different key columns.
+*
+* A default `through` is named after the two tables, so `posts.tags` and
+* `posts.featuredTags` both resolve to `posts_tags` — one keyed by `tag_id`,
+* the other by `featured_tag_id`. One table is created, from whichever came
+* first, so the other relation read and wrote a column that was never there.
+* The two sides of one link (`posts.tags` and `tags.posts`) share a junction
+* legitimately, and they name the same two columns — so the comparison is of
+* the (column, endpoint) pairs, in either order.
+*/
+function assertOneJunctionShape(seen, junctionTable, collection, relationName, relation) {
+	if (!isManyToMany(relation)) return;
+	const target = relation.target();
+	if (!target) return;
+	const sourceTable = getTableName(collection);
+	const targetTable = getTableName(target);
+	const { sourceColumn, targetColumn } = relation.through;
+	const keys = JSON.stringify([[sourceColumn, sourceTable], [targetColumn, targetTable]].sort());
+	const claim = `the relation "${relationName}" of collection "${describe(collection)}" ("${sourceColumn}" → ${sourceTable}, "${targetColumn}" → ${targetTable})`;
+	const first = seen.get(junctionTable);
+	if (!first) {
+		seen.set(junctionTable, {
+			keys,
+			claim
+		});
+		return;
+	}
+	if (first.keys === keys) return;
+	throw new Error(`Two many-to-many relations resolve to the junction table "${junctionTable}" with different key columns: ${first.claim} and ${claim}. Only one table is created, so one of them would read and write columns that do not exist. Give the second its own junction — \`through: { table: "${sourceTable}_${toSnakeCase(relationName)}" }\` — or, if both are meant to be one link, declare it once.`);
+}
 function planCollectionTable(collection, resolveCollection, triggerFunctionNeeded) {
 	const schema = schemaOf(collection);
 	const table = bareTableName(getTableName(collection));
@@ -1083,6 +1171,7 @@ function planCollectionTable(collection, resolveCollection, triggerFunctionNeede
 	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);
+	settleDefaultOnDelete(collection, columns, relations);
 	return {
 		schema,
 		table,
@@ -1222,19 +1311,58 @@ function applyTenantColumnEffects(collection, columns, schema, table) {
 * column — for the shape the documentation recommends.
 */
 function findTenantColumn(collection, columns, field) {
-	const direct = columns.find((c) => c.key === field);
+	const created = columns.filter((c) => !c.columnOwnedByProperty);
+	const direct = created.find((c) => c.key === field);
 	if (direct) return direct;
 	const prop = collection.properties?.[field];
 	if (prop?.type === "relation") {
 		const relation = findRelation(resolveCollectionRelations(collection), prop.relation?.relationName ?? field);
-		if (relation?.kind === "belongsTo" && relation.localKey) return columns.find((c) => c.column === relation.localKey);
+		if (relation?.kind === "belongsTo" && relation.localKey) return created.find((c) => c.column === relation.localKey);
 		return;
 	}
 	if (!prop) return void 0;
 	const columnName = resolveColumnName(field, prop);
-	return columns.find((c) => c.column === columnName);
+	return created.find((c) => c.column === columnName);
 }
 /**
+* The `ON DELETE` a link gets when the author did not say, decided from the
+* column as it will be created.
+*
+* {@link planRelationColumn} and {@link planReferenceColumn} see only their own
+* property's `required`, and two later facts change the premise: `tenant` makes
+* its column NOT NULL, and a declared property that owns a relation's column
+* decides that column's nullability itself. Defaulting before either produced
+* `NOT NULL … ON DELETE SET NULL` — a parent's delete that can only fail, and
+* fails with 23502 naming the child's column rather than as the foreign-key
+* refusal it is. An `onDelete` the author wrote is theirs and is kept.
+*/
+function settleDefaultOnDelete(collection, columns, relations) {
+	for (const column of columns) {
+		const fk = column.foreignKey;
+		if (!fk || declaresOnDelete(collection, relations, column)) continue;
+		const onDelete = defaultBelongsToOnDelete(!(columns.find((c) => c.column === column.column && !c.columnOwnedByProperty) ?? column).nullable);
+		if (onDelete === fk.onDelete) continue;
+		column.foreignKey = foreignKeyPlan({
+			schema: fk.schema,
+			table: fk.table,
+			column: fk.column,
+			targetSchema: fk.targetSchema,
+			targetTable: fk.targetTable,
+			targetColumn: fk.targetColumn,
+			onDelete,
+			onUpdate: fk.onUpdate
+		});
+	}
+}
+/** Whether the author wrote this link's `onDelete`. A `reference` has none to write. */
+var declaresOnDelete = (collection, relations, column) => {
+	const propName = column.source.propName;
+	if (column.source.kind !== "relation" || !propName) return false;
+	const prop = collection.properties?.[propName];
+	const relation = findRelation(relations, prop?.relation?.relationName ?? propName);
+	return relation?.kind === "belongsTo" && relation.onDelete !== void 0;
+};
+/**
 * The column a `belongsTo` relation owns, or `undefined` when the relation puts
 * no column on this table.
 *
@@ -1271,7 +1399,7 @@ function planRelationColumn(propName, prop, collection, relations, schema, table
 			column: relation.localKey,
 			targetSchema: schemaOf(target),
 			targetTable: bareTableName(getTableName(target)),
-			targetColumn: getPrimaryKeyName(target),
+			targetColumn: getPrimaryKeyColumn(target),
 			onDelete: relation.onDelete ?? defaultBelongsToOnDelete(required),
 			onUpdate: relation.onUpdate
 		}),
@@ -1300,7 +1428,7 @@ function planReferenceColumn(propName, prop, collection, resolveCollection, sche
 			column,
 			targetSchema: schemaOf(target),
 			targetTable: bareTableName(getTableName(target)),
-			targetColumn: getPrimaryKeyName(target),
+			targetColumn: getPrimaryKeyColumn(target),
 			onDelete: defaultBelongsToOnDelete(required)
 		}) : void 0,
 		source: {
@@ -1361,7 +1489,7 @@ function planJunctionTable(tableName, relation, source, junctionSpecs, resolveCo
 			column,
 			targetSchema: schemaOf(collection),
 			targetTable: bareTableName(getTableName(collection)),
-			targetColumn: getPrimaryKeyName(collection),
+			targetColumn: getPrimaryKeyColumn(collection),
 			onDelete
 		}),
 		source: { kind: "junction-key" }
@@ -1416,14 +1544,12 @@ function planRelations(collections, tableEntries) {
 			const { relation, source } = entry.junction;
 			if (!isManyToMany(relation)) continue;
 			const target = relation.target();
-			const owningRelationName = relation.relationName ?? toSnakeCase(getTableName(target));
-			let inverseRelationName;
+			const owningRelationName = sharedRelationName(relation, source);
+			let inverse;
 			try {
-				for (const targetRel of Object.values(resolveCollectionRelations(target))) if (targetRel.kind !== "belongsTo" && targetRel.cardinality === "many" && targetRel.relationName === owningRelationName) {
-					inverseRelationName = targetRel.relationName;
-					break;
-				}
+				inverse = Object.values(resolveCollectionRelations(target)).find((r) => r.kind === "manyToMany" && bareTableName(r.through.table) === bareTableName(tableName));
 			} catch {}
+			const inverseRelationName = inverse ? sharedRelationName(inverse, target) : `${tableName}_${relation.through.targetColumn}`;
 			plans.push({
 				tableVar,
 				key: relation.through.sourceColumn,
@@ -1433,12 +1559,13 @@ function planRelations(collections, tableEntries) {
 				fields: [relation.through.sourceColumn],
 				references: [getPrimaryKeyName(source)]
 			});
+			if (inverseRelationName === owningRelationName) continue;
 			plans.push({
 				tableVar,
 				key: relation.through.targetColumn,
 				kind: "one",
 				targetVar: getTableVarName(getTableName(target)),
-				relationName: inverseRelationName ?? `${tableName}_${relation.through.targetColumn}`,
+				relationName: inverseRelationName,
 				fields: [relation.through.targetColumn],
 				references: [getPrimaryKeyName(target)]
 			});
@@ -1533,4 +1660,4 @@ function planRelations(collections, tableEntries) {
 //#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 };
 
-//# sourceMappingURL=plan-schema-CboAIwLN.js.map
+//# sourceMappingURL=plan-schema-C0fxM8dY.js.map