@rebasepro/server-postgres 0.10.1-canary.d8d45b2 → 0.10.1-canary.ed78a2c

package/dist/{src-DmsRg8MR.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-B0v4IKaI.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,151 +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 are shared with other parents — a many-to-many, or a
+* multi-hop `via` chain.
+*
+* 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 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);
@@ -1581,34 +1573,79 @@ function findRelation(resolvedRelations, key) {
 }
 //#endregion
 //#region ../common/src/util/resolutions.ts
-function getSubcollections(collection) {
-	if (collection.childCollections) return collection.childCollections() ?? [];
+/**
+* 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
+* copy in `CollectionRegistry.normalizeCollection` that stamped each child with
+* the *target collection's* slug instead of the relation key. Since the
+* registry ran first and cached its answer onto `childCollections`, its version
+* was the one that won, and the frontend addressed child listings by a segment
+* the backend could not resolve.
+*
+* Order of precedence:
+*   1. `childCollections` — the explicit escape hatch for custom drivers.
+*   2. `subcollections` on an engine that has real containment (Firestore).
+*   3. many-relations on an engine that has relations (SQL).
+*/
+function getEntityChildViews(collection) {
+	const asSubcollections = (collections) => collections.filter(Boolean).map((child) => ({
+		key: child.slug,
+		collection: child,
+		source: { kind: "subcollection" }
+	}));
+	if (collection.childCollections) return asSubcollections(collection.childCollections() ?? []);
+	const capabilities = getDataSourceCapabilities(collection.engine);
 	const declaredSubcollections = getDeclaredSubcollections(collection);
-	if (getDataSourceCapabilities(collection.engine).supportsSubcollections && declaredSubcollections) return declaredSubcollections() ?? [];
-	if (getDataSourceCapabilities(collection.engine).supportsRelations) {
-		const resolvedRelations = resolveCollectionRelations(collection);
-		return Object.values(resolvedRelations).filter((r) => r.cardinality === "many").map((r) => {
-			const target = r.target();
-			if (!target) return void 0;
-			const relationKey = r.relationName || target.slug;
-			let customName;
-			if (collection.properties) {
-				const prop = Object.entries(collection.properties).find(([_, p]) => p.type === "relation" && p.relationName === relationKey);
-				if (prop && prop[1].name) customName = prop[1].name;
-			}
-			const baseOverrides = { slug: relationKey };
-			if (customName) {
-				baseOverrides.name = customName;
-				baseOverrides.singularName = customName;
+	if (capabilities.supportsSubcollections && declaredSubcollections) return asSubcollections(declaredSubcollections() ?? []);
+	if (!capabilities.supportsRelations) return [];
+	const resolvedRelations = resolveCollectionRelations(collection);
+	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;
+		let target;
+		try {
+			target = relation.target();
+		} catch {
+			continue;
+		}
+		if (!target) continue;
+		seen.add(identity);
+		const customName = Object.entries(collection.properties ?? {}).find(([propKey, p]) => p.type === "relation" && (p.relation?.relationName ?? propKey) === identity)?.[1]?.name;
+		const base = {
+			...target,
+			slug: relationKey,
+			...customName ? {
+				name: customName,
+				singularName: customName
+			} : {}
+		};
+		views.push({
+			key: relationKey,
+			collection: relation.overrides ? mergeDeep(base, relation.overrides) : base,
+			source: {
+				kind: "relation",
+				relationKey,
+				mode: isJunctionBackedRelation(relation) ? "linked" : "owned",
+				targetSlug: target.slug
 			}
-			const targetWithOverrides = {
-				...target,
-				...baseOverrides
-			};
-			return r.overrides ? mergeDeep(targetWithOverrides, r.overrides) : targetWithOverrides;
-		}).filter((c) => Boolean(c));
+		});
 	}
-	return [];
+	return views;
+}
+/**
+* The child views of `collection` as bare collections.
+*
+* The flattened view of {@link getEntityChildViews}, for navigation code that
+* only needs to match a path segment against a slug. Anything that cares *what
+* kind* of list it is showing — chiefly the admin, which must not offer a
+* global delete on a shared row — should read the views instead.
+*/
+function getSubcollections(collection) {
+	return getEntityChildViews(collection).map((view) => view.collection);
 }
 //#endregion
 //#region ../common/src/util/policy/sqlToPolicy.ts
@@ -2160,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;
@@ -2621,39 +2658,9 @@ function getJunctionSecurityRules(spec) {
 		return jsonLogic;
 	});
 })))();
