@rebasepro/common 0.10.1-canary.ff9ccd6 → 0.10.1-canary.g4db1bb1

package/dist/collections/CollectionRegistry.d.ts

@@ -51,12 +51,6 @@ export declare class CollectionRegistry {
     register(collection: CollectionConfig, rawCollection?: CollectionConfig): void;
     private _registerRecursively;
     normalizeCollection(collection: CollectionConfig): CollectionConfig;
-    /**
-     * 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.
-     */
-    private extractRelationsFromProperties;
     private normalizeProperties;
     private normalizeProperty;
     get(path: string): CollectionConfig | undefined;

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import { ANONYMOUS_USER_ID, CANONICAL_TO_REST, DEFAULT_DATA_SOURCE_KEY, EntityReference, EntityRelation, NULL_OPS, REST_TO_CANONICAL, getDataSourceCapabilities, getDeclaredSubcollections, isPostgresCollectionConfig, policy, toCanonicalOp } from "@rebasepro/types";
+import { ANONYMOUS_USER_ID, CANONICAL_TO_REST, DEFAULT_DATA_SOURCE_KEY, EntityReference, EntityRelation, NULL_OPS, REST_TO_CANONICAL, getDataSourceCapabilities, getDeclaredSubcollections, isManyToMany, isPostgresCollectionConfig, policy, toCanonicalOp } from "@rebasepro/types";
 import { deepClone, generateForeignKeyName, getIn, getPolicyOperations, isDefaultFieldConfigId, mergeDeep, randomString, removeFunctions, toSnakeCase } from "@rebasepro/utils";
 import jsonLogic from "json-logic-js";
 import { deepEqual } from "fast-equals";
@@ -372,151 +372,143 @@ function fullPathToCollectionSegments(path) {
 	return path.split("/").filter((e, i) => i % 2 === 0);
 }
 //#endregion
-//#region 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 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 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);
@@ -616,15 +608,21 @@ function resolveProperty(props) {
 	}
 	return resolvedProperty;
 }
