@rebasepro/server 0.10.1-canary.8d27c46 → 0.10.1-canary.af2af91

package/dist/api/rest/api-generator.d.ts

@@ -41,6 +41,20 @@ export declare class RestApiGenerator {
      * slug, never an id.
      */
     private enforceSubcollectionApiKeyPermission;
+    /**
+     * The collection a nested path writes into — the target of the relation its
+     * last segment names.
+     *
+     * Needed so a nested write can be checked against a schema at all. Without
+     * it these routes skipped `assertKnownWriteFields` entirely, which is why a
+     * typo `POST /posts` rejected with a 400 while the same typo on
+     * `POST /authors/1/posts` reached the database.
+     *
+     * Returns `undefined` rather than throwing when the path cannot be walked:
+     * the driver raises the authoritative error a moment later, and duplicating
+     * it here would report a resolution failure as a validation failure.
+     */
+    private resolveNestedWriteCollection;
     /**
      * Get the request-scoped driver. Throws if none is set — never falls
      * back to the unscoped `this.driver` to avoid bypassing RLS/auth.

package/dist/index.es.js

@@ -1309,6 +1309,19 @@ function sanitizeRelation(relation, sourceCollection, resolveCollection) {
 	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;
 }
+/**
+* Whether the target rows of this relation are reached through a junction — a
+* many-to-many, or a multi-hop `joinPath`.
+*
+* 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.
+*/
+function isJunctionBackedRelation(relation) {
+	return Boolean(relation.through) || Boolean(relation.joinPath && relation.joinPath.length > 1);
+}
 /** WeakMap cache — same collection instance always yields the same relation map. */
 var _resolvedRelationsCache = /* @__PURE__ */ new WeakMap();
 function resolveCollectionRelations(collection) {
@@ -1385,34 +1398,115 @@ function findRelation(resolvedRelations, key) {
 }
 //#endregion
 //#region ../common/src/util/resolutions.ts
-function getSubcollections(collection) {
-	if (collection.childCollections) return collection.childCollections() ?? [];
-	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;
+/**
+* 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);
 			}
-			const baseOverrides = { slug: relationKey };
-			if (customName) {
-				baseOverrides.name = customName;
-				baseOverrides.singularName = customName;
+		}
+	};
+	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
+* 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 (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();
+		} catch {
+			continue;
+		}
+		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 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);
 }
 policy.or(policy.serverContext(), policy.rolesOverlap(["admin"]));
 policy.or(policy.serverContext(), policy.rolesOverlap(["admin"]));
@@ -2308,18 +2402,6 @@ var CollectionRegistry = class {
 			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;
-				});
-			}
-		}
 		return result;
 	}
 	/**
@@ -2418,9 +2500,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;
@@ -2455,7 +2535,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);
 			}
 		}
@@ -4024,6 +4104,34 @@ var RestApiGenerator = class {
 		this.enforceApiKeyPermission(c, collectionPath.split("/").pop());
 	}
 	/**
+	* The collection a nested path writes into — the target of the relation its
+	* last segment names.
+	*
+	* Needed so a nested write can be checked against a schema at all. Without
+	* it these routes skipped `assertKnownWriteFields` entirely, which is why a
+	* typo `POST /posts` rejected with a 400 while the same typo on
+	* `POST /authors/1/posts` reached the database.
+	*
+	* Returns `undefined` rather than throwing when the path cannot be walked:
+	* the driver raises the authoritative error a moment later, and duplicating
+	* it here would report a resolution failure as a validation failure.
+	*/
+	resolveNestedWriteCollection(collectionPath) {
+		const segments = collectionPath.split("/").filter((s) => s && s !== "undefined");
+		let current = this.collections.find((c) => c.slug === segments[0]);
+		for (let i = 2; i < segments.length && current; i += 2) {
+			const relation = findRelation(resolveCollectionRelations(current), segments[i]);
+			if (!relation) return void 0;
+			try {
+				const target = relation.target();
+				current = this.collections.find((c) => c.slug === target?.slug) ?? target;
+			} catch {
+				return;
+			}
+		}
+		return current;
+	}
+	/**
 	* Get the request-scoped driver. Throws if none is set — never falls
 	* back to the unscoped `this.driver` to avoid bypassing RLS/auth.
 	*/
@@ -4264,7 +4372,9 @@ var RestApiGenerator = class {
 				}) : 0;
 				return c.json({ count: total });
 			} else if (parsed.id) {
-				const entity = await driver.fetchOne({
+				const queryOptions = this.parseQuery(c.req.queries());
+				const fetchService = driver.restFetchService;
+				const entity = fetchService ? await fetchService.fetchOneForRest(parsed.collectionPath, parsed.id, queryOptions.include) : await driver.fetchOne({
 					path: parsed.collectionPath,
 					id: parsed.id
 				});
@@ -4274,13 +4384,18 @@ var RestApiGenerator = class {
 				const queryDict = c.req.queries();
 				const queryOptions = this.parseQuery(queryDict);
 				const searchString = Array.isArray(queryDict.searchString) ? queryDict.searchString[queryDict.searchString.length - 1] : void 0;
-				const entities = await driver.fetchCollection({
-					path: parsed.collectionPath,
+				const fetchService = driver.restFetchService;
+				const listOptions = {
 					filter: queryOptions.where,
 					limit: queryOptions.limit,
+					offset: queryOptions.offset,
 					orderBy: queryOptions.orderBy?.[0]?.field,
 					order: queryOptions.orderBy?.[0]?.direction === "desc" ? "desc" : "asc",
 					searchString
+				};
+				const entities = fetchService ? await fetchService.fetchCollectionForRest(parsed.collectionPath, listOptions, queryOptions.include) : await driver.fetchCollection({
+					path: parsed.collectionPath,
+					...listOptions
 				});
 				const total = driver.count ? await driver.count({
 					path: parsed.collectionPath,
@@ -4306,6 +4421,8 @@ var RestApiGenerator = class {
 			const driver = this.getScopedDriver(c);
 			this.enforceSubcollectionApiKeyPermission(c, parsed.collectionPath);
 			const body = await parseJsonBody(c);
+			const targetCollection = this.resolveNestedWriteCollection(parsed.collectionPath);
+			if (targetCollection) assertKnownWriteFields(body, targetCollection);
 			const entity = await driver.save({
 				path: parsed.collectionPath,
 				values: body,
@@ -4322,6 +4439,8 @@ var RestApiGenerator = class {
 			const driver = this.getScopedDriver(c);
 			this.enforceSubcollectionApiKeyPermission(c, parsed.collectionPath);
 			const body = await parseJsonBody(c);
+			const targetCollection = this.resolveNestedWriteCollection(parsed.collectionPath);
+			if (targetCollection) assertKnownWriteFields(body, targetCollection);
 			const entity = await driver.save({
 				path: parsed.collectionPath,
 				id: parsed.id,