@strapi/database 5.50.0 → 5.50.1

package/dist/entity-manager/index.mjs

@@ -1,4 +1,4 @@
-import { castArray, pick, has, isNull, isEmpty, compact, differenceWith, isEqual, uniqBy, difference, map, isNil, isPlainObject, isArray, isString, isNumber, isUndefined, isObject, uniqWith, isInteger } from 'lodash/fp';
+import { castArray, pick, has, isNull, isEmpty, compact, differenceWith, uniqBy, difference, map, isNil, isPlainObject, isArray, isString, isNumber, isUndefined, isObject, uniqWith, isEqual, isInteger } from 'lodash/fp';
 import { isScalarAttribute, isRelationalAttribute } from '../utils/types.mjs';
 import { createField } from '../fields/index.mjs';
 import createQueryBuilder from '../query/query-builder.mjs';
@@ -900,7 +900,126 @@ const createEntityManager = (db)=>{
                         if (isPartialUpdate) {
                             if (isAnyToOne(attribute)) ;
                             relIdsToaddOrMove = toIds(cleanRelationData.connect);
-                            const relIdsToDelete = toIds(differenceWith(isEqual, cleanRelationData.disconnect, cleanRelationData.connect ?? []));
+                            // Use id-only comparison so a disconnect item whose id also appears in
+                            // the connect array is correctly excluded from deletion (deep-equality
+                            // fails because connect items carry extra fields like `position`).
+                            const relIdsToDelete = toIds(differenceWith((a, b)=>a.id === b.id, cleanRelationData.disconnect, cleanRelationData.connect ?? []));
+                            // When a connect item's position.before/after references an id that is
+                            // about to be deleted (relIdsToDelete), the referenced row won't exist by
+                            // the time the adjacentRelations query runs below, causing sortConnectArray
+                            // to throw. Rewrite such a position to point at the nearest surviving
+                            // neighbor in the relation's current order, so the item lands where the
+                            // deleted relation used to be instead of always falling back to the end.
+                            const idKey = (value)=>String(value);
+                            const deletedIds = new Set(relIdsToDelete.map(idKey));
+                            let resolvedConnect = cleanRelationData.connect ?? [];
+                            if (hasOrderColumn(attribute) && !isEmpty(relIdsToDelete) && resolvedConnect.some((item)=>{
+                                const adjacentId = item.position?.before ?? item.position?.after;
+                                return adjacentId != null && deletedIds.has(idKey(adjacentId));
+                            })) {
+                                const currentOrder = await this.createQueryBuilder(joinTable.name).select([
+                                    inverseJoinColumn.name,
+                                    orderColumnName
+                                ]).where({
+                                    [joinColumn.name]: id
+                                }).where(joinTable.on || {}).orderBy(orderColumnName).transacting(trx).execute();
+                                const orderedIds = currentOrder.map((rel)=>rel[inverseJoinColumn.name]);
+                                const orderedIdKeys = orderedIds.map(idKey);
+                                const connectIds = new Set(resolvedConnect.map((item)=>idKey(item.id)));
+                                const deletedIdsInCurrentOrder = new Set(orderedIds.map(idKey).filter((orderedId)=>deletedIds.has(orderedId)));
+                                // A neighbor is only a valid fallback target if it survives the delete
+                                // and isn't being moved by this connect payload.
+                                const findSurvivingNeighbor = (targetId, direction)=>{
+                                    let index = orderedIdKeys.indexOf(idKey(targetId));
+                                    while(index !== -1){
+                                        index += direction;
+                                        const candidate = orderedIds[index];
+                                        if (candidate === undefined) {
+                                            return undefined;
+                                        }
+                                        const candidateKey = idKey(candidate);
+                                        if (!deletedIds.has(candidateKey) && !connectIds.has(candidateKey)) {
+                                            return candidate;
+                                        }
+                                    }
+                                    return undefined;
+                                };
+                                const positionByConnectId = new Map();
+                                const connectGroups = new Map();
+                                const getConnectGroup = (targetId)=>{
+                                    const targetKey = idKey(targetId);
+                                    let group = connectGroups.get(targetKey);
+                                    if (!group) {
+                                        group = {
+                                            targetId,
+                                            before: [],
+                                            after: []
+                                        };
+                                        connectGroups.set(targetKey, group);
+                                    }
+                                    return group;
+                                };
+                                resolvedConnect.forEach((item)=>{
+                                    const { before, after } = item.position ?? {};
+                                    const adjacentId = before ?? after;
+                                    if (adjacentId == null || !deletedIds.has(idKey(adjacentId)) || !deletedIdsInCurrentOrder.has(idKey(adjacentId))) {
+                                        return;
+                                    }
+                                    const group = getConnectGroup(adjacentId);
+                                    if (before) {
+                                        group.before.push(item);
+                                    } else {
+                                        group.after.push(item);
+                                    }
+                                });
+                                connectGroups.forEach(({ targetId, before, after })=>{
+                                    const previousNeighbor = findSurvivingNeighbor(targetId, -1);
+                                    const nextNeighbor = findSurvivingNeighbor(targetId, 1);
+                                    let previousPositionId = previousNeighbor;
+                                    before.forEach((item)=>{
+                                        if (previousPositionId !== undefined) {
+                                            positionByConnectId.set(item.id, {
+                                                after: previousPositionId
+                                            });
+                                        } else if (nextNeighbor !== undefined) {
+                                            positionByConnectId.set(item.id, {
+                                                before: nextNeighbor
+                                            });
+                                        } else {
+                                            positionByConnectId.set(item.id, {
+                                                start: true
+                                            });
+                                        }
+                                        previousPositionId = item.id;
+                                    });
+                                    after.forEach((item)=>{
+                                        if (previousPositionId !== undefined) {
+                                            positionByConnectId.set(item.id, {
+                                                after: previousPositionId
+                                            });
+                                        } else if (nextNeighbor !== undefined) {
+                                            positionByConnectId.set(item.id, {
+                                                before: nextNeighbor
+                                            });
+                                        } else {
+                                            positionByConnectId.set(item.id, {
+                                                start: true
+                                            });
+                                        }
+                                        previousPositionId = item.id;
+                                    });
+                                });
+                                resolvedConnect = resolvedConnect.map((item)=>{
+                                    const position = positionByConnectId.get(item.id);
+                                    if (position) {
+                                        return {
+                                            ...item,
+                                            position
+                                        };
+                                    }
+                                    return item;
+                                });
+                            }
                             if (!isEmpty(relIdsToDelete)) {
                                 await deleteRelations({
                                     id,
@@ -937,7 +1056,7 @@ const createEntityManager = (db)=>{
                                         {
                                             [joinColumn.name]: id,
                                             [inverseJoinColumn.name]: {
-                                                $in: compact(cleanRelationData.connect?.map((r)=>r.position?.after || r.position?.before))
+                                                $in: compact(resolvedConnect.map((r)=>r.position?.after || r.position?.before))
                                             }
                                         },
                                         {
@@ -948,7 +1067,7 @@ const createEntityManager = (db)=>{
                                         }
                                     ]
                                 }).where(joinTable.on || {}).transacting(trx).execute();
-                                const orderMap = relationsOrderer(adjacentRelations, inverseJoinColumn.name, joinTable.orderColumnName, cleanRelationData.options?.strict).connect(cleanRelationData.connect ?? []).getOrderMap();
+                                const orderMap = relationsOrderer(adjacentRelations, inverseJoinColumn.name, joinTable.orderColumnName, cleanRelationData.options?.strict).connect(resolvedConnect).getOrderMap();
                                 insert.forEach((row)=>{
                                     row[orderColumnName] = orderMap[row[inverseJoinColumn.name]];
                                 });