-function resolveRelationProperty(property, relations, propertyKey) {
-	if (property.relation) return property;
-	const name = property.relationName || propertyKey;
-	const relation = name ? relations.find((rel) => rel.relationName === name) : void 0;
-	if (!relation) throw Error(`Relation ${name ?? "(unnamed)"} not found`);
-	return {
-		...property,
-		relation
-	};
+/**
+* The resolved relation a relation property refers to.
+*
+* Normalization stamps `resolvedRelation` onto the property, so this is usually
+* a field read. It falls back to resolving from the collection for properties
+* that never went through the registry — a preview, or a form rendered straight
+* from an authored config.
+*/
+function resolveRelationProperty(property, collection, propertyKey) {
+	if (property.resolvedRelation) return property.resolvedRelation;
+	if (property.relation) return resolveRelation(property.relation, collection, propertyKey);
+	const name = propertyKey ?? "";
+	const declared = resolveCollectionRelations(collection)[name];
+	if (!declared) throw Error(`Relation property '${name || "(unnamed)"}' on '${collection.slug}' declares no \`relation\`, and the collection has no relation of that name.`);
+	return declared;
 }
 /**
 * Resolve enum aliases for a string or number property
@@ -721,34 +719,79 @@ function resolveEnumValues(input) {
 	else if (Array.isArray(input)) return input;
 	else return;
 }
-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 src/util/policy/sqlToPolicy.ts
@@ -1624,8 +1667,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;
@@ -2070,100 +2113,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;
 	}
@@ -2208,9 +2184,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;
@@ -2245,7 +2219,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);
 			}
 		}
@@ -3356,6 +3330,6 @@ async function detectJunctionTables(executeSql) {
 	return junctionTables;
 }
 //#endregion
-export { COLLECTION_PATH_SEPARATOR, COMPOSITE_ID_SEPARATOR, CollectionRegistry, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, JUNCTION_TABLES_SQL, QueryBuilder, REBASE_INTERNAL_PREFIXES, REBASE_INTERNAL_SCHEMAS, and, buildCollection, buildCompositeId, buildConditionContext, buildProperty, buildPropertyCallbacks, buildRebaseData, buildRoutedRebaseData, buildSdkData, canCreateEntity, canDeleteEntity, canEditEntity, canReadCollection, checkOperation, classifyTable, cond, createDataSourceRegistry, createRelationRef, createRelationRefWithData, defaultUsersCollection, defineCollection, deserializeFilter, deserializeLogicalCondition, deserializeOrderBy, detectJunctionTables, embedParentExpression, enumToObjectEntries, evaluateCondition, evaluatePolicy, findAnonymousGrants, findRelation, fullPathToCollectionSegments, getArrayResolvedProperties, getColumnName, getDeclaredPrimaryKeys, getDefaultValueFor, getDefaultValueFortype, getDefaultValuesFor, getEffectiveSecurityRules, getEnumVarName, getInjectedSecurityRules, getJunctionCollectionConfig, getJunctionSecurityRules, getLabelOrConfigFrom, getPrimaryKeys, getReferenceFrom, getRelationFrom, getSubcollections, getTableName, getTableVarName, isPropertyBuilder, isRebaseInternalTable, normalizeToEntityRelation, or, parseIdValues, policyToPostgres, registerConditionOperations, resolveArrayProperties, resolveCollectionRelations, resolveDataSource, resolveEnumValues, resolveJunctionSpecs, resolvePrimaryKeys, resolveProperties, resolveProperty, resolvePropertyEnum, resolvePropertyRelation, resolveRelationProperty, resolveStorageFilenameString, resolveStoragePathString, resolveStorageSource, sanitizeData, sanitizeRelation, securityRuleToConditions, segmentsToStrippedPath, serializeFilter, serializeLogicalCondition, serializeOrderBy, sortProperties, sqlToPolicy, stripCollectionPath, traverseValueProperty, traverseValuesProperties, updateDateAutoValues, wrapAsEntityData, wrapAsSdkData };
+export { COLLECTION_PATH_SEPARATOR, COMPOSITE_ID_SEPARATOR, CollectionRegistry, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, JUNCTION_TABLES_SQL, QueryBuilder, REBASE_INTERNAL_PREFIXES, REBASE_INTERNAL_SCHEMAS, and, buildCollection, buildCompositeId, buildConditionContext, buildProperty, buildPropertyCallbacks, buildRebaseData, buildRoutedRebaseData, buildSdkData, canCreateEntity, canDeleteEntity, canEditEntity, canReadCollection, checkOperation, classifyTable, cond, createDataSourceRegistry, createRelationRef, createRelationRefWithData, defaultUsersCollection, defineCollection, deserializeFilter, deserializeLogicalCondition, deserializeOrderBy, detectJunctionTables, embedParentExpression, enumToObjectEntries, evaluateCondition, evaluatePolicy, findAnonymousGrants, findRelation, fullPathToCollectionSegments, getArrayResolvedProperties, getColumnName, getDeclaredPrimaryKeys, getDefaultValueFor, getDefaultValueFortype, getDefaultValuesFor, getEffectiveSecurityRules, getEntityChildViews, getEnumVarName, getInjectedSecurityRules, getJunctionCollectionConfig, getJunctionSecurityRules, getLabelOrConfigFrom, getPrimaryKeys, getReferenceFrom, getRelationFrom, getSubcollections, getTableName, getTableVarName, isJunctionBackedRelation, isPropertyBuilder, isRebaseInternalTable, normalizeToEntityRelation, or, parseIdValues, policyToPostgres, registerConditionOperations, resolveArrayProperties, resolveCollectionRelations, resolveDataSource, resolveEnumValues, resolveJunctionSpecs, resolvePrimaryKeys, resolveProperties, resolveProperty, resolvePropertyEnum, resolveRelation, resolveRelationProperty, resolveStorageFilenameString, resolveStoragePathString, resolveStorageSource, sanitizeData, securityRuleToConditions, segmentsToStrippedPath, serializeFilter, serializeLogicalCondition, serializeOrderBy, sortProperties, sqlToPolicy, stripCollectionPath, traverseValueProperty, traverseValuesProperties, updateDateAutoValues, wrapAsEntityData, wrapAsSdkData };
 
 //# sourceMappingURL=index.es.js.map