@rebasepro/server-postgres 0.12.0 → 0.12.1-canary.g009ed95

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

@@ -0,0 +1,56 @@
+/**
+ * The PostgreSQL type → Rebase property type mapping.
+ *
+ * Split out of `introspect-db-logic` so that the structural analysis can use it
+ * without importing the generator, which imports the analysis. Re-exported from
+ * `introspect-db-logic` so existing callers keep their import path.
+ */
+
+/**
+ * Map a PostgreSQL data type to a Rebase property type.
+ */
+export function mapPgType(dataType: string): string {
+    const dt = dataType.toLowerCase();
+
+    // Interval MUST be checked before numeric ("interval" contains "int")
+    if (dt === "interval") return "string";
+
+    // Array types MUST be checked before numeric ("_int4" contains "int")
+    if (dt === "array" || dt.startsWith("_")) return "array";
+
+    // Numeric types
+    if (
+        dt.includes("int") || // integer, smallint, bigint
+        dt.includes("numeric") ||
+        dt.includes("decimal") ||
+        dt.includes("serial") || // serial, bigserial
+        dt === "real" ||
+        dt === "float4" ||
+        dt === "float8" ||
+        dt === "double precision" ||
+        dt === "money"
+    ) {
+        return "number";
+    }
+
+    // Boolean
+    if (dt.includes("bool")) return "boolean";
+
+    // Date / Time
+    if (dt.includes("time") || dt.includes("date")) return "date";
+
+    // JSON
+    if (dt === "json" || dt === "jsonb") return "map";
+
+    // Binary
+    if (dt === "bytea") return "binary";
+
+    // Network types
+    if (dt === "inet" || dt === "cidr" || dt === "macaddr" || dt === "macaddr8") return "string";
+
+    // UUID
+    if (dt === "uuid") return "string";
+
+    // Text/varchar/char — default to string
+    return "string";
+}

package/src/schema/introspect-db.ts

@@ -7,19 +7,16 @@ import * as dotenv from "dotenv";
 import readline from "readline";
 
 import {
-    TableRow,
-    TableColumn,
-    EnumValue,
-    PrimaryKeyRow,
-    ForeignKeyRow,
     buildTablesMap,
     buildEnumMap,
-    identifyJoinTables,
     generateCollectionFile,
     generateIndexContent,
     mergeIndexContent,
     safeHostFromUrl
 } from "./introspect-db-logic";
