@rebasepro/server-postgres 0.9.1-canary.16c42e9 → 0.9.1-canary.1d2d8b5

package/src/services/RelationService.ts

@@ -1,4 +1,4 @@
-import { and, eq, inArray, or, sql, SQL } from "drizzle-orm";
+import { and, eq, inArray, 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,10 +7,9 @@ import { DrizzleConditionBuilder } from "../utils/drizzle-conditions";
 import {
     getCollectionByPath,
     getTableForCollection,
-    requirePrimaryKeys,
+    getPrimaryKeys,
     parseIdValues,
-    buildCompositeId,
-    type PrimaryKeyInfo
+    buildCompositeId
 } from "./collection-helpers";
 import { parseDataFromServer } from "../data-transformer";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
@@ -57,94 +56,6 @@ 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
      */
@@ -193,10 +104,10 @@ export class RelationService {
     ): Promise<RelatedRow<M>[]> {
         const targetCollection = relation.target();
         const targetTable = getTableForCollection(targetCollection, this.registry);
-        const idInfo = requirePrimaryKeys(targetCollection, this.registry);
+        const idInfo = getPrimaryKeys(targetCollection, this.registry);
         const idField = targetTable[idInfo[0].fieldName as keyof typeof targetTable] as AnyPgColumn;
 
-        const parentPks = requirePrimaryKeys(parentCollection, this.registry);
+        const parentPks = getPrimaryKeys(parentCollection, this.registry);
         const parentIdInfo = parentPks[0];
         const parsedParentIdObj = parseIdValues(parentId, parentPks);
         const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
@@ -237,7 +148,7 @@ export class RelationService {
             }
 
             // Add where condition for the parent row
-            const parentIdField = parentTable[requirePrimaryKeys(parentCollection, this.registry)[0].fieldName as keyof typeof parentTable] as AnyPgColumn;
+            const parentIdField = parentTable[getPrimaryKeys(parentCollection, this.registry)[0].fieldName as keyof typeof parentTable] as AnyPgColumn;
             query = query.where(eq(parentIdField, parsedParentId));
 
             if (options.limit) {
@@ -251,7 +162,14 @@ 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;
-                rows.push(await this.toRelatedRow<M>(targetRow, targetCollection, idInfo, { resolveNested: true }));
+                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
+                });
             }
 
             return rows;
@@ -310,7 +228,14 @@ export class RelationService {
         const rows: RelatedRow<M>[] = [];
         for (const row of results) {
             const targetRow = row[getTableName(targetCollection)] || row;
-            rows.push(await this.toRelatedRow<M>(targetRow as Record<string, unknown>, targetCollection, idInfo, { resolveNested: true }));
+            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
+            });
         }
 
         return rows;
