@rebasepro/server-postgres 0.9.1-canary.ad25bc0 → 0.9.1-canary.b10dcdf

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,
@@ -236,7 +243,17 @@ async function main() {
                 const merged = mergeIndexContent(existing, generatedFiles);
                 fs.writeFileSync(indexPath, merged, "utf-8");
             } else {
-                const indexContent = generateIndexContent(generatedFiles);
+                // --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);
                 fs.writeFileSync(indexPath, indexContent, "utf-8");
             }
             logger.info(chalk.green(`  ✓ ${indexPath}`));

package/src/services/FetchService.ts

@@ -7,15 +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 */
@@ -109,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.
@@ -127,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).
@@ -151,85 +143,6 @@ export class FetchService {
         return null;
     }
 
-    /**
-     * 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;
-                const targetPks = getPrimaryKeys(targetCollection, this.registry);
-                const targetIdField = targetPks[0].fieldName;
-
-                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 = String(targetRow[targetIdField] ?? targetRow.id ?? targetRow[Object.keys(targetRow)[0]]);
-                    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 targetPks = getPrimaryKeys(targetCollection, this.registry);
-                const targetIdField = targetPks[0].fieldName;
-                const relObj = relData as Record<string, unknown>;
-
-                const relId = String(relObj[targetIdField] ?? relObj.id ?? relObj[Object.keys(relObj)[0]]);
-                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,
@@ -271,57 +184,6 @@ export class FetchService {
         await Promise.all(promises);
     }
 
-    /**
-     * Post-fetch joinPath relations for a batch of flat rows.
-     * Uses batch fetching to avoid N+1 queries for list views.
-     */
-    private async resolveJoinPathRelationsBatch<M extends Record<string, unknown>>(
-        rows: Record<string, unknown>[],
-        collection: CollectionConfig,
-        collectionPath: string,
-        idInfo: { fieldName: string; type: "string" | "number" },
-        _databaseId?: string
-    ): Promise<void> {
-        if (rows.length === 0) return;
-
-        const resolvedRelations = resolveCollectionRelations(collection);
-
-        const joinPathRelations = Object.entries(resolvedRelations)
-            .filter(([key, relation]) => relation.joinPath && relation.joinPath.length > 0);
-
-        if (joinPathRelations.length === 0) return;
-
-        for (const [key, relation] of joinPathRelations) {
-            try {
-                const rowIds = rows.map(r => {
-                    const parsed = parseIdValues(String(r.id), [idInfo]);
-                    return parsed[idInfo.fieldName] as string | number;
-                });
-
-                const resultMap = await this.relationService.batchFetchRelatedEntities(
-                    collectionPath,
-                    rowIds,
-                    key,
-                    relation
-                );
-
-                for (const row of rows) {
-                    const parsed = parseIdValues(String(row.id), [idInfo]);
-                    const id = parsed[idInfo.fieldName] as string | number;
-                    const relatedRow = resultMap.get(String(id));
-
-                    if (relatedRow) {
-                        if (relation.cardinality === "one") {
-                            row[key] = createRelationRefWithData(relatedRow.id, relatedRow.path, relatedRow);
-                        }
-                    }
-                }
-            } catch (e) {
-                logger.warn(`Could not batch resolve joinPath relation '${key}'`, { error: e });
-            }
-        }
-    }
-
     /**
      * Resolves joinPath relations for raw REST rows and directly injects them.
      * Uses RelationService to query the database and maps results back to the flattened objects.
@@ -345,15 +207,25 @@ export class FetchService {
 
         if (joinPathRelations.length === 0) return;
 
-        const idInfo = idInfoArray[0];
+        // 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".
+        //
+        // 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 {
-                // Determine the parent IDs based on the parsed string ID from the REST row
-                const rowIds = rows.map(r => {
-                    const parsed = parseIdValues(String(r.id), idInfoArray);
-                    return parsed[idInfo.fieldName] as string | number;
-                });
+                const addressable = rows.filter(r => parentIdOf(r) !== undefined && parentIdOf(r) !== null);
+                if (addressable.length === 0) continue;
+                const rowIds = addressable.map(r => parentIdOf(r) as string | number);
 
                 if (relation.cardinality === "one") {
                     const resultMap = await this.relationService.batchFetchRelatedEntities(
@@ -363,19 +235,11 @@ export class FetchService {
                         relation
                     );
 
-                    for (const row of rows) {
-                        const parsed = parseIdValues(String(row.id), idInfoArray);
-                        const id = parsed[idInfo.fieldName] as string | number;
-                        const relatedRow = resultMap.get(String(id));
-
-                        if (relatedRow) {
-                            row[key] = {
-                                ...relatedRow.values,
-                                id: relatedRow.id
-                            };
-                        } else {
-                            row[key] = null;
-                        }
+                    for (const row of addressable) {
+                        const relatedRow = resultMap.get(String(parentIdOf(row)));
+                        // Columns only: the target's address is the consumer's to
+                        // derive, and merging it last overwrote a real `id` column.
+                        row[key] = relatedRow ? { ...relatedRow.values } : null;
                     }
                 } else if (relation.cardinality === "many") {
                     const resultMap = await this.relationService.batchFetchRelatedEntitiesMany(
@@ -385,14 +249,9 @@ export class FetchService {
                         relation
                     );
 
-                    for (const row of rows) {
-                        const parsed = parseIdValues(String(row.id), idInfoArray);
-                        const id = parsed[idInfo.fieldName] as string | number;
-                        const relatedList = resultMap.get(String(id)) || [];
-                        row[key] = relatedList.map(e => ({
-                            ...e.values,
-                            id: e.id
-                        }));
+                    for (const row of addressable) {
+                        const relatedList = resultMap.get(String(parentIdOf(row))) || [];
+                        row[key] = relatedList.map(e => ({ ...e.values }));
                     }
                 }
             } catch (e) {
@@ -401,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.
@@ -583,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;
 
@@ -610,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);
@@ -702,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;
 
@@ -734,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;
@@ -834,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.
      */
@@ -1020,11 +840,12 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
                     relationKey,
                     options
                 );
-                // Convert RelatedRow[] from RelationService to flat rows
-                return rows.map(row => ({
-                    ...row.values as Record<string, unknown>,
-                    id: row.id
-                }));
+                // 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) {
@@ -1138,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;
@@ -1198,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;
 
@@ -1225,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
@@ -1304,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;
 
@@ -1330,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);
@@ -1412,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;
 

package/src/services/PersistService.ts

@@ -383,8 +383,15 @@ export class PersistService {
             throw this.toUserFriendlyError(error, collection.slug);
         }
 
-        // Fetch the updated/created row to return with proper relation objects
-        const finalEntity = await this.fetchService.fetchOne<M>(collection.slug, savedId, databaseId);
+        // 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);
         if (!finalEntity) throw new Error("Could not fetch row after save.");
         return finalEntity;
     }