@rebasepro/server-postgres 0.9.1-canary.7dddf96 → 0.9.1-canary.a57c262

package/dist/services/FetchService.d.ts

@@ -40,37 +40,11 @@ export declare class FetchService {
      * the target relation so actual row data is returned.
      */
     private buildWithConfig;
-    /**
-     * Detect if a many-to-many relation uses a junction table in the Drizzle schema.
-     */
-    private isJunctionRelation;
     /**
      * 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;
-    /**
-     * The address a relation ref points at.
-     *
-     * The whole key, not its first column: a composite-keyed target addressed
-     * by `tenant_id` alone points at every row that shares it. And a target
-     * whose key cannot be resolved at all used to throw here — reading
-     * `targetPks[0]` of an empty array — taking down the parent's fetch over a
-     * relation it may not even have asked for; the first column is a guess, but
-     * a ref that resolves to nothing beats no rows at all.
-     */
-    private relationTargetAddress;
-    /**
-     * Convert a db.query result row (with nested relation objects) to a flat row.
-     * Handles:
-     * - Type normalization (dates, numbers, NaN) via normalizeDbValues
-     * - Converting nested relation objects to { id, path, __type: "relation" } for CMS
-     * - Flattening junction-table many-to-many results
-     *
-     * The row's own address is not among them: it is derived by the consumer
-     * from the collection's primary keys.
-     */
-    private drizzleResultToRow;
     /**
      * Post-fetch joinPath relations for a single flat row.
      * joinPath relations cannot be expressed via Drizzle's `with` config,
@@ -82,16 +56,6 @@ export declare class FetchService {
      * Uses RelationService to query the database and maps results back to the flattened objects.
      */
     private resolveJoinPathRelationsBatchRest;
-    /**
-     * Convert a db.query result row to a flat REST-style row with populated relations.
-     *
-     * Every column is copied through under its own name, with the value Postgres
-     * returned. This used to open with a synthesized `id` and then skip the key
-     * column, which renamed it (a `sku` primary key was served as `id`, and `sku`
-     * did not appear at all) and restringified it (`42` → `"42"`). Consumers that
-     * need an address derive it from the collection's primary keys.
-     */
-    private drizzleResultToRestRow;
     /**
      * Build db.query-compatible options from standard fetch options.
      * Handles filter, search, orderBy, limit, and cursor-based pagination.
@@ -122,8 +86,10 @@ export declare class FetchService {
     }): Promise<Record<string, unknown>[]>;
     /**
      * Fallback path used when db.query is unavailable.
-     * The primary path uses drizzleResultToRow which handles relation
-     * mapping without N+1 queries.
+     *
+     * The primary path runs the results through `toCmsRow`, which maps
+     * relations from what drizzle already nested — no query per row. This one
+     * has no nesting to read, so it resolves relations itself, in batches.
      *
      * Process raw database results into flat rows with relations.
      */

package/dist/services/RelationService.d.ts

@@ -20,6 +20,40 @@ export declare class RelationService {
     private db;
     private registry;
     constructor(db: DrizzleClient, registry: PostgresCollectionRegistry);
+    /**
+     * One target row, as the {@link RelatedRow} everything here returns.
+     *
+     * Eight sites built this by hand, which is how the address came to be the
+     * target's first key column in all eight — one edit, eight places to miss.
+     *
+     * `resolveNested` is the one thing they did not agree on, and the
+     * disagreement was invisible: the single-parent fetches pass `db` and
+     * `registry` to `parseDataFromServer`, so the target's *own* relations get
+     * resolved too, while the batch paths deliberately do not — a query per
+     * target row is the N+1 the batching exists to avoid. Naming the parameter
+     * makes that a decision rather than a difference between two call sites
+     * nobody was comparing.
+     */
+    private toRelatedRow;
+    /**
+     * A WHERE matching any of `parentIds`, by the whole key.
+     *
+     * A single key is an `IN (…)`. A composite one cannot be: matching
+     * `tenant_id IN (1, 1)` collects every row of tenant 1, so two parents that
+     * share their first column each receive the other's relations. It becomes
+     * an OR of ANDs — one exact address per parent — which Postgres indexes the
+     * same way it would a multi-column key lookup.
+     */
+    private parentKeyCondition;
+    /**
+     * Reject a relation that cannot express a composite-keyed parent.
+     *
+     * `localKey` and `foreignKeyOnTarget` are single column names: one column
+     * cannot reference a two-column key, so such a relation has no correct
+     * reading. Left alone it would silently match on the first key column and
+     * hand a tenant's rows to its neighbour — say so instead.
+     */
+    private assertSingleKeyAddressable;
     /**
      * Fetch rows related to a parent row through a specific relation
      */

package/dist/services/collection-helpers.d.ts

@@ -24,7 +24,37 @@ export interface DrizzleColumnMeta {
 export declare function getColumnMeta(col: AnyPgColumn): DrizzleColumnMeta;
 export declare function getCollectionByPath(collectionPath: string, registry: PostgresCollectionRegistry): CollectionConfig;
 export declare function getTableForCollection(collection: CollectionConfig, registry: PostgresCollectionRegistry): PgTable<any>;
+/**
+ * The key columns a collection's rows are addressed by.
+ *
+ * Three tiers, in order: properties marked `isId`, the primary keys of the
+ * drizzle schema, and finally a column literally named `id`. Only the first is
+ * visible to the browser, which is why a key known only to drizzle is reported
+ * at boot — see {@link warnOnKeysTheAdminCannotResolve}.
+ *
+ * Returns `[]` when nothing resolves, rather than throwing. It used to open by
+ * resolving the table, which throws when there is none — so the `isId` tier,
+ * which needs no table at all, was unreachable for exactly the collections
+ * most likely to have no table registered. Every caller that wanted "no keys"
+ * to mean "no keys" had to spell that out in a try/catch.
+ *
+ * Callers that cannot proceed without a key must say so themselves, naming the
+ * collection: an empty array here means "this collection has no address", which
+ * is a different answer in a notification (broadcast a wildcard) than in a save
+ * (fail).
+ */
 export declare function getPrimaryKeys(collection: CollectionConfig, registry: PostgresCollectionRegistry): PrimaryKeyInfo[];
+/**
+ * The key columns, for callers that cannot do their job without one.
+ *
+ * {@link getPrimaryKeys} answers "what keys, if any" and returns `[]` for a
+ * collection with no address. Most of this driver, though, is building a WHERE
+ * clause and has no meaning without a key — for those, an empty array is not an
+ * answer, and indexing `[0]` into it produces `Cannot read properties of
+ * undefined` three frames from where the real problem is. This says what is
+ * wrong and which collection it is wrong about.
+ */
+export declare function requirePrimaryKeys(collection: CollectionConfig, registry: PostgresCollectionRegistry): PrimaryKeyInfo[];
 /**
  * Collections whose key the *browser* cannot resolve, and what it will do
  * instead.
@@ -65,12 +95,9 @@ export declare function warnOnKeysTheAdminCannotResolve(collections: CollectionC
  * The address of a row: derived from the collection's primary keys, because a
  * row does not carry one — it is exactly its columns.
  *
- * Falls back to a literal `id` column, which covers the two cases where the
- * keys cannot be resolved: a row that reached us from somewhere other than the
- * postgres driver, and a collection whose table the registry cannot look up
- * (`getPrimaryKeys` throws for an unregistered table rather than returning
- * nothing). Returns `""` when there is no key and no `id` — callers decide what
- * that means, since "unaddressable" is a different answer in a notification
- * (broadcast a wildcard) than in a save (fail).
+ * Falls back to a literal `id` column, for a row that reached us from somewhere
+ * other than this driver. Returns `""` when there is no key and no `id` —
+ * callers decide what that means, since "unaddressable" is a different answer
+ * in a notification (broadcast a wildcard) than in a save (fail).
  */
 export declare function deriveRowAddress(row: Record<string, unknown>, collection: CollectionConfig, registry: PostgresCollectionRegistry): string;

package/dist/services/row-pipeline.d.ts

@@ -0,0 +1,60 @@
+import { CollectionConfig, Relation } from "@rebasepro/types";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+/**
+ * Turning a drizzle result into a row we serve.
+ *
+ * There are two shapes, and they are the same walk. Both take a row whose
+ * relation fields hold nested objects, both unwrap junction rows to reach the
+ * target behind them, and both leave every other column alone. They differ only
+ * in what they put where the relation was:
+ *
+ * - `"ref"` — a `{ id, path, __type: "relation" }` reference carrying the
+ *   target's values. This is what the admin renders.
+ * - `"inline"` — the target's own columns, flat. This is what REST serves.
+ *
+ * They used to be two functions that happened to agree, and the agreement was
+ * not enforced by anything: the row-identity bug had to be fixed five times
+ * across differently-shaped copies of this walk, and one of the copies was
+ * dead code nobody had noticed. Whatever the next cross-cutting change is, it
+ * is one edit here.
+ */
+export type RelationStyle = "ref" | "inline";
+/**
+ * Whether a many-relation reaches its target through a junction table.
+ *
+ * Also used to build the drizzle `with` config, which is why it is exported:
+ * the query has to nest one level deeper for a junction, and the row walk has
+ * to unwrap that same level back out.
+ */
+export declare function isJunctionRelation(relation: Relation): boolean;
+/**
+ * The address a relation ref points at.
+ *
+ * The whole key, not its first column: a composite-keyed target addressed by
+ * `tenant_id` alone points at every row that shares it. A target whose key
+ * cannot be resolved at all used to throw here — reading `[0]` of an empty
+ * array — taking down the parent's fetch over a relation it may not even have
+ * asked for. The first column is a guess, but a ref that resolves to nothing
+ * beats no rows at all.
+ */
+export declare function relationTargetAddress(targetRow: Record<string, unknown>, targetCollection: CollectionConfig, registry: PostgresCollectionRegistry): string;
+/**
+ * The row the admin renders: every column, with relations as references.
+ *
+ * Values are normalized (dates, numbers, NaN) because the admin's view-model
+ * expects real types. The row's own address is *not* among the columns — it is
+ * derived by the consumer from the collection's primary keys.
+ */
+export declare function toCmsRow(row: Record<string, unknown>, collection: CollectionConfig, registry: PostgresCollectionRegistry): Record<string, unknown>;
+/**
+ * The row REST serves: every column under its own name, with the value Postgres
+ * returned, and relations inlined as the target's columns.
+ *
+ * Deliberately not normalized: REST serves what the database holds, and JSON
+ * has its own opinions about dates that the admin's view-model does not share.
+ *
+ * Keyed by the row rather than by the relation list — a REST fetch only loads
+ * the relations `include` asked for, so the row is the authority on which are
+ * actually there.
+ */
+export declare function toRestRow(row: Record<string, unknown>, collection: CollectionConfig, registry: PostgresCollectionRegistry): Record<string, unknown>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgres",
   "type": "module",
-  "version": "0.9.1-canary.7dddf96",
+  "version": "0.9.1-canary.a57c262",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -71,18 +71,20 @@
     "execa": "^9.6.1",
     "pg": "^8.21.0",
     "ws": "^8.21.0",
-    "@rebasepro/common": "0.9.1-canary.7dddf96",
-    "@rebasepro/codegen": "0.9.1-canary.7dddf96",
-    "@rebasepro/server": "0.9.1-canary.7dddf96",
-    "@rebasepro/types": "0.9.1-canary.7dddf96",
-    "@rebasepro/utils": "0.9.1-canary.7dddf96"
+    "@rebasepro/codegen": "0.9.1-canary.a57c262",
+    "@rebasepro/common": "0.9.1-canary.a57c262",
+    "@rebasepro/utils": "0.9.1-canary.a57c262",
+    "@rebasepro/server": "0.9.1-canary.a57c262",
+    "@rebasepro/types": "0.9.1-canary.a57c262"
   },
   "devDependencies": {
+    "@hono/node-server": "^2.0.9",
     "@types/jest": "^30.0.0",
     "@types/node": "^25.9.3",
     "@types/pg": "^8.20.0",
     "@types/ws": "^8.18.1",
     "@vitejs/plugin-react": "^6.0.2",
+    "hono": "^4.12.25",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.11",
     "typescript": "^6.0.3",
@@ -103,6 +105,7 @@
     "test:lint": "eslint \"src/**\" --quiet",
     "test": "jest --passWithNoTests",
     "test:e2e": "vitest run --config vitest.e2e.config.ts",
-    "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f"
+    "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f",
+    "smoke:baas": "tsx scripts/smoke-baas.ts"
   }
 }

package/src/schema/introspect-db.ts

@@ -30,6 +30,7 @@ async function main() {
             "--force": Boolean,
             "--schema": String,
             "--data-inference": Boolean,
+            "--no-data-inference": Boolean,
             "-o": "--output",
             "-c": "--collections",
             "-f": "--force"
@@ -166,8 +167,14 @@ async function main() {
         logger.info(chalk.blue(`Found ${tablesMap.size} tables (including ${joinTables.size} detected join tables).`));
 
         let runDataInference = false;
-        if (args["--data-inference"] !== undefined) {
+        if (args["--no-data-inference"]) {
+            runDataInference = false;
+        } else if (args["--data-inference"] !== undefined) {
             runDataInference = args["--data-inference"];
+        } else if (!process.stdin.isTTY) {
+            // No terminal to answer the question below (scaffolding scripts, CI,
+            // `rebase init --introspect`) — asking would hang forever.
+            logger.info(chalk.gray("Skipping data inference (non-interactive run; pass --data-inference to enable)."));
         } else {
             const rl = readline.createInterface({
                 input: process.stdin,

package/src/services/FetchService.ts

@@ -7,16 +7,18 @@ import { DrizzleConditionBuilder } from "../utils/drizzle-conditions";
 import {
     getCollectionByPath,
     getTableForCollection,
-    getPrimaryKeys,
+    requirePrimaryKeys,
     deriveRowAddress,
     parseIdValues,
-    buildCompositeId
+    buildCompositeId,
+    COMPOSITE_ID_SEPARATOR
 } from "./collection-helpers";
 import { parseDataFromServer, normalizeDbValues } from "../data-transformer";
 import { RelationService } from "./RelationService";
 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 { logger } from "@rebasepro/server";
 
 /** Type-safe accessor for Drizzle's relational query API via dynamic table name */
@@ -110,7 +112,7 @@ export class FetchService {
             // Detect many-to-many junction tables:
             // If the relation goes through a junction table (relation.through exists or
             // the Drizzle schema maps to a junction table), we need two-level with.
-            if (relation.cardinality === "many" && this.isJunctionRelation(relation, collection)) {
+            if (relation.cardinality === "many" && isJunctionRelation(relation)) {
                 // The Drizzle relation points to the junction table.
                 // We need: { [junctionRelName]: { with: { [targetFkName]: true } } }
                 // The target FK name is the relation on the junction table that points to the actual target.
@@ -128,17 +130,6 @@ export class FetchService {
         return withConfig;
     }
 
-    /**
-     * Detect if a many-to-many relation uses a junction table in the Drizzle schema.
-     */
-    private isJunctionRelation(relation: Relation, _collection: CollectionConfig): boolean {
-        // If `through` is defined, it's explicitly a junction relation
-        if (relation.through) return true;
-        // If joinPath has an intermediate table, it's likely junction-based
-        if (relation.joinPath && relation.joinPath.length > 1) return true;
-        return false;
-    }
-
     /**
      * 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).
@@ -152,98 +143,6 @@ export class FetchService {
         return null;
     }
 
-    /**
-     * The address a relation ref points at.
-     *
-     * The whole key, not its first column: a composite-keyed target addressed
-     * by `tenant_id` alone points at every row that shares it. And a target
-     * whose key cannot be resolved at all used to throw here — reading
-     * `targetPks[0]` of an empty array — taking down the parent's fetch over a
-     * relation it may not even have asked for; the first column is a guess, but
-     * a ref that resolves to nothing beats no rows at all.
-     */
-    private relationTargetAddress(targetRow: Record<string, unknown>, targetCollection: CollectionConfig): string {
-        const address = deriveRowAddress(targetRow, targetCollection, this.registry);
-        if (address) return address;
-        const firstColumn = targetRow[Object.keys(targetRow)[0]];
-        return String(firstColumn ?? "");
-    }
-
-    /**
-     * Convert a db.query result row (with nested relation objects) to a flat row.
-     * Handles:
-     * - Type normalization (dates, numbers, NaN) via normalizeDbValues
-     * - Converting nested relation objects to { id, path, __type: "relation" } for CMS
-     * - Flattening junction-table many-to-many results
-     *
-     * The row's own address is not among them: it is derived by the consumer
-     * from the collection's primary keys.
-     */
-    private drizzleResultToRow<M extends Record<string, unknown>>(
-        row: Record<string, unknown>,
-        collection: CollectionConfig
-    ): Record<string, unknown> {
-        const resolvedRelations = resolveCollectionRelations(collection);
-
-        // Normalize non-relation values (dates, numbers, etc.)
-        const normalizedValues = normalizeDbValues(row as M, collection) as Record<string, unknown>;
-
-        // Convert nested relation objects to CMS-style { id, path, __type: "relation" }
-        for (const [key, relation] of Object.entries(resolvedRelations)) {
-            const drizzleRelName = relation.relationName || key;
-            const relData = row[drizzleRelName];
-
-            if (relData === undefined || relData === null) continue;
-
-            if (relation.cardinality === "many" && Array.isArray(relData)) {
-                const targetCollection = relation.target();
-                const targetPath = targetCollection.slug;
-
-                normalizedValues[key] = relData.map((item: Record<string, unknown>) => {
-                    // Handle junction table flattening:
-                    // Junction rows look like { post_id: 1, tag_id: { id: 5, name: "ts" } }
-                    let targetRow = item;
-                    if (this.isJunctionRelation(relation, collection)) {
-                        // Find the nested target object in the junction row
-                        const nestedKey = Object.keys(item).find(
-                            nk => typeof item[nk] === "object" && item[nk] !== null && !Array.isArray(item[nk])
-                        );
-                        if (nestedKey) {
-                            targetRow = item[nestedKey] as Record<string, unknown>;
-                        }
-                    }
-
-                    const relId = this.relationTargetAddress(targetRow, targetCollection);
-                    const targetValues = normalizeDbValues(targetRow, targetCollection);
-
-                    return createRelationRefWithData(relId, targetPath, {
-                        id: relId,
-                        path: targetPath,
-                        values: targetValues
-                    });
-                });
-            } else if (relation.cardinality === "one" && typeof relData === "object" && !Array.isArray(relData)) {
-                const targetCollection = relation.target();
-                const targetPath = targetCollection.slug;
-                const relObj = relData as Record<string, unknown>;
-
-                const relId = this.relationTargetAddress(relObj, targetCollection);
-                const targetValues = normalizeDbValues(relObj, targetCollection);
-
-                normalizedValues[key] = createRelationRefWithData(relId, targetPath, {
-                    id: relId,
-                    path: targetPath,
-                    values: targetValues
-                });
-            }
-        }
-
-        // A row is exactly its columns. The address is derived by the consumer
-        // from the collection's primary keys — writing it here would rename the
-        // key column (`sku` → `id`) and restringify it (`42` → `"42"`).
-        return normalizedValues;
-    }
-
     /**
      * Post-fetch joinPath relations for a single flat row.
      * joinPath relations cannot be expressed via Drizzle's `with` config,
@@ -308,13 +207,19 @@ export class FetchService {
 
         if (joinPathRelations.length === 0) return;
 
-        const idInfo = idInfoArray[0];
-        // These rows carry their key columns verbatim, so the parent id is read
-        // straight off them. It used to be parsed back out of a synthesized
+        // These rows carry their key columns verbatim, so the parent's address
+        // is derived from them. It used to be parsed back out of a synthesized
         // `id` — which no longer exists on a row, and threw (composite: parts
         // mismatch; numeric: NaN) into the catch below, where a warning is all
         // that separates "no relations" from "relations dropped".
-        const parentIdOf = (row: Record<string, unknown>) => row[idInfo.fieldName] as string | number | undefined;
+        //
+        // The whole key, because that is what the batch groups its results by:
+        // both sides derive the token the same way, so they agree by
+        // construction rather than by both happening to pick column zero.
+        const parentIdOf = (row: Record<string, unknown>): string | undefined => {
+            const address = buildCompositeId(row, idInfoArray);
+            return address && address.split(COMPOSITE_ID_SEPARATOR).some(part => part !== "") ? address : undefined;
+        };
 
         for (const [key, relation] of joinPathRelations) {
             try {
@@ -355,47 +260,6 @@ export class FetchService {
         }
     }
 
-    /**
-     * Convert a db.query result row to a flat REST-style row with populated relations.
-     *
-     * Every column is copied through under its own name, with the value Postgres
-     * returned. This used to open with a synthesized `id` and then skip the key
-     * column, which renamed it (a `sku` primary key was served as `id`, and `sku`
-     * did not appear at all) and restringified it (`42` → `"42"`). Consumers that
-     * need an address derive it from the collection's primary keys.
-     */
-    private drizzleResultToRestRow(
-        row: Record<string, unknown>,
-        collection: CollectionConfig
-    ): Record<string, unknown> {
-        const flat: Record<string, unknown> = {};
-        const resolvedRelations = resolveCollectionRelations(collection);
-
-        for (const [k, v] of Object.entries(row)) {
-            const relation = findRelation(resolvedRelations, k);
-            if (Array.isArray(v) && relation) {
-                // Many relation — inline each nested row, unwrapping junction rows
-                flat[k] = v.map((item: Record<string, unknown>) => {
-                    if (this.isJunctionRelation(relation, collection)) {
-                        const nestedKey = Object.keys(item).find(
-                            nk => typeof item[nk] === "object" && item[nk] !== null && !Array.isArray(item[nk])
-                        );
-                        if (nestedKey) {
-                            return { ...(item[nestedKey] as Record<string, unknown>) };
-                        }
-                    }
-                    return { ...item };
-                });
-            } else if (typeof v === "object" && v !== null && !Array.isArray(v) && relation) {
-                // One-to-one relation — inline the target's columns
-                flat[k] = { ...(v as Record<string, unknown>) };
-            } else {
-                flat[k] = v;
-            }
-        }
-        return flat;
-    }
-
     /**
      * Build db.query-compatible options from standard fetch options.
      * Handles filter, search, orderBy, limit, and cursor-based pagination.
@@ -537,7 +401,7 @@ export class FetchService {
     ): Promise<Record<string, unknown> | undefined> {
         const collection = getCollectionByPath(collectionPath, this.registry);
         const table = getTableForCollection(collection, this.registry);
-        const idInfoArray = getPrimaryKeys(collection, this.registry);
+        const idInfoArray = requirePrimaryKeys(collection, this.registry);
         const idInfo = idInfoArray[0];
         const idField = table[idInfo.fieldName as keyof typeof table] as AnyPgColumn;
 
@@ -564,7 +428,7 @@ export class FetchService {
 
                 if (!row) return undefined;
 
-                const flatRow = this.drizzleResultToRow<M>(row, collection);
+                const flatRow = toCmsRow(row, collection, this.registry);
 
                 // Post-fetch joinPath relations that Drizzle's `with` can't express
                 await this.resolveJoinPathRelations<M>(flatRow, collection, collectionPath, parsedId, databaseId);
@@ -656,7 +520,7 @@ export class FetchService {
     ): Promise<Record<string, unknown>[]> {
         const collection = getCollectionByPath(collectionPath, this.registry);
         const table = getTableForCollection(collection, this.registry);
-        const idInfoArray = getPrimaryKeys(collection, this.registry);
+        const idInfoArray = requirePrimaryKeys(collection, this.registry);
         const idInfo = idInfoArray[0];
         const idField = table[idInfo.fieldName as keyof typeof table] as AnyPgColumn;
 
@@ -688,7 +552,7 @@ export class FetchService {
                 const results = await qb.findMany(queryOpts as Parameters<NonNullable<typeof qb>["findMany"]>[0]);
 
                 const rows = (results as Record<string, unknown>[]).map(row =>
-                    this.drizzleResultToRow<M>(row, collection)
+                    toCmsRow(row, collection, this.registry)
                 );
 
                 return rows;
@@ -788,8 +652,10 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
 
     /**
      * Fallback path used when db.query is unavailable.
-     * The primary path uses drizzleResultToRow which handles relation
-     * mapping without N+1 queries.
+     *
+     * The primary path runs the results through `toCmsRow`, which maps
+     * relations from what drizzle already nested — no query per row. This one
+     * has no nesting to read, so it resolves relations itself, in batches.
      *
      * Process raw database results into flat rows with relations.
      */
@@ -1093,7 +959,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
 
         const collection = getCollectionByPath(collectionPath, this.registry);
         const table = getTableForCollection(collection, this.registry);
-        const idInfoArray = getPrimaryKeys(collection, this.registry);
+        const idInfoArray = requirePrimaryKeys(collection, this.registry);
         const idInfo = idInfoArray[0];
         const idField = table[idInfo.fieldName as keyof typeof table] as AnyPgColumn;
         const field = table[fieldName as keyof typeof table] as AnyPgColumn;
@@ -1153,7 +1019,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
     ): Promise<Record<string, unknown>[]> {
         const collection = getCollectionByPath(collectionPath, this.registry);
         const table = getTableForCollection(collection, this.registry);
-        const idInfoArray = getPrimaryKeys(collection, this.registry);
+        const idInfoArray = requirePrimaryKeys(collection, this.registry);
         const idInfo = idInfoArray[0];
         const idField = table[idInfo.fieldName as keyof typeof table] as AnyPgColumn;
 
@@ -1180,7 +1046,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
                 const results = await qb.findMany(queryOpts as Parameters<NonNullable<typeof qb>["findMany"]>[0]);
 
                 const restRows = (results as Record<string, unknown>[]).map(row =>
-                    this.drizzleResultToRestRow(row, collection)
+                    toRestRow(row, collection, this.registry)
                 );
 
                 // Drizzle relational query API doesn't resolve joinPath relations, fetch manually
@@ -1259,7 +1125,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
     ): Promise<Record<string, unknown> | null> {
         const collection = getCollectionByPath(collectionPath, this.registry);
         const table = getTableForCollection(collection, this.registry);
-        const idInfoArray = getPrimaryKeys(collection, this.registry);
+        const idInfoArray = requirePrimaryKeys(collection, this.registry);
         const idInfo = idInfoArray[0];
         const idField = table[idInfo.fieldName as keyof typeof table] as AnyPgColumn;
 
@@ -1285,7 +1151,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
 
                 if (!row) return null;
 
-                const restRow = this.drizzleResultToRestRow(row, collection);
+                const restRow = toRestRow(row, collection, this.registry);
 
                 // Drizzle relational query API doesn't resolve joinPath relations, fetch manually
                 await this.resolveJoinPathRelationsBatchRest([restRow], collection, collectionPath, idInfoArray, include);
@@ -1367,7 +1233,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
     ): Promise<Record<string, unknown>[]> {
         const collection = getCollectionByPath(collectionPath, this.registry);
         const table = getTableForCollection(collection, this.registry);
-        const idInfoArray = getPrimaryKeys(collection, this.registry);
+        const idInfoArray = requirePrimaryKeys(collection, this.registry);
         const idInfo = idInfoArray[0];
         const idField = table[idInfo.fieldName as keyof typeof table] as AnyPgColumn;