@@ -335,11 +260,11 @@ export class RelationService {
 
         const targetCollection = relation.target();
         const targetTable = getTableForCollection(targetCollection, this.registry);
-        const targetPks = requirePrimaryKeys(targetCollection, this.registry);
+        const targetPks = getPrimaryKeys(targetCollection, this.registry);
         const targetIdInfo = targetPks[0];
         const targetIdField = targetTable[targetIdInfo.fieldName as keyof typeof targetTable] as AnyPgColumn;
 
-        const parentPks = requirePrimaryKeys(parentCollection, this.registry);
+        const parentPks = getPrimaryKeys(parentCollection, this.registry);
         const parentIdInfo = parentPks[0];
         const parsedParentIdObj = parseIdValues(parentId, parentPks);
         const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
@@ -384,11 +309,11 @@ export class RelationService {
         const parentCollection = getCollectionByPath(parentCollectionPath, this.registry);
         const targetCollection = relation.target();
         const targetTable = getTableForCollection(targetCollection, this.registry);
-        const targetPks = requirePrimaryKeys(targetCollection, this.registry);
+        const targetPks = getPrimaryKeys(targetCollection, this.registry);
         const targetIdInfo = targetPks[0];
         const targetIdField = targetTable[targetIdInfo.fieldName as keyof typeof targetTable] as AnyPgColumn;
 
-        const parentPks = requirePrimaryKeys(parentCollection, this.registry);
+        const parentPks = getPrimaryKeys(parentCollection, this.registry);
         const parentIdInfo = parentPks[0];
         const parentTable = this.registry.getTable(getTableName(parentCollection));
         if (!parentTable) throw new Error("Parent table not found");
@@ -429,23 +354,27 @@ export class RelationService {
                 currentTable = joinTable;
             }
 
-            // Match every parent at once, each by its whole key.
-            query = query.where(this.parentKeyCondition(parentTable, parentPks, parentIds));
+            // 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));
 
             const results = await query;
             const targetTableName = relation.joinPath[relation.joinPath.length - 1].table;
             const resultMap = new Map<string, RelatedRow<Record<string, unknown>>>();
 
-            // Group by the parent's address — the same token the caller looks
-            // results up by, derived the same way on both sides.
+            // Group results by parent ID
             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(
-                    buildCompositeId(parentRow, parentPks),
-                    await this.toRelatedRow(targetRow, targetCollection, targetPks)
-                );
+                resultMap.set(String(parentId), {
+                    id: String(targetRow[targetIdInfo.fieldName]),
+                    path: targetCollection.slug,
+                    values: parsedValues as Record<string, unknown>
+                });
             }
 
             return resultMap;
@@ -458,7 +387,6 @@ 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`);
@@ -508,21 +436,19 @@ export class RelationService {
             for (const [parentIdStr, fkValue] of parentToFk) {
                 const targetRow = targetById.get(String(fkValue));
                 if (targetRow) {
-                    resultMap.set(parentIdStr, await this.toRelatedRow(targetRow, targetCollection, targetPks));
+                    const parsedValues = await parseDataFromServer(targetRow, targetCollection);
+                    resultMap.set(parentIdStr, {
+                        id: String(targetRow[targetIdInfo.fieldName]),
+                        path: targetCollection.slug,
+                        values: parsedValues as Record<string, unknown>
+                    });
                 }
             }
 
             return resultMap;
         }
 
-        // 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`
-        );
+        // Handle inverse relation types with batching
         let query = this.db.select().from(targetTable).$dynamic();
 
         // Build the relation query with ALL parent IDs
@@ -562,7 +488,12 @@ export class RelationService {
             }
 
             if (parentId !== undefined && parentIdSet.has(String(parentId))) {
-                resultMap.set(String(parentId), await this.toRelatedRow(targetRow, targetCollection, targetPks));
+                const parsedValues = await parseDataFromServer(targetRow, targetCollection);
+                resultMap.set(String(parentId), {
+                    id: String(targetRow[targetIdInfo.fieldName]),
+                    path: targetCollection.slug,
+                    values: parsedValues as Record<string, unknown>
+                });
             }
         }
 
@@ -585,11 +516,11 @@ export class RelationService {
         const parentCollection = getCollectionByPath(parentCollectionPath, this.registry);
         const targetCollection = relation.target();
         const targetTable = getTableForCollection(targetCollection, this.registry);
-        const targetPks = requirePrimaryKeys(targetCollection, this.registry);
+        const targetPks = getPrimaryKeys(targetCollection, this.registry);
         const targetIdInfo = targetPks[0];
         const targetIdField = targetTable[targetIdInfo.fieldName as keyof typeof targetTable] as AnyPgColumn;
 
-        const parentPks = requirePrimaryKeys(parentCollection, this.registry);
+        const parentPks = getPrimaryKeys(parentCollection, this.registry);
         const parentIdInfo = parentPks[0];
         const parentTable = this.registry.getTable(getTableName(parentCollection));
         if (!parentTable) throw new Error("Parent table not found");
@@ -619,7 +550,8 @@ export class RelationService {
                 currentTable = joinTable;
             }
 
-            query = query.where(this.parentKeyCondition(parentTable, parentPks, parentIds));
+            const parentIdField = parentTable[getPrimaryKeys(parentCollection, this.registry)[0].fieldName as keyof typeof parentTable] as AnyPgColumn;
+            query = query.where(inArray(parentIdField, parsedParentIds));
 
             const results = await query;
             const targetTableName = relation.joinPath[relation.joinPath.length - 1].table;
@@ -628,9 +560,15 @@ 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 = buildCompositeId(parentRow, parentPks);
+                const parentId = String(parentRow[parentIdInfo.fieldName]);
+                const parsedValues = await parseDataFromServer(targetRow, targetCollection);
+
                 const arr = resultMap.get(parentId) || [];
-                arr.push(await this.toRelatedRow(targetRow, targetCollection, targetPks));
+                arr.push({
+                    id: String(targetRow[targetIdInfo.fieldName]),
+                    path: targetCollection.slug,
+                    values: parsedValues as Record<string, unknown>
+                });
                 resultMap.set(parentId, arr);
             }
 
