@rebasepro/server-postgres 0.10.1-canary.ed8caed → 0.10.1-canary.g4db1bb1

package/dist/{src-lcfUP4xg.js → src-3VmUJ8Xn.js}

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from "module";
 import "process";
 __createRequire(import.meta.url);
 import { r as __require, t as __commonJSMin } from "./chunk-DSJWtz9O.js";
-import { c as getDeclaredSubcollections, d as REST_TO_CANONICAL, f as toCanonicalOp, l as isPostgresCollectionConfig, n as getDataSourceCapabilities, o as ANONYMOUS_USER_ID, p as EntityRelation, s as policy, u as NULL_OPS } from "./src-CBgtrPhJ.js";
+import { d as isPostgresCollectionConfig, f as NULL_OPS, h as EntityRelation, l as isManyToMany, m as toCanonicalOp, n as getDataSourceCapabilities, o as ANONYMOUS_USER_ID, p as REST_TO_CANONICAL, s as policy, u as getDeclaredSubcollections } from "./src-D5xBTl32.js";
 //#region ../common/src/util/common.ts
 var DEFAULT_ONE_OF_TYPE = "type";
 var DEFAULT_ONE_OF_VALUE = "value";
@@ -1405,164 +1405,143 @@ function enumToObjectEntries(enumValues) {
 	});
 }
 //#endregion
