@strapi/content-manager 5.55.1 → 5.56.0

package/dist/admin/pages/EditView/components/DocumentActions.mjs

@@ -8,41 +8,56 @@ import { useNavigate, useMatch, useParams } from 'react-router-dom';
 import { PUBLISHED_AT_ATTRIBUTE_NAME } from '../../../constants/attributes.mjs';
 import { SINGLE_TYPES } from '../../../constants/collections.mjs';
 import { useDocumentRBAC } from '../../../features/DocumentRBAC.mjs';
-import { useDocument, useDoc } from '../../../hooks/useDocument.mjs';
+import { useDoc } from '../../../hooks/useDocument.mjs';
 import { useDocumentActions } from '../../../hooks/useDocumentActions.mjs';
 import { useDocumentContext } from '../../../hooks/useDocumentContext.mjs';
 import { usePreviewContext } from '../../../preview/pages/Preview.mjs';
 import { LIST_PATH, CLONE_PATH } from '../../../router.mjs';
-import { useGetDraftRelationCountQuery as useLazyGetDraftRelationCountQuery, useUpdateDocumentMutation } from '../../../services/documents.mjs';
+import { useLazyGetDocumentQuery, useGetDraftRelationCountQuery as useLazyGetDraftRelationCountQuery } from '../../../services/documents.mjs';
 import { buildValidParams, isBaseQueryError } from '../../../utils/api.mjs';
-import { getIn, setIn, isObject } from '../../../utils/objects.mjs';
+import { getIn, isObject } from '../../../utils/objects.mjs';
 import { getTranslation } from '../../../utils/translations.mjs';
 import { handleInvisibleAttributes } from '../utils/data.mjs';
 import { EMPTY_DRAFT_RELATION_COUNTS, countLocalDraftRelations, normalizeDraftRelationCounts, resolveDraftRelationCounts, getDraftRelationsPublishState } from '../utils/draftRelationCounts.mjs';
 import { getEditViewShortcut } from '../utils/keyboardShortcuts.mjs';
-import { useRelationModal } from './FormInputs/Relations/RelationModal.mjs';
+import { useRelationModal, isAnyRelationModalOpen } from './FormInputs/Relations/RelationModal.mjs';
 
 const publishConfirmDialogOpeners = new Map();
 const openPublishConfirmDialog = (scope)=>{
     publishConfirmDialogOpeners.get(scope)?.();
 };
