@rebasepro/server-postgres 0.10.1-canary.7609565 → 0.10.1-canary.7801eed

package/src/schema/introspect-db-logic.ts

@@ -569,11 +569,11 @@ export function generateCollectionFile(
         // Date auto-value heuristics
         if (finalPropType === "date") {
             if (colNameLower === "created_at" || colNameLower === "createdat") {
-                extra += "\n            autoValue: \"on_create\",\n            ui: {\n                readOnly: true,\n                hideFromCollection: true\n            },";
+                extra += "\n            autoValue: \"on_create\",\n            admin: {\n                readOnly: true,\n                hideFromCollection: true\n            },";
             } else if (colNameLower === "updated_at" || colNameLower === "updatedat") {
-                extra += "\n            autoValue: \"on_update\",\n            ui: {\n                readOnly: true,\n                hideFromCollection: true\n            },";
+                extra += "\n            autoValue: \"on_update\",\n            admin: {\n                readOnly: true,\n                hideFromCollection: true\n            },";
             } else if (col.column_default && (col.column_default.includes("now()") || col.column_default.includes("CURRENT_TIMESTAMP"))) {
-                extra += "\n            autoValue: \"on_create\",\n            ui: {\n                readOnly: true\n            },";
+                extra += "\n            autoValue: \"on_create\",\n            admin: {\n                readOnly: true\n            },";
             }
         }
 
@@ -604,13 +604,13 @@ export function generateCollectionFile(
             if (isMedia) {
                 extra += `\n            storage: {\n                storagePath: "${tableName}/${col.column_name}"\n            },`;
             } else if (isUrl) {
-                extra += "\n            ui: {\n                url: true\n            },";
+                extra += "\n            url: true,";
             } else if (colNameLower === "description" || colNameLower === "summary" || colNameLower === "excerpt") {
-                extra += "\n            multiline: true,";
+                extra += "\n            admin: {\n                multiline: true\n            },";
             } else if (colNameLower === "content" || colNameLower === "body") {
                 extra += "\n            multiline: true,\n            markdown: true,";
             } else if (col.data_type === "text") {
-                extra += "\n            multiline: true,";
+                extra += "\n            admin: {\n                multiline: true\n            },";
             }
         }
 
@@ -700,11 +700,12 @@ export function generateCollectionFile(
         ${relName}: {
             name: "${relHumanName}",
             type: "relation",
-            target: () => ${targetCollectionCamel},
-            cardinality: "one",
-            direction: "owning",
-            localKey: "${fk.column_name}",
             // mapped from foreign key: ${fk.column_name} -> ${targetTableName}(${fk.foreign_column_name})
+            relation: {
+                kind: "belongsTo",
+                target: () => ${targetCollectionCamel},
+                localKey: "${fk.column_name}"
+            }
         },`);
         }
     }
@@ -718,15 +719,12 @@ export function generateCollectionFile(
         const targetCollectionCamel = toCollectionVarName(sourceTableName);
         imports.add(`import ${targetCollectionCamel} from "./${sourceTableName}";`);
 
-        const inverseRelName = fk.column_name.replace(/_id$/, "");
-
         relationsOutput += `
         {
+            kind: "hasMany",
             relationName: "${sourceTableName}",
             target: () => ${targetCollectionCamel},
-            cardinality: "many",
-            direction: "inverse",
-            inverseRelationName: "${inverseRelName}",
+            // the ${sourceTableName}.${fk.column_name} FK points back here
             foreignKeyOnTarget: "${fk.column_name}"
         },`;
     }
@@ -755,10 +753,9 @@ export function generateCollectionFile(
 
             relationsOutput += `
         {
+            kind: "manyToMany",
             relationName: "${relPropName}",
             target: () => ${tableName}Collection,
-            cardinality: "many",
-            direction: "owning",
             through: {
                 table: "${jt}",
                 sourceColumn: "${thisFk.column_name}",
@@ -776,24 +773,23 @@ export function generateCollectionFile(
             const targetCollectionCamel = toCollectionVarName(targetTableName);
             imports.add(`import ${targetCollectionCamel} from "./${targetTableName}";`);
 
-            // Determine direction (alphabetically first table is owning)
-            const direction = tableName < targetTableName ? "owning" : "inverse";
-
+            // Both sides of a many-to-many are `manyToMany`. There is no owning
+            // and inverse side to pick between any more, so this no longer
+            // guesses one from table-name ordering and no longer emits a
+            // half-configured relation on the losing side with a comment asking
+            // the reader to finish it by hand. Introspection already knows both
+            // junction columns; each side just names them from its own end.
             const thisFk = joinFks.find((fk) => fk.foreign_table_name === tableName);
 
-            let throughCode = "";
-            if (direction === "owning" && thisFk) {
-                throughCode = `\n            through: {\n                table: "${jt}",\n                sourceColumn: "${thisFk.column_name}",\n                targetColumn: "${otherFk.column_name}"\n            },`;
-            } else if (direction === "inverse") {
-                throughCode = "\n            // Make sure the target collection configures the 'through' property.";
-            }
+            const throughCode = thisFk
+                ? `\n            through: {\n                table: "${jt}",\n                sourceColumn: "${thisFk.column_name}",\n                targetColumn: "${otherFk.column_name}"\n            }`
+                : "";
 
             relationsOutput += `
         {
+            kind: "manyToMany",
             relationName: "${targetTableName}",
-            target: () => ${targetCollectionCamel},
-            cardinality: "many",
-            direction: "${direction}",${throughCode}
+            target: () => ${targetCollectionCamel},${throughCode}
         },`;
         }
     }

package/src/services/FetchService.ts

@@ -1,6 +1,6 @@
 import { and, asc, count, desc, eq, getTableName, gt, lt, or, SQL, TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm";
 import { AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
-import { CollectionConfig, FilterValues, Relation, LogicalCondition } from "@rebasepro/types";
+import { CollectionConfig, FilterValues, ResolvedRelation, LogicalCondition, isManyToMany } from "@rebasepro/types";
 import type { VectorSearchParams } from "@rebasepro/types";
 import { resolveCollectionRelations, findRelation, createRelationRef, createRelationRefWithData } from "@rebasepro/common";
 import { DrizzleConditionBuilder } from "../utils/drizzle-conditions";
@@ -19,6 +19,7 @@ import { RelationalQueryBuilder } from "drizzle-orm/pg-core/query-builders/query
 import { DrizzleClient } from "../interfaces";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
 import { toCmsRow, toRestRow, isJunctionRelation } from "./row-pipeline";
+import { isNestedPath, resolveNestedPath, type NestedPathHop } from "./nested-path";
 import { logger } from "@rebasepro/server";
 
 /** Type-safe accessor for Drizzle's relational query API via dynamic table name */
@@ -72,7 +73,7 @@ export class FetchService {
         let orderByField = table[orderBy as keyof typeof table] as AnyPgColumn;
         if (!orderByField && collection) {
             const property = collection.properties[orderBy];
-            if (property && property.type === "relation" && "relation" in property && property.relation?.direction === "owning") {
+            if (property && property.type === "relation" && "relation" in property && property.resolvedRelation?.kind === "belongsTo") {
                 orderByField = table[`${orderBy}_id` as keyof typeof table] as AnyPgColumn;
             }
         }
@@ -105,7 +106,7 @@ export class FetchService {
             const drizzleRelName = relation.relationName || key;
 
             // Skip relations that use joinPath as they are not mapped in Drizzle schemas
-            if (relation.joinPath && relation.joinPath.length > 0) {
+            if (relation.kind === "via") {
                 continue;
             }
 
@@ -134,8 +135,8 @@ export class FetchService {
      * Get the Drizzle relation name on the junction table that points to the actual target row.
      * For example, for posts_tags junction, this returns "tag_id" (the relation pointing to tags).
      */
-    private getJunctionTargetRelationName(relation: Relation, _collection: CollectionConfig): string | null {
-        if (relation.through) {
+    private getJunctionTargetRelationName(relation: ResolvedRelation, _collection: CollectionConfig): string | null {
+        if (isManyToMany(relation)) {
             // The junction relation on the junction table pointing to the target
             // uses the targetColumn name as the Drizzle relation name
             return relation.through.targetColumn.replace(/_id$/, "_id");
@@ -158,7 +159,7 @@ export class FetchService {
         const resolvedRelations = resolveCollectionRelations(collection);
 
         const promises = Object.entries(resolvedRelations)
-            .filter(([key, relation]) => relation.joinPath && relation.joinPath.length > 0)
+            .filter(([key, relation]) => relation.kind === "via")
             .map(async ([key, relation]) => {
                 try {
                     const relatedRows = await this.relationService.fetchRelatedEntities(
@@ -203,7 +204,7 @@ export class FetchService {
             !include || include.length === 0 || include[0] === "*" || include.includes(key);
 
         const joinPathRelations = Object.entries(resolvedRelations)
-            .filter(([key, relation]) => relation.joinPath && relation.joinPath.length > 0 && propertyKeys.has(key) && shouldInclude(key));
+            .filter(([key, relation]) => relation.kind === "via" && propertyKeys.has(key) && shouldInclude(key));
 
         if (joinPathRelations.length === 0) return;
 
@@ -279,7 +280,8 @@ export class FetchService {
             logical?: LogicalCondition;
         },
         collectionPath: string,
-        withConfig?: Record<string, unknown>
+        withConfig?: Record<string, unknown>,
+        scopeCondition?: SQL
     ): Record<string, unknown> {
         const queryOpts: Record<string, unknown> = {};
 
@@ -288,6 +290,8 @@ export class FetchService {
         // Build where conditions
         const allConditions: SQL[] = [];
 
+        if (scopeCondition) allConditions.push(scopeCondition);
+
         if (options.searchString) {
             const collection = getCollectionByPath(collectionPath, this.registry);
             const searchConditions = DrizzleConditionBuilder.buildSearchConditions(
@@ -391,6 +395,59 @@ export class FetchService {
         return [];
     }
 
+    /**
+     * Compile "rows reachable from this parent" into a `WHERE` condition on the
+     * target table, so a nested listing can run as an ordinary collection query.
+     */
+    private buildRelationScope(hop: NestedPathHop): SQL {
+        const parentPks = requirePrimaryKeys(hop.parentCollection, this.registry);
+        const parentIdInfo = parentPks[0];
+        const parsedParentId = parseIdValues(hop.parentId, parentPks)[parentIdInfo.fieldName];
+
+        const parent = () => {
+            const table = getTableForCollection(hop.parentCollection, this.registry);
+            const idColumn = table[parentIdInfo.fieldName as keyof typeof table] as AnyPgColumn;
+            if (!idColumn) {
+                throw new Error(`ID field '${parentIdInfo.fieldName}' not found in table for collection '${hop.parentCollection.slug}'`);
+            }
+            return { table,
+idColumn };
+        };
+
+        const targetTable = getTableForCollection(hop.targetCollection, this.registry);
+        const targetPks = requirePrimaryKeys(hop.targetCollection, this.registry);
+        const targetIdColumn = targetTable[targetPks[0].fieldName as keyof typeof targetTable] as AnyPgColumn;
+        if (!targetIdColumn) {
+            throw new Error(`ID field '${targetPks[0].fieldName}' not found in table for collection '${hop.targetCollection.slug}'`);
+        }
+
+        return DrizzleConditionBuilder.buildRelationScopeCondition(
+            hop.relation,
+            parent,
+            parsedParentId as string | number,
+            targetTable,
+            targetIdColumn,
+            this.registry
+        );
+    }
+
+    /**
+     * Whether `id` is actually reachable at `collectionPath`.
+     *
+     * Trivially true for a root path. For a nested one it is a real question:
+     * the path resolves to the target collection, and matching on the primary
+     * key alone made the parent segment decorative — `authors/1/posts/43`
+     * returned post 43 whoever wrote it, and the REST layer's delete then
+     * deleted it. A row that is not under this parent is reported as absent,
+     * which is what a caller addressing it through the parent should see.
+     */
+    private async isAddressableUnder(collectionPath: string, id: string | number): Promise<boolean> {
+        if (!isNestedPath(collectionPath)) return true;
+        const hop = resolveNestedPath(collectionPath, this.registry);
+        if (!hop) return true;
+        return this.relationService.isRelated(hop, id);
+    }
+
     /**
      * Fetch a single row by ID
      */
@@ -399,6 +456,8 @@ export class FetchService {
         id: string | number,
         databaseId?: string
     ): Promise<Record<string, unknown> | undefined> {
+        if (!await this.isAddressableUnder(collectionPath, id)) return undefined;
+
         const collection = getCollectionByPath(collectionPath, this.registry);
         const table = getTableForCollection(collection, this.registry);
         const idInfoArray = requirePrimaryKeys(collection, this.registry);
@@ -436,7 +495,7 @@ export class FetchService {
                 return flatRow;
             } catch (e) {
                 if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
-                    logger.error(`[FetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+                    logger.error(`[FetchService] ResolvedRelation inference error for collection '${collectionPath}': ${e.message}`);
                     logger.error("Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.");
                 }
                 logger.warn(`[FetchService] db.query.findFirst failed for ${collectionPath}, falling back to db.select`, { error: e });
@@ -516,8 +575,11 @@ export class FetchService {
             databaseId?: string;
             vectorSearch?: VectorSearchParams;
             logical?: LogicalCondition;
+            /** Narrow to the rows reachable from a parent through a relation. */
+            relatedTo?: NestedPathHop;
         } = {}
     ): Promise<Record<string, unknown>[]> {
+        const scopeCondition = options.relatedTo ? this.buildRelationScope(options.relatedTo) : undefined;
         const collection = getCollectionByPath(collectionPath, this.registry);
         const table = getTableForCollection(collection, this.registry);
         const idInfoArray = requirePrimaryKeys(collection, this.registry);
@@ -545,7 +607,7 @@ export class FetchService {
         if (qb && !options.searchString && !hasRelations && !options.vectorSearch) {
             try {
                 const queryOpts = this.buildDrizzleQueryOptions<M>(
-                    table, idField, idInfo, options, collectionPath, undefined
+                    table, idField, idInfo, options, collectionPath, undefined, scopeCondition
                 );
 
 
@@ -558,7 +620,7 @@ export class FetchService {
                 return rows;
             } catch (e) {
                 if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
-                    logger.error(`[FetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+                    logger.error(`[FetchService] ResolvedRelation inference error for collection '${collectionPath}': ${e.message}`);
                     logger.error("Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.");
                 }
                 logger.warn(`[FetchService] db.query.findMany failed for ${collectionPath}, falling back to db.select`, { error: e });
@@ -578,6 +640,8 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
             : this.db.select().from(table).$dynamic();
         const allConditions: SQL[] = [];
 
+        if (scopeCondition) allConditions.push(scopeCondition);
+
         if (options.searchString) {
             const searchConditions = DrizzleConditionBuilder.buildSearchConditions(
                 options.searchString, collection.properties, table
@@ -771,9 +835,13 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
             vectorSearch?: VectorSearchParams;
         } = {}
     ): Promise<Record<string, unknown>[]> {
-        // Handle multi-segment paths by resolving through relations
-        if (collectionPath.includes("/")) {
-            return this.fetchCollectionFromPath<M>(collectionPath, options);
+        // A nested path is the target collection narrowed by a relation — the
+        // same query, one condition heavier. It used to be a separate builder
+        // that honoured `limit` and nothing else.
+        const hop = isNestedPath(collectionPath) ? resolveNestedPath(collectionPath, this.registry) : undefined;
+        if (hop) {
+            return this.fetchRowsWithConditions<M>(hop.targetCollection.slug, { ...options,
+relatedTo: hop });
         }
 
         return this.fetchRowsWithConditions<M>(collectionPath, options);
@@ -799,65 +867,6 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
         });
     }
 
-    /**
-     * Fetch collection from multi-segment path
-     */
-    private async fetchCollectionFromPath<M extends Record<string, unknown>>(
-        path: string,
-        options: {
-            filter?: FilterValues<Extract<keyof M, string>>;
-            orderBy?: string;
-            order?: "desc" | "asc";
-            limit?: number;
-            startAfter?: Record<string, unknown>;
-            searchString?: string;
-            databaseId?: string;
-        } = {}
-    ): Promise<Record<string, unknown>[]> {
-        const pathSegments = path.split("/").filter(p => p && p !== "undefined");
-
-        if (pathSegments.length < 3 || pathSegments.length % 2 === 0) {
-            throw new Error(`Invalid relation path: ${path}. Expected format: collection/id/relation`);
-        }
-
-        const rootCollectionPath = pathSegments[0];
-        let currentCollection = getCollectionByPath(rootCollectionPath, this.registry);
-        let currentId: string | number = pathSegments[1];
-
-        for (let i = 2; i < pathSegments.length; i += 2) {
-            const relationKey = pathSegments[i];
-            const resolvedRelations = resolveCollectionRelations(currentCollection);
-            const relation = findRelation(resolvedRelations, relationKey);
-
-            if (!relation) {
-                throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug}'`);
-            }
-
-            if (i === pathSegments.length - 1) {
-                const rows = await this.relationService.fetchRelatedEntities<M>(
-                    currentCollection.slug,
-                    currentId,
-                    relationKey,
-                    options
-                );
-                // Flatten RelatedRow[] to rows: the target's columns, and only
-                // those. Merging `row.id` in last overwrote a real `id` column,
-                // and the address is derivable without it — a consumer resolves
-                // this path ("posts/1/comments") to the target collection and
-                // reads the key columns, which `values` carries.
-                return rows.map(row => ({ ...row.values as Record<string, unknown> }));
-            }
-
-            if (i + 1 < pathSegments.length) {
-                const nextEntityId = pathSegments[i + 1];
-                currentCollection = relation.target();
-                currentId = nextEntityId;
-            }
-        }
-
-        throw new Error(`Unable to resolve path: ${path}`);
-    }
-
     /**
      * Count rows in a collection
      */
@@ -869,16 +878,20 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
             databaseId?: string;
         } = {}
     ): Promise<number> {
-        if (collectionPath.includes("/")) {
-            return this.countEntitiesFromPath<M>(collectionPath, options);
-        }
+        // Same narrowing as the listing — and, unlike the count it replaces,
+        // the same `filter` and `searchString` too, so `total` describes the
+        // rows that were actually served.
+        const hop = isNestedPath(collectionPath) ? resolveNestedPath(collectionPath, this.registry) : undefined;
+        const effectivePath = hop ? hop.targetCollection.slug : collectionPath;
 
-        const collection = getCollectionByPath(collectionPath, this.registry);
+        const collection = getCollectionByPath(effectivePath, this.registry);
         const table = getTableForCollection(collection, this.registry);
 
         let query = this.db.select({ count: count() }).from(table).$dynamic();
         const allConditions: SQL[] = [];
 
+        if (hop) allConditions.push(this.buildRelationScope(hop));
+
         if (options.searchString) {
             const searchConditions = DrizzleConditionBuilder.buildSearchConditions(
                 options.searchString, collection.properties, table
@@ -888,7 +901,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
         }
 
         if (options.filter) {
-            const filterConditions = this.buildFilterConditions(options.filter, table, collectionPath);
+            const filterConditions = this.buildFilterConditions(options.filter, table, effectivePath);
             if (filterConditions.length > 0) allConditions.push(...filterConditions);
         }
 
@@ -901,50 +914,6 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
         return Number(result[0]?.count || 0);
     }
 
-    /**
-     * Count rows from multi-segment path
-     */
-    private async countEntitiesFromPath<M extends Record<string, unknown>>(
-        path: string,
-        options: { filter?: FilterValues<Extract<keyof M, string>>; databaseId?: string } = {}
-    ): Promise<number> {
-        const pathSegments = path.split("/").filter(p => p && p !== "undefined");
-
-        if (pathSegments.length < 3 || pathSegments.length % 2 === 0) {
-            throw new Error(`Invalid relation path: ${path}`);
-        }
-
-        const rootCollectionPath = pathSegments[0];
-        let currentCollection = getCollectionByPath(rootCollectionPath, this.registry);
-        let currentId: string | number = pathSegments[1];
-
-        for (let i = 2; i < pathSegments.length; i += 2) {
-            const relationKey = pathSegments[i];
-            const resolvedRelations = resolveCollectionRelations(currentCollection);
-            const relation = findRelation(resolvedRelations, relationKey);
-
-            if (!relation) {
-                throw new Error(`Relation '${relationKey}' not found`);
-            }
-
-            if (i === pathSegments.length - 1) {
-                return this.relationService.countRelatedEntities(
-                    currentCollection.slug,
-                    currentId,
-                    relationKey,
-                    options
-                );
-            }
-
-            if (i + 1 < pathSegments.length) {
-                currentCollection = relation.target();
-                currentId = pathSegments[i + 1];
-            }
-        }
-
-        throw new Error(`Unable to count for path: ${path}`);
-    }
-
     /**
      * Check if a field value is unique
      */
@@ -1014,9 +983,25 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
             searchString?: string;
             databaseId?: string;
             vectorSearch?: VectorSearchParams;
+            /** Narrow to the rows reachable from a parent through a relation. */
+            relatedTo?: NestedPathHop;
         } = {},
         include?: string[]
     ): Promise<Record<string, unknown>[]> {
+        // Resolve a nested path here rather than at the route, so `include`,
+        // `offset` and the rest reach a child listing by the same route they
+        // reach a root one.
+        if (isNestedPath(collectionPath)) {
+            const hop = resolveNestedPath(collectionPath, this.registry);
+            if (hop) {
+                return this.fetchCollectionForRest<M>(
+                    hop.targetCollection.slug, { ...options,
+relatedTo: hop }, include
+                );
+            }
+        }
+
+        const scopeCondition = options.relatedTo ? this.buildRelationScope(options.relatedTo) : undefined;
         const collection = getCollectionByPath(collectionPath, this.registry);
         const table = getTableForCollection(collection, this.registry);
         const idInfoArray = requirePrimaryKeys(collection, this.registry);
@@ -1039,7 +1024,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
                     : undefined;
 
                 const queryOpts = this.buildDrizzleQueryOptions<M>(
-                    table, idField, idInfo, options, collectionPath, withConfig
+                    table, idField, idInfo, options, collectionPath, withConfig, scopeCondition
                 );
 
 
@@ -1055,7 +1040,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
                 return restRows;
             } catch (e) {
                 if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
-                    logger.error(`[FetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+                    logger.error(`[FetchService] ResolvedRelation inference error for collection '${collectionPath}': ${e.message}`);
                     logger.error("Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.");
                 }
                 logger.warn(`[fetchCollectionForRest] db.query.findMany failed for ${collectionPath}, falling back`, { error: e });
@@ -1123,6 +1108,8 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
         include?: string[],
         databaseId?: string
     ): Promise<Record<string, unknown> | null> {
+        if (!await this.isAddressableUnder(collectionPath, id)) return null;
+
         const collection = getCollectionByPath(collectionPath, this.registry);
         const table = getTableForCollection(collection, this.registry);
         const idInfoArray = requirePrimaryKeys(collection, this.registry);
@@ -1159,7 +1146,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
                 return restRow;
             } catch (e) {
                 if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
-                    logger.error(`[FetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+                    logger.error(`[FetchService] ResolvedRelation inference error for collection '${collectionPath}': ${e.message}`);
                     logger.error("Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.");
                 }
                 logger.warn(`[fetchOneForRest] db.query.findFirst failed for ${collectionPath}, falling back`, { error: e });
@@ -1229,6 +1216,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
             startAfter?: Record<string, unknown>;
             searchString?: string;
             vectorSearch?: VectorSearchParams;
+            relatedTo?: NestedPathHop;
         } = {}
     ): Promise<Record<string, unknown>[]> {
         const collection = getCollectionByPath(collectionPath, this.registry);
@@ -1248,6 +1236,8 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
             : this.db.select().from(table).$dynamic();
         const allConditions: SQL[] = [];
 
+        if (options.relatedTo) allConditions.push(this.buildRelationScope(options.relatedTo));
+
         if (options.searchString) {
             const searchConditions = DrizzleConditionBuilder.buildSearchConditions(
                 options.searchString, collection.properties, table
@@ -1434,7 +1424,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
         const relation = resolvedRelations[relationKey];
 
         if (!relation) {
-            logger.warn(`[batchFetchManyRelatedRows] Relation '${relationKey}' not found, skipping`);
+            logger.warn(`[batchFetchManyRelatedRows] ResolvedRelation '${relationKey}' not found, skipping`);
             return new Map();
         }