@rebasepro/server-postgres 0.9.1-canary.5809e39 → 0.9.1-canary.58368ce

package/src/connection.ts

@@ -27,68 +27,11 @@ const DEFAULT_POOL: Required<PostgresPoolConfig> = {
     max: 20,
     idleTimeoutMillis: 30_000,
     connectionTimeoutMillis: 10_000,
-    // The client-side read timeout MUST be comfortably above the server-side
-    // statement_timeout. When the client timer fires first, node-postgres
-    // abandons the in-flight statement but keeps the connection — inside a
-    // transaction that leaves the tx open (and any pending ROLLBACK is
-    // spliced out of the client queue before it ever reaches the wire), so
-    // the pooled connection is returned still in-transaction with its RLS
-    // GUCs set. The server abort (SQLSTATE 57014) is the clean path; the
-    // client timeout is only a backstop for a dead network.
-    queryTimeout: 60_000,
+    queryTimeout: 30_000,
     statementTimeout: 30_000,
     keepAlive: true
 };
 
-/** ReadyForQuery status byte: `I` idle, `T` in transaction, `E` failed transaction. */
-const TX_IDLE = "I";
-
-/**
- * Destroy pool clients that are released while still inside a transaction.
- *
- * pg-pool returns a client to the idle list whenever `release()` is called
- * without an error — even if the connection is still mid-transaction (status
- * `T`/`E`). That happens in practice: drizzle's pool transaction releases in
- * a `finally` after attempting ROLLBACK, and if the ROLLBACK itself fails
- * (e.g. it was queued behind a statement that hit the client-side
- * query_timeout), the client goes back dirty. The next checkout then runs
- * its statements inside the zombie transaction — with the previous request's
- * `app.*` RLS GUCs still applied, which turns unrelated queries into
- * RLS-scoped ones (observed in production as registration failing with
- * SQLSTATE 42501 under a leaked anonymous context).
- *
- * pg-pool emits `release` before it consults its private `_expired` set, so
- * marking the client expired here makes `_release()` destroy it instead of
- * pooling it. Both `client._txStatus` (pg ≥ 8.16) and `pool._expired` are
- * private APIs — feature-detect and fall back to loud logging so an upstream
- * change degrades to observability, never to silent corruption.
- */
-export function guardPoolAgainstDirtyRelease(pool: Pool, label: string): void {
-    pool.on("release", (err: Error | undefined, client: unknown) => {
-        if (err) return; // errored clients are already destroyed by pg-pool
-        const txStatus = (client as { _txStatus?: string | null })?._txStatus;
-        if (typeof txStatus !== "string" || txStatus === TX_IDLE) return;
-
-        // pg-pool keeps expired clients in a WeakSet (a plain object works too
-        // if upstream ever changes it — duck-type on add/has).
-        const expired = (pool as unknown as { _expired?: { add(c: object): unknown; has(c: object): boolean } })._expired;
-        if (expired && typeof expired.add === "function" && typeof expired.has === "function" && client && typeof client === "object") {
-            expired.add(client);
-            logger.error(
-                `[${label}] Client released back to the pool while still in a transaction ` +
-                `(status '${txStatus}') — destroying it so the open transaction and its ` +
-                `session state (RLS GUCs) cannot leak into the next request.`
-            );
-        } else {
-            logger.error(
-                `[${label}] Client released mid-transaction (status '${txStatus}') but the ` +
-                `pool's internal expiry set is unavailable (pg-pool internals changed?). ` +
-                `The connection may leak its open transaction into subsequent requests.`
-            );
-        }
-    });
-}
-
 /**
  * Create a Drizzle-backed Postgres connection with a production-grade
  * connection pool.
@@ -132,7 +75,6 @@ export function createPostgresDatabaseConnection(
             logger.warn("[pg-pool] Connection timeout detected — pool will auto-retry");
         }
     });
-    guardPoolAgainstDirtyRelease(pool, "pg-pool");
 
     // Create drizzle instance — pass schema when available to enable db.query relational API
     const db = schema ? drizzle(pool, { schema }) : drizzle(pool);
@@ -176,7 +118,6 @@ export function createDirectDatabaseConnection(
     pool.on("error", (err) => {
         logger.error("[pg-direct-pool] Unexpected pool error", { detail: err.message });
     });
-    guardPoolAgainstDirtyRelease(pool, "pg-direct-pool");
 
     const db = schema ? drizzle(pool, { schema }) : drizzle(pool);
 
@@ -216,7 +157,6 @@ export function createReadReplicaConnection(
     pool.on("error", (err) => {
         logger.error("[pg-replica-pool] Unexpected pool error", { detail: err.message });
     });
-    guardPoolAgainstDirtyRelease(pool, "pg-replica-pool");
 
     const db = schema ? drizzle(pool, { schema }) : drizzle(pool);
 

package/src/databasePoolManager.ts

@@ -2,7 +2,6 @@ import { Pool } from "pg";
 import { drizzle } from "drizzle-orm/node-postgres";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { logger } from "@rebasepro/server";
-import { guardPoolAgainstDirtyRelease } from "./connection";
 
 export class DatabasePoolManager {
     private pools: Map<string, Pool> = new Map();
@@ -51,7 +50,6 @@ export class DatabasePoolManager {
         pool.on("error", (err) => {
             logger.error(`[DatabasePoolManager] Unexpected error on idle client for db ${databaseName}`, { error: err });
         });
-        guardPoolAgainstDirtyRelease(pool, `pg-pool:${databaseName}`);
 
         this.pools.set(databaseName, pool);
         return pool;

package/src/schema/doctor.ts

@@ -37,7 +37,7 @@ export type IssueSeverity = "error" | "warning" | "info";
 
 export interface DoctorIssue {
     severity: IssueSeverity;
-    category: "missing_table" | "missing_column" | "type_mismatch" | "missing_constraint" | "schema_stale" | "missing_enum" | "enum_value_mismatch" | "missing_foreign_key" | "sdk_stale" | "sdk_not_generated";
+    category: "missing_table" | "missing_column" | "type_mismatch" | "missing_constraint" | "schema_stale" | "missing_enum" | "enum_value_mismatch" | "missing_foreign_key" | "sdk_stale";
     table?: string;
     column?: string;
     expected?: string;
@@ -61,29 +61,19 @@ export function getExpectedColumnType(prop: Property): string | null {
             const sp = prop as StringProperty;
             if (sp.enum) return "USER-DEFINED"; // pgEnum → USER-DEFINED in information_schema
             if ("isId" in sp && sp.isId === "uuid") return "uuid";
-            if (sp.columnType === "uuid") return "uuid";
-            // A markdown/multiline string compiles to `text`, not varchar — the
-            // generator treats those UI hints as column-type signals, so the
-            // expectation here must too or every such column reads as drift.
-            if (sp.columnType === "text" || sp.ui?.markdown || sp.ui?.multiline) return "text";
+            if (sp.columnType === "text") return "text";
             if (sp.columnType === "char") return "character";
             return "character varying";
         }
         case "number": {
             const np = prop as NumberProperty;
-            if (np.columnType) {
-                // The generator passes any columnType straight through to drizzle,
-                // so mirror that rather than enumerating a subset (which reported
-                // drift for anything unlisted, e.g. smallint). Serial types are
-                // integers with a sequence default; information_schema reports the
-                // underlying width.
-                const serialWidths: Record<string, string> = {
-                    serial: "integer",
-                    bigserial: "bigint",
-                    smallserial: "smallint"
-                };
-                return serialWidths[np.columnType] ?? np.columnType;
-            }
+            if (np.columnType === "double precision") return "double precision";
+            if (np.columnType === "real") return "real";
+            if (np.columnType === "bigint") return "bigint";
+            if (np.columnType === "serial") return "integer"; // serial is integer under the hood
+            if (np.columnType === "bigserial") return "bigint";
+            if (np.columnType === "integer") return "integer";
+            if (np.columnType === "numeric") return "numeric";
             if (np.validation?.integer || ("isId" in np && np.isId)) return "integer";
             return "numeric";
         }
@@ -211,18 +201,15 @@ export async function checkCollectionsVsSdk(
 ): Promise<{ passed: boolean; issues: DoctorIssue[] }> {
     const issues: DoctorIssue[] = [];
 
-    // The typed SDK is opt-in — nothing in a scaffolded project imports it until
-    // you choose to. A project that never generated one isn't drifting, so report
-    // it as information rather than a warning; otherwise `doctor` can never come
-    // back clean on a fresh project and users learn to ignore its output.
+    // Check if SDK file exists
     if (!fs.existsSync(sdkFilePath)) {
         issues.push({
-            severity: "info",
-            category: "sdk_not_generated",
-            message: "Typed SDK not generated (optional).",
-            fix: "Run `rebase generate-sdk` if you want typed collection access"
+            severity: "warning",
+            category: "sdk_stale",
+            message: `Generated SDK typedefs file does not exist at "${sdkFilePath}".`,
+            fix: "Run `rebase generate-sdk`"
         });
-        return { passed: true,
+        return { passed: false,
 issues };
     }
 
@@ -644,15 +631,11 @@ export function renderReport(report: DoctorReport): void {
 }
 
 function renderPhase(label: string, passed: boolean, issues: DoctorIssue[]): void {
-    const errorCount = issues.filter((i) => i.severity === "error").length;
-    const warnCount = issues.filter((i) => i.severity === "warning").length;
-    const infoIssues = issues.filter((i) => i.severity === "info");
-
-    // Informational notes don't make a phase unhealthy, so key the header off
-    // real problems rather than `passed` alone.
-    if (errorCount === 0 && warnCount === 0) {
+    if (passed) {
         logger.info(`  ${chalk.green("✅")} ${label}: ${chalk.green("In sync")}`);
     } else {
+        const errorCount = issues.filter((i) => i.severity === "error").length;
+        const warnCount = issues.filter((i) => i.severity === "warning").length;
         const parts: string[] = [];
         if (errorCount > 0) parts.push(`${errorCount} error${errorCount > 1 ? "s" : ""}`);
         if (warnCount > 0) parts.push(`${warnCount} warning${warnCount > 1 ? "s" : ""}`);
@@ -660,14 +643,7 @@ function renderPhase(label: string, passed: boolean, issues: DoctorIssue[]): voi
     }
     logger.info("");
 
-    // Notes render as a quiet one-liner, not a full drift box.
-    for (const issue of infoIssues) {
-        const fixPart = issue.fix ? chalk.gray(` — ${issue.fix}`) : "";
-        logger.info(`  ${chalk.gray("ℹ")} ${chalk.gray(issue.message)}${fixPart}`);
-        logger.info("");
-    }
-
-    for (const issue of issues.filter((i) => i.severity !== "info")) {
+    for (const issue of issues) {
         const severityIcon = issue.severity === "error" ? chalk.red("✗") : chalk.yellow("⚠");
         const categoryLabel = formatCategory(issue.category);
         logger.info(`  ${chalk.gray("┌─")} ${severityIcon} ${chalk.bold(categoryLabel)} ${chalk.gray("─".repeat(Math.max(0, 42 - categoryLabel.length)))}`);
@@ -698,8 +674,7 @@ function formatCategory(cat: DoctorIssue["category"]): string {
         missing_enum: "Missing Enum",
         enum_value_mismatch: "Enum Value Mismatch",
         missing_foreign_key: "Missing Foreign Key",
-        sdk_stale: "Stale SDK Types",
-        sdk_not_generated: "SDK Types Not Generated"
+        sdk_stale: "Stale SDK Types"
     };
     return labels[cat];
 }

package/src/schema/introspect-db.ts

@@ -30,7 +30,6 @@ async function main() {
             "--force": Boolean,
             "--schema": String,
             "--data-inference": Boolean,
-            "--no-data-inference": Boolean,
             "-o": "--output",
             "-c": "--collections",
             "-f": "--force"
@@ -167,14 +166,8 @@ async function main() {
         logger.info(chalk.blue(`Found ${tablesMap.size} tables (including ${joinTables.size} detected join tables).`));
 
         let runDataInference = false;
-        if (args["--no-data-inference"]) {
-            runDataInference = false;
-        } else if (args["--data-inference"] !== undefined) {
+        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,
@@ -243,17 +236,7 @@ async function main() {
                 const merged = mergeIndexContent(existing, generatedFiles);
                 fs.writeFileSync(indexPath, merged, "utf-8");
             } else {
-                // --force replaces collections derived from the database, but the
-                // directory can also hold hand-written ones with no table in the
-                // introspected schema (the auth users collection lives in
-                // "rebase"). The backend discovers the whole directory, so an
-                // index listing only introspected tables would silently drop them
-                // from the admin UI while the API still served them.
-                const siblings = fs.readdirSync(outDir)
-                    .filter(f => f.endsWith(".ts") && f !== "index.ts")
-                    .map(f => f.replace(/\.ts$/, ""));
-                const allFiles = [...new Set([...generatedFiles, ...siblings])];
-                const indexContent = generateIndexContent(allFiles);
+                const indexContent = generateIndexContent(generatedFiles);
                 fs.writeFileSync(indexPath, indexContent, "utf-8");
             }
             logger.info(chalk.green(`  ✓ ${indexPath}`));

package/src/services/FetchService.ts

@@ -7,18 +7,16 @@ import { DrizzleConditionBuilder } from "../utils/drizzle-conditions";
 import {
     getCollectionByPath,
     getTableForCollection,
-    requirePrimaryKeys,
+    getPrimaryKeys,
     deriveRowAddress,
     parseIdValues,
-    buildCompositeId,
-    COMPOSITE_ID_SEPARATOR
+    buildCompositeId
 } 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 */
