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

package/src/schema/generate-drizzle-schema-logic.ts

@@ -97,12 +97,14 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
                 columnDefinition = `uuid("${colName}")`;
             } else if (stringProp.columnType === "uuid") {
                 columnDefinition = `uuid("${colName}")`;
-            } else if (stringProp.columnType === "text" || stringProp.ui?.markdown || stringProp.ui?.multiline) {
-                columnDefinition = `text("${colName}")`;
             } else if (stringProp.columnType === "char") {
                 columnDefinition = `char("${colName}")`;
-            } else {
+            } else if (stringProp.columnType === "varchar") {
                 columnDefinition = `varchar("${colName}")`;
+            } else {
+                // `text` is the default, and the only length-unbounded choice.
+                // Ask for `varchar` explicitly if you want the length constraint.
+                columnDefinition = `text("${colName}")`;
             }
             if (isIdProperty(propName, prop, collection)) {
                 columnDefinition += ".primaryKey()";
@@ -252,7 +254,7 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             const targetTableVar = getTableVarName(getTableName(targetCollection));
             const pkProp = getPrimaryKeyProp(targetCollection);
             const targetIdField = pkProp.name;
-            const baseColumn = pkProp.type === "number" ? `integer("${fkColumnName}")` : (pkProp.isUuid ? `uuid("${fkColumnName}")` : `varchar("${fkColumnName}")`);
+            const baseColumn = pkProp.type === "number" ? `integer("${fkColumnName}")` : (pkProp.isUuid ? `uuid("${fkColumnName}")` : `text("${fkColumnName}")`);
 
             const onUpdate = relation.onUpdate ? `onUpdate: "${relation.onUpdate}"` : "";
             const required = prop.validation?.required;
@@ -274,14 +276,14 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             const refProp = prop as ReferenceProperty;
             const targetCollection = collections.find(c => c.slug === refProp.path || getTableName(c) === refProp.path);
             if (!targetCollection) {
-                columnDefinition = `varchar("${colName}")`;
+                columnDefinition = `text("${colName}")`;
                 break;
             }
 
             const pkProp = getPrimaryKeyProp(targetCollection);
             const targetTableVar = getTableVarName(getTableName(targetCollection));
             const targetIdField = pkProp.name;
-            const baseColumn = pkProp.type === "number" ? `integer("${colName}")` : (pkProp.isUuid ? `uuid("${colName}")` : `varchar("${colName}")`);
+            const baseColumn = pkProp.type === "number" ? `integer("${colName}")` : (pkProp.isUuid ? `uuid("${colName}")` : `text("${colName}")`);
 
             const required = prop.validation?.required;
             const onDelete = required ? "cascade" : "set null";
@@ -597,8 +599,10 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
             const onDelete = relation.onDelete ?? "cascade";
             const refOptions = `{ onDelete: \"${onDelete}\" }`;
 
-            const sourceColType = isNumericId(sourceCollection) ? "integer" : (getPrimaryKeyProp(sourceCollection).isUuid ? "uuid" : "varchar");
-            const targetColType = isNumericId(targetCollection) ? "integer" : (getPrimaryKeyProp(targetCollection).isUuid ? "uuid" : "varchar");
+            // `text`, matching the string default: a junction column must have the
+            // same type as the primary key it references.
+            const sourceColType = isNumericId(sourceCollection) ? "integer" : (getPrimaryKeyProp(sourceCollection).isUuid ? "uuid" : "text");
+            const targetColType = isNumericId(targetCollection) ? "integer" : (getPrimaryKeyProp(targetCollection).isUuid ? "uuid" : "text");
             const sourceId = getPrimaryKeyName(sourceCollection);
             const targetId = getPrimaryKeyName(targetCollection);
 
@@ -637,7 +641,7 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
             // We should generate a basic id column if one was completely omitted.
             const hasIdColumn = Array.from(columns).some(col => col.includes(".primaryKey()"));
             if (!hasIdColumn) {
-                columns.add("    id: varchar(\"id\").primaryKey()");
+                columns.add("    id: text(\"id\").primaryKey()");
             }
 
             schemaContent += `${Array.from(columns).join(",\n")}`;

package/src/schema/generate-postgres-ddl-logic.ts

@@ -4,7 +4,7 @@ import { toSnakeCase, getPolicyNamesForRule } from "@rebasepro/utils";
 
 // --- Helper Functions ---
 
-const resolveColumnName = (propName: string, prop?: Property | null): string => {
+export const resolveColumnName = (propName: string, prop?: Property | null): string => {
     if (prop && "columnName" in prop && typeof prop.columnName === "string") {
         return prop.columnName;
     }
@@ -36,7 +36,7 @@ const getPrimaryKeyName = (collection: CollectionConfig): string => {
     return getPrimaryKeyProp(collection).name;
 };
 
-const isIdProperty = (propName: string, prop: Property, collection: CollectionConfig): boolean => {
+export const isIdProperty = (propName: string, prop: Property, collection: CollectionConfig): boolean => {
     if ("isId" in prop && Boolean(prop.isId)) return true;
     const hasExplicitId = Object.values(collection.properties ?? {}).some(p => "isId" in (p as unknown as object) && Boolean((p as unknown as Record<string, unknown>).isId));
     return !hasExplicitId && propName === "id";
@@ -90,7 +90,7 @@ const generateSinglePolicyDdl = (collection: CollectionConfig, rule: SecurityRul
     return `${ddl};\n`;
 };
 
-const getSqlColumnType = (propName: string, prop: Property, collection: CollectionConfig, collections: CollectionConfig[]): string => {
+export const getSqlColumnType = (propName: string, prop: Property, collection: CollectionConfig, collections: CollectionConfig[]): string => {
     switch (prop.type) {
         case "string": {
             const stringProp = prop as StringProperty;
@@ -103,13 +103,18 @@ const getSqlColumnType = (propName: string, prop: Property, collection: Collecti
             if (stringProp.isId === "uuid" || stringProp.columnType === "uuid") {
                 return "UUID";
             }
-            if (stringProp.columnType === "text" || stringProp.ui?.markdown || stringProp.ui?.multiline) {
-                return "TEXT";
-            }
             if (stringProp.columnType === "char") {
                 return "CHAR(255)";
             }
-            return "VARCHAR(255)";
+            if (stringProp.columnType === "varchar") {
+                return "VARCHAR(255)";
+            }
+            // `text` is the default. The two generators disagreed here before:
+            // this one emitted VARCHAR(255) while the drizzle path emitted a bare
+            // `varchar()`, which Postgres treats as unbounded — so the same
+            // property produced a capped column down one path and an uncapped one
+            // down the other.
+            return "TEXT";
         }
         case "number": {
             const numProp = prop as NumberProperty;
@@ -173,20 +178,20 @@ const getSqlColumnType = (propName: string, prop: Property, collection: Collecti
             try {
                 targetCollection = relation.target();
             } catch {
-                return "VARCHAR(255)";
+                return "TEXT";
             }
             const pkProp = getPrimaryKeyProp(targetCollection);
-            return pkProp.type === "number" ? "INTEGER" : (pkProp.isUuid ? "UUID" : "VARCHAR(255)");
+            return pkProp.type === "number" ? "INTEGER" : (pkProp.isUuid ? "UUID" : "TEXT");
         }
         case "reference": {
             const refProp = prop as ReferenceProperty;
             const targetCollection = collections.find(c => c.slug === refProp.path || getTableName(c) === refProp.path);
-            if (!targetCollection) return "VARCHAR(255)";
+            if (!targetCollection) return "TEXT";
             const pkProp = getPrimaryKeyProp(targetCollection);
-            return pkProp.type === "number" ? "INTEGER" : (pkProp.isUuid ? "UUID" : "VARCHAR(255)");
+            return pkProp.type === "number" ? "INTEGER" : (pkProp.isUuid ? "UUID" : "TEXT");
         }
         default:
-            return "VARCHAR(255)";
+            return "TEXT";
     }
 };
 
@@ -287,8 +292,10 @@ export const generatePostgresDdl = async (
             const targetSchema = isPostgresCollectionConfig(targetCollection) && targetCollection.schema ? targetCollection.schema : "public";
             const { sourceColumn, targetColumn } = relation.through;
 
-            const sourceColType = isNumericId(sourceCollection) ? "INTEGER" : (getPrimaryKeyProp(sourceCollection).isUuid ? "UUID" : "VARCHAR(255)");
-            const targetColType = isNumericId(targetCollection) ? "INTEGER" : (getPrimaryKeyProp(targetCollection).isUuid ? "UUID" : "VARCHAR(255)");
+            // TEXT, matching the string default: a junction column has to have the
+            // same type as the primary key it references.
+            const sourceColType = isNumericId(sourceCollection) ? "INTEGER" : (getPrimaryKeyProp(sourceCollection).isUuid ? "UUID" : "TEXT");
+            const targetColType = isNumericId(targetCollection) ? "INTEGER" : (getPrimaryKeyProp(targetCollection).isUuid ? "UUID" : "TEXT");
             const sourceId = getPrimaryKeyName(sourceCollection);
             const targetId = getPrimaryKeyName(targetCollection);
 
@@ -424,7 +431,7 @@ export const generatePostgresDdl = async (
             // Backwards compatibility: add default id primary key if missing
             const hasPk = columns.some(c => c.includes("PRIMARY KEY"));
             if (!hasPk) {
-                columns.unshift('  "id" VARCHAR(255) PRIMARY KEY');
+                columns.unshift('  "id" TEXT PRIMARY KEY');
             }
 
             ddl += columns.join(",\n");

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

@@ -51,10 +51,11 @@ export function inferPropertyFromData(
             }
         }
 
-        // Currency
-        if (colNameLower.includes("price") || colNameLower.includes("cost") || colNameLower.includes("amount") || colNameLower.includes("fee") || pgDataType === "money") {
-            extraLines.push("            ui: {\n                currency: true\n            }");
-        }
+        // No currency heuristic. `admin.currency` was never a declared option and
+        // nothing reads it, so a column called `price` got a block of config that did
+        // nothing — invisible because this generator emits *source text*, which no
+        // typechecker ever saw. Reinstate it by adding `currency` to
+        // AdminNumberOptions first, and something that renders it.
     }
 
     // ── JSON / JSONB Analysis ────────────────────────────────────────────
@@ -169,11 +170,10 @@ export function inferPropertyFromData(
             if (isPk) extraLines.push("            isId: \"cuid\"");
         }
 
-        // Color Codes
-        const allColors = validValues.every(v => typeof v === "string" && COLOR_HEX_REGEX.test(v));
-        if (allColors) {
-            extraLines.push("            ui: {\n                color: true\n            }");
-        }
+        // No colour heuristic. `admin.color` was never a declared option and nothing
+        // reads it — the same dead branch `currency` was. This generator emits *source
+        // text*, so no typechecker ever saw either. Reinstate by adding the option and
+        // something that renders it first.
 
         // Text Lengths, Multiline & Markdown
         let maxLength = 0;
@@ -212,9 +212,9 @@ export function inferPropertyFromData(
         if (allAbsoluteUrls) {
             const isImage = validValues.some(v => typeof v === "string" && v.match(/\.(jpeg|jpg|gif|png|webp|svg)/i));
             if (isImage || isMedia) {
-                extraLines.push("            ui: {\n                url: \"image\"\n            }");
+                extraLines.push("            url: true,\n            admin: {\n                urlPreview: \"image\"\n            }");
             } else {
-                extraLines.push("            ui: {\n                url: true\n            }");
+                extraLines.push("            url: true");
             }
         } else {
             const hasFileExtension = validValues.some(v => typeof v === "string" && v.match(/\.[a-zA-Z0-9]+$/));
@@ -225,9 +225,9 @@ export function inferPropertyFromData(
                 extraLines.push(`            storage: {\n                storagePath: "${inferredStoragePath}"\n            }`);
             } else if (isUrl) {
                 if (isMedia) {
-                    extraLines.push("            ui: {\n                url: \"image\"\n            }");
+                    extraLines.push("            url: true,\n            admin: {\n                urlPreview: \"image\"\n            }");
                 } else {
-                    extraLines.push("            ui: {\n                url: true\n            }");
+                    extraLines.push("            url: true");
                 }
             }
         }

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            },";
             }
         }
 

package/src/services/FetchService.ts

@@ -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 */
@@ -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);
@@ -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
                 );
 
 
@@ -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
                 );
 
 
@@ -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);
@@ -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