@payloadcms/ui 3.0.0-beta.126 → 3.0.0-beta.128

package/dist/providers/DocumentInfo/index.js

@@ -1,21 +1,17 @@
 'use client';
 
 import { jsx as _jsx } from "react/jsx-runtime";
-import { notFound } from 'next/navigation.js';
-import { reduceFieldsToValues } from 'payload/shared';
 import * as qs from 'qs-esm';
 import React, { createContext, useCallback, useContext, useEffect, useRef, useState } from 'react';
+import { useAuth } from '../../providers/Auth/index.js';
 import { requests } from '../../utilities/api.js';
 import { formatDocTitle } from '../../utilities/formatDocTitle.js';
-import { getFormState } from '../../utilities/getFormState.js';
-import { hasSavePermission as getHasSavePermission } from '../../utilities/hasSavePermission.js';
-import { isEditing as getIsEditing } from '../../utilities/isEditing.js';
-import { useAuth } from '../Auth/index.js';
 import { useConfig } from '../Config/index.js';
 import { useLocale } from '../Locale/index.js';
 import { usePreferences } from '../Preferences/index.js';
 import { useTranslation } from '../Translation/index.js';
 import { UploadEditsProvider, useUploadEdits } from '../UploadEdits/index.js';
+import { useGetDocPermissions } from './useGetDocPermissions.js';
 const Context = /*#__PURE__*/createContext({});
 export const useDocumentInfo = () => {
   return useContext(Context);
@@ -27,82 +23,78 @@ const DocumentInfo = ({
   const {
     id,
     collectionSlug,
+    currentEditor: currentEditorFromProps,
     docPermissions: docPermissionsFromProps,
     globalSlug,
+    hasPublishedDoc: hasPublishedDocFromProps,
     hasPublishPermission: hasPublishPermissionFromProps,
     hasSavePermission: hasSavePermissionFromProps,
-    initialData: initialDataFromProps,
-    initialState: initialStateFromProps,
-    onLoadError,
-    onSave: onSaveFromProps
+    initialData: data,
+    initialState,
+    isLocked: isLockedFromProps,
+    lastUpdateTime: lastUpdateTimeFromProps,
+    mostRecentVersionIsAutosaved: mostRecentVersionIsAutosavedFromProps,
+    unpublishedVersionCount: unpublishedVersionCountFromProps,
+    versionCount: versionCountFromProps
   } = props;
+  const [docPermissions, setDocPermissions] = useState(docPermissionsFromProps);
+  const [hasSavePermission, setHasSavePermission] = useState(hasSavePermissionFromProps);
+  const [hasPublishPermission, setHasPublishPermission] = useState(hasPublishPermissionFromProps);
+  const {
+    permissions
+  } = useAuth();
   const {
     config: {
       admin: {
         dateFormat
       },
-      collections,
-      globals,
       routes: {
         api
       },
       serverURL
-    }
+    },
+    getEntityConfig
   } = useConfig();
-  const collectionConfig = collections.find(c => c.slug === collectionSlug);
-  const globalConfig = globals.find(g => g.slug === globalSlug);
+  const collectionConfig = getEntityConfig({
+    collectionSlug
+  });
+  const globalConfig = getEntityConfig({
+    globalSlug
+  });
+  const abortControllerRef = useRef(new AbortController());
   const docConfig = collectionConfig || globalConfig;
-  const lockDocumentsProp = docConfig?.lockDocuments !== undefined ? docConfig?.lockDocuments : true;
-  const isLockingEnabled = lockDocumentsProp !== false;
   const {
     i18n
   } = useTranslation();
   const {
     uploadEdits
   } = useUploadEdits();
-  const [documentTitle, setDocumentTitle] = useState(() => {
-    if (!initialDataFromProps) {
-      return '';
-    }
-    return formatDocTitle({
-      collectionConfig,
-      data: {
-        ...initialDataFromProps,
-        id
-      },
-      dateFormat,
-      fallback: id?.toString(),
-      globalConfig,
-      i18n
-    });
-  });
-  const [isLoading, setIsLoading] = useState(false);
-  const [isError, setIsError] = useState(false);
-  const [data, setData] = useState(initialDataFromProps);
-  const [initialState, setInitialState] = useState(initialStateFromProps);
-  const [publishedDoc, setPublishedDoc] = useState(null);
-  const [versions, setVersions] = useState(null);
-  const [docPermissions, setDocPermissions] = useState(docPermissionsFromProps);
-  const [hasSavePermission, setHasSavePermission] = useState(hasSavePermissionFromProps);
-  const [hasPublishPermission, setHasPublishPermission] = useState(hasPublishPermissionFromProps);
-  const [documentIsLocked, setDocumentIsLocked] = useState(false);
-  const [currentEditor, setCurrentEditor] = useState(null);
-  const [lastUpdateTime, setLastUpdateTime] = useState(null);
+  const [documentTitle, setDocumentTitle] = useState(() => formatDocTitle({
+    collectionConfig,
+    data: {
+      ...data,
+      id
+    },
+    dateFormat,
+    fallback: id?.toString(),
+    globalConfig,
+    i18n
+  }));
+  const [mostRecentVersionIsAutosaved, setMostRecentVersionIsAutosaved] = useState(mostRecentVersionIsAutosavedFromProps);
+  const [versionCount, setVersionCount] = useState(versionCountFromProps);
+  const [hasPublishedDoc, setHasPublishedDoc] = useState(hasPublishedDocFromProps);
+  const [unpublishedVersionCount, setUnpublishedVersionCount] = useState(unpublishedVersionCountFromProps);
+  const [documentIsLocked, setDocumentIsLocked] = useState(isLockedFromProps);
+  const [currentEditor, setCurrentEditor] = useState(currentEditorFromProps);
+  const [lastUpdateTime, setLastUpdateTime] = useState(lastUpdateTimeFromProps);
   const isInitializing = initialState === undefined || data === undefined;
-  const [unpublishedVersions, setUnpublishedVersions] = useState(null);
   const {
     getPreference,
     setPreference
   } = usePreferences();
-  const {
-    permissions
-  } = useAuth();
   const {
     code: locale
   } = useLocale();
-  const prevLocale = useRef(locale);
-  const hasInitializedDocPermissions = useRef(false);
-  const versionsConfig = docConfig?.versions;
   const baseURL = `${serverURL}${api}`;
   let slug;
   let pluralType;
@@ -119,13 +111,6 @@ const DocumentInfo = ({
       preferencesKey = `collection-${slug}-${id}`;
     }
   }
-  const isEditing = getIsEditing({
-    id,
-    collectionSlug,
-    globalSlug
-  });
-  const operation = isEditing ? 'update' : 'create';
-  const shouldFetchVersions = Boolean(versionsConfig && docPermissions?.readVersions?.permission);
   const unlockDocument = useCallback(async (docId, slug_0) => {
     try {
       const isGlobal = slug_0 === globalSlug;
@@ -181,203 +166,19 @@ const DocumentInfo = ({
       console.error('Failed to update the document editor', error_0);
     }
   }, [serverURL, api, globalSlug]);
-  useEffect(() => {
-    if (!isLockingEnabled || !id && !globalSlug) {
-      return;
-    }
-    const fetchDocumentLockState = async () => {
-      if (id || globalSlug) {
-        try {
-          const slug_2 = collectionSlug ?? globalSlug;
-          const isGlobal_1 = slug_2 === globalSlug;
-          const query_1 = isGlobal_1 ? `where[globalSlug][equals]=${slug_2}` : `where[document.value][equals]=${id}&where[document.relationTo][equals]=${slug_2}`;
-          const request_1 = await requests.get(`${serverURL}${api}/payload-locked-documents?${query_1}`);
-          const {
-            docs: docs_1
-          } = await request_1.json();
-          if (docs_1.length > 0) {
-            const newEditor = docs_1[0].user?.value;
-            const lastUpdatedAt = new Date(docs_1[0].updatedAt).getTime();
-            if (newEditor && typeof newEditor === 'object' && typeof currentEditor === 'object' ? newEditor.id !== currentEditor?.id : newEditor !== currentEditor) {
-              setCurrentEditor(newEditor);
-              setDocumentIsLocked(true);
-              setLastUpdateTime(lastUpdatedAt);
-            }
-          } else {
-            setDocumentIsLocked(false);
-          }
-          // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        } catch (error_1) {
-          // swallow error
-        }
-      }
-    };
-    void fetchDocumentLockState();
-  }, [id, serverURL, api, collectionSlug, globalSlug, currentEditor, isLockingEnabled]);
-  const getVersions = useCallback(async () => {
-    let versionFetchURL;
-    let publishedFetchURL;
-    let unpublishedVersionJSON = null;
-    let versionJSON = null;
-    let shouldFetch = true;
-    const versionParams = {
-      depth: 0,
-      limit: 0,
-      where: {
-        and: []
-      }
-    };
-    const publishedVersionParams = {
-      depth: 0,
-      locale: locale || undefined,
-      where: {
-        and: [{
-          or: [{
-            _status: {
-              equals: 'published'
-            }
-          }, {
-            _status: {
-              exists: false
-            }
-          }]
-        }]
-      }
-    };
-    if (globalSlug) {
-      versionFetchURL = `${baseURL}/globals/${globalSlug}/versions`;
-      publishedFetchURL = `${baseURL}/globals/${globalSlug}?${qs.stringify(publishedVersionParams)}`;
-    }
-    if (collectionSlug) {
-      versionFetchURL = `${baseURL}/${collectionSlug}/versions`;
-      publishedVersionParams.where.and.push({
-        id: {
-          equals: id
-        }
-      });
-      publishedFetchURL = `${baseURL}/${collectionSlug}?${qs.stringify(publishedVersionParams)}`;
-      if (!id) {
-        shouldFetch = false;
-      }
-      versionParams.where.and.push({
-        parent: {
-          equals: id
-        }
-      });
-    }
-    if (shouldFetch) {
-      let publishedJSON;
-      if (versionsConfig?.drafts) {
-        publishedJSON = await fetch(publishedFetchURL, {
-          credentials: 'include',
-          headers: {
-            'Accept-Language': i18n.language
-          }
-        }).then(res => res.json());
-        if (collectionSlug) {
-          publishedJSON = publishedJSON?.docs?.[0];
-        }
-      }
-      if (shouldFetchVersions) {
-        versionJSON = await fetch(`${versionFetchURL}?${qs.stringify(versionParams)}`, {
-          credentials: 'include',
-          headers: {
-            'Accept-Language': i18n.language
-          }
-        }).then(res_0 => res_0.json());
-        if (publishedJSON?.updatedAt) {
-          const newerVersionParams = {
-            ...versionParams,
-            where: {
-              ...versionParams.where,
-              and: [...versionParams.where.and, {
-                'version._status': {
-                  equals: 'draft'
-                }
-              }, {
-                updatedAt: {
-                  greater_than: publishedJSON.updatedAt
-                }
-              }]
-            }
-          };
-          // Get any newer versions available
-          const newerVersionRes = await fetch(`${versionFetchURL}?${qs.stringify(newerVersionParams)}`, {
-            credentials: 'include',
-            headers: {
-              'Accept-Language': i18n.language
-            }
-          });
-          if (newerVersionRes.status === 200) {
-            unpublishedVersionJSON = await newerVersionRes.json();
-          }
-        }
-      }
-      setPublishedDoc(publishedJSON);
-      setVersions(versionJSON);
-      setUnpublishedVersions(unpublishedVersionJSON);
-    }
-  }, [i18n, globalSlug, collectionSlug, id, baseURL, locale, versionsConfig, shouldFetchVersions]);
-  const getDocPermissions = React.useCallback(async data_0 => {
-    const params = {
-      locale: locale || undefined
-    };
-    const idToUse = data_0?.id || id;
-    const newIsEditing = getIsEditing({
-      id: idToUse,
-      collectionSlug,
-      globalSlug
-    });
-    if (newIsEditing) {
-      const docAccessURL = collectionSlug ? `/${collectionSlug}/access/${idToUse}` : globalSlug ? `/globals/${globalSlug}/access` : null;
-      if (docAccessURL) {
-        const res_1 = await fetch(`${serverURL}${api}${docAccessURL}?${qs.stringify(params)}`, {
-          body: JSON.stringify({
-            ...(data_0 || {}),
-            _status: 'draft'
-          }),
-          credentials: 'include',
-          headers: {
-            'Accept-Language': i18n.language,
-            'Content-Type': 'application/json'
-          },
-          method: 'post'
-        });
-        const json = await res_1.json();
-        const publishedAccessJSON = await fetch(`${serverURL}${api}${docAccessURL}?${qs.stringify(params)}`, {
-          body: JSON.stringify({
-            ...(data_0 || {}),
-            _status: 'published'
-          }),
-          credentials: 'include',
-          headers: {
-            'Accept-Language': i18n.language,
-            'Content-Type': 'application/json'
-          },
-          method: 'POST'
-        }).then(res_2 => res_2.json());
-        setDocPermissions(json);
-        setHasSavePermission(getHasSavePermission({
-          collectionSlug,
-          docPermissions: json,
-          globalSlug,
-          isEditing: newIsEditing
-        }));
-        setHasPublishPermission(publishedAccessJSON?.update?.permission);
-      }
-    } else {
-      // when creating new documents, there is no permissions saved for this document yet
-      // use the generic entity permissions instead
-      const newDocPermissions = collectionSlug ? permissions?.collections?.[collectionSlug] : permissions?.globals?.[globalSlug];
-      setDocPermissions(newDocPermissions);
-      setHasSavePermission(getHasSavePermission({
-        collectionSlug,
-        docPermissions: newDocPermissions,
-        globalSlug,
-        isEditing: newIsEditing
-      }));
-    }
-  }, [serverURL, api, id, permissions, i18n.language, locale, collectionSlug, globalSlug]);
+  const getDocPermissions = useGetDocPermissions({
+    id: id,
+    api,
+    collectionSlug,
+    globalSlug,
+    i18n,
+    locale,
+    permissions,
+    serverURL,
+    setDocPermissions,
+    setHasPublishPermission,
+    setHasSavePermission
+  });
   const getDocPreferences = useCallback(() => {
     return getPreference(preferencesKey);
   }, [getPreference, preferencesKey]);
@@ -401,89 +202,13 @@ const DocumentInfo = ({
       }
     }
   }, [setPreference, preferencesKey, getDocPreferences]);
-  const onSave = React.useCallback(async json_0 => {
-    if (typeof onSaveFromProps === 'function') {
-      void onSaveFromProps(json_0);
-    }
-    const docPreferences = await getDocPreferences();
-    const newData = collectionSlug ? json_0.doc : json_0.result;
-    const {
-      state: newState
-    } = await getFormState({
-      apiRoute: api,
-      body: {
-        id,
-        collectionSlug,
-        data: newData,
-        docPreferences,
-        globalSlug,
-        locale,
-        operation,
-        schemaPath: collectionSlug || globalSlug
-      },
-      serverURL
-    });
-    setInitialState(newState);
-    setData(newData);
-    await getDocPermissions(newData);
-  }, [api, collectionSlug, getDocPreferences, globalSlug, id, operation, locale, onSaveFromProps, serverURL, getDocPermissions]);
-  useEffect(() => {
-    const abortController = new AbortController();
-    const localeChanged = locale !== prevLocale.current;
-    if (initialStateFromProps === undefined || initialDataFromProps === undefined || localeChanged) {
-      if (localeChanged) {
-        prevLocale.current = locale;
-      }
-      const getInitialState = async () => {
-        setIsError(false);
-        setIsLoading(true);
-        try {
-          const {
-            state: result
-          } = await getFormState({
-            apiRoute: api,
-            body: {
-              id,
-              collectionSlug,
-              globalSlug,
-              locale,
-              operation,
-              schemaPath: collectionSlug || globalSlug
-            },
-            onError: onLoadError,
-            serverURL,
-            signal: abortController.signal
-          });
-          const data_1 = reduceFieldsToValues(result, true);
-          setData(data_1);
-          if (localeChanged) {
-            void getDocPermissions(data_1);
-          }
-          setInitialState(result);
-        } catch (err) {
-          if (!abortController.signal.aborted) {
-            if (typeof onLoadError === 'function') {
-              void onLoadError();
-            }
-            setIsError(true);
-            setIsLoading(false);
-          }
-        }
-        setIsLoading(false);
-      };
-      void getInitialState();
+  const incrementVersionCount = useCallback(() => {
+    if (collectionConfig && collectionConfig.versions) {
+      setVersionCount(Math.min(versionCount + 1, collectionConfig.versions.maxPerDoc));
+    } else if (globalConfig && globalConfig.versions) {
+      setVersionCount(Math.min(versionCount + 1, globalConfig.versions.max));
     }
-    return () => {
-      try {
-        abortController.abort();
-      } catch (error_2) {
-        // swallow error
-      }
-    };
-  }, [api, operation, collectionSlug, serverURL, id, globalSlug, locale, onLoadError, initialDataFromProps, initialStateFromProps, getDocPermissions]);
-  useEffect(() => {
-    void getVersions();
-  }, [getVersions]);
+  }, [collectionConfig, globalConfig, versionCount]);
   useEffect(() => {
     setDocumentTitle(formatDocTitle({
       collectionConfig,
@@ -496,30 +221,32 @@ const DocumentInfo = ({
       globalConfig,
       i18n
     }));
-  }, [collectionConfig, data, dateFormat, i18n, id, globalConfig]);
+  }, [collectionConfig, globalConfig, data, dateFormat, i18n, id]);
+  // clean on unmount
   useEffect(() => {
-    if (data && (collectionSlug || globalSlug)) {
-      if (hasInitializedDocPermissions.current === false && (!docPermissions || hasSavePermission === undefined || hasSavePermission === null || hasPublishPermission === undefined || hasPublishPermission === null)) {
-        hasInitializedDocPermissions.current = true;
-        void getDocPermissions(data);
+    const re1 = abortControllerRef.current;
+    return () => {
+      if (re1) {
+        try {
+          re1.abort();
+        } catch (_err) {
+          // swallow error
+        }
       }
-    }
-  }, [getDocPermissions, docPermissionsFromProps, hasSavePermissionFromProps, hasPublishPermissionFromProps, setDocPermissions, collectionSlug, globalSlug, data, docPermissions, hasSavePermission, hasPublishPermission]);
+    };
+  }, []);
   const action = React.useMemo(() => {
     const docURL = `${baseURL}${pluralType === 'globals' ? `/globals` : ''}/${slug}${id ? `/${id}` : ''}`;
-    const params_0 = {
+    const params = {
       depth: 0,
       'fallback-locale': 'null',
       locale,
       uploadEdits: uploadEdits || undefined
     };
-    return `${docURL}${qs.stringify(params_0, {
+    return `${docURL}${qs.stringify(params, {
       addQueryPrefix: true
     })}`;
   }, [baseURL, locale, pluralType, id, slug, uploadEdits]);
-  if (isError) {
-    notFound();
-  }
   const value = {
     ...props,
     action,
@@ -529,26 +256,29 @@ const DocumentInfo = ({
     documentIsLocked,
     getDocPermissions,
     getDocPreferences,
-    getVersions,
+    hasPublishedDoc,
     hasPublishPermission,
     hasSavePermission,
+    incrementVersionCount,
     initialData: data,
     initialState,
     isInitializing,
-    isLoading,
     lastUpdateTime,
-    onSave,
+    mostRecentVersionIsAutosaved,
     preferencesKey,
-    publishedDoc,
     setCurrentEditor,
     setDocFieldPreferences,
     setDocumentIsLocked,
     setDocumentTitle,
+    setHasPublishedDoc,
+    setLastUpdateTime,
+    setMostRecentVersionIsAutosaved,
+    setUnpublishedVersionCount,
     title: documentTitle,
     unlockDocument,
-    unpublishedVersions,
+    unpublishedVersionCount,
     updateDocumentEditor,
-    versions
+    versionCount
   };
   return /*#__PURE__*/_jsx(Context.Provider, {
     value: value,