@@ -112,7 +110,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" && isJunctionRelation(relation)) {
+            if (relation.cardinality === "many" && this.isJunctionRelation(relation, collection)) {
                 // 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.
@@ -130,6 +128,17 @@ 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).
@@ -143,6 +152,98 @@ 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,
@@ -207,19 +308,13 @@ export class FetchService {
 
         if (joinPathRelations.length === 0) return;
 
-        // 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
+        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
         // `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".
-        //
-        // 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;
-        };
+        const parentIdOf = (row: Record<string, unknown>) => row[idInfo.fieldName] as string | number | undefined;
 
         for (const [key, relation] of joinPathRelations) {
             try {
@@ -260,6 +355,47 @@ 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.
@@ -401,7 +537,7 @@ export class FetchService {
     ): Promise<Record<string, unknown> | undefined> {
         const collection = getCollectionByPath(collectionPath, this.registry);
         const table = getTableForCollection(collection, this.registry);
-        const idInfoArray = requirePrimaryKeys(collection, this.registry);
+        const idInfoArray = getPrimaryKeys(collection, this.registry);
         const idInfo = idInfoArray[0];
         const idField = table[idInfo.fieldName as keyof typeof table] as AnyPgColumn;
 
@@ -428,7 +564,7 @@ export class FetchService {
 
                 if (!row) return undefined;
 
-                const flatRow = toCmsRow(row, collection, this.registry);
+                const flatRow = this.drizzleResultToRow<M>(row, collection);
 
                 // Post-fetch joinPath relations that Drizzle's `with` can't express
                 await this.resolveJoinPathRelations<M>(flatRow, collection, collectionPath, parsedId, databaseId);
@@ -520,7 +656,7 @@ export class FetchService {
     ): Promise<Record<string, unknown>[]> {
         const collection = getCollectionByPath(collectionPath, this.registry);
         const table = getTableForCollection(collection, this.registry);
-        const idInfoArray = requirePrimaryKeys(collection, this.registry);
+        const idInfoArray = getPrimaryKeys(collection, this.registry);
         const idInfo = idInfoArray[0];
         const idField = table[idInfo.fieldName as keyof typeof table] as AnyPgColumn;
 
@@ -552,7 +688,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 =>
-                    toCmsRow(row, collection, this.registry)
+                    this.drizzleResultToRow<M>(row, collection)
                 );
 
                 return rows;
@@ -652,10 +788,8 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
 
     /**
      * Fallback path used when db.query is unavailable.
-     *
-     * 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.
+     * The primary path uses drizzleResultToRow which handles relation
+     * mapping without N+1 queries.
      *
      * Process raw database results into flat rows with relations.
      */
@@ -959,7 +1093,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
 
         const collection = getCollectionByPath(collectionPath, this.registry);
         const table = getTableForCollection(collection, this.registry);
-        const idInfoArray = requirePrimaryKeys(collection, this.registry);
+        const idInfoArray = getPrimaryKeys(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;
@@ -1019,7 +1153,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 = requirePrimaryKeys(collection, this.registry);
+        const idInfoArray = getPrimaryKeys(collection, this.registry);
         const idInfo = idInfoArray[0];
         const idField = table[idInfo.fieldName as keyof typeof table] as AnyPgColumn;
 
@@ -1046,7 +1180,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 =>
-                    toRestRow(row, collection, this.registry)
+                    this.drizzleResultToRestRow(row, collection)
                 );
 
                 // Drizzle relational query API doesn't resolve joinPath relations, fetch manually
@@ -1125,7 +1259,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 = requirePrimaryKeys(collection, this.registry);
+        const idInfoArray = getPrimaryKeys(collection, this.registry);
         const idInfo = idInfoArray[0];
         const idField = table[idInfo.fieldName as keyof typeof table] as AnyPgColumn;
 
@@ -1151,7 +1285,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
 
                 if (!row) return null;
 
-                const restRow = toRestRow(row, collection, this.registry);
+                const restRow = this.drizzleResultToRestRow(row, collection);
 
                 // Drizzle relational query API doesn't resolve joinPath relations, fetch manually
                 await this.resolveJoinPathRelationsBatchRest([restRow], collection, collectionPath, idInfoArray, include);
@@ -1233,7 +1367,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 = requirePrimaryKeys(collection, this.registry);
+        const idInfoArray = getPrimaryKeys(collection, this.registry);
         const idInfo = idInfoArray[0];
         const idField = table[idInfo.fieldName as keyof typeof table] as AnyPgColumn;
 

package/src/services/PersistService.ts

@@ -383,15 +383,8 @@ export class PersistService {
             throw this.toUserFriendlyError(error, collection.slug);
         }
 
-        // Fetch the saved row back through the same walk `GET /:id` serves, so a
-        // write's answer is the read that follows it. This used to be `fetchOne`
-        // — the admin view-model walk — whose `__type: "relation"` refs then
-        // leaked into REST responses, afterSave callbacks, history records and
-        // app-level realtime payloads, none of which see that shape from any
-        // read path. The admin does not need them here either: its rows arrive
-        // over the realtime subscription refetch, which still serves the
-        // view-model walk.
-        const finalEntity = await this.fetchService.fetchOneForRest(collection.slug, savedId, undefined, databaseId);
+        // Fetch the updated/created row to return with proper relation objects
+        const finalEntity = await this.fetchService.fetchOne<M>(collection.slug, savedId, databaseId);
         if (!finalEntity) throw new Error("Could not fetch row after save.");
         return finalEntity;
     }