-const connectRelationToParent = (parentDataToUpdate, fieldToConnect, data, fieldToConnectUID)=>{
+/**
+ * Builds the local-form patch needed to connect a newly created/published relation into the
+ * parent's own relation field, given that field's CURRENT (possibly unsaved) live value.
+ *
+ * This only ever touches the parent's in-memory form state (via `setParentFormValue`, sourced
+ * from the parent's own `useForm(...).onChange`) — it deliberately never persists the parent
+ * document to the server, so connecting a relation on the fly can't silently save unrelated
+ * unsaved edits made elsewhere in the parent's form.
+ */ const buildRelationConnectPatch = (currentFieldValue, fieldToConnect, data, status, fieldToConnectUID)=>{
+    // Spread the freshly created/published document first so its own mainField (e.g. `name`) and
+    // other attributes — including its real numeric `id`, not just `documentId` — are available.
+    // Without the real `id`, the relation field's "already connected" search filter (which keys off
+    // `rel.id`) can't recognize this item, so it would stay selectable in the relation combobox
+    // even after being connected. Keeping the label/status render correct needs the mainField too,
+    // which is why we still spread the whole document rather than only picking id/documentId/locale.
     const relationToConnect = {
-        id: data.documentId,
+        ...data,
         documentId: data.documentId,
-        locale: data.locale
+        locale: data.locale,
+        ...status ? {
+            status
+        } : {}
     };
     /*
-   * Check if the fieldToConnect is already present in the parentDataToUpdate.
-   * This happens in particular when in the parentDocument you have created
-   * a new component without saving.
-   */ const fieldValue = getIn(parentDataToUpdate, fieldToConnect);
-    const relationFieldValue = isObject(fieldValue) ? fieldValue : undefined;
+   * Check if the fieldToConnect already has a value. This happens in particular when in the
+   * parent document you have created a new component without saving.
+   */ const relationFieldValue = isObject(currentFieldValue) ? currentFieldValue : undefined;
     const isFieldPresent = relationFieldValue !== undefined;
     const fieldPath = fieldToConnect.split('.');
     const fieldName = fieldPath.at(-1);
     if (!fieldName) {
-        return parentDataToUpdate;
+        return null;
     }
     const parentPath = fieldPath.slice(0, -1).join('.');
     const existingConnect = Array.isArray(relationFieldValue?.connect) ? relationFieldValue.connect : [];
@@ -58,11 +73,10 @@ const connectRelationToParent = (parentDataToUpdate, fieldToConnect, data, field
         connect,
         disconnect: []
     };
-    const dataWithRelation = setIn(parentDataToUpdate, fieldToConnect, relationValue);
-    if (!isFieldPresent && fieldToConnectUID && parentPath) {
-        return setIn(dataWithRelation, `${parentPath}.__component`, fieldToConnectUID);
-    }
-    return dataWithRelation;
+    return {
+        relationValue,
+        componentUIDPath: !isFieldPresent && fieldToConnectUID && parentPath ? `${parentPath}.__component` : undefined
+    };
 };
 const DocumentActions = ({ actions })=>{
     const { formatMessage } = useIntl();
@@ -447,18 +461,6 @@ const transformData = (data)=>{
     return data;
 };
 const transformDocumentData = (data)=>transformData(data);
-const prepareParentDataForRelationUpdate = (parentFormValues, fallbackParentFormValues, options)=>{
-    const parentDataToUpdate = parentFormValues ?? fallbackParentFormValues;
-    if (!parentDataToUpdate) {
-        return parentDataToUpdate;
-    }
-    const { data } = handleInvisibleAttributes(transformDocumentData(parentDataToUpdate), {
-        ...options,
-        // The live snapshot can omit saved invisible fields, so retain the parent's saved initial values.
-        initialValues: fallbackParentFormValues
-    });
-    return data;
-};
 /* -------------------------------------------------------------------------------------------------
  * DocumentActionComponents
  * -----------------------------------------------------------------------------------------------*/ const PublishAction = ({ activeTab, documentId, model, collectionType, meta, document })=>{
@@ -476,6 +478,7 @@ const prepareParentDataForRelationUpdate = (parentFormValues, fallbackParentForm
         }));
     const { publish, isLoading } = useDocumentActions();
     const onPreview = usePreviewContext('PublishAction', (state)=>state.onPreview, false);
+    const [fetchDraftDocument] = useLazyGetDocumentQuery();
     const [countDraftRelations, { isError: isErrorDraftRelations }] = useLazyGetDraftRelationCountQuery();
     const [localDraftRelationCounts, setLocalDraftRelationCounts] = React.useState(EMPTY_DRAFT_RELATION_COUNTS);
     const [serverDraftRelationCounts, setServerDraftRelationCounts] = React.useState(EMPTY_DRAFT_RELATION_COUNTS);
@@ -493,18 +496,15 @@ const prepareParentDataForRelationUpdate = (parentFormValues, fallbackParentForm
     // need to discriminate if the publish is coming from a relation modal or in the edit view
     const relationContext = useRelationModal('PublishAction', ()=>true, false);
     const fromRelationModal = relationContext != undefined;
-    const isRelationModalOpen = useRelationModal('PublishAction', (state)=>state.state.isModalOpen, false);
     const publishConfirmScope = fromRelationModal ? 'relation-modal' : onPreview ? 'preview' : 'panel';
     const dispatch = useRelationModal('PublishAction', (state)=>state.dispatch);
     const fieldToConnect = useRelationModal('PublishAction', (state)=>state.state.fieldToConnect, false);
     const fieldToConnectUID = useRelationModal('PublishAction', (state)=>state.state.fieldToConnectUID, false);
     const getParentFormValues = useRelationModal('PublishAction', (state)=>state.state.getParentFormValues, false);
+    const setParentFormValue = useRelationModal('PublishAction', (state)=>state.state.setParentFormValue, false);
     const documentHistory = useRelationModal('PublishAction', (state)=>state.state.documentHistory, false);
-    const rootDocumentMeta = useRelationModal('PublishAction', (state)=>state.rootDocumentMeta);
     const dispatchGuidedTour = useGuidedTour('PublishAction', (s)=>s.dispatch);
     const { currentDocumentMeta } = useDocumentContext('PublishAction');
-    const [updateDocumentMutation] = useUpdateDocumentMutation();
-    const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler();
     const idToPublish = currentDocumentMeta.documentId || id;
     React.useEffect(()=>{
         if (isErrorDraftRelations) {
@@ -577,16 +577,6 @@ const prepareParentDataForRelationUpdate = (parentFormValues, fallbackParentForm
     }, [
         fetchDraftRelationsCount
     ]);
-    const parentDocumentMetaToUpdate = documentHistory?.at(-2) ?? rootDocumentMeta;
-    const parentDocumentData = useDocument({
-        documentId: parentDocumentMetaToUpdate?.documentId,
-        model: parentDocumentMetaToUpdate?.model,
-        collectionType: parentDocumentMetaToUpdate?.collectionType,
-        params: parentDocumentMetaToUpdate?.params
-    }, {
-        skip: !parentDocumentMetaToUpdate
-    });
-    const { getInitialFormValues } = useDoc();
     const isDocumentPublished = (document?.[PUBLISHED_AT_ATTRIBUTE_NAME] || meta?.availableStatus.some((doc)=>doc[PUBLISHED_AT_ATTRIBUTE_NAME] !== null)) && document?.status !== 'modified';
     // eslint-disable-next-line react-hooks/exhaustive-deps
     const performPublish = async ()=>{
@@ -643,6 +633,17 @@ const prepareParentDataForRelationUpdate = (parentFormValues, fallbackParentForm
             // Reset form with current values as new initial values (clears errors/submitting and sets modified to false)
             if ('data' in res) {
                 resetForm(getValues());
+                // This document is now persisted with whatever local connect patches were merged into
+                // it, if any (see the pendingConnects explanation below) — they'd be stale from here on.
+                dispatch?.({
+                    type: 'CLEAR_PENDING_CONNECTS',
+                    payload: {
+                        documentMeta: {
+                            model,
+                            documentId: res.data.documentId
+                        }
+                    }
+                });
                 dispatchGuidedTour({
                     type: 'set_completed_actions',
                     payload: [
@@ -668,42 +669,45 @@ const prepareParentDataForRelationUpdate = (parentFormValues, fallbackParentForm
                         params: currentDocumentMeta.params
                     };
                     /*
-           * Update, if needed, the parent relation with the newly published document.
-           * Check if in history we have the parent relation otherwise use the
-           * rootDocument
-           */ if (fieldToConnect && documentHistory && (parentDocumentMetaToUpdate.documentId || parentDocumentMetaToUpdate.collectionType === SINGLE_TYPES)) {
-                        const fallbackParentFormValues = parentDocumentMetaToUpdate.collectionType === SINGLE_TYPES ? getInitialFormValues() : parentDocumentData.getInitialFormValues();
-                        const parentDataToUpdate = prepareParentDataForRelationUpdate(getParentFormValues?.(), fallbackParentFormValues, {
-                            schema: parentDocumentData.schema,
-                            components: parentDocumentData.components
+           * Connect the newly published document to the parent's relation field, purely in local
+           * form state — never on the server. This must not persist the parent document,
+           * otherwise publishing here would silently save any of the parent's other unrelated
+           * unsaved edits too.
+           *
+           * The parent is either the root document that originally opened the modal (its own Form
+           * stays mounted for the whole session, so it's safe to write into directly) or a nested
+           * document still further up the modal's documentHistory (whose Form is the SAME shared
+           * instance the modal reuses at every level, wholesale-replaced on every navigation — a
+           * direct write there would land on the wrong document and be gone the moment we
+           * navigate). For the latter the patch is queued on GO_TO_CREATED_RELATION below instead,
+           * to be re-applied once that document becomes current again.
+           */ const isNestedParent = Array.isArray(documentHistory) && documentHistory.length >= 2;
+                    let connectPatch;
+                    if (fieldToConnect && (setParentFormValue || isNestedParent)) {
+                        const currentFieldValue = getIn(getParentFormValues?.(), fieldToConnect);
+                        // Publishing a brand-new document creates two rows sharing one documentId — a draft
+                        // and a published one, each with its own numeric id. The parent's relation search
+                        // (and its "already connected" filter) identifies items by the draft row's id, so
+                        // connecting with the publish response's id would leave this relation still
+                        // selectable there. Fetch the draft row to get the id the search actually expects.
+                        const draftDocument = await fetchDraftDocument({
+                            collectionType,
+                            model,
+                            documentId: res.data.documentId,
+                            params: currentDocumentMeta.params
                         });
-                        const metaDocumentToUpdate = documentHistory.at(-2) ?? rootDocumentMeta;
-                        if (parentDataToUpdate) {
-                            const dataToUpdate = connectRelationToParent(parentDataToUpdate, fieldToConnect, res.data, fieldToConnectUID);
-                            try {
-                                const updateRes = await updateDocumentMutation({
-                                    collectionType: metaDocumentToUpdate.collectionType,
-                                    model: metaDocumentToUpdate.model,
-                                    documentId: metaDocumentToUpdate.collectionType !== SINGLE_TYPES ? metaDocumentToUpdate.documentId : undefined,
-                                    params: metaDocumentToUpdate.params,
-                                    data: dataToUpdate
-                                });
-                                if ('error' in updateRes) {
-                                    toggleNotification({
-                                        type: 'danger',
-                                        message: formatAPIError(updateRes.error)
-                                    });
-                                    return;
-                                }
-                            } catch (err) {
-                                toggleNotification({
-                                    type: 'danger',
-                                    message: formatMessage({
-                                        id: 'notification.error',
-                                        defaultMessage: 'An error occurred'
-                                    })
-                                });
-                                throw err;
+                        const patch = buildRelationConnectPatch(currentFieldValue, fieldToConnect, draftDocument.data?.data ?? res.data, 'published', fieldToConnectUID);
+                        if (patch && isNestedParent) {
+                            connectPatch = {
+                                fieldToConnect,
+                                relationValue: patch.relationValue,
+                                componentUIDPath: patch.componentUIDPath,
+                                componentUID: patch.componentUIDPath ? fieldToConnectUID : undefined
+                            };
+                        } else if (patch && setParentFormValue) {
+                            setParentFormValue(fieldToConnect, patch.relationValue);
+                            if (patch.componentUIDPath) {
+                                setParentFormValue(patch.componentUIDPath, fieldToConnectUID);
                             }
                         }
                     }
@@ -711,7 +715,8 @@ const prepareParentDataForRelationUpdate = (parentFormValues, fallbackParentForm
                         type: 'GO_TO_CREATED_RELATION',
                         payload: {
                             document: newRelation,
-                            shouldBypassConfirmation: true
+                            shouldBypassConfirmation: true,
+                            connectPatch
                         }
                     });
                 }
@@ -757,7 +762,9 @@ const prepareParentDataForRelationUpdate = (parentFormValues, fallbackParentForm
                 return;
             }
             e.preventDefault();
-            if (!fromRelationModal && isRelationModalOpen) {
+            // When a relation modal is open, only its own PublishAction instance (fromRelationModal)
+            // should react to the shortcut — otherwise the background entry publishes at the same time.
+            if (!fromRelationModal && isAnyRelationModalOpen()) {
                 return;
             }
             if (isDisabled) {
@@ -777,7 +784,6 @@ const prepareParentDataForRelationUpdate = (parentFormValues, fallbackParentForm
         fromRelationModal,
         getFreshDraftRelationCounts,
         isDisabled,
-        isRelationModalOpen,
         performPublish,
         publishConfirmScope,
         schema?.options?.draftAndPublish
@@ -873,7 +879,6 @@ const UpdateAction = ({ activeTab, documentId, model, collectionType })=>{
     const { currentDocument: { components } } = useDocumentContext('UpdateAction');
     const [{ rawQuery }] = useQueryParams();
     const onPreview = usePreviewContext('UpdateAction', (state)=>state.onPreview, false);
-    const { getInitialFormValues } = useDoc();
     const isSubmitting = useForm('UpdateAction', ({ isSubmitting })=>isSubmitting);
     const modified = useForm('UpdateAction', ({ modified })=>modified);
     const setSubmitting = useForm('UpdateAction', ({ setSubmitting })=>setSubmitting);
@@ -889,21 +894,10 @@ const UpdateAction = ({ activeTab, documentId, model, collectionType })=>{
     const fieldToConnect = useRelationModal('UpdateAction', (state)=>state.state.fieldToConnect, false);
     const fieldToConnectUID = useRelationModal('PublishAction', (state)=>state.state.fieldToConnectUID, false);
     const getParentFormValues = useRelationModal('UpdateAction', (state)=>state.state.getParentFormValues, false);
+    const setParentFormValue = useRelationModal('UpdateAction', (state)=>state.state.setParentFormValue, false);
     const documentHistory = useRelationModal('UpdateAction', (state)=>state.state.documentHistory, false);
-    const rootDocumentMeta = useRelationModal('UpdateAction', (state)=>state.rootDocumentMeta);
     const fromRelationModal = relationContext != undefined;
     const { currentDocumentMeta } = useDocumentContext('UpdateAction');
-    const [updateDocumentMutation] = useUpdateDocumentMutation();
-    const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler();
-    const parentDocumentMetaToUpdate = documentHistory?.at(-2) ?? rootDocumentMeta;
-    const parentDocumentData = useDocument({
-        documentId: parentDocumentMetaToUpdate?.documentId,
-        model: parentDocumentMetaToUpdate?.model,
-        collectionType: parentDocumentMetaToUpdate?.collectionType,
-        params: parentDocumentMetaToUpdate?.params
-    }, {
-        skip: !parentDocumentMetaToUpdate
-    });
     const { schema } = useDoc();
     const suitableSchema = fromRelationModal ? relationalModalSchema : schema;
     const hasDraftAndPublished = suitableSchema?.options?.draftAndPublish ?? false;
@@ -975,6 +969,17 @@ const UpdateAction = ({ activeTab, documentId, model, collectionType })=>{
                     setErrors(formatValidationErrors(res.error));
                 } else {
                     resetForm(latestValues);
+                    // This document is now persisted with whatever local connect patches were merged into
+                    // it, if any (see the pendingConnects explanation below) — they'd be stale from here on.
+                    dispatch?.({
+                        type: 'CLEAR_PENDING_CONNECTS',
+                        payload: {
+                            documentMeta: {
+                                model,
+                                documentId
+                            }
+                        }
+                    });
                 }
             } else {
                 const { data } = handleInvisibleAttributes(transformDocumentData(latestValues), {
@@ -995,43 +1000,34 @@ const UpdateAction = ({ activeTab, documentId, model, collectionType })=>{
                             params: currentDocumentMeta.params
                         };
                         /*
-             * Update, if needed, the parent relation with the newly published document.
-             * Check if in history we have the parent relation otherwise use the
-             * rootDocument
-             */ if (fieldToConnect && documentHistory && (parentDocumentMetaToUpdate.documentId || parentDocumentMetaToUpdate.collectionType === SINGLE_TYPES)) {
-                            const fallbackParentFormValues = parentDocumentMetaToUpdate.collectionType === SINGLE_TYPES ? getInitialFormValues() : parentDocumentData.getInitialFormValues();
-                            const parentDataToUpdate = prepareParentDataForRelationUpdate(getParentFormValues?.(), fallbackParentFormValues, {
-                                schema: parentDocumentData.schema,
-                                components: parentDocumentData.components
-                            });
-                            if (parentDataToUpdate) {
-                                const dataToUpdate = connectRelationToParent(parentDataToUpdate, fieldToConnect, res.data, fieldToConnectUID);
-                                try {
-                                    const updateRes = await updateDocumentMutation({
-                                        collectionType: parentDocumentMetaToUpdate.collectionType,
-                                        model: parentDocumentMetaToUpdate.model,
-                                        documentId: parentDocumentMetaToUpdate.collectionType !== SINGLE_TYPES ? parentDocumentMetaToUpdate.documentId : undefined,
-                                        params: parentDocumentMetaToUpdate.params,
-                                        data: {
-                                            ...dataToUpdate
-                                        }
-                                    });
-                                    if ('error' in updateRes) {
-                                        toggleNotification({
-                                            type: 'danger',
-                                            message: formatAPIError(updateRes.error)
-                                        });
-                                        return;
-                                    }
-                                } catch (err) {
-                                    toggleNotification({
-                                        type: 'danger',
-                                        message: formatMessage({
-                                            id: 'notification.error',
-                                            defaultMessage: 'An error occurred'
-                                        })
-                                    });
-                                    throw err;
+             * Connect the newly created document to the parent's relation field, purely in local
+             * form state — never on the server. This must not persist the parent document,
+             * otherwise saving here would silently save any of the parent's other unrelated
+             * unsaved edits too.
+             *
+             * The parent is either the root document that originally opened the modal (its own
+             * Form stays mounted for the whole session, so it's safe to write into directly) or a
+             * nested document still further up the modal's documentHistory (whose Form is the
+             * SAME shared instance the modal reuses at every level, wholesale-replaced on every
+             * navigation — a direct write there would land on the wrong document and be gone the
+             * moment we navigate). For the latter the patch is queued on GO_TO_CREATED_RELATION
+             * below instead, to be re-applied once that document becomes current again.
+             */ const isNestedParent = Array.isArray(documentHistory) && documentHistory.length >= 2;
+                        let connectPatch;
+                        if (fieldToConnect && (setParentFormValue || isNestedParent)) {
+                            const currentFieldValue = getIn(getParentFormValues?.(), fieldToConnect);
+                            const patch = buildRelationConnectPatch(currentFieldValue, fieldToConnect, res.data, hasDraftAndPublished ? 'draft' : undefined, fieldToConnectUID);
+                            if (patch && isNestedParent) {
+                                connectPatch = {
+                                    fieldToConnect,
+                                    relationValue: patch.relationValue,
+                                    componentUIDPath: patch.componentUIDPath,
+                                    componentUID: patch.componentUIDPath ? fieldToConnectUID : undefined
+                                };
+                            } else if (patch && setParentFormValue) {
+                                setParentFormValue(fieldToConnect, patch.relationValue);
+                                if (patch.componentUIDPath) {
+                                    setParentFormValue(patch.componentUIDPath, fieldToConnectUID);
                                 }
                             }
                         }
@@ -1039,7 +1035,8 @@ const UpdateAction = ({ activeTab, documentId, model, collectionType })=>{
                             type: 'GO_TO_CREATED_RELATION',
                             payload: {
                                 document: createdRelation,
-                                shouldBypassConfirmation: true
+                                shouldBypassConfirmation: true,
+                                connectPatch
                             }
                         });
                     } else {
@@ -1076,12 +1073,19 @@ const UpdateAction = ({ activeTab, documentId, model, collectionType })=>{
     handleUpdateRef.current = handleUpdate;
     const isDisabledRef = React.useRef(isDisabled);
     isDisabledRef.current = isDisabled;
+    const fromRelationModalRef = React.useRef(fromRelationModal);
+    fromRelationModalRef.current = fromRelationModal;
     React.useEffect(()=>{
         const handleKeyDown = (e)=>{
             if (getEditViewShortcut(e) !== 'save') {
                 return;
             }
             e.preventDefault();
+            // When a relation modal is open, only its own UpdateAction instance (fromRelationModal)
+            // should react to the shortcut — otherwise the background entry saves at the same time.
+            if (!fromRelationModalRef.current && isAnyRelationModalOpen()) {
+                return;
+            }
             if (!isDisabledRef.current) {
                 handleUpdateRef.current();
             }