-//#region ../common/src/util/relations.ts
-function sanitizeRelation(relation, sourceCollection, resolveCollection) {
-	if (!relation.target) throw new Error("Relation is missing a `target` collection.");
-	const rawTarget = relation.target;
-	let targetCollection;
-	if (typeof rawTarget === "string") {
-		if (resolveCollection) targetCollection = resolveCollection(rawTarget);
-		if (!targetCollection) targetCollection = {
-			slug: rawTarget,
-			name: rawTarget
-		};
-	} else if (typeof rawTarget === "function") {
-		const evaluated = rawTarget();
-		if (typeof evaluated === "string") {
-			if (resolveCollection) targetCollection = resolveCollection(evaluated);
-			if (!targetCollection) targetCollection = {
-				slug: evaluated,
-				name: evaluated
-			};
-		} else targetCollection = evaluated;
-	} else if (rawTarget && typeof rawTarget === "object") targetCollection = rawTarget;
-	if (!targetCollection) throw new Error("Relation is missing a valid `target` collection.");
-	const newRelation = { ...relation };
-	newRelation.target = () => {
-		if (typeof rawTarget === "string") return resolveCollection && resolveCollection(rawTarget) || targetCollection;
-		else if (typeof rawTarget === "function") {
-			const evaluated = rawTarget();
-			if (typeof evaluated === "string") return resolveCollection && resolveCollection(evaluated) || targetCollection;
-			return evaluated;
-		}
-		return targetCollection;
+//#region ../common/src/util/resolve-relation.ts
+/**
+* Fill in a relation's defaults.
+*
+* This replaces `sanitizeRelation`, which had to work out *which kind of link
+* you meant* from whichever optional fields happened to be set — 194 lines of
+* it, including a pass that inspected the target collection's own relations to
+* decide whether a `many`/`inverse` pair was a one-to-many or the far side of a
+* many-to-many, wrapped in a `try/catch` that fell through to the wrong answer
+* when it could not tell. Two consumers running that logic at different moments
+* could reach different conclusions about the same relation.
+*
+* With the kind declared there is nothing to work out. What remains is
+* defaulting — a table name, a column name — which is deterministic, depends
+* only on the relation and its two endpoints, and cannot fail. That is why this
+* function returns rather than throws, and why it needs no cache to be
+* consistent.
+*/
+function resolveRelation(relation, sourceCollection, propertyKey) {
+	const target = relation.target;
+	if (typeof target !== "function") throw new Error(`Relation${relation.relationName ? ` '${relation.relationName}'` : ""} on '${sourceCollection.slug}' has no \`target\`. Give it a thunk: \`target: () => otherCollection\`.`);
+	const targetCollection = target();
+	if (!targetCollection?.slug) throw new Error(`Relation${relation.relationName ? ` '${relation.relationName}'` : ""} on '${sourceCollection.slug}' has a \`target\` that did not resolve to a collection.`);
+	const relationName = relation.relationName ?? propertyKey ?? toSnakeCase(targetCollection.slug);
+	const shared = {
+		relationName,
+		target,
+		targetSlug: targetCollection.slug,
+		onUpdate: relation.onUpdate,
+		onDelete: relation.onDelete,
+		overrides: relation.overrides,
+		validation: relation.validation
 	};
-	if (!newRelation.relationName) newRelation.relationName = toSnakeCase(targetCollection.slug);
-	if (!newRelation.direction) if (newRelation.foreignKeyOnTarget) newRelation.direction = "inverse";
-	else if (newRelation.through) newRelation.direction = "owning";
-	else if (newRelation.cardinality === "many") newRelation.direction = "inverse";
-	else newRelation.direction = "owning";
-	if (!newRelation.joinPath) {
-		const sourceName = toSnakeCase(sourceCollection.slug ?? sourceCollection.name);
-		if (newRelation.cardinality === "one" && newRelation.direction === "owning") {
-			if (!newRelation.localKey) newRelation.localKey = generateForeignKeyName(newRelation.relationName);
-		} else if (newRelation.cardinality === "one" && newRelation.direction === "inverse") {
-			if (!newRelation.foreignKeyOnTarget) {
-				let foundForeignKey = false;
-				try {
-					const targetRelations = getDataSourceCapabilities(targetCollection.engine).supportsRelations ? targetCollection.relations || [] : [];
-					for (const targetRel of targetRelations) if (targetRel.direction === "owning" && targetRel.cardinality === "one" && targetRel.localKey) try {
-						if (targetRel.target().slug === sourceCollection.slug) {
-							newRelation.foreignKeyOnTarget = targetRel.localKey;
-							foundForeignKey = true;
-							break;
-						}
-					} catch (e) {
-						continue;
-					}
-				} catch (e) {}
-				if (!foundForeignKey) newRelation.foreignKeyOnTarget = generateForeignKeyName(newRelation.inverseRelationName ? toSnakeCase(newRelation.inverseRelationName) : sourceName);
-			}
-		} else if (newRelation.cardinality === "many" && newRelation.direction === "inverse") {
-			let isManyToManyInverse = false;
-			if (newRelation.inverseRelationName && !newRelation.foreignKeyOnTarget) try {
-				const targetRelations = getDataSourceCapabilities(targetCollection.engine).supportsRelations ? targetCollection.relations || [] : [];
-				for (const targetRel of targetRelations) if (targetRel.cardinality === "many" && (targetRel.direction === "owning" || !targetRel.direction) && targetRel.relationName === newRelation.inverseRelationName) {
-					isManyToManyInverse = true;
-					break;
-				}
-				if (!isManyToManyInverse && targetCollection.properties) for (const [propKey, prop] of Object.entries(targetCollection.properties)) {
-					if (prop.type !== "relation") continue;
-					const relProp = prop;
-					if ((relProp.relationName || propKey) === newRelation.inverseRelationName && relProp.cardinality === "many" && (relProp.direction === "owning" || !relProp.direction)) {
-						isManyToManyInverse = true;
-						break;
-					}
+	const sourceName = toSnakeCase(sourceCollection.slug ?? sourceCollection.name);
+	switch (relation.kind) {
+		case "belongsTo": return {
+			...shared,
+			kind: "belongsTo",
+			cardinality: "one",
+			writable: true,
+			shared: false,
+			localKey: relation.localKey ?? generateForeignKeyName(relationName)
+		};
+		case "hasOne": return {
+			...shared,
+			kind: "hasOne",
+			cardinality: "one",
+			writable: true,
+			shared: false,
+			foreignKeyOnTarget: relation.foreignKeyOnTarget ?? generateForeignKeyName(sourceName)
+		};
+		case "hasMany": return {
+			...shared,
+			kind: "hasMany",
+			cardinality: "many",
+			writable: true,
+			shared: false,
+			foreignKeyOnTarget: relation.foreignKeyOnTarget ?? generateForeignKeyName(sourceName)
+		};
+		case "manyToMany": {
+			const sourceTable = getTableName(sourceCollection);
+			const targetTable = getTableName(targetCollection);
+			return {
+				...shared,
+				kind: "manyToMany",
+				cardinality: "many",
+				writable: true,
+				shared: true,
+				through: {
+					table: relation.through?.table ?? [sourceTable, targetTable].sort().join("_"),
+					sourceColumn: relation.through?.sourceColumn ?? generateForeignKeyName(sourceName),
+					targetColumn: relation.through?.targetColumn ?? generateForeignKeyName(relationName)
 				}
-			} catch (e) {}
-			if (!isManyToManyInverse && !newRelation.foreignKeyOnTarget) newRelation.foreignKeyOnTarget = generateForeignKeyName(sourceName);
-		} else if (newRelation.cardinality === "many" && newRelation.direction === "owning") {
-			const sourceTableName = getTableName(sourceCollection);
-			const targetTableName = getTableName(targetCollection);
-			newRelation.through = {
-				table: newRelation.through?.table ?? [sourceTableName, targetTableName].sort().join("_"),
-				sourceColumn: newRelation.through?.sourceColumn ?? generateForeignKeyName(sourceName),
-				targetColumn: newRelation.through?.targetColumn ?? generateForeignKeyName(newRelation.relationName)
 			};
 		}
+		case "via": return {
+			...shared,
+			kind: "via",
+			cardinality: relation.cardinality,
+			writable: false,
+			shared: true,
+			joinPath: relation.joinPath
+		};
+		default: throw new Error(`Unknown relation kind: ${JSON.stringify(relation)}`);
 	}
-	if (newRelation.cardinality === "one" && newRelation.direction === "owning" && !newRelation.localKey && !newRelation.joinPath) throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'owning' one-to-one relation requires a 'localKey'. Check the relation config for '${newRelation.relationName}'`);
-	if (newRelation.cardinality === "one" && newRelation.direction === "inverse" && !newRelation.foreignKeyOnTarget && !newRelation.joinPath) throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'inverse' one-to-one relation requires a 'foreignKeyOnTarget'. Check the relation config for '${newRelation.relationName}'`);
-	if (newRelation.cardinality === "many" && newRelation.direction === "inverse" && !newRelation.foreignKeyOnTarget && !newRelation.joinPath && !newRelation.inverseRelationName) throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'inverse' one-to-many relation requires a 'foreignKeyOnTarget'. Check the relation config for '${newRelation.relationName}'`);
-	return newRelation;
 }
+//#endregion
+//#region ../common/src/util/relations.ts
 /**
-* Whether the target rows of this relation are reached through a junction — a
-* many-to-many, or a multi-hop `joinPath`.
+* Whether the target rows are shared with other parents — a many-to-many, or a
+* multi-hop `via` chain.
 *
-* The distinction decides what a write "through" the relation may touch: a
-* junction-backed target is shared with other parents, so the parent owns the
-* *link* and not the row. The backend enforces that (an unlink rather than a
-* delete) and the admin renders it (remove-from-parent rather than delete), so
-* the predicate lives here rather than once per side.
+* Decides what a write "through" the relation may touch: a shared target
+* belongs to every parent that links it, so the parent owns the *link* and not
+* the row. The backend enforces that (an unlink rather than a delete) and the
+* admin renders it (remove-from-parent rather than delete).
+*
+* Now a field on the resolved relation rather than a re-derivation, so both
+* sides read the same answer instead of each computing one.
 */
 function isJunctionBackedRelation(relation) {
-	return Boolean(relation.through) || Boolean(relation.joinPath && relation.joinPath.length > 1);
+	return relation.shared;
 }
 /** WeakMap cache — same collection instance always yields the same relation map. */
 var _resolvedRelationsCache = /* @__PURE__ */ new WeakMap();
+/**
+* Every relation a collection declares, keyed by the name it is addressed by.
+*
+* A relation reaches the map from either of two places — the collection's
+* `relations` array, or a `relation` property that declares one inline — and is
+* keyed by its resolved `relationName`, which is what a nested path segment,
+* an `include` key and an admin tab all match against.
+*
+* Resolution no longer swallows failures. It used to wrap each relation in a
+* `try/catch` that dropped anything it could not work out, so a
+* mis-declared relation silently vanished instead of being reported; with the
+* kind declared, the only remaining failure is a `target` that does not resolve,
+* which is worth hearing about.
+*/
 function resolveCollectionRelations(collection) {
 	const cached = _resolvedRelationsCache.get(collection);
 	if (cached) return cached;
 	if (!getDataSourceCapabilities(collection.engine).supportsRelations) return {};
 	const relations = {};
-	const registeredRelationNames = /* @__PURE__ */ new Set();
-	if (collection.relations) collection.relations.forEach((relation) => {
-		try {
-			const normalizedRelation = sanitizeRelation(relation, collection);
-			const relationKey = normalizedRelation.relationName;
-			if (relationKey) {
-				relations[relationKey] = normalizedRelation;
-				registeredRelationNames.add(relationKey);
-			}
-		} catch (e) {}
-	});
-	if (collection.properties) Object.entries(collection.properties).forEach(([propKey, prop]) => {
-		const relation = resolvePropertyRelation({
-			propertyKey: propKey,
-			property: prop,
-			sourceCollection: collection
-		});
-		if (relation) {
-			if (relations[propKey]) return;
-			if (!relation.relationName) relation.relationName = propKey;
-			const normalizedRelation = sanitizeRelation(relation, collection);
-			relations[propKey] = normalizedRelation;
-			registeredRelationNames.add(normalizedRelation.relationName ?? propKey);
-		}
-	});
+	for (const relation of collection.relations ?? []) {
+		const resolved = resolveRelation(relation, collection);
+		relations[resolved.relationName] = resolved;
+	}
+	for (const [propertyKey, property] of Object.entries(collection.properties ?? {})) {
+		if (property?.type !== "relation") continue;
+		const declared = property.relation;
+		if (!declared || relations[propertyKey]) continue;
+		relations[propertyKey] = resolveRelation(declared, collection, propertyKey);
+	}
 	_resolvedRelationsCache.set(collection, relations);
 	return relations;
 }
-function resolvePropertyRelation({ propertyKey, property, sourceCollection }) {
-	if (property.type !== "relation") return void 0;
-	const relProp = property;
-	if (relProp.target) return {
-		relationName: relProp.relationName || propertyKey,
-		target: relProp.target,
-		cardinality: relProp.cardinality || "one",
-		direction: relProp.direction || "owning",
-		inverseRelationName: relProp.inverseRelationName,
-		localKey: relProp.localKey,
-		foreignKeyOnTarget: relProp.foreignKeyOnTarget,
-		through: relProp.through,
-		joinPath: relProp.joinPath,
-		onUpdate: relProp.onUpdate,
-		onDelete: relProp.onDelete,
-		overrides: relProp.overrides
-	};
-	console.warn(`Unrecognized or missing relation target for property '${propertyKey}' in collection '${sourceCollection.slug}'`);
-}
 function getTableName(collection) {
 	if (getDataSourceCapabilities(collection.engine).supportsRelations) return collection.table ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
 	return toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
@@ -1595,40 +1574,6 @@ function findRelation(resolvedRelations, key) {
 //#endregion
 //#region ../common/src/util/resolutions.ts
 /**
-* Relation identities that only ever appear *below* the top level of
-* `properties` — inside a `map`, an `array`, or a `oneOf` branch.
-*
-* A relation declared at the top level is a list hanging off the record and
-* earns a tab. One declared inside a map is a field of that map. Both end up in
-* the collection's flat `relations` array after normalization, so the shape of
-* `properties` is the only remaining evidence of which is which.
-*
-* An identity declared in both places is *not* nested-only, and keeps its tab.
-*/
-function getNestedRelationIdentities(properties) {
-	const topLevel = /* @__PURE__ */ new Set();
-	const nested = /* @__PURE__ */ new Set();
-	const walk = (props, depth) => {
-		if (!props) return;
-		for (const [key, property] of Object.entries(props)) {
-			if (!property) continue;
-			if (property.type === "relation") {
-				const relProp = property;
-				(depth === 0 ? topLevel : nested).add(relProp.relationName ?? key);
-			} else if (property.type === "map") walk(property.properties, depth + 1);
-			else if (property.type === "array") {
-				const arrayProp = property;
-				if (Array.isArray(arrayProp.of)) arrayProp.of.forEach((p) => walk({ entry: p }, depth + 1));
-				else if (arrayProp.of) walk({ entry: arrayProp.of }, depth + 1);
-				if (arrayProp.oneOf?.properties) walk(arrayProp.oneOf.properties, depth + 1);
-			}
-		}
-	};
-	walk(properties, 0);
-	for (const identity of topLevel) nested.delete(identity);
-	return nested;
-}
-/**
 * The lists rendered inside an entity view of `collection` — its tabs.
 *
 * The single derivation. There used to be two that disagreed: this one, and a
@@ -1655,14 +1600,12 @@ function getEntityChildViews(collection) {
 	if (capabilities.supportsSubcollections && declaredSubcollections) return asSubcollections(declaredSubcollections() ?? []);
 	if (!capabilities.supportsRelations) return [];
 	const resolvedRelations = resolveCollectionRelations(collection);
-	const nestedOnly = getNestedRelationIdentities(collection.properties);
 	const views = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const [relationKey, relation] of Object.entries(resolvedRelations)) {
 		if (relation.cardinality !== "many") continue;
 		const identity = relation.relationName ?? relationKey;
 		if (seen.has(identity)) continue;
-		if (nestedOnly.has(identity)) continue;
 		let target;
 		try {
 			target = relation.target();
@@ -1671,7 +1614,7 @@ function getEntityChildViews(collection) {
 		}
 		if (!target) continue;
 		seen.add(identity);
-		const customName = Object.entries(collection.properties ?? {}).find(([propKey, p]) => p.type === "relation" && (p.relationName ?? propKey) === identity)?.[1]?.name;
+		const customName = Object.entries(collection.properties ?? {}).find(([propKey, p]) => p.type === "relation" && (p.relation?.relationName ?? propKey) === identity)?.[1]?.name;
 		const base = {
 			...target,
 			slug: relationKey,
@@ -2254,8 +2197,8 @@ function resolveJunctionSpecs(collections) {
 	for (const collection of collections) {
 		const resolved = resolveCollectionRelations(collection);
 		for (const relation of Object.values(resolved)) {
-			if (!relation.through) continue;
-			const targetCollection = typeof relation.target === "function" ? relation.target() : void 0;
+			if (!isManyToMany(relation)) continue;
+			const targetCollection = relation.target();
 			if (!targetCollection) continue;
 			const rawName = relation.through.table;
 			const table = rawName.includes(".") ? rawName.split(".").pop() : rawName;
@@ -3297,88 +3240,33 @@ var CollectionRegistry = class {
 			if (!result.dataSource) result.dataSource = resolved.key;
 			if (!result.engine) result.engine = resolved.engine;
 		}
-		const extractedRelations = this.extractRelationsFromProperties(result.properties);
-		const relResult = result;
-		const manualRelations = getDataSourceCapabilities(result.engine).supportsRelations ? relResult.relations ?? [] : [];
-		const mergedRelationsRaw = [...extractedRelations];
-		for (const manual of manualRelations) {
-			const name = manual.relationName;
-			if (!name) mergedRelationsRaw.push(manual);
-			else {
-				const existingIndex = mergedRelationsRaw.findIndex((r) => r.relationName === name);
-				if (existingIndex === -1) mergedRelationsRaw.push(manual);
-				else mergedRelationsRaw[existingIndex] = {
-					...manual,
-					...mergedRelationsRaw[existingIndex]
-				};
-			}
-		}
-		let mergedRelations = mergedRelationsRaw;
-		if (getDataSourceCapabilities(result.engine).supportsRelations) {
-			mergedRelations = mergedRelationsRaw.map((r) => {
-				try {
-					return sanitizeRelation(r, result, (slug) => this.get(slug));
-				} catch {
-					return r;
-				}
-			});
-			relResult.relations = mergedRelations;
-		}
-		result.properties = this.normalizeProperties(result.properties, mergedRelations);
+		result.properties = this.normalizeProperties(result.properties, result);
 		return result;
 	}
-	/**
-	* Extract Relation[] from properties that have inline relation config (i.e. `target` is set).
-	* This allows developers to define relations directly on properties without a separate
-	* `relations[]` entry on the collection.
-	*/
-	extractRelationsFromProperties(properties) {
-		const relations = [];
-		for (const [key, property] of Object.entries(properties)) if (property.type === "relation") {
-			const relProp = property;
-			const target = relProp.target ?? relProp.relation?.target;
-			if (target) {
-				const relationName = relProp.relationName ?? relProp.relation?.relationName ?? key;
-				relations.push({
-					relationName,
-					target,
-					cardinality: relProp.cardinality ?? relProp.relation?.cardinality ?? "one",
-					direction: relProp.direction ?? relProp.relation?.direction ?? "owning",
-					inverseRelationName: relProp.inverseRelationName ?? relProp.relation?.inverseRelationName,
-					localKey: relProp.localKey ?? relProp.relation?.localKey,
-					foreignKeyOnTarget: relProp.foreignKeyOnTarget ?? relProp.relation?.foreignKeyOnTarget,
-					through: relProp.through ?? relProp.relation?.through,
-					joinPath: relProp.joinPath ?? relProp.relation?.joinPath,
-					onUpdate: relProp.onUpdate ?? relProp.relation?.onUpdate,
-					onDelete: relProp.onDelete ?? relProp.relation?.onDelete,
-					overrides: relProp.overrides ?? relProp.relation?.overrides
-				});
-			}
-		} else if (property.type === "map" && property.properties) relations.push(...this.extractRelationsFromProperties(property.properties));
-		return relations;
-	}
-	normalizeProperties(properties, relations) {
+	normalizeProperties(properties, collection) {
 		const newProperties = {};
-		for (const key in properties) newProperties[key] = this.normalizeProperty(key, properties[key], relations);
+		for (const key in properties) newProperties[key] = this.normalizeProperty(key, properties[key], collection);
 		return newProperties;
 	}
-	normalizeProperty(key, property, relations) {
+	normalizeProperty(key, property, collection) {
 		const newProperty = { ...property };
-		if (newProperty.type === "map" && newProperty.properties) newProperty.properties = this.normalizeProperties(newProperty.properties, relations);
+		if (newProperty.type === "map" && newProperty.properties) newProperty.properties = this.normalizeProperties(newProperty.properties, collection);
 		else if (newProperty.type === "array") {
 			const arrayProp = newProperty;
-			if (arrayProp.of) if (Array.isArray(arrayProp.of)) arrayProp.of = arrayProp.of.map((p, i) => this.normalizeProperty(`${key}[${i}]`, p, relations));
-			else arrayProp.of = this.normalizeProperty(`${key}.of`, arrayProp.of, relations);
-			else if (arrayProp.oneOf && arrayProp.oneOf.properties) arrayProp.oneOf.properties = this.normalizeProperties(arrayProp.oneOf.properties, relations);
+			if (arrayProp.of) if (Array.isArray(arrayProp.of)) arrayProp.of = arrayProp.of.map((p, i) => this.normalizeProperty(`${key}[${i}]`, p, collection));
+			else arrayProp.of = this.normalizeProperty(`${key}.of`, arrayProp.of, collection);
+			else if (arrayProp.oneOf && arrayProp.oneOf.properties) arrayProp.oneOf.properties = this.normalizeProperties(arrayProp.oneOf.properties, collection);
 		} else if ((newProperty.type === "string" || newProperty.type === "number") && newProperty.enum) {
 			const stringOrNumberProperty = newProperty;
 			if (typeof stringOrNumberProperty.enum === "object" && !Array.isArray(stringOrNumberProperty.enum)) stringOrNumberProperty.enum = enumToObjectEntries(stringOrNumberProperty.enum)?.filter((value) => value && (value.id || value.id === 0) && value.label) ?? [];
 		} else if (newProperty.type === "relation") {
 			const relationProperty = newProperty;
-			const name = relationProperty.relationName || key;
-			const relation = relations.find((r) => r.relationName === name);
-			if (relation) relationProperty.relation = relation;
-			else console.warn(`Could not find relation for property '${key}' with relationName: ${name}`);
+			if (relationProperty.relation) relationProperty.resolvedRelation = resolveRelation(relationProperty.relation, collection, key);
+			else {
+				const declared = resolveCollectionRelations(collection)[key];
+				if (declared) relationProperty.resolvedRelation = declared;
+				else console.warn(`Relation property '${key}' on '${collection.slug}' declares no \`relation\`, and the collection has no relation of that name.`);
+			}
 		}
 		return newProperty;
 	}
@@ -4103,4 +3991,4 @@ async function detectJunctionTables(executeSql) {
 //#endregion
 export { DEFAULT_ONE_OF_TYPE as A, createRelationRefWithData as C, mergeDeep as D, getPolicyNamesForRule as E, camelCase as O, createRelationRef as S, updateDateAutoValues as T, getTableVarName as _, getJunctionCollectionConfig as a, getDeclaredPrimaryKeys as b, getEffectiveSecurityRules as c, securityRuleToConditions as d, findAnonymousGrants as f, getTableName as g, getEnumVarName as h, CollectionRegistry as i, DEFAULT_ONE_OF_VALUE as j, toSnakeCase as k, buildPropertyCallbacks as l, getColumnName as m, detectJunctionTables as n, getJunctionSecurityRules as o, findRelation as p, buildSdkData as r, resolveJunctionSpecs as s, classifyTable as t, policyToPostgres as u, resolveCollectionRelations as v, normalizeToEntityRelation as w, parseIdValues as x, buildCompositeId as y };
 
-//# sourceMappingURL=src-lcfUP4xg.js.map
+//# sourceMappingURL=src-3VmUJ8Xn.js.map