@strapi/content-type-builder 5.56.0 → 5.58.0

package/dist/admin/components/DataManager/reducer.mjs

@@ -1,10 +1,13 @@
 import merge from 'lodash/merge';
 import omit from 'lodash/omit';
+import uniq from 'lodash/uniq';
 import { applyPrivateSearchDefault } from '../../utils/applyPrivateSearchDefault.mjs';
+import { getVisibleConditionEntries } from '../../utils/conditions.mjs';
 import { getRelationType } from '../../utils/getRelationType.mjs';
 import { makeUnique } from '../../utils/makeUnique.mjs';
 import { createUndoRedoSlice } from './undoRedo.mjs';
 import { sectionKeyForKind, getDeleteFolderOnlySiblingNameCollisions, MAX_FOLDER_DEPTH, isFolderNameTakenBySibling, createEmptyContentStructure, findSiblingFolderByName } from './utils/contentStructure.mjs';
+import { isStorageCompatibleRename } from './utils/isStorageCompatibleRename.mjs';
 
 const initialState = {
     components: {},
@@ -73,6 +76,84 @@ const createAttribute = (properties)=>{
         status: 'NEW'
     };
 };
+/**
+ * Records an attribute rename hop in the order the user performed it, so the
+ * server can replay the exact path as a data-preserving migration.
+ *
+ * - Only renames of fields that already exist in the database are recorded; a
+ *   brand-new field (status NEW) has no data yet, so its renames are ignored.
+ * - A rename that also changes the field's type / relation / component is not
+ *   recorded (see `isStorageCompatibleRename`).
+ * - Each hop (`previousName -> newName`) is appended verbatim. The recorded
+ *   sequence is inherently collision-free because the CTB never allows two
+ *   fields to share a name — a "swap" is expressed through the user's own
+ *   intermediate-name hop, so no synthetic temp column is ever needed.
+ */ const recordRename = (type, previousAttribute, newAttribute)=>{
+    if (previousAttribute.status === 'NEW') {
+        return;
+    }
+    const oldName = previousAttribute.name;
+    const newName = newAttribute?.name;
+    if (!newName || oldName === newName) {
+        return;
+    }
+    if (!isStorageCompatibleRename(previousAttribute, newAttribute)) {
+        return;
+    }
+    if (!type.renames) {
+        type.renames = [];
+    }
+    type.renames.push({
+        oldName,
+        newName
+    });
+};
+/**
+ * Remembers the names of a rename hop the user declined to preserve data for,
+ * so the rest of that chain is declined without another prompt.
+ */ const recordDeclinedRename = (type, previousAttribute, newAttribute)=>{
+    const oldName = previousAttribute.name;
+    const newName = newAttribute?.name;
+    if (!newName || oldName === newName) {
+        return;
+    }
+    type.declinedRenameNames = uniq([
+        ...type.declinedRenameNames ?? [],
+        oldName,
+        newName
+    ]);
+};
+/**
+ * Applies the rename consent carried by an edit: either records the hop or
+ * remembers it as declined. Never both.
+ */ const applyRenameConsent = (type, previousAttribute, newAttribute, { recordRename: shouldRecordRename = true, declineRename: shouldDecline = false })=>{
+    if (shouldDecline) {
+        recordDeclinedRename(type, previousAttribute, newAttribute);
+        return;
+    }
+    if (shouldRecordRename) {
+        recordRename(type, previousAttribute, newAttribute);
+    }
+};
+/**
+ * Points the conditions of the type's other fields at the new name of a renamed
+ * field. Runs for every rename, recorded or not, so the conditions follow the
+ * field whether or not its data is preserved.
+ */ const renameConditionVars = (type, previousAttribute, newAttribute)=>{
+    const oldName = previousAttribute.name;
+    const newName = newAttribute?.name;
+    if (!newName || oldName === newName) {
+        return;
+    }
+    type.attributes.forEach((attribute)=>{
+        getVisibleConditionEntries(attribute.conditions).forEach(({ fieldVar })=>{
+            if (fieldVar.var === oldName) {
+                fieldVar.var = newName;
+                setAttributeStatus(attribute, 'CHANGED');
+            }
+        });
+    });
+};
 const setAttributeAt = (type, index, attribute)=>{
     const previousAttribute = type.attributes[index];
     const newStatus = getNewStatus(previousAttribute.status, 'CHANGED');
@@ -112,6 +193,30 @@ const removeAttributeByName = (type, name)=>{
         setAttributeStatus(attr, 'REMOVED');
     }
 };