-//#endregion
-//#region ../common/src/util/filter-operator-resolution.ts
-/**
-* Default operators offered per property type, before engine capabilities and
-* per-property narrowing are applied. These mirror what the built-in filter
-* fields can render.
-*/
-var COMPARISON_OPS = [
-	"==",
-	"!=",
-	">",
-	">=",
-	"<",
-	"<="
-];
-var NULL_CHECK_OPS = ["is-null", "is-not-null"];
-var MEMBERSHIP_OPS = ["in", "not-in"];
-var PATTERN_OPS = [
-	"like",
-	"ilike",
-	"not-like",
-	"not-ilike"
-];
-[
-	...COMPARISON_OPS,
-	...MEMBERSHIP_OPS,
-	...PATTERN_OPS,
-	...NULL_CHECK_OPS
-], [
-	...COMPARISON_OPS,
-	...MEMBERSHIP_OPS,
-	...NULL_CHECK_OPS
-], [...COMPARISON_OPS, ...NULL_CHECK_OPS], [...NULL_CHECK_OPS], [...MEMBERSHIP_OPS, ...NULL_CHECK_OPS], [...MEMBERSHIP_OPS, ...NULL_CHECK_OPS];
+/**
+* Apply PropertyConditions to a resolved property, evaluating all JSON Logic rules.
+*/
 //#endregion
 //#region ../../node_modules/.pnpm/fast-equals@6.0.0/node_modules/fast-equals/dist/es/index.mjs
 var { getOwnPropertyNames, getOwnPropertySymbols } = Object;
@@ -3233,100 +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);
-		if (!result.childCollections) {
-			const capabilities = getDataSourceCapabilities(result.engine);
-			const declaredSubcollections = getDeclaredSubcollections(result);
-			if (capabilities.supportsSubcollections && declaredSubcollections) result.childCollections = declaredSubcollections;
-			else if (capabilities.supportsRelations && relResult.relations) {
-				const manyRelations = relResult.relations.filter((r) => r.cardinality === "many");
-				if (manyRelations.length > 0) result.childCollections = () => manyRelations.map((r) => {
-					const target = r.target();
-					return r.overrides ? mergeDeep(target, r.overrides) : target;
-				});
-			}
-		}
+		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;
 	}
@@ -3371,9 +3311,7 @@ var CollectionRegistry = class {
 			const relation = findRelation(resolveCollectionRelations(currentCollection), relationKey);
 			if (!relation) throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug}'`);
 			const target = relation.target();
-			const targetRelationKey = relation.relationName || target.slug;
-			const targetSlug = relation.overrides?.slug ?? targetRelationKey;
-			currentCollection = this.get(targetSlug) || this.normalizeCollection(target);
+			currentCollection = this.collectionsByTableName.get(getTableName(target)) ?? this.normalizeCollection(target);
 			if (i + 1 < pathSegments.length) {}
 		}
 		return currentCollection;
@@ -3408,7 +3346,7 @@ var CollectionRegistry = class {
 				if (!subcollections || subcollections.length === 0) throw new Error(`No subcollections found for ${currentCollection.slug} in path: ${path}`);
 				const subcollection = subcollections.find((c) => c.slug === subcollectionSlug);
 				if (!subcollection) throw new Error(`Subcollection '${subcollectionSlug}' not found in ${currentCollection.slug}`);
-				currentCollection = this.get(subcollection.slug) || this.normalizeCollection(subcollection);
+				currentCollection = this.normalizeCollection(subcollection);
 				collections.push(currentCollection);
 			}
 		}
@@ -4053,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-DmsRg8MR.js.map
+//# sourceMappingURL=src-3VmUJ8Xn.js.map