@rebasepro/server-postgres 0.9.1-canary.1d2d8b5 → 0.9.1-canary.26fe4b2

package/src/services/RelationService.ts

@@ -1,4 +1,4 @@
-import { and, eq, inArray, sql, SQL } from "drizzle-orm";
+import { and, eq, inArray, or, sql, SQL } from "drizzle-orm";
 import { AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
 import { DrizzleClient } from "../interfaces";
 import { CollectionConfig, FilterValues, Relation } from "@rebasepro/types";
@@ -7,9 +7,10 @@ import { DrizzleConditionBuilder } from "../utils/drizzle-conditions";
 import {
     getCollectionByPath,
     getTableForCollection,
-    getPrimaryKeys,
+    requirePrimaryKeys,
     parseIdValues,
-    buildCompositeId
+    buildCompositeId,
+    type PrimaryKeyInfo
 } from "./collection-helpers";
 import { parseDataFromServer } from "../data-transformer";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
@@ -56,6 +57,94 @@ export interface RelatedRow<M extends Record<string, unknown> = Record<string, u
 export class RelationService {
     constructor(private db: DrizzleClient, private registry: PostgresCollectionRegistry) { }
 
+    /**
+     * One target row, as the {@link RelatedRow} everything here returns.
+     *
+     * Eight sites built this by hand, which is how the address came to be the
+     * target's first key column in all eight — one edit, eight places to miss.
+     *
+     * `resolveNested` is the one thing they did not agree on, and the
+     * disagreement was invisible: the single-parent fetches pass `db` and
+     * `registry` to `parseDataFromServer`, so the target's *own* relations get
+     * resolved too, while the batch paths deliberately do not — a query per
+     * target row is the N+1 the batching exists to avoid. Naming the parameter
+     * makes that a decision rather than a difference between two call sites
+     * nobody was comparing.
+     */
+    private async toRelatedRow<M extends Record<string, unknown>>(
+        targetRow: Record<string, unknown>,
+        targetCollection: CollectionConfig,
+        targetPks: PrimaryKeyInfo[],
+        options?: { resolveNested?: boolean }
+    ): Promise<RelatedRow<M>> {
+        const values = options?.resolveNested
+            ? await parseDataFromServer(targetRow, targetCollection, this.db, this.registry)
+            : await parseDataFromServer(targetRow, targetCollection);
+
+        return {
+            // The whole key: a composite target addressed by its first column
+            // names every row that shares it.
+            id: buildCompositeId(targetRow, targetPks),
+            path: targetCollection.slug,
+            values: values as M
+        };
+    }
+
+    /**
+     * A WHERE matching any of `parentIds`, by the whole key.
+     *
+     * A single key is an `IN (…)`. A composite one cannot be: matching
+     * `tenant_id IN (1, 1)` collects every row of tenant 1, so two parents that
+     * share their first column each receive the other's relations. It becomes
+     * an OR of ANDs — one exact address per parent — which Postgres indexes the
+     * same way it would a multi-column key lookup.
+     */
+    private parentKeyCondition(
+        parentTable: PgTable,
+        parentPks: PrimaryKeyInfo[],
+        parentIds: (string | number)[]
+    ): SQL {
+        const columnFor = (fieldName: string) => {
+            const col = parentTable[fieldName as keyof typeof parentTable] as AnyPgColumn;
+            if (!col) throw new Error(`Key column '${fieldName}' not found in parent table`);
+            return col;
+        };
+
+        if (parentPks.length === 1) {
+            const values = parentIds.map(id => parseIdValues(id, parentPks)[parentPks[0].fieldName]);
+            return inArray(columnFor(parentPks[0].fieldName), values);
+        }
+
+        const perParent = parentIds.map(id => {
+            const values = parseIdValues(id, parentPks);
+            return and(...parentPks.map(pk => eq(columnFor(pk.fieldName), values[pk.fieldName])));
+        });
+        return or(...perParent) as SQL;
+    }
+
+    /**
+     * Reject a relation that cannot express a composite-keyed parent.
+     *
+     * `localKey` and `foreignKeyOnTarget` are single column names: one column
+     * cannot reference a two-column key, so such a relation has no correct
+     * reading. Left alone it would silently match on the first key column and
+     * hand a tenant's rows to its neighbour — say so instead.
+     */
+    private assertSingleKeyAddressable(
+        parentCollection: CollectionConfig,
+        parentPks: PrimaryKeyInfo[],
+        via: string
+    ): void {
+        if (parentPks.length > 1) {
+            throw new Error(
+                `Relation on '${parentCollection.slug}' uses '${via}', a single foreign-key column, but ` +
+                `'${parentCollection.slug}' is keyed on ${parentPks.map(k => `'${k.fieldName}'`).join(" + ")}. ` +
+                `One column cannot reference a composite key — express this relation with \`joinPath\`, whose ` +
+                `\`on.from\`/\`on.to\` take every key column.`
+            );
+        }
+    }
+
     /**
      * Fetch rows related to a parent row through a specific relation
      */
@@ -104,10 +193,10 @@ export class RelationService {
     ): Promise<RelatedRow<M>[]> {
         const targetCollection = relation.target();
         const targetTable = getTableForCollection(targetCollection, this.registry);
-        const idInfo = getPrimaryKeys(targetCollection, this.registry);
+        const idInfo = requirePrimaryKeys(targetCollection, this.registry);
         const idField = targetTable[idInfo[0].fieldName as keyof typeof targetTable] as AnyPgColumn;
 
-        const parentPks = getPrimaryKeys(parentCollection, this.registry);
+        const parentPks = requirePrimaryKeys(parentCollection, this.registry);
         const parentIdInfo = parentPks[0];
         const parsedParentIdObj = parseIdValues(parentId, parentPks);
         const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
@@ -148,7 +237,7 @@ export class RelationService {
             }
 
             // Add where condition for the parent row
-            const parentIdField = parentTable[getPrimaryKeys(parentCollection, this.registry)[0].fieldName as keyof typeof parentTable] as AnyPgColumn;
+            const parentIdField = parentTable[requirePrimaryKeys(parentCollection, this.registry)[0].fieldName as keyof typeof parentTable] as AnyPgColumn;
             query = query.where(eq(parentIdField, parsedParentId));
 
             if (options.limit) {
@@ -162,14 +251,7 @@ export class RelationService {
             const rows: RelatedRow<M>[] = [];
             for (const row of results as Array<Record<string, unknown>>) {
                 const targetRow = (row[targetTableName] as Record<string, unknown>) || row;
-                const id = targetRow[idInfo[0].fieldName as string];
-                const parsedValues = await parseDataFromServer(targetRow, targetCollection, this.db, this.registry);
-
-                rows.push({
-                    id: id?.toString() || "",
-                    path: targetCollection.slug,
-                    values: parsedValues as M
-                });
+                rows.push(await this.toRelatedRow<M>(targetRow, targetCollection, idInfo, { resolveNested: true }));
             }
 
             return rows;
@@ -228,14 +310,7 @@ export class RelationService {
         const rows: RelatedRow<M>[] = [];
         for (const row of results) {
             const targetRow = row[getTableName(targetCollection)] || row;
-            const id = targetRow[idInfo[0].fieldName];
-            const parsedValues = await parseDataFromServer(targetRow, targetCollection, this.db, this.registry);
-
-            rows.push({
-                id: id?.toString() || "",
-                path: targetCollection.slug,
-                values: parsedValues as M
-            });
+            rows.push(await this.toRelatedRow<M>(targetRow as Record<string, unknown>, targetCollection, idInfo, { resolveNested: true }));
         }
 
         return rows;
@@ -260,11 +335,11 @@ export class RelationService {
 
         const targetCollection = relation.target();
         const targetTable = getTableForCollection(targetCollection, this.registry);
-        const targetPks = getPrimaryKeys(targetCollection, this.registry);
+        const targetPks = requirePrimaryKeys(targetCollection, this.registry);
         const targetIdInfo = targetPks[0];
         const targetIdField = targetTable[targetIdInfo.fieldName as keyof typeof targetTable] as AnyPgColumn;
 
-        const parentPks = getPrimaryKeys(parentCollection, this.registry);
+        const parentPks = requirePrimaryKeys(parentCollection, this.registry);
         const parentIdInfo = parentPks[0];
         const parsedParentIdObj = parseIdValues(parentId, parentPks);
         const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
@@ -309,11 +384,11 @@ export class RelationService {
         const parentCollection = getCollectionByPath(parentCollectionPath, this.registry);
         const targetCollection = relation.target();
         const targetTable = getTableForCollection(targetCollection, this.registry);
-        const targetPks = getPrimaryKeys(targetCollection, this.registry);
+        const targetPks = requirePrimaryKeys(targetCollection, this.registry);
         const targetIdInfo = targetPks[0];
         const targetIdField = targetTable[targetIdInfo.fieldName as keyof typeof targetTable] as AnyPgColumn;
 
-        const parentPks = getPrimaryKeys(parentCollection, this.registry);
+        const parentPks = requirePrimaryKeys(parentCollection, this.registry);
         const parentIdInfo = parentPks[0];
         const parentTable = this.registry.getTable(getTableName(parentCollection));
         if (!parentTable) throw new Error("Parent table not found");
@@ -354,27 +429,23 @@ export class RelationService {
                 currentTable = joinTable;
             }
 
-            // Add where condition for ALL parent rows at once
-            const parentIdField = parentTable[getPrimaryKeys(parentCollection, this.registry)[0].fieldName as keyof typeof parentTable] as AnyPgColumn;
-            query = query.where(inArray(parentIdField, parsedParentIds));
+            // Match every parent at once, each by its whole key.
+            query = query.where(this.parentKeyCondition(parentTable, parentPks, parentIds));
 
             const results = await query;
             const targetTableName = relation.joinPath[relation.joinPath.length - 1].table;
             const resultMap = new Map<string, RelatedRow<Record<string, unknown>>>();
 
-            // Group results by parent ID
+            // Group by the parent's address — the same token the caller looks
+            // results up by, derived the same way on both sides.
             for (const row of results as Array<Record<string, unknown>>) {
                 const parentRow = (row[getTableName(parentCollection)] || row) as Record<string, unknown>;
                 const targetRow = (row[targetTableName] || row) as Record<string, unknown>;
-                const parentId = parentRow[parentIdInfo.fieldName] as string | number;
-
-                const parsedValues = await parseDataFromServer(targetRow, targetCollection);
 
-                resultMap.set(String(parentId), {
-                    id: String(targetRow[targetIdInfo.fieldName]),
-                    path: targetCollection.slug,
-                    values: parsedValues as Record<string, unknown>
-                });
+                resultMap.set(
+                    buildCompositeId(parentRow, parentPks),
+                    await this.toRelatedRow(targetRow, targetCollection, targetPks)
+                );
             }
 
             return resultMap;
@@ -387,6 +458,7 @@ export class RelationService {
         //   2. Query the target table with unique FK values
         //   3. Map results back to parent rows via their FK values
         if (relation.direction === "owning" && relation.localKey) {
+            this.assertSingleKeyAddressable(parentCollection, parentPks, relation.localKey);
             const localKeyCol = parentTable[relation.localKey as keyof typeof parentTable] as AnyPgColumn;
             if (!localKeyCol) {
                 throw new Error(`Local key column '${relation.localKey}' not found in parent table`);
@@ -436,19 +508,21 @@ export class RelationService {
             for (const [parentIdStr, fkValue] of parentToFk) {
                 const targetRow = targetById.get(String(fkValue));
                 if (targetRow) {
-                    const parsedValues = await parseDataFromServer(targetRow, targetCollection);
-                    resultMap.set(parentIdStr, {
-                        id: String(targetRow[targetIdInfo.fieldName]),
-                        path: targetCollection.slug,
-                        values: parsedValues as Record<string, unknown>
-                    });
+                    resultMap.set(parentIdStr, await this.toRelatedRow(targetRow, targetCollection, targetPks));
                 }
             }
 
             return resultMap;
         }
 
-        // Handle inverse relation types with batching
+        // Handle inverse relation types with batching. The parent is named by a
+        // single FK column on the target, so a composite-keyed parent has no
+        // correct reading here either.
+        this.assertSingleKeyAddressable(
+            parentCollection,
+            parentPks,
+            relation.foreignKeyOnTarget ?? `${relation.inverseRelationName}_id`
+        );
         let query = this.db.select().from(targetTable).$dynamic();
 
         // Build the relation query with ALL parent IDs
@@ -488,12 +562,7 @@ export class RelationService {
             }
 
             if (parentId !== undefined && parentIdSet.has(String(parentId))) {
-                const parsedValues = await parseDataFromServer(targetRow, targetCollection);
-                resultMap.set(String(parentId), {
-                    id: String(targetRow[targetIdInfo.fieldName]),
-                    path: targetCollection.slug,
-                    values: parsedValues as Record<string, unknown>
-                });
+                resultMap.set(String(parentId), await this.toRelatedRow(targetRow, targetCollection, targetPks));
             }
         }
 
@@ -516,11 +585,11 @@ export class RelationService {
         const parentCollection = getCollectionByPath(parentCollectionPath, this.registry);
         const targetCollection = relation.target();
         const targetTable = getTableForCollection(targetCollection, this.registry);
-        const targetPks = getPrimaryKeys(targetCollection, this.registry);
+        const targetPks = requirePrimaryKeys(targetCollection, this.registry);
         const targetIdInfo = targetPks[0];
         const targetIdField = targetTable[targetIdInfo.fieldName as keyof typeof targetTable] as AnyPgColumn;
 
-        const parentPks = getPrimaryKeys(parentCollection, this.registry);
+        const parentPks = requirePrimaryKeys(parentCollection, this.registry);
         const parentIdInfo = parentPks[0];
         const parentTable = this.registry.getTable(getTableName(parentCollection));
         if (!parentTable) throw new Error("Parent table not found");
@@ -550,8 +619,7 @@ export class RelationService {
                 currentTable = joinTable;
             }
 
-            const parentIdField = parentTable[getPrimaryKeys(parentCollection, this.registry)[0].fieldName as keyof typeof parentTable] as AnyPgColumn;
-            query = query.where(inArray(parentIdField, parsedParentIds));
+            query = query.where(this.parentKeyCondition(parentTable, parentPks, parentIds));
 
             const results = await query;
             const targetTableName = relation.joinPath[relation.joinPath.length - 1].table;
@@ -560,15 +628,9 @@ export class RelationService {
             for (const row of results as Array<Record<string, unknown>>) {
                 const parentRow = (row[getTableName(parentCollection)] || row) as Record<string, unknown>;
                 const targetRow = (row[targetTableName] || row) as Record<string, unknown>;
-                const parentId = String(parentRow[parentIdInfo.fieldName]);
-                const parsedValues = await parseDataFromServer(targetRow, targetCollection);
-
+                const parentId = buildCompositeId(parentRow, parentPks);
                 const arr = resultMap.get(parentId) || [];
-                arr.push({
-                    id: String(targetRow[targetIdInfo.fieldName]),
-                    path: targetCollection.slug,
-                    values: parsedValues as Record<string, unknown>
-                });
+                arr.push(await this.toRelatedRow(targetRow, targetCollection, targetPks));
                 resultMap.set(parentId, arr);
             }
 
@@ -579,6 +641,9 @@ export class RelationService {
         // This is the standard path for posts→tags style relations where
         // sanitizeRelation populated the `through` config.
         if (relation.through && relation.cardinality === "many" && relation.direction === "owning") {
+            // The junction names its parent with one column, so the same
+            // single-key limit applies as for a direct foreign key.
+            this.assertSingleKeyAddressable(parentCollection, parentPks, `${relation.through.table}.${relation.through.sourceColumn}`);
             const junctionTable = this.registry.getTable(relation.through.table);
             if (!junctionTable) {
                 logger.warn(`[batchFetchRelatedEntitiesMany] Junction table '${relation.through.table}' not found`);
@@ -612,21 +677,21 @@ export class RelationService {
                 const targetData = (row[targetTableName] || row) as Record<string, unknown>;
 
                 const parentId = String(junctionData[relation.through.sourceColumn]);
-                const parsedValues = await parseDataFromServer(targetData, targetCollection);
-
                 const arr = resultMap.get(parentId) || [];
-                arr.push({
-                    id: String(targetData[targetIdInfo.fieldName]),
-                    path: targetCollection.slug,
-                    values: parsedValues as Record<string, unknown>
-                });
+                arr.push(await this.toRelatedRow(targetData, targetCollection, targetPks));
                 resultMap.set(parentId, arr);
             }
 
             return resultMap;
         }
 
-        // Handle FK-based relations (one-to-many inverse)
+        // Handle FK-based relations (one-to-many inverse). One column on the
+        // target names the parent, so a composite-keyed parent cannot be named.
+        this.assertSingleKeyAddressable(
+            parentCollection,
+            parentPks,
+            relation.foreignKeyOnTarget ?? `${relation.inverseRelationName}_id`
+        );
         let query = this.db.select().from(targetTable).$dynamic();
 
         query = applyDynamicRelationQuery(
@@ -668,14 +733,9 @@ export class RelationService {
             }
 
             if (parentId !== undefined && parentIdSet.has(String(parentId))) {
-                const parsedValues = await parseDataFromServer(targetRow, targetCollection);
                 const key = String(parentId);
                 const arr = resultMap.get(key) || [];
-                arr.push({
-                    id: String(targetRow[targetIdInfo.fieldName]),
-                    path: targetCollection.slug,
-                    values: parsedValues as Record<string, unknown>
-                });
+                arr.push(await this.toRelatedRow(targetRow, targetCollection, targetPks));
                 resultMap.set(key, arr);
             }
         }
@@ -746,7 +806,7 @@ export class RelationService {
                     continue;
                 }
 
-                const parentPks = getPrimaryKeys(collection, this.registry);
+                const parentPks = requirePrimaryKeys(collection, this.registry);
                 const parentIdInfo = parentPks[0];
                 const parsedParentIdObj = parseIdValues(id, parentPks);
                 const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
@@ -755,7 +815,7 @@ export class RelationService {
                 await tx.delete(junctionTable).where(eq(sourceJunctionColumn, parsedParentId));
 
                 if (targetEntityIds.length > 0) {
-                    const targetPks = getPrimaryKeys(targetCollection, this.registry);
+                    const targetPks = requirePrimaryKeys(targetCollection, this.registry);
                     const targetIdInfo = targetPks[0];
                     const parsedTargetIds = targetEntityIds.map(id => parseIdValues(id, targetPks)[targetIdInfo.fieldName]);
 
@@ -784,7 +844,7 @@ export class RelationService {
                     continue;
                 }
 
-                const parentPks = getPrimaryKeys(collection, this.registry);
+                const parentPks = requirePrimaryKeys(collection, this.registry);
                 const parentIdInfo = parentPks[0];
                 const parsedParentIdObj = parseIdValues(id, parentPks);
                 const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
@@ -793,7 +853,7 @@ export class RelationService {
                 await tx.delete(junctionTable).where(eq(sourceJunctionColumn, parsedParentId));
 
                 if (targetEntityIds.length > 0) {
-                    const targetPks = getPrimaryKeys(targetCollection, this.registry);
+                    const targetPks = requirePrimaryKeys(targetCollection, this.registry);
                     const targetIdInfo = targetPks[0];
                     const parsedTargetIds = targetEntityIds.map(id => parseIdValues(id, targetPks)[targetIdInfo.fieldName]);
 
@@ -813,7 +873,7 @@ export class RelationService {
             } else if (relation.cardinality === "many" && relation.direction === "inverse" && relation.foreignKeyOnTarget) {
                 // Handle one-to-many (inverse) by updating target FK to point to parent
                 const targetTable = getTableForCollection(targetCollection, this.registry);
-                const targetPks = getPrimaryKeys(targetCollection, this.registry);
+                const targetPks = requirePrimaryKeys(targetCollection, this.registry);
                 const targetIdInfo = targetPks[0];
                 const targetIdCol = targetTable[targetIdInfo.fieldName as keyof typeof targetTable] as AnyPgColumn;
                 const fkCol = targetTable[relation.foreignKeyOnTarget as keyof typeof targetTable] as AnyPgColumn;
@@ -823,7 +883,7 @@ export class RelationService {
                     continue;
                 }
 
-                const parentPks = getPrimaryKeys(collection, this.registry);
+                const parentPks = requirePrimaryKeys(collection, this.registry);
                 const parentIdInfo = parentPks[0];
                 const parsedParentIdObj = parseIdValues(id, parentPks);
                 const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
@@ -865,7 +925,6 @@ export class RelationService {
             relationKey: string;
             relation: Relation;
             newValue: unknown;
-            currentId?: string | number;
         }>
     ) {
         for (const update of inverseRelationUpdates) {
@@ -874,9 +933,9 @@ export class RelationService {
             try {
                 const targetCollection = relation.target();
                 const targetTable = getTableForCollection(targetCollection, this.registry);
-                const targetPks = getPrimaryKeys(targetCollection, this.registry);
+                const targetPks = requirePrimaryKeys(targetCollection, this.registry);
                 const targetIdInfo = targetPks[0];
-                const sourcePks = getPrimaryKeys(sourceCollection, this.registry);
+                const sourcePks = requirePrimaryKeys(sourceCollection, this.registry);
                 const sourceIdInfo = sourcePks[0];
 
                 // Handle inverse relations with joinPath
@@ -1033,7 +1092,7 @@ export class RelationService {
                 }
 
                 // Perform the junction table update
-                const sourcePks = getPrimaryKeys(sourceCollection, this.registry);
+                const sourcePks = requirePrimaryKeys(sourceCollection, this.registry);
                 const sourceIdInfo = sourcePks[0];
                 const parsedSourceIdObj = parseIdValues(sourceEntityId, sourcePks);
                 const parsedSourceId = parsedSourceIdObj[sourceIdInfo.fieldName];
@@ -1043,7 +1102,7 @@ export class RelationService {
 
                 // Add new entries if newValue is provided
                 if (newValue && Array.isArray(newValue) && newValue.length > 0) {
-                    const targetPks = getPrimaryKeys(targetCollection, this.registry);
+                    const targetPks = requirePrimaryKeys(targetCollection, this.registry);
                     const targetIdInfo = targetPks[0];
                     const targetEntityIds = (newValue as Array<{ id: string | number } | string | number>).map((rel) => typeof rel === "object" && rel !== null ? rel.id : rel);
                     const parsedTargetIds = targetEntityIds.map(id => parseIdValues(id, targetPks)[targetIdInfo.fieldName]);
@@ -1058,7 +1117,7 @@ export class RelationService {
                     }
                 } else if (newValue && !Array.isArray(newValue)) {
                     // Single value for one-to-one
-                    const targetPks = getPrimaryKeys(targetCollection, this.registry);
+                    const targetPks = requirePrimaryKeys(targetCollection, this.registry);
                     const targetIdInfo = targetPks[0];
                     const targetId = typeof newValue === "object" && newValue !== null ? (newValue as Record<string, unknown>).id as string | number : newValue as string | number;
                     const parsedTargetIdObj = parseIdValues(targetId, targetPks);
@@ -1105,7 +1164,7 @@ export class RelationService {
                 return;
             }
 
-            const sourcePks = getPrimaryKeys(sourceCollection, this.registry);
+            const sourcePks = requirePrimaryKeys(sourceCollection, this.registry);
             const sourceIdInfo = sourcePks[0];
             const parsedSourceIdObj = parseIdValues(sourceEntityId, sourcePks);
             const parsedSourceId = parsedSourceIdObj[sourceIdInfo.fieldName];
@@ -1115,7 +1174,7 @@ export class RelationService {
 
             // Add new entries if newValue is provided
             if (newValue && Array.isArray(newValue) && newValue.length > 0) {
-                const targetPks = getPrimaryKeys(targetCollection, this.registry);
+                const targetPks = requirePrimaryKeys(targetCollection, this.registry);
                 const targetIdInfo = targetPks[0];
                 const targetEntityIds = (newValue as Array<{ id: string | number }>).map((rel) => rel.id);
                 const parsedTargetIds = targetEntityIds.map(id => parseIdValues(id, targetPks)[targetIdInfo.fieldName]);
@@ -1152,14 +1211,14 @@ export class RelationService {
             const { relation, newTargetId } = upd;
             const targetCollection = relation.target();
             const targetTable = getTableForCollection(targetCollection, this.registry);
-            const targetPks = getPrimaryKeys(targetCollection, this.registry);
+            const targetPks = requirePrimaryKeys(targetCollection, this.registry);
             const targetIdInfo = targetPks[0];
             const targetIdCol = targetTable[targetIdInfo.fieldName as keyof typeof targetTable] as AnyPgColumn;
 
             // Determine mapping of columns
             const { targetFKColName, parentSourceColName } = this.resolveJoinPathWriteMapping(parentCollection, relation);
             const parentTable = getTableForCollection(parentCollection, this.registry);
-            const parentPks = getPrimaryKeys(parentCollection, this.registry);
+            const parentPks = requirePrimaryKeys(parentCollection, this.registry);
             const parentIdInfo = parentPks[0];
             const parsedParentIdObj = parseIdValues(parentId, parentPks);
             const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
@@ -1284,7 +1343,7 @@ parentSourceColName };
             }
 
             // Parse the new row ID to the correct type
-            const targetPks = getPrimaryKeys(targetCollection, this.registry);
+            const targetPks = requirePrimaryKeys(targetCollection, this.registry);
             const targetIdInfo = targetPks[0];
             const parsedNewEntityIdObj = parseIdValues(newEntityId, targetPks);
             const parsedNewEntityId = parsedNewEntityIdObj[targetIdInfo.fieldName];