@strapi/content-manager 0.0.0-experimental.35644b9b8cc9cb7d3104ab14464d2de4f1bd19ed → 0.0.0-experimental.36f6fd69b4f935991d26f27957949ec71f187528

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

@@ -1,12 +1,14 @@
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import * as React from 'react';
 import { useNotification, useAPIErrorHandler, useQueryParams, useForm } from '@strapi/admin/strapi-admin';
-import { Menu, Flex, Button, VisuallyHidden, Dialog, Modal, Typography, Radio } from '@strapi/design-system';
+import { Flex, Button, Menu, VisuallyHidden, Dialog, Modal, Typography, Radio } from '@strapi/design-system';
 import { More, Cross, WarningCircle } from '@strapi/icons';
 import mapValues from 'lodash/fp/mapValues';
+import get from 'lodash/get';
+import merge from 'lodash/merge';
+import set from 'lodash/set';
 import { useIntl } from 'react-intl';
 import { useNavigate, useMatch, useParams } from 'react-router-dom';
-import { styled } from 'styled-components';
 import { PUBLISHED_AT_ATTRIBUTE_NAME } from '../../../constants/attributes.mjs';
 import { SINGLE_TYPES } from '../../../constants/collections.mjs';
 import { useDocumentRBAC } from '../../../features/DocumentRBAC.mjs';
@@ -17,10 +19,42 @@ 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 { isBaseQueryError, buildValidParams } from '../../../utils/api.mjs';
-import { stringToObject, deepMerge } from '../../../utils/mergeObject.mjs';
 import { getTranslation } from '../../../utils/translations.mjs';
+import { handleInvisibleAttributes } from '../utils/data.mjs';
 import { useRelationModal } from './FormInputs/Relations/RelationModal.mjs';
 
+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 } = useIntl();
     const [primaryAction, secondaryAction, ...restActions] = actions.filter((action)=>{
@@ -119,11 +153,6 @@ const DocumentActionButton = (action)=>{
         ]
     });
 };
