@strapi/content-manager 0.0.0-next.3dfa46a688dac778822b4cb229acfc1ce41e71ed → 0.0.0-next.3e666b1ad96ac2e82634e548e10ea7c7797a7474

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

@@ -6,19 +6,24 @@ var strapiAdmin = require('@strapi/admin/strapi-admin');
 var designSystem = require('@strapi/design-system');
 var Icons = require('@strapi/icons');
 var mapValues = require('lodash/fp/mapValues');
+var get = require('lodash/get');
+var merge = require('lodash/merge');
+var set = require('lodash/set');
 var reactIntl = require('react-intl');
 var reactRouterDom = require('react-router-dom');
-var styledComponents = require('styled-components');
 var attributes = require('../../../constants/attributes.js');
 var collections = require('../../../constants/collections.js');
-var DocumentContext = require('../../../features/DocumentContext.js');
 var DocumentRBAC = require('../../../features/DocumentRBAC.js');
 var useDocument = require('../../../hooks/useDocument.js');
 var useDocumentActions = require('../../../hooks/useDocumentActions.js');
+var useDocumentContext = require('../../../hooks/useDocumentContext.js');
+var Preview = require('../../../preview/pages/Preview.js');
 var router = require('../../../router.js');
 var documents = require('../../../services/documents.js');
 var api = require('../../../utils/api.js');
 var translations = require('../../../utils/translations.js');
+var data = require('../utils/data.js');
+var RelationModal = require('./FormInputs/Relations/RelationModal.js');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -39,6 +44,38 @@ function _interopNamespaceDefault(e) {
 
 var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
 
+const connectRelationToParent = (parentDataToUpdate, fieldToConnect, data, fieldToConnectUID)=>{
+    /*
+   * 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 isFieldPresent = !!get(parentDataToUpdate, fieldToConnect);
+    const fieldToConnectPath = isFieldPresent ? fieldToConnect : fieldToConnect.split('.').slice(0, -1).join('.');
+    const fieldToConnectValue = isFieldPresent ? {
+        connect: [
+            {
+                id: data.documentId,
+                documentId: data.documentId,
+                locale: data.locale
+            }
+        ]
+    } : {
+        [fieldToConnect.split('.').pop()]: {
+            connect: [
+                {
+                    id: data.documentId,
+                    documentId: data.documentId,
+                    locale: data.locale
+                }
+            ],
+            disconnect: []
+        },
+        // In case the object was not present you need to pass the componentUID of the parent document
+        __component: fieldToConnectUID
+    };
+    const objectToConnect = set({}, fieldToConnectPath, fieldToConnectValue);
+    return merge(parentDataToUpdate, objectToConnect);
+};
 const DocumentActions = ({ actions })=>{
     const { formatMessage } = reactIntl.useIntl();
     const [primaryAction, secondaryAction, ...restActions] = actions.filter((action)=>{
@@ -137,11 +174,6 @@ const DocumentActionButton = (action)=>{
         ]
     });
 };
-const MenuItem = styledComponents.styled(designSystem.Menu.Item)`
-  &:hover {
-    background: ${({ theme, isVariantDanger, isDisabled })=>isVariantDanger && !isDisabled ? theme.colors.danger100 : 'neutral'};
-  }
-`;
 const DocumentActionsMenu = ({ actions, children, label, variant = 'tertiary' })=>{
     const [isOpen, setIsOpen] = React__namespace.useState(false);
     const [dialogId, setDialogId] = React__namespace.useState(null);
@@ -203,27 +235,19 @@ const DocumentActionsMenu = ({ actions, children, label, variant = 'tertiary' })
                 popoverPlacement: "bottom-end",
                 children: [
                     actions.map((action)=>{
-                        return /*#__PURE__*/ jsxRuntime.jsx(MenuItem, {
+                        return /*#__PURE__*/ jsxRuntime.jsx(designSystem.Menu.Item, {
                             disabled: action.disabled,
                             /* @ts-expect-error – TODO: this is an error in the DS where it is most likely a synthetic event, not regular. */ onSelect: handleClick(action),
                             display: "block",
-                            isVariantDanger: action.variant === 'danger',
-                            isDisabled: action.disabled,
+                            variant: action.variant === 'danger' ? action.variant : 'default',
+                            startIcon: action.icon,
                             children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
                                 justifyContent: "space-between",
                                 gap: 4,
-                                children: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
-                                    color: !action.disabled ? convertActionVariantToColor(action.variant) : 'inherit',
+                                children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
                                     gap: 2,
                                     tag: "span",
-                                    children: [
-                                        /*#__PURE__*/ jsxRuntime.jsx(designSystem.Flex, {
-                                            tag: "span",
-                                            color: !action.disabled ? convertActionVariantToIconColor(action.variant) : 'inherit',
-                                            children: action.icon
-                                        }),
-                                        action.label
-                                    ]
+                                    children: action.label
                                 })
                             })
                         }, action.id);
