@rebasepro/server-postgresql 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

package/src/services/EntityPersistService.ts

@@ -2,7 +2,7 @@ import { eq, and } from "drizzle-orm";
 import { AnyPgColumn } from "drizzle-orm/pg-core";
 // import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { Entity, EntityCollection, Properties, Relation } from "@rebasepro/types";
-import { getTableName, resolveCollectionRelations } from "@rebasepro/common";
+import { getTableName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
 import { DrizzleConditionBuilder } from "../utils/drizzle-conditions";
 import {
     getCollectionByPath,
@@ -56,7 +56,7 @@ export class EntityPersistService {
     /**
      * Save an entity (create or update)
      */
-    async saveEntity<M extends Record<string, any>>(
+    async saveEntity<M extends Record<string, unknown>>(
         collectionPath: string,
         values: Partial<M>,
         entityId?: string | number,
@@ -65,6 +65,7 @@ export class EntityPersistService {
         // If saving under a nested relation path, resolve the parent and inject FK
         let effectiveCollectionPath = collectionPath;
         const effectiveValues: Partial<M> = { ...values };
+        let junctionTableInfo: { parentCollection: EntityCollection; parentId: string | number; relation: Relation; relationKey: string; } | undefined;
 
         if (collectionPath.includes("/")) {
             const segments = collectionPath.split("/").filter(Boolean);
@@ -75,11 +76,12 @@ export class EntityPersistService {
 
                 for (let i = 2; i < segments.length; i += 2) {
                     const relationKey = segments[i];
-                    const resolvedRelations = resolveCollectionRelations(currentCollection as import("@rebasepro/types").PostgresCollection<any, any>);
-                    const relation = resolvedRelations[relationKey];
+                    const resolvedRelations = resolveCollectionRelations(currentCollection);
+                    const relation = findRelation(resolvedRelations, relationKey);
 
                     if (!relation) {
-                        throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug}'`);
+                        const available = Object.keys(resolvedRelations).join(", ") || "(none)";
+                        throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug}'. Available relations: [${available}]`);
                     }
 
                     if (i === segments.length - 1) {
@@ -93,7 +95,7 @@ export class EntityPersistService {
                             const parsedParentIdObj = parseIdValues(currentEntityId, parentIdInfoArray);
                             const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
 
-                            (effectiveValues as Record<string, unknown>).__junction_table_info = {
+                            junctionTableInfo = {
                                 parentCollection: currentCollection,
                                 parentId: parsedParentId,
                                 relation: relation,
@@ -161,7 +163,7 @@ export class EntityPersistService {
         // Separate relations that require special handling
         const relationValues: Record<string, unknown> = {};
         const otherValues: Partial<M> = { ...effectiveValues };
-        const resolvedRelations = resolveCollectionRelations(collection as import("@rebasepro/types").PostgresCollection<any, any>);
+        const resolvedRelations = resolveCollectionRelations(collection);
 
         for (const key in resolvedRelations) {
             const relation = resolvedRelations[key];
@@ -174,17 +176,13 @@ export class EntityPersistService {
         }
 
         // Transform relations to IDs, then sanitize
-        const processedData = serializeDataToServer(otherValues as M, collection.properties as Properties, collection, this.registry);
+        const serializedResult = serializeDataToServer(otherValues as M, collection.properties as Properties, collection, this.registry);
 
-        // Extract relation updates before sanitizing
-        const inverseRelationUpdates = ((processedData as Record<string, unknown>).__inverseRelationUpdates as Array<{ relationKey: string; relation: Relation; newValue: unknown; currentEntityId?: string | number; }>) || [];
-        const joinPathRelationUpdates = ((processedData as Record<string, unknown>).__joinPathRelationUpdates as Array<{ relationKey: string; relation: Relation; newTargetId: string | number | null; }>) || [];
-        const junctionTableInfo = (processedData as Record<string, unknown>).__junction_table_info as { parentCollection: EntityCollection<any, any>; parentId: string | number; relation: Relation; relationKey: string; } | undefined;
-        delete (processedData as Record<string, unknown>).__inverseRelationUpdates;
-        delete (processedData as Record<string, unknown>).__joinPathRelationUpdates;
-        delete (processedData as Record<string, unknown>).__junction_table_info;
+        // Extract relation updates from the typed result
+        const inverseRelationUpdates = serializedResult.inverseRelationUpdates;
+        const joinPathRelationUpdates = serializedResult.joinPathRelationUpdates;
 
-        const entityData = sanitizeAndConvertDates(processedData);
+        const entityData = sanitizeAndConvertDates(serializedResult.scalarData);
 
         let savedId: string | number;
         try {
@@ -211,7 +209,7 @@ export class EntityPersistService {
                     // empty after relation stripping and Drizzle throws "No values to set".
                     const scalarKeys = Object.keys(entityData as Record<string, unknown>);
                     if (scalarKeys.length > 0) {
-                        let updateQuery = tx.update(table).set(entityData as Record<string, unknown>);
+                        const updateQuery = tx.update(table).set(entityData as Record<string, unknown>);
                         const conditions = [];
                         for (const info of idInfoArray) {
                             const field = table[info.fieldName as keyof typeof table] as AnyPgColumn;

package/src/services/RelationService.ts

@@ -2,7 +2,7 @@ import { and, eq, inArray, sql, SQL } from "drizzle-orm";
 import { AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
 import { DrizzleClient } from "../interfaces";
 import { Entity, EntityCollection, FilterValues, Relation } from "@rebasepro/types";
-import { getTableName, resolveCollectionRelations } from "@rebasepro/common";
+import { getTableName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
 import { DrizzleConditionBuilder } from "../utils/drizzle-conditions";
 import {
     getCollectionByPath,
@@ -24,7 +24,7 @@ export class RelationService {
     /**
      * Fetch entities related to a parent entity through a specific relation
      */
-    async fetchRelatedEntities<M extends Record<string, any>>(
+    async fetchRelatedEntities<M extends Record<string, unknown>>(
         parentCollectionPath: string,
         parentEntityId: string | number,
         relationKey: string,
@@ -39,11 +39,12 @@ export class RelationService {
         } = {}
     ): Promise<Entity<M>[]> {
         const parentCollection = getCollectionByPath(parentCollectionPath, this.registry);
-        const resolvedRelations = resolveCollectionRelations(parentCollection as import("@rebasepro/types").PostgresCollection<any, any>);
-        const relation = resolvedRelations[relationKey];
+        const resolvedRelations = resolveCollectionRelations(parentCollection);
+        const relation = findRelation(resolvedRelations, relationKey);
 
         if (!relation) {
-            throw new Error(`Relation '${relationKey}' not found in collection '${parentCollectionPath}'`);
+            const available = Object.keys(resolvedRelations).join(", ") || "(none)";
+            throw new Error(`Relation '${relationKey}' not found in collection '${parentCollectionPath}'. Available relations: [${available}]`);
         }
 
         return this.fetchEntitiesUsingJoins<M>(parentCollection, parentEntityId, relation, options);
@@ -52,7 +53,7 @@ export class RelationService {
     /**
      * Fetch entities using join paths for complex relations
      */
-    async fetchEntitiesUsingJoins<M extends Record<string, any>>(
+    async fetchEntitiesUsingJoins<M extends Record<string, unknown>>(
         parentCollection: EntityCollection,
         parentEntityId: string | number,
         relation: Relation,
@@ -209,16 +210,19 @@ export class RelationService {
     /**
      * Count related entities for a parent entity
      */
-    async countRelatedEntities<M extends Record<string, any>>(
+    async countRelatedEntities<M extends Record<string, unknown>>(
         parentCollectionPath: string,
         parentEntityId: string | number,
         relationKey: string,
         options: { filter?: FilterValues<Extract<keyof M, string>>; databaseId?: string } = {}
     ): Promise<number> {
         const parentCollection = getCollectionByPath(parentCollectionPath, this.registry);
-        const resolvedRelations = resolveCollectionRelations(parentCollection as import("@rebasepro/types").PostgresCollection<any, any>);
-        const relation = resolvedRelations[relationKey];
-        if (!relation) throw new Error(`Relation '${relationKey}' not found in collection '${parentCollectionPath}'`);
+        const resolvedRelations = resolveCollectionRelations(parentCollection);
+        const relation = findRelation(resolvedRelations, relationKey);
+        if (!relation) {
+            const available = Object.keys(resolvedRelations).join(", ") || "(none)";
+            throw new Error(`Relation '${relationKey}' not found in collection '${parentCollectionPath}'. Available relations: [${available}]`);
+        }
 
         const targetCollection = relation.target();
         const targetTable = getTableForCollection(targetCollection, this.registry);
@@ -265,7 +269,7 @@ export class RelationService {
         parentEntityIds: (string | number)[],
         _relationKey: string,
         relation: Relation
-    ): Promise<Map<string | number, Entity<Record<string, unknown>>>> {
+    ): Promise<Map<string, Entity<Record<string, unknown>>>> {
         if (parentEntityIds.length === 0) return new Map();
 
         const parentCollection = getCollectionByPath(parentCollectionPath, this.registry);
@@ -323,25 +327,95 @@ export class RelationService {
 
             const results = await query;
             const targetTableName = relation.joinPath[relation.joinPath.length - 1].table;
-            const resultMap = new Map<string | number, Entity<Record<string, unknown>>>();
+            const resultMap = new Map<string, Entity<Record<string, unknown>>>();
 
             // Group results by parent ID
-            results.forEach((row: Record<string, unknown>) => {
+            for (const row of results as Array<Record<string, unknown>>) {
                 const parentEntity = (row[getTableName(parentCollection)] || row) as Record<string, unknown>;
                 const targetEntity = (row[targetTableName] || row) as Record<string, unknown>;
                 const parentId = parentEntity[parentIdInfo.fieldName] as string | number;
 
-                resultMap.set(parentId, {
+                const parsedValues = await parseDataFromServer(targetEntity, targetCollection);
+
+                resultMap.set(String(parentId), {
                     id: String(targetEntity[targetIdInfo.fieldName]),
                     path: targetCollection.slug,
-                    values: targetEntity
+                    values: parsedValues as Record<string, unknown>
                 });
-            });
+            }
 
             return resultMap;
         }
 
-        // Handle other relation types with batching
+        // Handle owning relations with proper FK-based batching.
+        // For owning relations, parent entities hold the FK (e.g. posts.author_id).
+        // We need to:
+        //   1. Fetch FK values from the parent table in a single query
+        //   2. Query the target table with unique FK values
+        //   3. Map results back to parent entities via their FK values
+        if (relation.direction === "owning" && 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`);
+            }
+
+            // Step 1: Fetch all FK values from parent table in ONE query
+            const fkRows = await this.db
+                .select({
+                    parentId: parentIdCol,
+                    fkValue: localKeyCol
+                })
+                .from(parentTable)
+                .where(inArray(parentIdCol, parsedParentIds));
+
+            // Build parentId → fkValue mapping and collect unique FK values
+            const parentToFk = new Map<string, string | number>();
+            const uniqueFkValues: (string | number)[] = [];
+            const seenFks = new Set<string>();
+
+            for (const row of fkRows as Array<{ parentId: string | number; fkValue: string | number | null }>) {
+                if (row.fkValue == null) continue;
+                parentToFk.set(String(row.parentId), row.fkValue);
+                const fkStr = String(row.fkValue);
+                if (!seenFks.has(fkStr)) {
+                    seenFks.add(fkStr);
+                    uniqueFkValues.push(row.fkValue);
+                }
+            }
+
+            if (uniqueFkValues.length === 0) return new Map();
+
+            // Step 2: Fetch all target entities in ONE query
+            const targetResults = await this.db
+                .select()
+                .from(targetTable)
+                .where(inArray(targetIdField, uniqueFkValues));
+
+            // Index target entities by their ID
+            const targetById = new Map<string, Record<string, unknown>>();
+            for (const row of targetResults as Array<Record<string, unknown>>) {
+                const tid = String(row[targetIdInfo.fieldName]);
+                targetById.set(tid, row);
+            }
+
+            // Step 3: Map back to parent entities
+            const resultMap = new Map<string, Entity<Record<string, unknown>>>();
+            for (const [parentIdStr, fkValue] of parentToFk) {
+                const targetEntity = targetById.get(String(fkValue));
+                if (targetEntity) {
+                    const parsedValues = await parseDataFromServer(targetEntity, targetCollection);
+                    resultMap.set(parentIdStr, {
+                        id: String(targetEntity[targetIdInfo.fieldName]),
+                        path: targetCollection.slug,
+                        values: parsedValues as Record<string, unknown>
+                    });
+                }
+            }
+
+            return resultMap;
+        }
+
+        // Handle inverse relation types with batching
         let query = this.db.select().from(targetTable).$dynamic();
 
         // Build the relation query with ALL parent IDs
@@ -359,10 +433,15 @@ export class RelationService {
         );
 
         const results = await query;
-        const resultMap = new Map<string | number, Entity<Record<string, unknown>>>();
+        const resultMap = new Map<string, Entity<Record<string, unknown>>>();
+
+        // Build a Set<string> for O(1) parent-ID lookups that is immune to
+        // number-vs-string type mismatches (Drizzle may return either depending
+        // on the column type and driver).
+        const parentIdSet = new Set(parsedParentIds.map(String));
 
         // Map results back to parent entities
-        results.forEach((row: Record<string, unknown>) => {
+        for (const row of results as Array<Record<string, unknown>>) {
             const targetEntity = (row[getTableName(targetCollection)] || row) as Record<string, unknown>;
 
             // Determine the parent ID this result belongs to based on the relation type
@@ -373,23 +452,201 @@ export class RelationService {
             } else if (relation.direction === "inverse" && relation.cardinality === "one" && relation.inverseRelationName) {
                 const inferredForeignKeyName = `${relation.inverseRelationName}_id`;
                 parentId = targetEntity[inferredForeignKeyName] as string | number | undefined;
-            } else if (relation.direction === "owning" && relation.localKey) {
-                for (const parsedParentId of parsedParentIds) {
-                    if (!resultMap.has(parsedParentId)) {
-                        parentId = parsedParentId;
-                        break;
-                    }
-                }
             }
 
-            if (parentId !== undefined && parsedParentIds.includes(parentId)) {
-                resultMap.set(parentId, {
+            if (parentId !== undefined && parentIdSet.has(String(parentId))) {
+                const parsedValues = await parseDataFromServer(targetEntity, targetCollection);
+                resultMap.set(String(parentId), {
+                    id: String(targetEntity[targetIdInfo.fieldName]),
+                    path: targetCollection.slug,
+                    values: parsedValues as Record<string, unknown>
+                });
+            }
+        }
+
+        return resultMap;
+    }
+
+    /**
+     * Batch fetch many-cardinality related entities for multiple parent entities.
+     * Returns a Map<parentId, Entity[]> instead of Map<parentId, Entity>.
+     * Uses a single SQL query with IN clause to avoid N+1.
+     */
+    async batchFetchRelatedEntitiesMany(
+        parentCollectionPath: string,
+        parentEntityIds: (string | number)[],
+        _relationKey: string,
+        relation: Relation
+    ): Promise<Map<string, Entity<Record<string, unknown>>[]>> {
+        if (parentEntityIds.length === 0) return new Map();
+
+        const parentCollection = getCollectionByPath(parentCollectionPath, this.registry);
+        const targetCollection = relation.target();
+        const targetTable = getTableForCollection(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 = getPrimaryKeys(parentCollection, this.registry);
+        const parentIdInfo = parentPks[0];
+        const parentTable = this.registry.getTable(getTableName(parentCollection));
+        if (!parentTable) throw new Error("Parent table not found");
+        const parentIdCol = parentTable[parentIdInfo.fieldName as keyof typeof parentTable] as AnyPgColumn;
+
+        const parsedParentIds = parentEntityIds.map(id => parseIdValues(id, parentPks)[parentIdInfo.fieldName]);
+
+        // Handle join path relations (many-to-many through junction tables)
+        if (relation.joinPath && relation.joinPath.length > 0) {
+            let query = this.db.select().from(parentTable).$dynamic();
+            let currentTable = parentTable;
+
+            for (const join of relation.joinPath) {
+                const joinTable = this.registry.getTable(join.table);
+                if (!joinTable) throw new Error(`Join table not found: ${join.table}`);
+
+                const fromColumn = Array.isArray(join.on.from) ? join.on.from[0] : join.on.from;
+                const toColumn = Array.isArray(join.on.to) ? join.on.to[0] : join.on.to;
+                const fromColName = fromColumn.split(".").pop()!;
+                const toColName = toColumn.split(".").pop()!;
+
+                const fromCol = currentTable[fromColName as keyof typeof currentTable] as AnyPgColumn;
+                const toCol = joinTable[toColName as keyof typeof joinTable] as AnyPgColumn;
+                if (!fromCol || !toCol) throw new Error(`Join columns not found: ${fromColumn} -> ${toColumn}`);
+
+                // @ts-expect-error Drizzle mutates base query generic on innerJoin
+                query = query.innerJoin(joinTable, eq(fromCol, toCol));
+                currentTable = joinTable;
+            }
+
+            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, Entity<Record<string, unknown>>[]>();
+
+            for (const row of results as Array<Record<string, unknown>>) {
+                const parentEntity = (row[getTableName(parentCollection)] || row) as Record<string, unknown>;
+                const targetEntity = (row[targetTableName] || row) as Record<string, unknown>;
+                const parentId = String(parentEntity[parentIdInfo.fieldName]);
+                const parsedValues = await parseDataFromServer(targetEntity, targetCollection);
+
+                const arr = resultMap.get(parentId) || [];
+                arr.push({
+                    id: String(targetEntity[targetIdInfo.fieldName]),
+                    path: targetCollection.slug,
+                    values: parsedValues as Record<string, unknown>
+                });
+                resultMap.set(parentId, arr);
+            }
+
+            return resultMap;
+        }
+
+        // Handle many-to-many owning relations with junction table (relation.through)
+        // 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") {
+            const junctionTable = this.registry.getTable(relation.through.table);
+            if (!junctionTable) {
+                console.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) {
+                console.warn(`[batchFetchRelatedEntitiesMany] Junction columns not found in '${relation.through.table}'`);
+                return new Map();
+            }
+
+            // SELECT target.*, junction.sourceColumn FROM junction
+            // INNER JOIN target ON junction.targetColumn = target.id
+            // WHERE junction.sourceColumn IN (parentIds)
+            const query = this.db
+                .select()
+                .from(junctionTable)
+                .innerJoin(targetTable, eq(targetJunctionCol, targetIdField))
+                .where(inArray(sourceJunctionCol, parsedParentIds));
+
+            const results = await query;
+            const resultMap = new Map<string, Entity<Record<string, unknown>>[]>();
+            const targetTableName = getTableName(targetCollection);
+
+            for (const row of results as Array<Record<string, unknown>>) {
+                // The junction table data is namespaced under its table name
+                const junctionData = (row[relation.through.table] || row) as Record<string, unknown>;
+                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>
+                });
+                resultMap.set(parentId, arr);
+            }
+
+            return resultMap;
+        }
+
+        // Handle FK-based relations (one-to-many inverse)
+        let query = this.db.select().from(targetTable).$dynamic();
+
+        // @ts-expect-error buildRelationQuery uses dynamic queries
+        query = DrizzleConditionBuilder.buildRelationQuery(
+            query,
+            relation,
+            parsedParentIds,
+            targetTable,
+            parentTable,
+            parentIdCol,
+            targetIdField,
+            this.registry,
+            []
+        );
+
+        const results = await query;
+        const resultMap = new Map<string, Entity<Record<string, unknown>>[]>();
+
+        // Build a Set<string> for O(1) parent-ID lookups that is immune to
+        // number-vs-string type mismatches (Drizzle may return either depending
+        // on the column type and driver).
+        const parentIdSet = new Set(parsedParentIds.map(String));
+
+        for (const row of results as Array<Record<string, unknown>>) {
+            const targetEntity = (row[getTableName(targetCollection)] || row) as Record<string, unknown>;
+
+            let parentId: string | number | undefined;
+
+            if (relation.through && relation.direction === "inverse") {
+                // Inverse many-to-many via junction table: the junction's targetColumn
+                // references the parent (since from the inverse perspective, source/target are swapped).
+                const junctionData = (row[relation.through.table] || row) as Record<string, unknown>;
+                parentId = junctionData[relation.through.targetColumn] as string | number | undefined;
+            } else if (relation.direction === "inverse" && relation.foreignKeyOnTarget) {
+                parentId = targetEntity[relation.foreignKeyOnTarget] as string | number | undefined;
+            } else if (relation.direction === "inverse" && relation.inverseRelationName) {
+                const inferredForeignKeyName = `${relation.inverseRelationName}_id`;
+                parentId = targetEntity[inferredForeignKeyName] as string | number | undefined;
+            }
+
+            if (parentId !== undefined && parentIdSet.has(String(parentId))) {
+                const parsedValues = await parseDataFromServer(targetEntity, targetCollection);
+                const key = String(parentId);
+                const arr = resultMap.get(key) || [];
+                arr.push({
                     id: String(targetEntity[targetIdInfo.fieldName]),
                     path: targetCollection.slug,
-                    values: targetEntity
+                    values: parsedValues as Record<string, unknown>
                 });
+                resultMap.set(key, arr);
             }
-        });
+        }
 
         return resultMap;
     }
@@ -397,16 +654,16 @@ export class RelationService {
     /**
      * Update many-to-many and junction relations
      */
-    async updateRelationsUsingJoins<M extends Record<string, any>>(
+    async updateRelationsUsingJoins<M extends Record<string, unknown>>(
         tx: DrizzleClient,
         collection: EntityCollection,
         entityId: string | number,
         relationValues: Partial<M>
     ) {
-        const resolvedRelations = resolveCollectionRelations(collection as import("@rebasepro/types").PostgresCollection<any, any>);
+        const resolvedRelations = resolveCollectionRelations(collection);
 
         for (const [key, value] of Object.entries(relationValues)) {
-            const relation = resolvedRelations[key];
+            const relation = findRelation(resolvedRelations, key);
             if (!relation || relation.cardinality !== "many") continue;
 
             const targetEntityIds = (value && Array.isArray(value)) ? value.map((rel: { id: string | number }) => rel.id) : [];
@@ -517,6 +774,10 @@ export class RelationService {
                         await tx.insert(junctionTable).values(newLinks);
                     }
                 }
+            } else if (relation.through && relation.cardinality === "many" && relation.direction === "inverse") {
+                // Inverse M2M relations should be saved from the owning side.
+                // The owning collection manages the junction table rows.
+                console.warn(`[updateRelationsUsingJoins] Inverse M2M relation '${key}' in collection '${collection.slug}' should be saved from the owning side. Skipping.`);
             } 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);
@@ -601,7 +862,7 @@ export class RelationService {
 
                 // Check if this is a many-to-many inverse relation
                 if (relation.cardinality === "many" && relation.direction === "inverse") {
-                    const targetCollectionRelations = resolveCollectionRelations(targetCollection as import("@rebasepro/types").PostgresCollection<any, any>);
+                    const targetCollectionRelations = resolveCollectionRelations(targetCollection);
                     let junctionInfo: { table: string; sourceColumn: string; targetColumn: string } | null = null;
 
                     for (const [relationKey, targetRelation] of Object.entries(targetCollectionRelations)) {
@@ -752,7 +1013,7 @@ export class RelationService {
                 if (newValue && Array.isArray(newValue) && newValue.length > 0) {
                     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 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]);
 
                     const newLinks = parsedTargetIds.map(targetId => ({
@@ -767,7 +1028,7 @@ export class RelationService {
                     // Single value for one-to-one
                     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 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];
 
@@ -955,7 +1216,8 @@ export class RelationService {
             currentFrom = prevStep.on.from;
         }
         const parentSourceColName = DrizzleConditionBuilder.getColumnNamesFromColumns(currentFrom)[0];
-        return { targetFKColName, parentSourceColName };
+        return { targetFKColName,
+parentSourceColName };
     }
 
     /**