@@ -641,9 +579,6 @@ 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`);
@@ -677,21 +612,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(await this.toRelatedRow(targetData, targetCollection, targetPks));
+                arr.push({
+                    id: String(targetData[targetIdInfo.fieldName]),
+                    path: targetCollection.slug,
+                    values: parsedValues as Record<string, unknown>
+                });
                 resultMap.set(parentId, arr);
             }
 
             return resultMap;
         }
 
-        // 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`
-        );
+        // Handle FK-based relations (one-to-many inverse)
         let query = this.db.select().from(targetTable).$dynamic();
 
         query = applyDynamicRelationQuery(
@@ -733,9 +668,14 @@ 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(await this.toRelatedRow(targetRow, targetCollection, targetPks));
+                arr.push({
+                    id: String(targetRow[targetIdInfo.fieldName]),
+                    path: targetCollection.slug,
+                    values: parsedValues as Record<string, unknown>
+                });
                 resultMap.set(key, arr);
             }
         }
@@ -806,7 +746,7 @@ export class RelationService {
                     continue;
                 }
 
-                const parentPks = requirePrimaryKeys(collection, this.registry);
+                const parentPks = getPrimaryKeys(collection, this.registry);
                 const parentIdInfo = parentPks[0];
                 const parsedParentIdObj = parseIdValues(id, parentPks);
                 const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