-const MenuItem = styled(Menu.Item)`
-  &:hover {
-    background: ${({ theme, isVariantDanger, isDisabled })=>isVariantDanger && !isDisabled ? theme.colors.danger100 : 'neutral'};
-  }
-`;
 const DocumentActionsMenu = ({ actions, children, label, variant = 'tertiary' })=>{
     const [isOpen, setIsOpen] = React.useState(false);
     const [dialogId, setDialogId] = React.useState(null);
@@ -185,27 +214,19 @@ const DocumentActionsMenu = ({ actions, children, label, variant = 'tertiary' })
                 popoverPlacement: "bottom-end",
                 children: [
                     actions.map((action)=>{
-                        return /*#__PURE__*/ jsx(MenuItem, {
+                        return /*#__PURE__*/ jsx(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__*/ jsx(Flex, {
                                 justifyContent: "space-between",
                                 gap: 4,
-                                children: /*#__PURE__*/ jsxs(Flex, {
-                                    color: !action.disabled ? convertActionVariantToColor(action.variant) : 'inherit',
+                                children: /*#__PURE__*/ jsx(Flex, {
                                     gap: 2,
                                     tag: "span",
-                                    children: [
-                                        /*#__PURE__*/ jsx(Flex, {
-                                            tag: "span",
-                                            color: !action.disabled ? convertActionVariantToIconColor(action.variant) : 'inherit',
-                                            children: action.icon
-                                        }),
-                                        action.label
-                                    ]
+                                    children: action.label
                                 })
                             })
                         }, action.id);
@@ -233,30 +254,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 } = useIntl();
     const handleClose = async ()=>{
@@ -362,7 +359,10 @@ const transformData = (data)=>{
     const isCloning = useMatch(CLONE_PATH) !== null;
     const { id } = useParams();
     const { formatMessage } = useIntl();
-    const canPublish = useDocumentRBAC('PublishAction', ({ canPublish })=>canPublish);
+    const { canPublish, canReadFields } = useDocumentRBAC('PublishAction', ({ canPublish, canReadFields })=>({
+            canPublish,
+            canReadFields
+        }));
     const { publish, isLoading } = useDocumentActions();
     const onPreview = usePreviewContext('UpdateAction', (state)=>state.onPreview, false);
     const [countDraftRelations, { isLoading: isLoadingDraftRelations, isError: isErrorDraftRelations }] = useLazyGetDraftRelationCountQuery();
@@ -376,11 +376,13 @@ const transformData = (data)=>{
     const setErrors = useForm('PublishAction', (state)=>state.setErrors);
     const formValues = useForm('PublishAction', ({ values })=>values);
     const resetForm = useForm('PublishAction', ({ resetForm })=>resetForm);
+    const { currentDocument: { components } } = useDocumentContext('PublishAction');
     // 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 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 documentHistory = useRelationModal('PublishAction', (state)=>state.state.documentHistory, false);
     const rootDocumentMeta = useRelationModal('PublishAction', (state)=>state.rootDocumentMeta);
     const { currentDocumentMeta } = useDocumentContext('PublishAction');
@@ -478,6 +480,7 @@ const transformData = (data)=>{
     }, {
         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';
     if (!schema?.options?.draftAndPublish) {
         return null;
@@ -489,21 +492,39 @@ 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 { data } = handleInvisibleAttributes(transformData(formValues), {
+                schema,
+                components
+            });
             const res = await publish({
                 collectionType,
                 model,
                 documentId,
                 params: currentDocumentMeta.params
-            }, transformData(formValues));
+            }, data);
             // Reset form if successful
             if ('data' in res) {
                 resetForm();
@@ -523,30 +544,21 @@ const transformData = (data)=>{
                         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) {
-                        const parentDataToUpdate = parentDocumentData.getInitialFormValues();
+                    /*
+           * 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 parentDataToUpdate = parentDocumentMetaToUpdate.collectionType === SINGLE_TYPES ? getInitialFormValues() : parentDocumentData.getInitialFormValues();
                         const metaDocumentToUpdate = documentHistory.at(-2) ?? rootDocumentMeta;
-                        const objectToConnect = stringToObject(fieldToConnect, {
-                            connect: [
-                                {
-                                    id: res.data.documentId,
-                                    documentId: res.data.documentId,
-                                    locale: res.data.locale
-                                }
-                            ]
-                        });
-                        const dataToUpdate = deepMerge(parentDataToUpdate, objectToConnect);
+                        const dataToUpdate = connectRelationToParent(parentDataToUpdate, fieldToConnect, res.data, fieldToConnectUID);
                         try {
                             const updateRes = await updateDocumentMutation({
                                 collectionType: metaDocumentToUpdate.collectionType,
                                 model: metaDocumentToUpdate.model,
-                                documentId: metaDocumentToUpdate.documentId,
+                                documentId: metaDocumentToUpdate.collectionType !== SINGLE_TYPES ? metaDocumentToUpdate.documentId : undefined,
                                 params: metaDocumentToUpdate.params,
-                                data: {
-                                    ...dataToUpdate
-                                }
+                                data: dataToUpdate
                             });
                             if ('error' in updateRes) {
                                 toggleNotification({
@@ -646,11 +658,14 @@ const UpdateAction = ({ activeTab, documentId, model, collectionType })=>{
     const isCloning = cloneMatch !== null;
     const { formatMessage } = useIntl();
     const { create, update, clone, isLoading } = useDocumentActions();
+    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);
+    const initialValues = useForm('UpdateAction', ({ initialValues })=>initialValues);
     const document = useForm('UpdateAction', ({ values })=>values);
     const validate = useForm('UpdateAction', (state)=>state.validate);
     const setErrors = useForm('UpdateAction', (state)=>state.setErrors);
@@ -658,7 +673,9 @@ const UpdateAction = ({ activeTab, documentId, model, collectionType })=>{
     const dispatch = useRelationModal('UpdateAction', (state)=>state.dispatch);
     // need to discriminate if the update is coming from a relation modal or in the edit view
     const relationContext = useRelationModal('UpdateAction', ()=>true, false);
+    const relationalModalSchema = useRelationModal('UpdateAction', (state)=>state.currentDocument.schema, false);
     const fieldToConnect = useRelationModal('UpdateAction', (state)=>state.state.fieldToConnect, false);
+    const fieldToConnectUID = useRelationModal('PublishAction', (state)=>state.state.fieldToConnectUID, false);
     const documentHistory = useRelationModal('UpdateAction', (state)=>state.state.documentHistory, false);
     const rootDocumentMeta = useRelationModal('UpdateAction', (state)=>state.rootDocumentMeta);
     const fromRelationModal = relationContext != undefined;
@@ -674,6 +691,7 @@ const UpdateAction = ({ activeTab, documentId, model, collectionType })=>{
     }, {
         skip: !parentDocumentMetaToUpdate
     });
+    const { schema } = useDoc();
     const handleUpdate = React.useCallback(async ()=>{
         setSubmitting(true);
         try {
@@ -710,22 +728,32 @@ const UpdateAction = ({ activeTab, documentId, model, collectionType })=>{
                     setErrors(formatValidationErrors(res.error));
                 }
             } else if (documentId || collectionType === SINGLE_TYPES) {
+                const { data } = handleInvisibleAttributes(transformData(document), {
+                    schema: fromRelationModal ? relationalModalSchema : schema,
+                    initialValues,
+                    components
+                });
                 const res = await update({
                     collectionType,
                     model,
                     documentId,
                     params: currentDocumentMeta.params
-                }, transformData(document));
+                }, data);
                 if ('error' in res && isBaseQueryError(res.error) && res.error.name === 'ValidationError') {
                     setErrors(formatValidationErrors(res.error));
                 } else {
                     resetForm();
                 }
             } else {
+                const { data } = handleInvisibleAttributes(transformData(document), {
+                    schema: fromRelationModal ? relationalModalSchema : schema,
+                    initialValues,
+                    components
+                });
                 const res = await create({
                     model,
                     params: currentDocumentMeta.params
-                }, transformData(document));
+                }, data);
                 if ('data' in res && collectionType !== SINGLE_TYPES) {
                     if (fromRelationModal) {
                         const createdRelation = {
@@ -734,25 +762,18 @@ const UpdateAction = ({ activeTab, documentId, model, 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) {
-                            const parentDataToUpdate = parentDocumentData.getInitialFormValues();
-                            const objectToConnect = stringToObject(fieldToConnect, {
-                                connect: [
-                                    {
-                                        id: res.data.documentId,
-                                        documentId: res.data.documentId,
-                                        locale: res.data.locale
-                                    }
-                                ]
-                            });
-                            const dataToUpdate = deepMerge(parentDataToUpdate, objectToConnect);
+                        /*
+             * 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 parentDataToUpdate = parentDocumentMetaToUpdate.collectionType === 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.documentId,
+                                    documentId: parentDocumentMetaToUpdate.collectionType !== SINGLE_TYPES ? parentDocumentMetaToUpdate.documentId : undefined,
                                     params: parentDocumentMetaToUpdate.params,
                                     data: {
                                         ...dataToUpdate
@@ -828,10 +849,16 @@ const UpdateAction = ({ activeTab, documentId, model, collectionType })=>{
         documentHistory,
         parentDocumentMetaToUpdate,
         dispatch,
+        getInitialFormValues,
         parentDocumentData,
+        fieldToConnectUID,
         updateDocumentMutation,
         formatAPIError,
-        onPreview
+        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.useEffect(()=>{