+/**
+ * Carries the pending rename state of `existing` over to a full replacement of
+ * the type (the AI chat's `applyChange`). Appending the incoming hops after the
+ * existing ones is order-correct: the chat transform diffs against the current
+ * reducer entry, whose attributes already carry the manual renames, so its hops
+ * start from where the manual hops ended.
+ */ const mergeRenameState = (existing, incoming)=>{
+    const renames = [
+        ...existing?.renames ?? [],
+        ...incoming.renames ?? []
+    ];
+    const declinedRenameNames = uniq([
+        ...existing?.declinedRenameNames ?? [],
+        ...incoming.declinedRenameNames ?? []
+    ]);
+    return {
+        ...renames.length > 0 ? {
+            renames
+        } : {},
+        ...declinedRenameNames.length > 0 ? {
+            declinedRenameNames
+        } : {}
+    };
+};
 const updateType = (type, data)=>{
     merge(type, data);
     setStatus(type, 'CHANGED');
@@ -401,7 +506,7 @@ const slice = createUndoRedoSlice({
             attr.components = updatedComponents;
         },
         editAttribute: (state, action)=>{
-            const { name, attributeToSet, forTarget, targetUid } = action.payload;
+            const { name, attributeToSet, forTarget, targetUid, recordRename, declineRename, recordTargetRename, declineTargetRename } = action.payload;
             const type = getType(state, {
                 forTarget,
                 targetUid
@@ -411,6 +516,11 @@ const slice = createUndoRedoSlice({
                 return;
             }
             const previousAttribute = type.attributes[initialAttributeIndex];
+            applyRenameConsent(type, previousAttribute, attributeToSet, {
+                recordRename,
+                declineRename
+            });
+            renameConditionVars(type, previousAttribute, attributeToSet);
             setAttributeAt(type, initialAttributeIndex, attributeToSet);
             if (previousAttribute.type !== attributeToSet.type) {
                 return;
@@ -450,6 +560,14 @@ const slice = createUndoRedoSlice({
                 };
                 // create or recreate(at old index) targetAttribute
                 if (previousTargetAttributeIndex !== -1 && previousTarget.uid === newTarget.uid) {
+                    // The counterpart is renamed on the target type: without a hop
+                    // there, the side owning the join table would lose its links.
+                    if (previousTargetAttribute) {
+                        applyRenameConsent(newTarget, previousTargetAttribute, newTargetAttribute, {
+                            recordRename: recordTargetRename,
+                            declineRename: declineTargetRename
+                        });
+                    }
                     // re-create at previousIdx if possible
                     replaceAttributeAt(newTarget, previousTargetAttributeIndex, newTargetAttribute);
                 } else {
@@ -461,14 +579,20 @@ const slice = createUndoRedoSlice({
             }
         },
         editCustomFieldAttribute: (state, action)=>{
-            const { forTarget, targetUid, name, attributeToSet } = action.payload;
+            const { forTarget, targetUid, name, attributeToSet, recordRename, declineRename } = action.payload;
             const initialAttributeName = name;
             const type = getType(state, {
                 forTarget,
                 targetUid
             });
             const initialAttributeIndex = findAttributeIndex(type, initialAttributeName);
+            const previousAttribute = type.attributes[initialAttributeIndex];
             setAttributeAt(type, initialAttributeIndex, attributeToSet);
+            applyRenameConsent(type, previousAttribute, attributeToSet, {
+                recordRename,
+                declineRename
+            });
+            renameConditionVars(type, previousAttribute, attributeToSet);
         },
         reloadPlugin: ()=>{
             return initialState;
@@ -887,6 +1011,7 @@ const slice = createUndoRedoSlice({
                             const component = state.components[uid];
                             state.components[uid] = {
                                 ...schema,
+                                ...mergeRenameState(component, schema),
                                 status: component?.status === 'NEW' ? 'NEW' : schema.status
                             };
                         } else {
@@ -894,6 +1019,7 @@ const slice = createUndoRedoSlice({
                             const previousKind = contentType?.kind;
                             state.contentTypes[uid] = {
                                 ...schema,
+                                ...mergeRenameState(contentType, schema),
                                 status: contentType?.status === 'NEW' ? 'NEW' : schema.status
                             };
                             if (previousKind && schema.kind && schema.kind !== previousKind) {