@rebasepro/server-postgres 0.13.1-canary.gf57a27e → 0.14.0

package/src/services/RelationService.ts

@@ -1,13 +1,14 @@
-import { and, eq, inArray, or, sql, SQL } from "drizzle-orm";
+import { and, eq, inArray, notInArray, or, sql, SQL, getTableName as drizzleTableName } from "drizzle-orm";
 import { AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
 import { DrizzleClient } from "../interfaces";
 import { CollectionConfig, FilterValues, ResolvedRelation, ResolvedManyToMany, ResolvedHasMany, ResolvedHasOne } from "@rebasepro/types";
-import { getTableName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
+import { getTableName, resolveCollectionRelations, findRelation, fieldKeyForColumn } from "@rebasepro/common";
 import { hasForeignKeyOnTarget, isManyToMany, type ResolvedVia } from "@rebasepro/types";
 import { DrizzleConditionBuilder } from "../utils/drizzle-conditions";
 import {
     getCollectionByPath,
     getTableForCollection,
+    relationMisconfigured,
     requirePrimaryKeys,
     parseIdValues,
     buildCompositeId,
@@ -17,8 +18,14 @@ import {
 } from "./collection-helpers";
 import { parseDataFromServer } from "../data-transformer";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
-import { logger } from "@rebasepro/server";
+import { ApiError, logger } from "@rebasepro/server";
 import type { NestedPathHop } from "./nested-path";
+import {
+    applyJunctionMembership,
+    bindJoinPathJunction,
+    bindThroughJunction,
+    removeJunctionLink
+} from "./junction-writes";
 
 /**
  * The ids in a to-many relation write, whatever shape the caller sent.
@@ -221,7 +228,11 @@ export class RelationService {
         return keyByParentId.get(String(parentId));
     }
 
-    private async resolveSourceKeys(
+    /**
+     * Shared with {@link RelationWriteService}: a write needs the same source
+     * key a read does, and resolving it twice is how the two would disagree.
+     */
+    async resolveSourceKeys(
         parentCollection: CollectionConfig,
         relation: ResolvedHasOne | ResolvedHasMany,
         parentIds: (string | number)[],
@@ -575,51 +586,6 @@ export class RelationService {
         return (await this.countRelatedRows(hop.parentCollection, hop.parentId, hop.relation, identity)) > 0;
     }
 
-    /**
-     * Remove the junction row linking a parent to `targetId`, leaving the target
-     * row itself alone.
-     *
-     * This is what `DELETE authors/1/tags/5` has to mean for a many-to-many: the
-     * target is shared, so deleting the row would remove the tag from every other
-     * post that uses it. It used to do exactly that — resolve the path to the
-     * `tags` table and delete by primary key.
-     */
-    async unlinkRelatedEntity(
-        tx: DrizzleClient,
-        hop: NestedPathHop,
-        targetId: string | number
-    ): Promise<void> {
-        if (!isManyToMany(hop.relation)) {
-            throw new Error(`Relation '${hop.relationKey}' has no junction table to unlink through`);
-        }
-        const through = hop.relation.through;
-
-        const junctionTable = this.registry.getTable(through.table);
-        if (!junctionTable) {
-            throw new Error(`Junction table not found: ${through.table}`);
-        }
-
-        const sourceJunctionColumn = junctionTable[through.sourceColumn as keyof typeof junctionTable] as AnyPgColumn;
-        const targetJunctionColumn = junctionTable[through.targetColumn as keyof typeof junctionTable] as AnyPgColumn;
-
-        if (!sourceJunctionColumn || !targetJunctionColumn) {
-            throw new Error(`Junction columns not found for relation '${hop.relationKey}' on table '${through.table}'`);
-        }
-
-        const parentPks = requirePrimaryKeys(hop.parentCollection, this.registry);
-        const parsedParentId = parseIdValues(hop.parentId, parentPks)[parentPks[0].fieldName];
-
-        const targetPks = requirePrimaryKeys(hop.targetCollection, this.registry);
-        const parsedTargetId = parseIdValues(targetId, targetPks)[targetPks[0].fieldName];
-
-        await tx.delete(junctionTable).where(and(
-            eq(sourceJunctionColumn, parsedParentId),
-            eq(targetJunctionColumn, parsedTargetId)
-        ));
-
-        logger.info(`Unlinked '${hop.relationKey}' ${parsedTargetId} from ${hop.parentCollection.slug} ${parsedParentId}`);
-    }
-
     /**
      * Batch fetch related rows for multiple parent rows to avoid N+1 queries
      */
@@ -709,7 +675,10 @@ export class RelationService {
         //   3. Map results back to parent rows via their FK values
         if (relation.kind === "belongsTo") {
             this.assertSingleKeyAddressable(parentCollection, parentPks, relation.localKey);
-            const localKeyCol = parentTable[relation.localKey as keyof typeof parentTable] as AnyPgColumn;
+            // `localKey` is the column; the generated table is keyed by the wire
+            // name, so `author_id` finds nothing where the key is `authorId`.
+            const localKeyField = fieldKeyForColumn(parentCollection, relation.localKey);
+            const localKeyCol = parentTable[localKeyField as keyof typeof parentTable] as AnyPgColumn;
             if (!localKeyCol) {
                 throw new Error(`Local key column '${relation.localKey}' not found in parent table`);
             }
@@ -819,7 +788,9 @@ export class RelationService {
 
             // Keyed by string throughout: Drizzle returns a numeric column as a
             // number or a string depending on the column type and the driver.
-            const foreignKeyValue = targetRow[relation.foreignKeyOnTarget] as string | number | undefined;
+            const foreignKeyValue = targetRow[
+                fieldKeyForColumn(targetCollection, relation.foreignKeyOnTarget)
+            ] as string | number | undefined;
             if (foreignKeyValue === undefined || foreignKeyValue === null) continue;
 
             const parentId = parentIdByKey.get(String(foreignKeyValue));
@@ -906,19 +877,17 @@ export class RelationService {
             // 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`);
-                return new Map();
-            }
-
-            const sourceJunctionCol = junctionTable[relation.through.sourceColumn as keyof typeof junctionTable] as AnyPgColumn;
-            const targetJunctionCol = junctionTable[relation.through.targetColumn as keyof typeof junctionTable] as AnyPgColumn;
 
-            if (!sourceJunctionCol || !targetJunctionCol) {
-                logger.warn(`[batchFetchRelatedEntitiesMany] Junction columns not found in '${relation.through.table}'`);
-                return new Map();
-            }
+            // An empty map here is a lie a caller cannot see through: `posts/1/tags`
+            // answering `[]` is exactly what a post with no tags looks like. That
+            // is the failure `assertRelationsResolve` was written to make
+            // impossible at boot; this says the same thing if one gets past it.
+            const { table: junctionTable, parentColumn: sourceJunctionCol, targetColumn: targetJunctionCol } =
+                bindThroughJunction(
+                    this.registry,
+                    relation.through,
+                    `${parentCollection.slug}.${relation.relationName}`
+                );
 
             // SELECT target.*, junction.sourceColumn FROM junction
             // INNER JOIN target ON junction.targetColumn = target.id
@@ -990,7 +959,9 @@ export class RelationService {
             // what reaches here names the parent with a column on the target.
             if (!hasForeignKeyOnTarget(relation)) continue;
 
-            const foreignKeyValue = targetRow[relation.foreignKeyOnTarget] as string | number | undefined;
+            const foreignKeyValue = targetRow[
+                fieldKeyForColumn(targetCollection, relation.foreignKeyOnTarget)
+            ] as string | number | undefined;
             if (foreignKeyValue === undefined || foreignKeyValue === null) continue;
 
             const parentId = parentIdByKey.get(String(foreignKeyValue));
@@ -1004,635 +975,4 @@ export class RelationService {
 
         return resultMap;
     }
-
-    /**
-     * Update many-to-many and junction relations
-     */
-    async updateRelationsUsingJoins<M extends Record<string, unknown>>(
-        tx: DrizzleClient,
-        collection: CollectionConfig,
-        id: string | number,
-        relationValues: Partial<M>
-    ) {
-        const resolvedRelations = resolveCollectionRelations(collection);
-
-        for (const [key, value] of Object.entries(relationValues)) {
-            const relation = findRelation(resolvedRelations, key);
-            if (!relation || relation.cardinality !== "many") continue;
-
-            const targetEntityIds = relationTargetIds(value, key, collection.slug);
-            const targetCollection = relation.target();
-
-            // Use joinPath if available
-            if (relation.kind === "via") {
-                const parentTableName = getTableName(collection);
-                const targetTableName = getTableName(targetCollection);
-
-                let junctionTable: PgTable | undefined = undefined;
-                let sourceJunctionColumn: AnyPgColumn | null = null;
-                let targetJunctionColumn: AnyPgColumn | null = null;
-
-                const junctionTableName = relation.joinPath.find(step =>
-                    step.table !== parentTableName && step.table !== targetTableName
-                )?.table;
-
-                if (junctionTableName) {
-                    junctionTable = this.registry.getTable(junctionTableName);
-
-                    if (junctionTable) {
-                        for (const joinStep of relation.joinPath) {
-                            const fromTable = DrizzleConditionBuilder.getTableNamesFromColumns(joinStep.on.from)[0];
-                            const toTable = DrizzleConditionBuilder.getTableNamesFromColumns(joinStep.on.to)[0];
-
-                            if (fromTable === parentTableName && toTable === junctionTableName) {
-                                const columnNames = DrizzleConditionBuilder.getColumnNamesFromColumns(joinStep.on.to);
-                                sourceJunctionColumn = junctionTable[columnNames[0] as keyof typeof junctionTable] as AnyPgColumn;
-                            } else if (fromTable === junctionTableName && toTable === parentTableName) {
-                                const columnNames = DrizzleConditionBuilder.getColumnNamesFromColumns(joinStep.on.from);
-                                sourceJunctionColumn = junctionTable[columnNames[0] as keyof typeof junctionTable] as AnyPgColumn;
-                            }
-
-                            if (fromTable === junctionTableName && toTable === targetTableName) {
-                                const columnNames = DrizzleConditionBuilder.getColumnNamesFromColumns(joinStep.on.from);
-                                targetJunctionColumn = junctionTable[columnNames[0] as keyof typeof junctionTable] as AnyPgColumn;
-                            } else if (fromTable === targetTableName && toTable === junctionTableName) {
-                                const columnNames = DrizzleConditionBuilder.getColumnNamesFromColumns(joinStep.on.to);
-                                targetJunctionColumn = junctionTable[columnNames[0] as keyof typeof junctionTable] as AnyPgColumn;
-                            }
-                        }
-                    }
-                }
-
-                if (!junctionTable || !sourceJunctionColumn || !targetJunctionColumn) {
-                    logger.warn(`Could not determine junction table for relation '${key}' in collection '${collection.slug}'`);
-                    continue;
-                }
-
-                const parentPks = requirePrimaryKeys(collection, this.registry);
-                const parentIdInfo = parentPks[0];
-                const parsedParentIdObj = parseIdValues(id, parentPks);
-                const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
-
-                // Delete existing relations for this row
-                await tx.delete(junctionTable).where(eq(sourceJunctionColumn, parsedParentId));
-
-                if (targetEntityIds.length > 0) {
-                    const targetPks = requirePrimaryKeys(targetCollection, this.registry);
-                    const targetIdInfo = targetPks[0];
-                    const parsedTargetIds = targetEntityIds.map(id => parseIdValues(id, targetPks)[targetIdInfo.fieldName]);
-
-                    const newLinks = parsedTargetIds.map(targetId => ({
-                        [sourceJunctionColumn.name]: parsedParentId,
-                        [targetJunctionColumn.name]: targetId
-                    }));
-
-                    if (newLinks.length > 0) {
-                        await tx.insert(junctionTable).values(newLinks);
-                    }
-                }
-            } else if (relation.kind === "manyToMany") {
-                // Handle many-to-many relations with junction table using 'through' property
-                const junctionTable = this.registry.getTable(relation.through.table);
-                if (!junctionTable) {
-                    logger.warn(`Junction table '${relation.through.table}' not found for relation '${key}' in collection '${collection.slug}'`);
-                    continue;
-                }
-
-                const sourceJunctionColumn = junctionTable[relation.through.sourceColumn as keyof typeof junctionTable] as AnyPgColumn;
-                const targetJunctionColumn = junctionTable[relation.through.targetColumn as keyof typeof junctionTable] as AnyPgColumn;
-
-                if (!sourceJunctionColumn || !targetJunctionColumn) {
-                    logger.warn(`Junction columns not found for relation '${key}'`);
-                    continue;
-                }
-
-                const parentPks = requirePrimaryKeys(collection, this.registry);
-                const parentIdInfo = parentPks[0];
-                const parsedParentIdObj = parseIdValues(id, parentPks);
-                const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
-
-                // Delete existing relations for this row
-                await tx.delete(junctionTable).where(eq(sourceJunctionColumn, parsedParentId));
-
-                if (targetEntityIds.length > 0) {
-                    const targetPks = requirePrimaryKeys(targetCollection, this.registry);
-                    const targetIdInfo = targetPks[0];
-                    const parsedTargetIds = targetEntityIds.map(id => parseIdValues(id, targetPks)[targetIdInfo.fieldName]);
-
-                    const newLinks = parsedTargetIds.map(targetId => ({
-                        [sourceJunctionColumn.name]: parsedParentId,
-                        [targetJunctionColumn.name]: targetId
-                    }));
-
-                    if (newLinks.length > 0) {
-                        await tx.insert(junctionTable).values(newLinks);
-                    }
-                }
-            } else if (relation.cardinality === "many" && hasForeignKeyOnTarget(relation)) {
-                // 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 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;
-
-                if (!fkCol || !targetIdCol) {
-                    logger.warn(`Invalid inverse-many config for relation '${key}' in collection '${collection.slug}'`);
-                    continue;
-                }
-
-                // What the children's foreign key must hold — the parent's id
-                // unless the link declares a `sourceKey`, and then the value of
-                // that column on this parent row.
-                const parentKeyValue = (await this.resolveSourceKeys(collection, relation, [id], tx))
-                    .keyByParentId.get(String(id));
-
-                if (parentKeyValue === undefined) {
-                    throw new Error(
-                        `Cannot write relation '${key}' on '${collection.slug}': row '${id}' has no value in ` +
-                        `\`sourceKey: "${sourceKeyField(relation, collection, this.registry)}"\`, so there is ` +
-                        "nothing for the related rows to point at."
-                    );
-                }
-
-                // Clear existing links not in the new set
-                if (targetEntityIds.length > 0) {
-                    const parsedTargetIds = targetEntityIds.map(id => parseIdValues(id, targetPks)[targetIdInfo.fieldName]);
-                    await tx
-                        .update(targetTable)
-                        .set({ [relation.foreignKeyOnTarget]: null })
-                        .where(and(eq(fkCol, parentKeyValue), sql`${targetIdCol} NOT IN (${sql.join(parsedTargetIds)})`));
-
-                    // Set FK for the provided targets
-                    await tx
-                        .update(targetTable)
-                        .set({ [relation.foreignKeyOnTarget]: parentKeyValue })
-                        .where(inArray(targetIdCol as AnyPgColumn, parsedTargetIds as unknown[]));
-                } else {
-                    // If empty array provided, clear all existing links for this parent
-                    await tx
-                        .update(targetTable)
-                        .set({ [relation.foreignKeyOnTarget]: null })
-                        .where(eq(fkCol, parentKeyValue));
-                }
-            } else {
-                logger.warn(`Many relation '${key}' in collection '${collection.slug}' lacks write configuration and will be skipped during save.`);
-            }
-        }
-    }
-
-    /**
-     * Update inverse relations (where FK is on the target table)
-     */
-    async updateInverseRelations(
-        tx: DrizzleClient,
-        sourceCollection: CollectionConfig,
-        sourceEntityId: string | number,
-        inverseRelationUpdates: Array<{
-            relationKey: string;
-            relation: ResolvedRelation;
-            newValue: unknown;
-        }>
-    ) {
-        for (const update of inverseRelationUpdates) {
-            const { relation, newValue } = update;
-
-            try {
-                const targetCollection = relation.target();
-                const targetTable = getTableForCollection(targetCollection, this.registry);
-                const targetPks = requirePrimaryKeys(targetCollection, this.registry);
-                const targetIdInfo = targetPks[0];
-                const sourcePks = requirePrimaryKeys(sourceCollection, this.registry);
-                const sourceIdInfo = sourcePks[0];
-
-                if (relation.kind === "via") {
-                    await this.updateInverseJoinPathRelation(
-                        tx,
-                        sourceCollection,
-                        sourceEntityId,
-                        targetCollection,
-                        relation,
-                        newValue
-                    );
-                    continue;
-                }
-
-                // A many-to-many names its own junction. This used to walk the
-                // *target's* relations looking for an owning side whose
-                // `relationName` matched `inverseRelationName`, and swap its
-                // source/target columns — a search that silently did nothing
-                // when the far side was declared differently than expected.
-                if (isManyToMany(relation)) {
-                    await this.updateManyToManyInverseRelation(
-                        tx,
-                        sourceCollection,
-                        sourceEntityId,
-                        targetCollection,
-                        relation,
-                        newValue,
-                        {
-                            table: relation.through.table,
-                            sourceColumn: relation.through.sourceColumn,
-                            targetColumn: relation.through.targetColumn
-                        }
-                    );
-                    continue;
-                }
-
-                // What is left names the parent with a column on the target.
-                if (!hasForeignKeyOnTarget(relation)) {
-                    logger.warn(`Relation '${relation.relationName}' has no column on the target to write. Skipping.`);
-                    continue;
-                }
-
-                const foreignKeyColumn = targetTable[relation.foreignKeyOnTarget! as keyof typeof targetTable] as AnyPgColumn;
-                if (!foreignKeyColumn) {
-                    logger.warn(`Foreign key column '${relation.foreignKeyOnTarget}' not found in target table for relation '${relation.relationName}'`);
-                    continue;
-                }
-
-                // The value the target's foreign key holds: this row's id, or
-                // the column named by `sourceKey` when the link joins on one.
-                const sourceKeyValue = (await this.resolveSourceKeys(sourceCollection, relation, [sourceEntityId], tx))
-                    .keyByParentId.get(String(sourceEntityId));
-
-                if (sourceKeyValue === undefined) {
-                    throw new Error(
-                        `Cannot write relation '${relation.relationName}' on '${sourceCollection.slug}': row ` +
-                        `'${sourceEntityId}' has no value in \`sourceKey: ` +
-                        `"${sourceKeyField(relation, sourceCollection, this.registry)}"\`, so there is nothing ` +
-                        "for the related row to point at."
-                    );
-                }
-
-                if (newValue === null || newValue === undefined) {
-                    await tx
-                        .update(targetTable)
-                        .set({ [relation.foreignKeyOnTarget!]: null })
-                        .where(eq(foreignKeyColumn, sourceKeyValue));
-                } else {
-                    const parsedNewTargetIdObj = parseIdValues(newValue as string | number, targetPks);
-                    const parsedNewTargetId = parsedNewTargetIdObj[targetIdInfo.fieldName];
-                    const targetIdField = targetTable[targetIdInfo.fieldName as keyof typeof targetTable] as AnyPgColumn;
-
-                    // First, clear any existing FK that points to this source row
-                    await tx
-                        .update(targetTable)
-                        .set({ [relation.foreignKeyOnTarget!]: null })
-                        .where(eq(foreignKeyColumn, sourceKeyValue));
-
-                    // Then, update the new target row to point to this source row
-                    await tx
-                        .update(targetTable)
-                        .set({ [relation.foreignKeyOnTarget!]: sourceKeyValue })
-                        .where(eq(targetIdField, parsedNewTargetId));
-                }
-            } catch (e) {
-                logger.warn(`Failed to update inverse relation '${relation.relationName}'`, { error: e });
-            }
-        }
-    }
-
-    /**
-     * Handle inverse relations with joinPath
-     */
-    private async updateInverseJoinPathRelation(
-        tx: DrizzleClient,
-        sourceCollection: CollectionConfig,
-        sourceEntityId: string | number,
-        targetCollection: CollectionConfig,
-        relation: ResolvedVia,
-        newValue: unknown
-    ) {
-        try {
-
-            const sourceTableName = getTableName(sourceCollection);
-            const targetTableName = getTableName(targetCollection);
-
-            // Find intermediate tables that are neither source nor target
-            const intermediateTables = relation.joinPath
-                .map(step => step.table)
-                .filter(table => table !== sourceTableName && table !== targetTableName);
-
-            // If there's exactly one intermediate table, it's likely a junction table for many-to-many
-            if (intermediateTables.length === 1 && relation.cardinality === "many") {
-                const junctionTableName = intermediateTables[0];
-                const junctionTable = this.registry.getTable(junctionTableName);
-
-                if (!junctionTable) {
-                    logger.warn(`Junction table '${junctionTableName}' not found for inverse joinPath relation '${relation.relationName}'`);
-                    return;
-                }
-
-                let sourceJunctionColumn: AnyPgColumn | null = null;
-                let targetJunctionColumn: AnyPgColumn | null = null;
-
-                for (const step of relation.joinPath) {
-                    if (step.table === junctionTableName) {
-                        const fromTable = DrizzleConditionBuilder.getTableNamesFromColumns(step.on.from)[0];
-                        const toColumnNames = DrizzleConditionBuilder.getColumnNamesFromColumns(step.on.to);
-                        const fromColumnNames = DrizzleConditionBuilder.getColumnNamesFromColumns(step.on.from);
-
-                        if (fromTable === sourceTableName) {
-                            sourceJunctionColumn = junctionTable[toColumnNames[0] as keyof typeof junctionTable] as AnyPgColumn;
-                        } else if (fromTable === targetTableName) {
-                            targetJunctionColumn = junctionTable[toColumnNames[0] as keyof typeof junctionTable] as AnyPgColumn;
-                        } else {
-                            const toTable = DrizzleConditionBuilder.getTableNamesFromColumns(step.on.to)[0];
-                            if (toTable === sourceTableName) {
-                                sourceJunctionColumn = junctionTable[fromColumnNames[0] as keyof typeof junctionTable] as AnyPgColumn;
-                            } else if (toTable === targetTableName) {
-                                targetJunctionColumn = junctionTable[fromColumnNames[0] as keyof typeof junctionTable] as AnyPgColumn;
-                            }
-                        }
-                    }
-                }
-
-                if (!sourceJunctionColumn || !targetJunctionColumn) {
-                    logger.warn(`Could not determine junction columns for inverse joinPath relation '${relation.relationName}'`);
-                    return;
-                }
-
-                // Perform the junction table update
-                const sourcePks = requirePrimaryKeys(sourceCollection, this.registry);
-                const sourceIdInfo = sourcePks[0];
-                const parsedSourceIdObj = parseIdValues(sourceEntityId, sourcePks);
-                const parsedSourceId = parsedSourceIdObj[sourceIdInfo.fieldName];
-
-                // Clear existing entries for this source row
-                await tx.delete(junctionTable).where(eq(sourceJunctionColumn, parsedSourceId));
-
-                // Add new entries if newValue is provided
-                if (newValue && Array.isArray(newValue) && newValue.length > 0) {
-                    const targetPks = requirePrimaryKeys(targetCollection, this.registry);
-                    const targetIdInfo = targetPks[0];
-                    // This path already read both shapes; the other two did not.
-                    // Same helper now, so the three cannot drift again.
-                    const targetEntityIds = relationTargetIds(newValue, relation.relationName, sourceCollection.slug);
-                    const parsedTargetIds = targetEntityIds.map(id => parseIdValues(id, targetPks)[targetIdInfo.fieldName]);
-
-                    const newLinks = parsedTargetIds.map(targetId => ({
-                        [sourceJunctionColumn!.name]: parsedSourceId,
-                        [targetJunctionColumn!.name]: targetId
-                    }));
-
-                    if (newLinks.length > 0) {
-                        await tx.insert(junctionTable).values(newLinks);
-                    }
-                } else if (newValue && !Array.isArray(newValue)) {
-                    // Single value for one-to-one
-                    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);
-                    const parsedTargetId = parsedTargetIdObj[targetIdInfo.fieldName];
-
-                    const newLink = {
-                        [sourceJunctionColumn.name]: parsedSourceId,
-                        [targetJunctionColumn.name]: parsedTargetId
-                    };
-
-                    await tx.insert(junctionTable).values(newLink);
-                }
-            }
-        } catch (error) {
-            logger.error(`Failed to update inverse joinPath relation '${relation.relationName}'`, { error: error });
-            throw error;
-        }
-    }
-
-    /**
-     * Handle many-to-many inverse relation updates using junction tables
-     */
-    private async updateManyToManyInverseRelation(
-        tx: DrizzleClient,
-        sourceCollection: CollectionConfig,
-        sourceEntityId: string | number,
-        targetCollection: CollectionConfig,
-        relation: ResolvedRelation,
-        newValue: unknown,
-        junctionInfo: { table: string; sourceColumn: string; targetColumn: string }
-    ) {
-        try {
-            const junctionTable = this.registry.getTable(junctionInfo.table);
-            if (!junctionTable) {
-                logger.warn(`Junction table '${junctionInfo.table}' not found for many-to-many inverse relation '${relation.relationName}'`);
-                return;
-            }
-
-            const sourceJunctionColumn = junctionTable[junctionInfo.sourceColumn as keyof typeof junctionTable] as AnyPgColumn;
-            const targetJunctionColumn = junctionTable[junctionInfo.targetColumn as keyof typeof junctionTable] as AnyPgColumn;
-
-            if (!sourceJunctionColumn || !targetJunctionColumn) {
-                logger.warn(`Junction columns not found for relation '${relation.relationName}'`);
-                return;
-            }
-
-            const sourcePks = requirePrimaryKeys(sourceCollection, this.registry);
-            const sourceIdInfo = sourcePks[0];
-            const parsedSourceIdObj = parseIdValues(sourceEntityId, sourcePks);
-            const parsedSourceId = parsedSourceIdObj[sourceIdInfo.fieldName];
-
-            // Clear existing entries for this source row
-            await tx.delete(junctionTable).where(eq(sourceJunctionColumn, parsedSourceId));
-
-            // Add new entries if newValue is provided
-            if (newValue && Array.isArray(newValue) && newValue.length > 0) {
-                const targetPks = requirePrimaryKeys(targetCollection, this.registry);
-                const targetIdInfo = targetPks[0];
-                const targetEntityIds = relationTargetIds(newValue, relation.relationName, sourceCollection.slug);
-                const parsedTargetIds = targetEntityIds.map(id => parseIdValues(id, targetPks)[targetIdInfo.fieldName]);
-
-                const newLinks = parsedTargetIds.map(targetId => ({
-                    [sourceJunctionColumn.name]: parsedSourceId,
-                    [targetJunctionColumn.name]: targetId
-                }));
-
-                if (newLinks.length > 0) {
-                    await tx.insert(junctionTable).values(newLinks);
-                }
-            }
-        } catch (error) {
-            logger.error(`Failed to update many-to-many inverse relation '${relation.relationName}'`, { error: error });
-            throw error;
-        }
-    }
-
-    /**
-     * Update one-to-one relations that use joinPath
-     */
-    async updateJoinPathOneToOneRelations(
-        tx: DrizzleClient,
-        parentCollection: CollectionConfig,
-        parentId: string | number,
-        updates: Array<{
-            relationKey: string;
-            // Only a `via` relation has a join path to write through, and the
-            // caller only collects those.
-            relation: ResolvedVia;
-            newTargetId: string | number | null;
-        }>
-    ) {
-        for (const upd of updates) {
-            const { relation, newTargetId } = upd;
-            const targetCollection = relation.target();
-            const targetTable = getTableForCollection(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 = requirePrimaryKeys(parentCollection, this.registry);
-            const parentIdInfo = parentPks[0];
-            const parsedParentIdObj = parseIdValues(parentId, parentPks);
-            const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
-
-            const parentIdCol = parentTable[parentIdInfo.fieldName as keyof typeof parentTable] as AnyPgColumn;
-            const parentSourceCol = parentTable[parentSourceColName as keyof typeof parentTable] as AnyPgColumn;
-            const targetFKCol = targetTable[targetFKColName as keyof typeof targetTable] as AnyPgColumn;
-
-            if (!parentSourceCol) {
-                logger.warn(`Parent source column '${parentSourceColName}' not found for joinPath relation '${relation.relationName}'`);
-                continue;
-            }
-            if (!targetFKCol) {
-                logger.warn(`Target FK column '${targetFKColName}' not found for joinPath relation '${relation.relationName}'`);
-                continue;
-            }
-
-            // Fetch the parent row to obtain the value for parentSourceCol
-            const parentRows = await tx
-                .select({ val: parentSourceCol })
-                .from(parentTable)
-                .where(eq(parentIdCol, parsedParentId))
-                .limit(1);
-            if (parentRows.length === 0) continue;
-            const parentFKValue = parentRows[0].val as string | number | null;
-
-            if (newTargetId === null || newTargetId === undefined) {
-                // Clear any target rows currently linked to this parent via the FK
-                if (parentFKValue !== null && parentFKValue !== undefined) {
-                    await tx.update(targetTable)
-                        .set({ [targetFKColName]: null })
-                        .where(eq(targetFKCol, String(parentFKValue)));
-                }
-                continue;
-            }
-
-            // Parse the new target id
-            const parsedTargetIdObj = parseIdValues(newTargetId, targetPks);
-            const parsedTargetId = parsedTargetIdObj[targetIdInfo.fieldName];
-
-            // Ensure one-to-one by clearing existing link from any target rows with this parent FK
-            if (parentFKValue !== null && parentFKValue !== undefined) {
-                await tx.update(targetTable)
-                    .set({ [targetFKColName]: null })
-                    .where(eq(targetFKCol, String(parentFKValue)));
-            } else {
-                logger.warn(`Cannot set joinPath relation '${relation.relationName}' because parent FK value is null/undefined`);
-                continue;
-            }
-
-            // Now set the FK on the target row
-            await tx.update(targetTable)
-                .set({ [targetFKColName]: parentFKValue })
-                .where(eq(targetIdCol, parsedTargetId));
-        }
-    }
-
-    /**
-     * Resolve joinPath write mapping for one-to-one relations
-     */
-    resolveJoinPathWriteMapping(
-        parentCollection: CollectionConfig,
-        relation: ResolvedVia
-    ): { targetFKColName: string; parentSourceColName: string } {
-        if (!relation.joinPath || relation.joinPath.length === 0) {
-            throw new Error("resolveJoinPathWriteMapping requires a joinPath relation");
-        }
-        const parentTableName = getTableName(parentCollection);
-        const lastStep = relation.joinPath[relation.joinPath.length - 1];
-        const targetFKColName = DrizzleConditionBuilder.getColumnNamesFromColumns(lastStep.on.to)[0];
-        let currentFrom = lastStep.on.from;
-
-        let safety = 0;
-        while (safety++ < 10) {
-            const currentFromTable = DrizzleConditionBuilder.getTableNamesFromColumns(currentFrom)[0];
-            if (currentFromTable === parentTableName) {
-                break;
-            }
-            const prevStep = relation.joinPath.find((s) => {
-                const to = Array.isArray(s.on.to) ? s.on.to[0] : s.on.to;
-                return to === currentFrom;
-            });
-            if (!prevStep) {
-                throw new Error(`Could not resolve parent source column for joinPath relation '${relation.relationName}'`);
-            }
-            currentFrom = prevStep.on.from;
-        }
-        const parentSourceColName = DrizzleConditionBuilder.getColumnNamesFromColumns(currentFrom)[0];
-        return { targetFKColName,
-parentSourceColName };
-    }
-
-    /**
-     * Handle junction table creation for many-to-many path-based saves
-     */
-    async handleJunctionTableCreation(
-        tx: DrizzleClient,
-        newEntityId: string | number,
-        junctionTableInfo: {
-            parentCollection: CollectionConfig;
-            parentId: string | number;
-            // Only a junction-backed relation has a link to write, and the
-            // caller only builds this for one — stated here so the body needs
-            // no narrowing.
-            relation: ResolvedManyToMany;
-            relationKey: string;
-        }
-    ) {
-        const { parentCollection, parentId, relation, relationKey } = junctionTableInfo;
-        const targetCollection = relation.target();
-
-        try {
-            const junctionTable = this.registry.getTable(relation.through.table);
-            if (!junctionTable) {
-                logger.warn(`Junction table '${relation.through.table}' not found for relation '${relationKey}'`);
-                return;
-            }
-
-            const sourceJunctionColumn = junctionTable[relation.through.sourceColumn as keyof typeof junctionTable] as AnyPgColumn;
-            const targetJunctionColumn = junctionTable[relation.through.targetColumn as keyof typeof junctionTable] as AnyPgColumn;
-
-            if (!sourceJunctionColumn || !targetJunctionColumn) {
-                logger.warn(`Junction columns not found for relation '${relationKey}'`);
-                return;
-            }
-
-            // Parse the new row ID to the correct type
-            const targetPks = requirePrimaryKeys(targetCollection, this.registry);
-            const targetIdInfo = targetPks[0];
-            const parsedNewEntityIdObj = parseIdValues(newEntityId, targetPks);
-            const parsedNewEntityId = parsedNewEntityIdObj[targetIdInfo.fieldName];
-
-            // Create the junction table entry linking parent to the target row.
-            const junctionData = {
-                [sourceJunctionColumn.name]: parentId,
-                [targetJunctionColumn.name]: parsedNewEntityId
-            };
-
-            // Idempotent: a link either exists or it does not, so asking for one
-            // twice is not an error. This is what lets `PUT parent/id/child/childId`
-            // mean "this row belongs to this parent's set" — the only way to
-            // attach an *existing* row, which previously had none.
-            await tx.insert(junctionTable).values(junctionData).onConflictDoNothing();
-
-            logger.info(`Linked '${relationKey}' ${parsedNewEntityId} to ${parentId}`);
-        } catch (error) {
-            logger.error(`Failed to create junction table entry for relation '${relationKey}'`, { error: error });
-            throw error;
-        }
-    }
 }