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

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