+import { countRowsUpTo, readSchemaMetadata } from "./introspect-db-queries";
+import { classifyTables, lookupCandidates, LOOKUP_MAX_ROWS } from "./introspect-db-structure";
+import { parseCheckConstraints } from "./introspect-db-constraints";
 import { logger } from "@rebasepro/server";
 
 async function main() {
@@ -89,82 +86,41 @@ async function main() {
     logger.info(chalk.gray(`Introspecting schema '${pgSchema}'...`));
 
     try {
-        // 1. Get Tables
-        const { rows: tables } = await client.query<TableRow>(`
-            SELECT table_name
-            FROM information_schema.tables
-            WHERE table_schema = $1 AND table_type = 'BASE TABLE'
-              AND table_name NOT LIKE 'drizzle_%'
-              AND table_name NOT LIKE 'rebase_%'
-            ORDER BY table_name
-        `, [pgSchema]);
-
-        // 2. Get Columns
-        const { rows: columns } = await client.query<TableColumn>(`
-            SELECT 
-                c.table_name, 
-                c.column_name, 
-                c.data_type, 
-                c.udt_name, 
-                c.is_nullable, 
-                c.column_default,
-                (SELECT a.atttypmod FROM pg_attribute a 
-                 JOIN pg_class pc ON a.attrelid = pc.oid 
-                 WHERE pc.relname = c.table_name 
-                   AND a.attname = c.column_name 
-                   AND pc.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema)) as atttypmod
-            FROM information_schema.columns c
-            WHERE c.table_schema = $1
-        `, [pgSchema]);
-
-        // 2b. Get Enum Types and their values
-        const { rows: enumValues } = await client.query<EnumValue>(`
-            SELECT t.typname AS enum_name,
-                   e.enumlabel AS enum_value,
-                   e.enumsortorder AS sort_order
-            FROM pg_type t
-            JOIN pg_enum e ON t.oid = e.enumtypid
-            JOIN pg_namespace n ON t.typnamespace = n.oid
-            WHERE n.nspname = $1
-            ORDER BY t.typname, e.enumsortorder
-        `, [pgSchema]);
-
-        // Build a map: enum_name -> ordered list of values
-        const enumMap = buildEnumMap(enumValues);
-
-        // 3. Get Primary Keys
-        const { rows: pks } = await client.query<PrimaryKeyRow>(`
-            SELECT t.relname as table_name, a.attname as column_name
-            FROM   pg_index i
-            JOIN   pg_attribute a ON a.attrelid = i.indrelid
-                                AND a.attnum = ANY(i.indkey)
-            JOIN   pg_class t ON t.oid = i.indrelid
-            JOIN   pg_namespace n ON n.oid = t.relnamespace
-            WHERE  i.indisprimary AND n.nspname = $1
-        `, [pgSchema]);
+        const metadata = await readSchemaMetadata(client, pgSchema);
+        const enumMap = buildEnumMap(metadata.enumValues);
+        const tablesMap = buildTablesMap(metadata.tables, metadata.columns, metadata.pks, metadata.fks);
+        const fks = metadata.fks;
+
+        // Only tables that could structurally be a code list are counted, and
+        // each count stops at the threshold — see `countRowsUpTo`. Introspection
+        // runs against a database it does not own, so "cheap on a table of any
+        // size" is a requirement, not an optimization.
+        for (const table of lookupCandidates(metadata, tablesMap)) {
+            try {
+                metadata.rowCounts[table] = await countRowsUpTo(client, pgSchema, table, LOOKUP_MAX_ROWS);
+            } catch (err) {
+                // A table this run cannot read is simply not classified as a code
+                // list; everything else about it still generates.
+                logger.info(chalk.gray(`  (skipped row count for ${table}: ${err instanceof Error ? err.message : String(err)})`));
+            }
+        }
 
-        // 4. Get Foreign Keys
-        const { rows: fks } = await client.query<ForeignKeyRow>(`
-            SELECT
-                tc.table_name, 
-                kcu.column_name, 
-                ccu.table_name AS foreign_table_name,
-                ccu.column_name AS foreign_column_name 
-            FROM 
-                information_schema.table_constraints AS tc 
-                JOIN information_schema.key_column_usage AS kcu
-                  ON tc.constraint_name = kcu.constraint_name
-                  AND tc.table_schema = kcu.table_schema
-                JOIN information_schema.constraint_column_usage AS ccu
-                  ON ccu.constraint_name = tc.constraint_name
-                  AND ccu.table_schema = tc.table_schema
-            WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = $1
-        `, [pgSchema]);
+        const classifications = classifyTables(metadata, tablesMap);
+        const checkFacts = parseCheckConstraints(metadata.checks);
+        const joinTables = new Set(
+            Array.from(classifications.values())
+                .filter((c) => c.role === "junction")
+                .map((c) => c.table)
+        );
 
-        const tablesMap = buildTablesMap(tables, columns, pks, fks);
-        const joinTables = identifyJoinTables(tablesMap);
+        const roleCount = (role: string) =>
+            Array.from(classifications.values()).filter((c) => c.role === role).length;
 
-        logger.info(chalk.blue(`Found ${tablesMap.size} tables (including ${joinTables.size} detected join tables).`));
+        logger.info(chalk.blue(`Found ${tablesMap.size} tables.`));
+        logger.info(chalk.gray(
+            `  ${roleCount("entity")} entities, ${joinTables.size} join tables (folded into relations), ` +
+            `${roleCount("lookup")} code lists, ${roleCount("owned-child")} owned by another table (hidden from navigation).`
+        ));
 
         let runDataInference = false;
         if (args["--no-data-inference"]) {
@@ -224,7 +180,8 @@ async function main() {
                     joinTables,
                     tablesMap,
                     enumMap,
-                    sampleData
+                    sampleData,
+                    { metadata, classifications, checkFacts }
                 );
 
                 fs.writeFileSync(filePath, fileContent, "utf-8");

package/src/schema/introspect-runtime.test.ts

@@ -1,4 +1,6 @@
 import { describe, expect, it } from "@jest/globals";
+import { resolveCollectionRelations } from "@rebasepro/common";
+import type { CollectionConfig } from "@rebasepro/types";
 
 import { buildCollectionsFromSchema, introspectSchema, readRlsStatus, IntrospectedSchema, Queryable } from "./introspect-runtime";
 import { buildTablesMap, identifyJoinTables, TableColumn, ForeignKeyRow, PrimaryKeyRow } from "./introspect-db-logic";
@@ -121,14 +123,60 @@ describe("buildCollectionsFromSchema", () => {
         const props = posts.properties as any;
 
         expect(props.author_id).toBeUndefined();
-        expect(props.author).toEqual({
-            name: "Author",
-            type: "relation",
-            target: "authors",
-            cardinality: "one",
-            direction: "owning",
-            localKey: "author_id"
-        });
+        expect(props.author.name).toBe("Author");
+        expect(props.author.type).toBe("relation");
+        // The descriptor is nested under `relation`, carries `kind`, and its
+        // `target` is a thunk — see the resolvability test below for why none of
+        // those three are stylistic.
+        expect(props.author.relation).toMatchObject({ kind: "belongsTo", localKey: "author_id" });
+        expect(typeof props.author.relation.target).toBe("function");
+        expect(props.author.relation.target().slug).toBe("authors");
+    });
+
+    /**
+     * The shape has to be one the resolver actually reads.
+     *
+     * This path emitted `cardinality` / `direction` / a bare-string `target`
+     * flat on the property — the shape `Relation` stopped accepting, and the
+     * same drift `introspect-emits-valid-relations.test.ts` caught in the
+     * generated-file path and this one was missed by. Nothing threw:
+     * `resolveCollectionRelations` reads `property.relation`, found none, and
+     * reported a collection with no relations at all.
+     *
+     * The visible cost was writes. `assertKnownWriteFields` learns an owning
+     * relation's FK column from the *resolved* relation's `localKey`, and the FK
+     * column is deliberately absent from `properties` ("surfaces as a
+     * relation"), so with nothing resolving, `POST /api/data/orders` with
+     * `product_id` came back 400 `has no field 'product_id'` — the column was
+     * simultaneously the only way to set the relation and not a known field.
+     *
+     * Asserting the literal object is what let it drift, so this asserts
+     * through the resolver instead: a future reshape has to keep it resolvable,
+     * not merely keep the keys someone once wrote down.
+     */
+    it("emits a relation the resolver can read, so the fk column is writable", () => {
+        const schema = schemaOf(
+            [
+                column({ table_name: "products", column_name: "id", data_type: "integer", udt_name: "int4", is_nullable: "NO" }),
+                column({ table_name: "orders", column_name: "id", data_type: "integer", udt_name: "int4", is_nullable: "NO" }),
+                column({ table_name: "orders", column_name: "product_id", data_type: "integer", udt_name: "int4" })
+            ],
+            [
+                { table_name: "products", column_name: "id" },
+                { table_name: "orders", column_name: "id" }
+            ],
+            [{ table_name: "orders", column_name: "product_id", foreign_table_name: "products", foreign_column_name: "id" }]
+        );
+
+        const orders = buildCollectionsFromSchema(schema, "public").find((c) => c.slug === "orders")!;
+        const resolved = resolveCollectionRelations(orders as unknown as CollectionConfig);
+
+        expect(Object.keys(resolved)).toEqual(["product"]);
+        expect(resolved.product.kind).toBe("belongsTo");
+        // `localKey` is the field `assertKnownWriteFields` adds to the known set,
+        // which is what makes `product_id` writable. The write itself is covered
+        // end-to-end by `scripts/smoke-baas.ts` against a real database.
+        expect((resolved.product as { localKey: string }).localKey).toBe("product_id");
     });
 
     it("skips join tables — they are an edge between collections, not a collection", () => {

package/src/schema/introspect-runtime.ts

@@ -207,13 +207,30 @@ function buildProperties(
 }
 
 /**
- * Owning relations, derived from this table's foreign keys. Mirrors the shape
- * `generateCollectionFile` emits, except `target` uses the slug string form
- * rather than a thunk to a module import.
+ * Owning relations, derived from this table's foreign keys — the same shape
+ * `generateCollectionFile` writes into a collection file: a `relation` property
+ * whose nested descriptor carries `kind`, a `target` thunk and the `localKey`.
+ *
+ * The shape is load-bearing, not cosmetic. `resolveCollectionRelations` reads
+ * relations from `property.relation` and `resolveRelation` requires `target` to
+ * be a thunk; this used to emit `target`/`cardinality`/`localKey` flat on the
+ * property with the slug as a bare string, which satisfies neither. Nothing
+ * threw — the resolver simply skipped every such property and reported that the
+ * collection had no relations. So an introspected BaaS collection had its FK
+ * columns removed from `properties` (they "surface as relations") and then no
+ * resolvable relation to surface as, which is why writing the FK column
+ * directly came back as `has no field 'product_id'`: `assertKnownWriteFields`
+ * learns that column from the resolved relation's `localKey`.
+ *
+ * The thunk closes over the collections being built in this same pass rather
+ * than importing a module, which is what a runtime introspection has instead of
+ * generated files. It is called lazily, after the map is fully populated, so a
+ * table may reference one introspected later.
  */
 function buildRelations(
     meta: TableMeta,
-    slugByTable: Map<string, string>
+    slugByTable: Map<string, string>,
+    collectionBySlug: Map<string, PostgresCollectionConfig>
 ): Record<string, Record<string, unknown>> {
     const relations: Record<string, Record<string, unknown>> = {};
 
@@ -233,10 +250,11 @@ function buildRelations(
         relations[key] = {
             name: humanize(key),
             type: "relation",
-            target: targetSlug,
-            cardinality: "one",
-            direction: "owning",
-            localKey: fk.column_name
+            relation: {
+                kind: "belongsTo",
+                target: () => collectionBySlug.get(targetSlug),
+                localKey: fk.column_name
+            }
         };
     }
 
@@ -259,6 +277,9 @@ export function buildCollectionsFromSchema(
     }
 
     const collections: PostgresCollectionConfig[] = [];
+    // Filled as we go; the relation thunks read it lazily, so a table may point
+    // at one that has not been built yet at the moment its relation is created.
+    const collectionBySlug = new Map<string, PostgresCollectionConfig>();
 
     for (const [tableName, meta] of tablesMap) {
         if (joinTables.has(tableName)) continue;
@@ -273,11 +294,12 @@ export function buildCollectionsFromSchema(
             icon: getIconForTable(tableName),
             properties: {
                 ...buildProperties(meta, enumMap),
-                ...buildRelations(meta, slugByTable)
+                ...buildRelations(meta, slugByTable, collectionBySlug)
             }
         } as unknown as PostgresCollectionConfig;
 
         collections.push(collection);
+        collectionBySlug.set(tableName, collection);
     }
 
     return collections;

package/src/security/policy-drift.test.ts

@@ -158,15 +158,23 @@ describe("checkPolicyDrift", () => {
     it("also flags the tautology in a WITH CHECK clause", async () => {
         const cols = [collection("posts")];
         const expected = parseExpectedPolicies(generatePostgresPoliciesDdl(cols));
+        const withCheck = expected.filter((p) => p.hasWithCheck);
+        // Asserted rather than assumed: if the generator ever stopped emitting a
+        // WITH CHECK for these rules the fixture would carry no tautology at
+        // all, and every assertion below would be vacuously satisfied.
+        expect(withCheck.length).toBeGreaterThan(0);
+
         const live = expected.map((p) => liveRow(p, {
             with_check: p.hasWithCheck ? "(auth.uid() IS NOT NULL)" : null
         }));
 
         const drift = await checkPolicyDrift(dbWith(live), cols);
 
-        const flagged = drift.insecure.some((i) => /WITH CHECK/.test(i.reason));
-        // Only assert when the fixture actually had a WITH CHECK policy to carry it.
-        if (expected.some((p) => p.hasWithCheck)) expect(flagged).toBe(true);
+        // Every WITH CHECK policy carries the tautology and no USING clause
+        // does, so anything flagged here came from the WITH CHECK scan — the
+        // half that a check reading only `qual` would miss entirely.
+        expect(drift.insecure.map((i) => i.policy.name)).toEqual(withCheck.map((p) => p.name));
+        expect(drift.insecure.every((i) => /WITH CHECK/.test(i.reason))).toBe(true);
     });
 
     it("parses roles when the driver returns the raw {a,b} text form", async () => {

package/src/services/FetchService.ts

@@ -1,10 +1,10 @@
-import { and, asc, count, desc, eq, getTableName, gt, lt, or, SQL, TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm";
+import { and, asc, count, desc, eq, getTableColumns, getTableName, gt, lt, or, SQL, TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm";
 import { AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
 import { CollectionConfig, FilterValues, ResolvedRelation, LogicalCondition, isManyToMany } from "@rebasepro/types";
 import type { VectorSearchParams } from "@rebasepro/types";
 import { resolveCollectionRelations, findRelation, createRelationRef, createRelationRefWithData } from "@rebasepro/common";
 import { generateForeignKeyName } from "@rebasepro/utils";
-import { DrizzleConditionBuilder, type FilterCompilationOptions } from "../utils/drizzle-conditions";
+import { DrizzleConditionBuilder, getUnknownFilterFieldsMode, type FilterCompilationOptions } from "../utils/drizzle-conditions";
 import {
     getCollectionByPath,
     getTableForCollection,
@@ -20,9 +20,9 @@ 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 { toFlatRow, toRestRow, isJunctionRelation } from "./row-pipeline";
 import { isNestedPath, resolveNestedPath, type NestedPathHop } from "./nested-path";
-import { logger } from "@rebasepro/server";
+import { ApiError, logger } from "@rebasepro/server";
 
 /** Type-safe accessor for Drizzle's relational query API via dynamic table name */
 type DbQueryAccessor = Record<string, RelationalQueryBuilder<any, any>> | undefined;
@@ -129,12 +129,10 @@ export class FetchService {
         if (direct) return direct;
 
         // Owning relation, resolved: the relation names its own local key.
-        if (collection) {
-            const relation = resolveCollectionRelations(collection)[orderBy];
-            if (relation?.kind === "belongsTo") {
-                const foreignKey = columnAt(relation.localKey);
-                if (foreignKey) return foreignKey;
-            }
+        const declaredRelation = collection ? resolveCollectionRelations(collection)[orderBy] : undefined;
+        if (declaredRelation?.kind === "belongsTo") {
+            const foreignKey = columnAt(declaredRelation.localKey);
+            if (foreignKey) return foreignKey;
         }
 
         // No collection in hand — the two shapes an owning relation's key takes
@@ -145,7 +143,61 @@ export class FetchService {
             if (foreignKey) return foreignKey;
         }
 
-        return undefined;
+        // Nothing resolved. Returning `undefined` is exactly what the docblock
+        // above describes: the caller drops the ORDER BY and hands back rows in
+        // whatever order Postgres pleases, while the requester believes they
+        // are sorted. `?orderBy=titel` answered 200 with unsorted data and no
+        // hint that the sort had been ignored.
+        //
+        // A *filter* naming a field that does not exist is already refused for
+        // precisely this reason — it "used to widen results silently". An
+        // unresolvable sort field is the same drift between a query and the
+        // schema, so it answers the same way and honours the same switch: one
+        // knob, because a deployment that wants the lenient behaviour wants it
+        // for both.
+        const collectionName = collection?.slug ?? collection?.name;
+        const onCollection = collectionName ? ` on collection '${collectionName}'` : "";
+
+        // A declared to-many relation is a different mistake from a typo, and
+        // saying "unknown field" about a field the collection plainly declares
+        // sends the reader looking for a spelling error that is not there.
+        // There is simply no single value per row to order by — `posts.tags` is
+        // a set — so no ORDER BY exists to write, with or without a typo.
+        if (declaredRelation && declaredRelation.kind !== "belongsTo") {
+            throw ApiError.badRequest(
+                `Cannot sort by '${orderBy}'${onCollection}: it is a to-many relation ` +
+                `(${declaredRelation.kind}), which has no single value per row to order by.`,
+                "ORDER_BY_FIELD_NOT_SORTABLE",
+                { field: orderBy, kind: declaredRelation.kind, ...(collectionName && { collection: collectionName }) }
+            );
+        }
+
+        if (getUnknownFilterFieldsMode() === "warn") {
+            logger.warn(
+                `Sorting by field '${orderBy}'${onCollection}, but it does not exist in the table — ` +
+                "the ORDER BY was dropped and these rows are unsorted."
+            );
+            return undefined;
+        }
+
+        let validFields: string[] = [];
+        try {
+            validFields = Object.keys(getTableColumns(table)).sort();
+        } catch {
+            // A table stand-in without Drizzle's column symbols — the message
+            // is worth less without the list, but not worth failing over.
+        }
+
+        throw ApiError.badRequest(
+            `Unknown orderBy field '${orderBy}'${onCollection}` +
+            (validFields.length > 0 ? `. Valid fields: ${validFields.join(", ")}` : ""),
+            "UNKNOWN_ORDER_BY_FIELD",
+            {
+                field: orderBy,
+                ...(collectionName && { collection: collectionName }),
+                ...(validFields.length > 0 && { validFields })
+            }
+        );
     }
 
     /**
@@ -555,7 +607,7 @@ idColumn };
 
                 if (!row) return undefined;
 
-                const flatRow = toCmsRow(row, collection, this.registry);
+                const flatRow = toFlatRow(row, collection, this.registry);
 
                 // Post-fetch joinPath relations that Drizzle's `with` can't express
                 await this.resolveJoinPathRelations<M>(flatRow, collection, collectionPath, parsedId, databaseId);
@@ -682,7 +734,7 @@ idColumn };
                 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)
+                    toFlatRow(row, collection, this.registry)
                 );
 
                 return rows;
@@ -785,7 +837,7 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
     /**
      * Fallback path used when db.query is unavailable.
      *
-     * The primary path runs the results through `toCmsRow`, which maps
+     * The primary path runs the results through `toFlatRow`, 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.
      *
@@ -942,6 +994,7 @@ relatedTo: hop });
         collectionPath: string,
         options: {
             filter?: FilterValues<Extract<keyof M, string>>;
+            logical?: LogicalCondition;
             searchString?: string;
             databaseId?: string;
         } = {}
@@ -973,6 +1026,13 @@ relatedTo: hop });
             if (filterConditions.length > 0) allConditions.push(...filterConditions);
         }
 
+        if (options.logical) {
+            const logicalCondition = DrizzleConditionBuilder.buildLogicalConditions(
+                options.logical, table, effectivePath, this.filterContext(effectivePath, table)
+            );
+            if (logicalCondition) allConditions.push(logicalCondition);
+        }
+
         if (allConditions.length > 0) {
             const finalCondition = DrizzleConditionBuilder.combineConditionsWithAnd(allConditions);
             if (finalCondition) query = query.where(finalCondition);
@@ -1043,6 +1103,8 @@ relatedTo: hop });
         collectionPath: string,
         options: {
             filter?: FilterValues<Extract<keyof M, string>>;
+            /** An `or(...)`/`and(...)` group, applied alongside `filter`. */
+            logical?: LogicalCondition;
             orderBy?: string;
             order?: "desc" | "asc";
             limit?: number;

package/src/services/PersistService.ts

@@ -1,7 +1,7 @@
 import { eq, and, sql, SQL } from "drizzle-orm";
 import { AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
 // import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { CollectionConfig, Properties, ResolvedRelation, type ResolvedManyToMany, isManyToMany } from "@rebasepro/types";
+import { CollectionConfig, Properties, ResolvedRelation, type ResolvedManyToMany, isManyToMany, hasForeignKeyOnTarget } from "@rebasepro/types";
 import { getTableName, resolveCollectionRelations } from "@rebasepro/common";
 import { DrizzleConditionBuilder } from "../utils/drizzle-conditions";
 import {
@@ -240,16 +240,30 @@ export class PersistService {
                     throw ApiError.notFound(`No row "${id}" in "${collectionPath}" to update.`);
                 }
             } else {
-                // One-to-many create: stamp the parent's id onto the child's FK.
+                // One-to-many create: stamp the parent's key onto the child's FK.
                 const targetColumnName = this.resolveParentForeignKeyColumn(hop);
 
                 if (targetColumnName) {
-                    const parsedParentId = parentIdForWrite();
+                    // Not necessarily the id in the path: a link with a
+                    // `sourceKey` is pointed at a column on the parent row, and
+                    // stamping the id would create a child that belongs to
+                    // nobody — a row the read path would never return again.
+                    const parentKeyValue = hasForeignKeyOnTarget(hop.relation)
+                        ? await this.relationService.parentKeyValue(hop.parentCollection, hop.relation, hop.parentId)
+                        : parentIdForWrite();
+
+                    if (parentKeyValue === undefined) {
+                        throw ApiError.badRequest(
+                            `Cannot create under "${collectionPath}": the parent row has no value in ` +
+                            `\`sourceKey\`, so the new row has nothing to point at.`
+                        );
+                    }
+
                     const existingValue = (effectiveValues as Record<string, unknown>)[targetColumnName];
-                    if (existingValue !== undefined && existingValue !== null && existingValue !== parsedParentId) {
-                        logger.warn(`Overriding provided value '${existingValue}' for FK '${targetColumnName}' with path parent id '${parsedParentId}'.`);
+                    if (existingValue !== undefined && existingValue !== null && existingValue !== parentKeyValue) {
+                        logger.warn(`Overriding provided value '${existingValue}' for FK '${targetColumnName}' with path parent key '${parentKeyValue}'.`);
                     }
-                    (effectiveValues as Record<string, unknown>)[targetColumnName] = parsedParentId;
+                    (effectiveValues as Record<string, unknown>)[targetColumnName] = parentKeyValue;
                 }
             }
         }