@@ -815,7 +755,7 @@ export class RelationService {
                 await tx.delete(junctionTable).where(eq(sourceJunctionColumn, parsedParentId));
 
                 if (targetEntityIds.length > 0) {
-                    const targetPks = requirePrimaryKeys(targetCollection, this.registry);
+                    const targetPks = getPrimaryKeys(targetCollection, this.registry);
                     const targetIdInfo = targetPks[0];
                     const parsedTargetIds = targetEntityIds.map(id => parseIdValues(id, targetPks)[targetIdInfo.fieldName]);
 
@@ -844,7 +784,7 @@ export class RelationService {
                     continue;
                 }
 
-                const parentPks = requirePrimaryKeys(collection, this.registry);
+                const parentPks = getPrimaryKeys(collection, this.registry);
                 const parentIdInfo = parentPks[0];
                 const parsedParentIdObj = parseIdValues(id, parentPks);
                 const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
@@ -853,7 +793,7 @@ export class RelationService {
                 await tx.delete(junctionTable).where(eq(sourceJunctionColumn, parsedParentId));
 
                 if (targetEntityIds.length > 0) {
-                    const targetPks = requirePrimaryKeys(targetCollection, this.registry);
+                    const targetPks = getPrimaryKeys(targetCollection, this.registry);
                     const targetIdInfo = targetPks[0];
                     const parsedTargetIds = targetEntityIds.map(id => parseIdValues(id, targetPks)[targetIdInfo.fieldName]);
 
@@ -873,7 +813,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 = requirePrimaryKeys(targetCollection, this.registry);
+                const targetPks = getPrimaryKeys(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;
@@ -883,7 +823,7 @@ export class RelationService {
                     continue;
                 }
 
-                const parentPks = requirePrimaryKeys(collection, this.registry);
+                const parentPks = getPrimaryKeys(collection, this.registry);
                 const parentIdInfo = parentPks[0];
                 const parsedParentIdObj = parseIdValues(id, parentPks);
                 const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
@@ -925,6 +865,7 @@ export class RelationService {
             relationKey: string;
             relation: Relation;
             newValue: unknown;
+            currentId?: string | number;
         }>
     ) {
         for (const update of inverseRelationUpdates) {
@@ -933,9 +874,9 @@ export class RelationService {
             try {
                 const targetCollection = relation.target();
                 const targetTable = getTableForCollection(targetCollection, this.registry);
-                const targetPks = requirePrimaryKeys(targetCollection, this.registry);
+                const targetPks = getPrimaryKeys(targetCollection, this.registry);
                 const targetIdInfo = targetPks[0];
-                const sourcePks = requirePrimaryKeys(sourceCollection, this.registry);
+                const sourcePks = getPrimaryKeys(sourceCollection, this.registry);
                 const sourceIdInfo = sourcePks[0];
 
                 // Handle inverse relations with joinPath
@@ -1092,7 +1033,7 @@ export class RelationService {
                 }
 
                 // Perform the junction table update
-                const sourcePks = requirePrimaryKeys(sourceCollection, this.registry);
+                const sourcePks = getPrimaryKeys(sourceCollection, this.registry);
                 const sourceIdInfo = sourcePks[0];
                 const parsedSourceIdObj = parseIdValues(sourceEntityId, sourcePks);
                 const parsedSourceId = parsedSourceIdObj[sourceIdInfo.fieldName];
@@ -1102,7 +1043,7 @@ export class RelationService {
 
                 // Add new entries if newValue is provided
                 if (newValue && Array.isArray(newValue) && newValue.length > 0) {
-                    const targetPks = requirePrimaryKeys(targetCollection, this.registry);
+                    const targetPks = getPrimaryKeys(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]);
@@ -1117,7 +1058,7 @@ export class RelationService {
                     }
                 } else if (newValue && !Array.isArray(newValue)) {
                     // Single value for one-to-one
-                    const targetPks = requirePrimaryKeys(targetCollection, this.registry);
+                    const targetPks = getPrimaryKeys(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);
@@ -1164,7 +1105,7 @@ export class RelationService {
                 return;
             }
 
-            const sourcePks = requirePrimaryKeys(sourceCollection, this.registry);
+            const sourcePks = getPrimaryKeys(sourceCollection, this.registry);
             const sourceIdInfo = sourcePks[0];
             const parsedSourceIdObj = parseIdValues(sourceEntityId, sourcePks);
             const parsedSourceId = parsedSourceIdObj[sourceIdInfo.fieldName];
@@ -1174,7 +1115,7 @@ export class RelationService {
 
             // Add new entries if newValue is provided
             if (newValue && Array.isArray(newValue) && newValue.length > 0) {
-                const targetPks = requirePrimaryKeys(targetCollection, this.registry);
+                const targetPks = getPrimaryKeys(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]);
@@ -1211,14 +1152,14 @@ export class RelationService {
             const { relation, newTargetId } = upd;
             const targetCollection = relation.target();
             const targetTable = getTableForCollection(targetCollection, this.registry);
-            const targetPks = requirePrimaryKeys(targetCollection, this.registry);
+            const targetPks = getPrimaryKeys(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 = requirePrimaryKeys(parentCollection, this.registry);
+            const parentPks = getPrimaryKeys(parentCollection, this.registry);
             const parentIdInfo = parentPks[0];
             const parsedParentIdObj = parseIdValues(parentId, parentPks);
             const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
@@ -1343,7 +1284,7 @@ parentSourceColName };
             }
 
             // Parse the new row ID to the correct type
-            const targetPks = requirePrimaryKeys(targetCollection, this.registry);
+            const targetPks = getPrimaryKeys(targetCollection, this.registry);
             const targetIdInfo = targetPks[0];
             const parsedNewEntityIdObj = parseIdValues(newEntityId, targetPks);
             const parsedNewEntityId = parsedNewEntityIdObj[targetIdInfo.fieldName];