@strapi/core 5.50.1 → 5.51.0

package/dist/migrations/database/5.0.0-discard-drafts.mjs

@@ -477,6 +477,62 @@ const recordClonedComponentPair = (clonedComponentPairsCache, componentUid, orig
     enqueueColumn(joinTable?.orderColumn, 'asc');
     enqueueColumn('id', 'asc');
 };
+/**
+ * v4 join rows often only persisted order on one side of a bidirectional join table.
+ * When cloning relations for draft rows, derive missing order values from the other side
+ * so populate does not fall back to primary-key order.
+ */ const assignMissingOrderColumnFromFallback = (relations, { orderColumn, fallbackOrderColumn, groupByColumn, tieBreakerColumn })=>{
+    if (!orderColumn || !fallbackOrderColumn || relations.length === 0) {
+        return relations;
+    }
+    const byGroup = new Map();
+    for (const relation of relations){
+        const groupId = relation[groupByColumn];
+        const key = groupId ?? 'null';
+        const group = byGroup.get(key);
+        if (group) {
+            group.push(relation);
+        } else {
+            byGroup.set(key, [
+                relation
+            ]);
+        }
+    }
+    for (const group of byGroup.values()){
+        if (!group.some((relation)=>relation[orderColumn] == null)) {
+            continue;
+        }
+        const sorted = [
+            ...group
+        ].sort((left, right)=>{
+            const leftOrder = left[fallbackOrderColumn];
+            const rightOrder = right[fallbackOrderColumn];
+            if (leftOrder != null && rightOrder != null) {
+                if (leftOrder !== rightOrder) {
+                    return leftOrder - rightOrder;
+                }
+            } else if (leftOrder != null) {
+                return -1;
+            } else if (rightOrder != null) {
+                return 1;
+            }
+            if (tieBreakerColumn) {
+                const leftTie = normalizeId(left[tieBreakerColumn]) ?? left[tieBreakerColumn];
+                const rightTie = normalizeId(right[tieBreakerColumn]) ?? right[tieBreakerColumn];
+                if (leftTie != null && rightTie != null && leftTie !== rightTie) {
+                    return leftTie < rightTie ? -1 : 1;
+                }
+            }
+            return 0;
+        });
+        sorted.forEach((relation, index)=>{
+            if (relation[orderColumn] == null) {
+                relation[orderColumn] = index + 1;
+            }
+        });
+    }
+    return relations;
+};
 /**
  * Builds a stable key for join-table relations to detect duplicates.
  * Key format: sourceId::targetId::field::componentType
@@ -488,14 +544,15 @@ const recordClonedComponentPair = (clonedComponentPairsCache, componentUid, orig
 };
 /**
  * Queries existing relations from a join table and builds a set of keys for duplicate detection.
- */ async function getExistingRelationKeys({ trx, joinTable, sourceColumnName, targetColumnName, sourceIds }) {
+ */ async function getExistingRelationKeys({ trx, joinTable, sourceColumnName, targetColumnName, filterIds, filterColumnName }) {
     const existingKeys = new Set();
-    if (sourceIds.length === 0) {
+    const columnName = filterColumnName ?? sourceColumnName;
+    if (filterIds.length === 0) {
         return existingKeys;
     }
-    const idChunks = chunkArray(sourceIds, getBatchSize(trx, 1000));
+    const idChunks = chunkArray(filterIds, getBatchSize(trx, 1000));
     for (const chunk of idChunks){
-        const existingRelationsQuery = trx(joinTable.name).select('*').whereIn(sourceColumnName, chunk);
+        const existingRelationsQuery = trx(joinTable.name).select('*').whereIn(columnName, chunk);
         applyJoinTableOrdering(existingRelationsQuery, joinTable, sourceColumnName);
         const existingRelations = await existingRelationsQuery;
         for (const relation of existingRelations){
@@ -1440,7 +1497,7 @@ const debug = createDebug('strapi::migration::discard-drafts');
                 joinTable,
                 sourceColumnName,
                 targetColumnName,
-                sourceIds: draftSourceIds
+                filterIds: draftSourceIds
             });
             const relationsToInsert = newRelations.filter((relation)=>{
                 const targetId = normalizeId(relation[targetColumnName]) ?? relation[targetColumnName];
@@ -1512,7 +1569,8 @@ const debug = createDebug('strapi::migration::discard-drafts');
                 joinTable,
                 sourceColumnName,
                 targetColumnName,
-                sourceIds: draftTargetIds
+                filterIds: draftTargetIds,
+                filterColumnName: targetColumnName
             });
             const publishedIdChunks = chunkArray(publishedTargetIds, getBatchSize(trx, 1000));
             for (const chunk of publishedIdChunks){
@@ -1542,6 +1600,12 @@ const debug = createDebug('strapi::migration::discard-drafts');
                 if (newRelations.length === 0) {
                     continue;
                 }
+                assignMissingOrderColumnFromFallback(newRelations, {
+                    orderColumn: joinTable.inverseOrderColumnName,
+                    fallbackOrderColumn: joinTable.orderColumnName,
+                    groupByColumn: targetColumnName,
+                    tieBreakerColumn: sourceColumnName
+                });
                 await insertRelationsWithDuplicateHandling({
                     trx,
                     tableName: joinTable.name,
@@ -1657,7 +1721,7 @@ const debug = createDebug('strapi::migration::discard-drafts');
                 joinTable,
                 sourceColumnName,
                 targetColumnName,
-                sourceIds: draftSourceIds
+                filterIds: draftSourceIds
             });
             // Filter out relations that already exist
             const relationsToInsert = safeRelations.filter((relation)=>{
@@ -1666,6 +1730,12 @@ const debug = createDebug('strapi::migration::discard-drafts');
                 return !existingKeys.has(key);
             });
             if (relationsToInsert.length > 0) {
+                assignMissingOrderColumnFromFallback(relationsToInsert, {
+                    orderColumn: joinTable.orderColumnName,
+                    fallbackOrderColumn: joinTable.inverseOrderColumnName,
+                    groupByColumn: sourceColumnName,
+                    tieBreakerColumn: targetColumnName
+                });
                 await insertRelationsWithDuplicateHandling({
                     trx,
                     tableName: joinTable.name,