@@ -251,30 +275,6 @@ const DocumentActionsMenu = ({ actions, children, label, variant = 'tertiary' })
         ]
     });
 };
-const convertActionVariantToColor = (variant = 'secondary')=>{
-    switch(variant){
-        case 'danger':
-            return 'danger600';
-        case 'secondary':
-            return undefined;
-        case 'success':
-            return 'success600';
-        default:
-            return 'primary600';
-    }
-};
-const convertActionVariantToIconColor = (variant = 'secondary')=>{
-    switch(variant){
-        case 'danger':
-            return 'danger600';
-        case 'secondary':
-            return 'neutral500';
-        case 'success':
-            return 'success600';
-        default:
-            return 'primary600';
-    }
-};
 const DocumentActionConfirmDialog = ({ onClose, onCancel, onConfirm, title, content, isOpen, variant = 'secondary', loading })=>{
     const { formatMessage } = reactIntl.useIntl();
     const handleClose = async ()=>{
@@ -371,8 +371,8 @@ const transformData = (data)=>{
 };
 /* -------------------------------------------------------------------------------------------------
  * DocumentActionComponents
- * -----------------------------------------------------------------------------------------------*/ const PublishAction = ({ activeTab, documentId, model, collectionType, meta, document, onPreview, fromPreview = false, fromRelationModal = false })=>{
-    const schema = DocumentContext.useDocumentContext('PublishAction', (state)=>state.document.schema);
+ * -----------------------------------------------------------------------------------------------*/ const PublishAction = ({ activeTab, documentId, model, collectionType, meta, document })=>{
+    const { currentDocument: { schema } } = useDocumentContext.useDocumentContext('PublishAction');
     const navigate = reactRouterDom.useNavigate();
     const { toggleNotification } = strapiAdmin.useNotification();
     const { _unstableFormatValidationErrors: formatValidationErrors } = strapiAdmin.useAPIErrorHandler();
@@ -380,23 +380,36 @@ const transformData = (data)=>{
     const isCloning = reactRouterDom.useMatch(router.CLONE_PATH) !== null;
     const { id } = reactRouterDom.useParams();
     const { formatMessage } = reactIntl.useIntl();
-    const canPublish = DocumentRBAC.useDocumentRBAC('PublishAction', ({ canPublish })=>canPublish);
-    const { publish, isLoading } = useDocumentActions.useDocumentActions(fromPreview, fromRelationModal);
+    const { canPublish, canReadFields } = DocumentRBAC.useDocumentRBAC('PublishAction', ({ canPublish, canReadFields })=>({
+            canPublish,
+            canReadFields
+        }));
+    const { publish, isLoading } = useDocumentActions.useDocumentActions();
+    const onPreview = Preview.usePreviewContext('UpdateAction', (state)=>state.onPreview, false);
     const [countDraftRelations, { isLoading: isLoadingDraftRelations, isError: isErrorDraftRelations }] = documents.useGetDraftRelationCountQuery();
     const [localCountOfDraftRelations, setLocalCountOfDraftRelations] = React__namespace.useState(0);
     const [serverCountOfDraftRelations, setServerCountOfDraftRelations] = React__namespace.useState(0);
-    const [{ query, rawQuery }] = strapiAdmin.useQueryParams();
-    const params = React__namespace.useMemo(()=>api.buildValidParams(query), [
-        query
-    ]);
+    const [{ rawQuery }] = strapiAdmin.useQueryParams();
     const modified = strapiAdmin.useForm('PublishAction', ({ modified })=>modified);
     const setSubmitting = strapiAdmin.useForm('PublishAction', ({ setSubmitting })=>setSubmitting);
     const isSubmitting = strapiAdmin.useForm('PublishAction', ({ isSubmitting })=>isSubmitting);
     const validate = strapiAdmin.useForm('PublishAction', (state)=>state.validate);
     const setErrors = strapiAdmin.useForm('PublishAction', (state)=>state.setErrors);
     const formValues = strapiAdmin.useForm('PublishAction', ({ values })=>values);
-    const rootDocumentMeta = DocumentContext.useDocumentContext('PublishAction', (state)=>state.rootDocumentMeta);
-    const currentDocumentMeta = DocumentContext.useDocumentContext('PublishAction', (state)=>state.meta);
+    const resetForm = strapiAdmin.useForm('PublishAction', ({ resetForm })=>resetForm);
+    const { currentDocument: { components } } = useDocumentContext.useDocumentContext('PublishAction');
+    // need to discriminate if the publish is coming from a relation modal or in the edit view
+    const relationContext = RelationModal.useRelationModal('PublishAction', ()=>true, false);
+    const fromRelationModal = relationContext != undefined;
+    const dispatch = RelationModal.useRelationModal('PublishAction', (state)=>state.dispatch);
+    const fieldToConnect = RelationModal.useRelationModal('PublishAction', (state)=>state.state.fieldToConnect, false);
+    const fieldToConnectUID = RelationModal.useRelationModal('PublishAction', (state)=>state.state.fieldToConnectUID, false);
+    const documentHistory = RelationModal.useRelationModal('PublishAction', (state)=>state.state.documentHistory, false);
+    const rootDocumentMeta = RelationModal.useRelationModal('PublishAction', (state)=>state.rootDocumentMeta);
+    const { currentDocumentMeta } = useDocumentContext.useDocumentContext('PublishAction');
+    const [updateDocumentMutation] = documents.useUpdateDocumentMutation();
+    const { _unstableFormatAPIError: formatAPIError } = strapiAdmin.useAPIErrorHandler();
+    const idToPublish = currentDocumentMeta.documentId || id;
     React__namespace.useEffect(()=>{
         if (isErrorDraftRelations) {
             toggleNotification({
@@ -460,7 +473,7 @@ const transformData = (data)=>{
                 collectionType,
                 model,
                 documentId,
-                params
+                params: currentDocumentMeta.params
             });
             if (error) {
                 throw error;
@@ -477,8 +490,18 @@ const transformData = (data)=>{
         countDraftRelations,
         collectionType,
         model,
-        params
+        currentDocumentMeta.params
     ]);
+    const parentDocumentMetaToUpdate = documentHistory?.at(-2) ?? rootDocumentMeta;
+    const parentDocumentData = useDocument.useDocument({
+        documentId: parentDocumentMetaToUpdate?.documentId,
+        model: parentDocumentMetaToUpdate?.model,
+        collectionType: parentDocumentMetaToUpdate?.collectionType,
+        params: parentDocumentMetaToUpdate?.params
+    }, {
+        skip: !parentDocumentMetaToUpdate
+    });
+    const { getInitialFormValues } = useDocument.useDoc();
     const isDocumentPublished = (document?.[attributes.PUBLISHED_AT_ATTRIBUTE_NAME] || meta?.availableStatus.some((doc)=>doc[attributes.PUBLISHED_AT_ATTRIBUTE_NAME] !== null)) && document?.status !== 'modified';
     if (!schema?.options?.draftAndPublish) {
         return null;
@@ -490,30 +513,99 @@ const transformData = (data)=>{
                 status: 'published'
             });
             if (errors) {
-                toggleNotification({
-                    type: 'danger',
-                    message: formatMessage({
-                        id: 'content-manager.validation.error',
-                        defaultMessage: 'There are validation errors in your document. Please fix them before saving.'
-                    })
+                const hasUnreadableRequiredField = Object.keys(schema.attributes).some((fieldName)=>{
+                    const attribute = schema.attributes[fieldName];
+                    return attribute?.required && !(canReadFields ?? []).includes(fieldName);
                 });
+                if (hasUnreadableRequiredField) {
+                    toggleNotification({
+                        type: 'danger',
+                        message: formatMessage({
+                            id: 'content-manager.validation.error.unreadable-required-field',
+                            defaultMessage: 'Your current permissions prevent access to certain required fields. Please request access from an administrator to proceed.'
+                        })
+                    });
+                } else {
+                    toggleNotification({
+                        type: 'danger',
+                        message: formatMessage({
+                            id: 'content-manager.validation.error',
+                            defaultMessage: 'There are validation errors in your document. Please fix them before saving.'
+                        })
+                    });
+                }
                 return;
             }
-            const isPublishingRelation = rootDocumentMeta.documentId !== currentDocumentMeta.documentId;
+            const { data: data$1 } = data.handleInvisibleAttributes(transformData(formValues), {
+                schema,
+                components
+            });
             const res = await publish({
                 collectionType,
                 model,
                 documentId,
-                params: isPublishingRelation ? currentDocumentMeta.params : params
-            }, transformData(formValues));
+                params: currentDocumentMeta.params
+            }, data$1);
+            // Reset form if successful
+            if ('data' in res) {
+                resetForm();
+            }
             if ('data' in res && collectionType !== collections.SINGLE_TYPES) {
                 /**
          * TODO: refactor the router so we can just do `../${res.data.documentId}` instead of this.
-         */ if (id === 'create') {
+         */ if (idToPublish === 'create' && !fromRelationModal) {
                     navigate({
                         pathname: `../${collectionType}/${model}/${res.data.documentId}`,
                         search: rawQuery
                     });
+                } else if (fromRelationModal) {
+                    const newRelation = {
+                        documentId: res.data.documentId,
+                        collectionType,
+                        model,
+                        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 === collections.SINGLE_TYPES)) {
+                        const parentDataToUpdate = parentDocumentMetaToUpdate.collectionType === collections.SINGLE_TYPES ? getInitialFormValues() : parentDocumentData.getInitialFormValues();
+                        const metaDocumentToUpdate = documentHistory.at(-2) ?? rootDocumentMeta;
+                        const dataToUpdate = connectRelationToParent(parentDataToUpdate, fieldToConnect, res.data, fieldToConnectUID);
+                        try {
+                            const updateRes = await updateDocumentMutation({
+                                collectionType: metaDocumentToUpdate.collectionType,
+                                model: metaDocumentToUpdate.model,
+                                documentId: metaDocumentToUpdate.collectionType !== collections.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;
+                        }
+                    }
+                    dispatch({
+                        type: 'GO_TO_CREATED_RELATION',
+                        payload: {
+                            document: newRelation,
+                            shouldBypassConfirmation: true
+                        }
+                    });
                 }
             } else if ('error' in res && api.isBaseQueryError(res.error) && res.error.name === 'ValidationError') {
                 setErrors(formatValidationErrors(res.error));
@@ -579,27 +671,48 @@ PublishAction.position = [
     'preview',
     'relation-modal'
 ];
-const UpdateAction = ({ activeTab, documentId, model, collectionType, onPreview, fromPreview = false, fromRelationModal = false })=>{
+const UpdateAction = ({ activeTab, documentId, model, collectionType })=>{
     const navigate = reactRouterDom.useNavigate();
     const { toggleNotification } = strapiAdmin.useNotification();
     const { _unstableFormatValidationErrors: formatValidationErrors } = strapiAdmin.useAPIErrorHandler();
     const cloneMatch = reactRouterDom.useMatch(router.CLONE_PATH);
     const isCloning = cloneMatch !== null;
     const { formatMessage } = reactIntl.useIntl();
-    const { create, update, clone, isLoading } = useDocumentActions.useDocumentActions(fromPreview, fromRelationModal);
-    const [{ query, rawQuery }] = strapiAdmin.useQueryParams();
-    const params = React__namespace.useMemo(()=>api.buildValidParams(query), [
-        query
-    ]);
+    const { create, update, clone, isLoading } = useDocumentActions.useDocumentActions();
+    const { currentDocument: { components } } = useDocumentContext.useDocumentContext('UpdateAction');
+    const [{ rawQuery }] = strapiAdmin.useQueryParams();
+    const onPreview = Preview.usePreviewContext('UpdateAction', (state)=>state.onPreview, false);
+    const { getInitialFormValues } = useDocument.useDoc();
     const isSubmitting = strapiAdmin.useForm('UpdateAction', ({ isSubmitting })=>isSubmitting);
     const modified = strapiAdmin.useForm('UpdateAction', ({ modified })=>modified);
     const setSubmitting = strapiAdmin.useForm('UpdateAction', ({ setSubmitting })=>setSubmitting);
+    const initialValues = strapiAdmin.useForm('UpdateAction', ({ initialValues })=>initialValues);
     const document = strapiAdmin.useForm('UpdateAction', ({ values })=>values);
     const validate = strapiAdmin.useForm('UpdateAction', (state)=>state.validate);
     const setErrors = strapiAdmin.useForm('UpdateAction', (state)=>state.setErrors);
-    const resetForm = strapiAdmin.useForm('PublishAction', ({ resetForm })=>resetForm);
-    const rootDocumentMeta = DocumentContext.useDocumentContext('UpdateAction', (state)=>state.rootDocumentMeta);
-    const currentDocumentMeta = DocumentContext.useDocumentContext('UpdateAction', (state)=>state.meta);
+    const resetForm = strapiAdmin.useForm('UpdateAction', ({ resetForm })=>resetForm);
+    const dispatch = RelationModal.useRelationModal('UpdateAction', (state)=>state.dispatch);
+    // need to discriminate if the update is coming from a relation modal or in the edit view
+    const relationContext = RelationModal.useRelationModal('UpdateAction', ()=>true, false);
+    const relationalModalSchema = RelationModal.useRelationModal('UpdateAction', (state)=>state.currentDocument.schema, false);
+    const fieldToConnect = RelationModal.useRelationModal('UpdateAction', (state)=>state.state.fieldToConnect, false);
+    const fieldToConnectUID = RelationModal.useRelationModal('PublishAction', (state)=>state.state.fieldToConnectUID, false);
+    const documentHistory = RelationModal.useRelationModal('UpdateAction', (state)=>state.state.documentHistory, false);
+    const rootDocumentMeta = RelationModal.useRelationModal('UpdateAction', (state)=>state.rootDocumentMeta);
+    const fromRelationModal = relationContext != undefined;
+    const { currentDocumentMeta } = useDocumentContext.useDocumentContext('UpdateAction');
+    const [updateDocumentMutation] = documents.useUpdateDocumentMutation();
+    const { _unstableFormatAPIError: formatAPIError } = strapiAdmin.useAPIErrorHandler();
+    const parentDocumentMetaToUpdate = documentHistory?.at(-2) ?? rootDocumentMeta;
+    const parentDocumentData = useDocument.useDocument({
+        documentId: parentDocumentMetaToUpdate?.documentId,
+        model: parentDocumentMetaToUpdate?.model,
+        collectionType: parentDocumentMetaToUpdate?.collectionType,
+        params: parentDocumentMetaToUpdate?.params
+    }, {
+        skip: !parentDocumentMetaToUpdate
+    });
+    const { schema } = useDocument.useDoc();
     const handleUpdate = React__namespace.useCallback(async ()=>{
         setSubmitting(true);
         try {
@@ -623,7 +736,7 @@ const UpdateAction = ({ activeTab, documentId, model, collectionType, onPreview,
                 const res = await clone({
                     model,
                     documentId: cloneMatch.params.origin,
-                    params
+                    params: currentDocumentMeta.params
                 }, transformData(document));
                 if ('data' in res) {
                     navigate({
@@ -636,31 +749,91 @@ const UpdateAction = ({ activeTab, documentId, model, collectionType, onPreview,
                     setErrors(formatValidationErrors(res.error));
                 }
             } else if (documentId || collectionType === collections.SINGLE_TYPES) {
-                const isEditingRelation = rootDocumentMeta.documentId !== currentDocumentMeta.documentId;
+                const { data: data$1 } = data.handleInvisibleAttributes(transformData(document), {
+                    schema: fromRelationModal ? relationalModalSchema : schema,
+                    initialValues,
+                    components
+                });
                 const res = await update({
                     collectionType,
                     model,
                     documentId,
-                    params: isEditingRelation ? currentDocumentMeta.params : params
-                }, transformData(document));
+                    params: currentDocumentMeta.params
+                }, data$1);
                 if ('error' in res && api.isBaseQueryError(res.error) && res.error.name === 'ValidationError') {
                     setErrors(formatValidationErrors(res.error));
                 } else {
                     resetForm();
                 }
             } else {
+                const { data: data$1 } = data.handleInvisibleAttributes(transformData(document), {
+                    schema: fromRelationModal ? relationalModalSchema : schema,
+                    initialValues,
+                    components
+                });
                 const res = await create({
                     model,
-                    params
-                }, transformData(document));
+                    params: currentDocumentMeta.params
+                }, data$1);
                 if ('data' in res && collectionType !== collections.SINGLE_TYPES) {
-                    navigate({
-                        pathname: `../${res.data.documentId}`,
-                        search: rawQuery
-                    }, {
-                        replace: true,
-                        relative: 'path'
-                    });
+                    if (fromRelationModal) {
+                        const createdRelation = {
+                            documentId: res.data.documentId,
+                            collectionType,
+                            model,
+                            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 === collections.SINGLE_TYPES)) {
+                            const parentDataToUpdate = parentDocumentMetaToUpdate.collectionType === collections.SINGLE_TYPES ? getInitialFormValues() : parentDocumentData.getInitialFormValues();
+                            const dataToUpdate = connectRelationToParent(parentDataToUpdate, fieldToConnect, res.data, fieldToConnectUID);
+                            try {
+                                const updateRes = await updateDocumentMutation({
+                                    collectionType: parentDocumentMetaToUpdate.collectionType,
+                                    model: parentDocumentMetaToUpdate.model,
+                                    documentId: parentDocumentMetaToUpdate.collectionType !== collections.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;
+                            }
+                        }
+                        dispatch({
+                            type: 'GO_TO_CREATED_RELATION',
+                            payload: {
+                                document: createdRelation,
+                                shouldBypassConfirmation: true
+                            }
+                        });
+                    } else {
+                        navigate({
+                            pathname: `../${res.data.documentId}`,
+                            search: rawQuery
+                        }, {
+                            replace: true,
+                            relative: 'path'
+                        });
+                    }
                 } else if ('error' in res && api.isBaseQueryError(res.error) && res.error.name === 'ValidationError') {
                     setErrors(formatValidationErrors(res.error));
                 }
@@ -672,30 +845,41 @@ const UpdateAction = ({ activeTab, documentId, model, collectionType, onPreview,
             }
         }
     }, [
+        setSubmitting,
+        modified,
+        validate,
+        isCloning,
+        documentId,
+        collectionType,
+        toggleNotification,
+        formatMessage,
         clone,
+        model,
         cloneMatch?.params.origin,
-        collectionType,
-        create,
-        currentDocumentMeta.documentId,
         currentDocumentMeta.params,
         document,
-        documentId,
-        formatMessage,
-        formatValidationErrors,
-        isCloning,
-        model,
-        modified,
         navigate,
-        onPreview,
-        params,
         rawQuery,
-        resetForm,
-        rootDocumentMeta.documentId,
         setErrors,
-        setSubmitting,
-        toggleNotification,
+        formatValidationErrors,
         update,
-        validate
+        resetForm,
+        create,
+        fromRelationModal,
+        fieldToConnect,
+        documentHistory,
+        parentDocumentMetaToUpdate,
+        dispatch,
+        getInitialFormValues,
+        parentDocumentData,
+        fieldToConnectUID,
+        updateDocumentMutation,
+        formatAPIError,
+        onPreview,
+        initialValues,
+        schema,
+        components,
+        relationalModalSchema
     ]);
     // Auto-save on CMD+S or CMD+Enter on macOS, and CTRL+S or CTRL+Enter on Windows/Linux
     React__namespace.useEffect(()=>{