@wordpress/core-data 6.16.0 → 6.17.1

package/build-module/resolvers.js

@@ -2,26 +2,27 @@
  * External dependencies
  */
 import { camelCase } from 'change-case';
+
 /**
  * WordPress dependencies
  */
-
 import { addQueryArgs } from '@wordpress/url';
 import apiFetch from '@wordpress/api-fetch';
+
 /**
  * Internal dependencies
  */
-
 import { STORE_NAME } from './name';
 import { getOrLoadEntitiesConfig, DEFAULT_ENTITY_KEY } from './entities';
 import { forwardResolver, getNormalizedCommaSeparable } from './utils';
+import { getSyncProvider } from './sync';
+
 /**
  * Requests authors from the REST API.
  *
  * @param {Object|undefined} query Optional object of query parameters to
  *                                 include with request.
  */
-
 export const getAuthors = query => async ({
   dispatch
 }) => {
@@ -31,10 +32,10 @@ export const getAuthors = query => async ({
   });
   dispatch.receiveUserQuery(path, users);
 };
+
 /**
  * Requests the current user from the REST API.
  */
-
 export const getCurrentUser = () => async ({
   dispatch
 }) => {
@@ -43,6 +44,7 @@ export const getCurrentUser = () => async ({
   });
   dispatch.receiveCurrentUser(currentUser);
 };
+
 /**
  * Requests an entity's record from the REST API.
  *
@@ -53,74 +55,98 @@ export const getCurrentUser = () => async ({
  *                                 include with request. If requesting specific
  *                                 fields, fields must always include the ID.
  */
-
 export const getEntityRecord = (kind, name, key = '', query) => async ({
   select,
   dispatch
 }) => {
   const configs = await dispatch(getOrLoadEntitiesConfig(kind));
   const entityConfig = configs.find(config => config.name === name && config.kind === kind);
-
   if (!entityConfig || entityConfig?.__experimentalNoFetch) {
     return;
   }
-
   const lock = await dispatch.__unstableAcquireStoreLock(STORE_NAME, ['entities', 'records', kind, name, key], {
     exclusive: false
   });
-
   try {
-    if (query !== undefined && query._fields) {
-      // If requesting specific fields, items and query association to said
-      // records are stored by ID reference. Thus, fields must always include
-      // the ID.
-      query = { ...query,
-        _fields: [...new Set([...(getNormalizedCommaSeparable(query._fields) || []), entityConfig.key || DEFAULT_ENTITY_KEY])].join()
-      };
-    } // Disable reason: While true that an early return could leave `path`
-    // unused, it's important that path is derived using the query prior to
-    // additional query modifications in the condition below, since those
-    // modifications are relevant to how the data is tracked in state, and not
-    // for how the request is made to the REST API.
-    // eslint-disable-next-line @wordpress/no-unused-vars-before-return
-
-
-    const path = addQueryArgs(entityConfig.baseURL + (key ? '/' + key : ''), { ...entityConfig.baseURLParams,
-      ...query
-    });
+    // Entity supports configs,
+    // use the sync algorithm instead of the old fetch behavior.
+    if (window.__experimentalEnableSync && entityConfig.syncConfig && !query) {
+      const objectId = entityConfig.getSyncObjectId(key);
+
+      // Loads the persisted document.
+      await getSyncProvider().bootstrap(entityConfig.syncObjectType, objectId, record => {
+        dispatch.receiveEntityRecords(kind, name, record, query);
+      });
 
-    if (query !== undefined) {
-      query = { ...query,
-        include: [key]
-      }; // The resolution cache won't consider query as reusable based on the
-      // fields, so it's tested here, prior to initiating the REST request,
-      // and without causing `getEntityRecords` resolution to occur.
+      // Boostraps the edited document as well (and load from peers).
+      await getSyncProvider().bootstrap(entityConfig.syncObjectType + '--edit', objectId, record => {
+        dispatch({
+          type: 'EDIT_ENTITY_RECORD',
+          kind,
+          name,
+          recordId: key,
+          edits: record,
+          meta: {
+            undo: undefined
+          }
+        });
+      });
+    } else {
+      if (query !== undefined && query._fields) {
+        // If requesting specific fields, items and query association to said
+        // records are stored by ID reference. Thus, fields must always include
+        // the ID.
+        query = {
+          ...query,
+          _fields: [...new Set([...(getNormalizedCommaSeparable(query._fields) || []), entityConfig.key || DEFAULT_ENTITY_KEY])].join()
+        };
+      }
 
-      const hasRecords = select.hasEntityRecords(kind, name, query);
+      // Disable reason: While true that an early return could leave `path`
+      // unused, it's important that path is derived using the query prior to
+      // additional query modifications in the condition below, since those
+      // modifications are relevant to how the data is tracked in state, and not
+      // for how the request is made to the REST API.
 
-      if (hasRecords) {
-        return;
+      // eslint-disable-next-line @wordpress/no-unused-vars-before-return
+      const path = addQueryArgs(entityConfig.baseURL + (key ? '/' + key : ''), {
+        ...entityConfig.baseURLParams,
+        ...query
+      });
+      if (query !== undefined) {
+        query = {
+          ...query,
+          include: [key]
+        };
+
+        // The resolution cache won't consider query as reusable based on the
+        // fields, so it's tested here, prior to initiating the REST request,
+        // and without causing `getEntityRecords` resolution to occur.
+        const hasRecords = select.hasEntityRecords(kind, name, query);
+        if (hasRecords) {
+          return;
+        }
       }
+      const record = await apiFetch({
+        path
+      });
+      dispatch.receiveEntityRecords(kind, name, record, query);
     }
-
-    const record = await apiFetch({
-      path
-    });
-    dispatch.receiveEntityRecords(kind, name, record, query);
   } finally {
     dispatch.__unstableReleaseStoreLock(lock);
   }
 };
+
 /**
  * Requests an entity's record from the REST API.
  */
-
 export const getRawEntityRecord = forwardResolver('getEntityRecord');
+
 /**
  * Requests an entity's record from the REST API.
  */
-
 export const getEditedEntityRecord = forwardResolver('getEntityRecord');
+
 /**
  * Requests the entity's records from the REST API.
  *
@@ -129,40 +155,37 @@ export const getEditedEntityRecord = forwardResolver('getEntityRecord');
  * @param {Object?} query Query Object. If requesting specific fields, fields
  *                        must always include the ID.
  */
-
 export const getEntityRecords = (kind, name, query = {}) => async ({
   dispatch
 }) => {
   const configs = await dispatch(getOrLoadEntitiesConfig(kind));
   const entityConfig = configs.find(config => config.name === name && config.kind === kind);
-
   if (!entityConfig || entityConfig?.__experimentalNoFetch) {
     return;
   }
-
   const lock = await dispatch.__unstableAcquireStoreLock(STORE_NAME, ['entities', 'records', kind, name], {
     exclusive: false
   });
-
   try {
     if (query._fields) {
       // If requesting specific fields, items and query association to said
       // records are stored by ID reference. Thus, fields must always include
       // the ID.
-      query = { ...query,
+      query = {
+        ...query,
         _fields: [...new Set([...(getNormalizedCommaSeparable(query._fields) || []), entityConfig.key || DEFAULT_ENTITY_KEY])].join()
       };
     }
-
-    const path = addQueryArgs(entityConfig.baseURL, { ...entityConfig.baseURLParams,
+    const path = addQueryArgs(entityConfig.baseURL, {
+      ...entityConfig.baseURLParams,
       ...query
     });
     let records = Object.values(await apiFetch({
       path
-    })); // If we request fields but the result doesn't contain the fields,
+    }));
+    // If we request fields but the result doesn't contain the fields,
     // explicitly set these fields as "undefined"
     // that way we consider the query "fullfilled".
-
     if (query._fields) {
       records = records.map(record => {
         query._fields.split(',').forEach(field => {
@@ -170,15 +193,14 @@ export const getEntityRecords = (kind, name, query = {}) => async ({
             record[field] = undefined;
           }
         });
-
         return record;
       });
     }
+    dispatch.receiveEntityRecords(kind, name, records, query);
 
-    dispatch.receiveEntityRecords(kind, name, records, query); // When requesting all fields, the list of results can be used to
+    // When requesting all fields, the list of results can be used to
     // resolve the `getEntityRecord` selector in addition to `getEntityRecords`.
     // See https://github.com/WordPress/gutenberg/pull/26575
-
     if (!query?._fields && !query.context) {
       const key = entityConfig.key || DEFAULT_ENTITY_KEY;
       const resolutionsArgs = records.filter(record => record[key]).map(record => [kind, name, record[key]]);
@@ -197,15 +219,13 @@ export const getEntityRecords = (kind, name, query = {}) => async ({
     dispatch.__unstableReleaseStoreLock(lock);
   }
 };
-
 getEntityRecords.shouldInvalidate = (action, kind, name) => {
   return (action.type === 'RECEIVE_ITEMS' || action.type === 'REMOVE_ITEMS') && action.invalidateCache && kind === action.kind && name === action.name;
 };
+
 /**
  * Requests the current theme.
  */
-
-
 export const getCurrentTheme = () => async ({
   dispatch,
   resolveSelect
@@ -215,17 +235,17 @@ export const getCurrentTheme = () => async ({
   });
   dispatch.receiveCurrentTheme(activeThemes[0]);
 };
+
 /**
  * Requests theme supports data from the index.
  */
-
 export const getThemeSupports = forwardResolver('getCurrentTheme');
+
 /**
  * Requests a preview from the from the Embed API.
  *
  * @param {string} url URL to get the preview for.
  */
-
 export const getEmbedPreview = url => async ({
   dispatch
 }) => {
@@ -241,6 +261,7 @@ export const getEmbedPreview = url => async ({
     dispatch.receiveEmbedPreview(url, false);
   }
 };
+
 /**
  * Checks whether the current user can perform the given action on the given
  * REST resource.
@@ -250,7 +271,6 @@ export const getEmbedPreview = url => async ({
  * @param {string}  resource        REST resource to check, e.g. 'media' or 'posts'.
  * @param {?string} id              ID of the rest resource to check.
  */
-
 export const canUser = (requestedAction, resource, id) => async ({
   dispatch,
   registry
@@ -260,26 +280,21 @@ export const canUser = (requestedAction, resource, id) => async ({
   } = registry.select(STORE_NAME);
   const resourcePath = id ? `${resource}/${id}` : resource;
   const retrievedActions = ['create', 'read', 'update', 'delete'];
-
   if (!retrievedActions.includes(requestedAction)) {
     throw new Error(`'${requestedAction}' is not a valid action.`);
-  } // Prevent resolving the same resource twice.
-
+  }
 
+  // Prevent resolving the same resource twice.
   for (const relatedAction of retrievedActions) {
     if (relatedAction === requestedAction) {
       continue;
     }
-
     const isAlreadyResolving = hasStartedResolution('canUser', [relatedAction, resource, id]);
-
     if (isAlreadyResolving) {
       return;
     }
   }
-
   let response;
-
   try {
     response = await apiFetch({
       path: `/wp/v2/${resourcePath}`,
@@ -290,11 +305,11 @@ export const canUser = (requestedAction, resource, id) => async ({
     // Do nothing if our OPTIONS request comes back with an API error (4xx or
     // 5xx). The previously determined isAllowed value will remain in the store.
     return;
-  } // Optional chaining operator is used here because the API requests don't
+  }
+
+  // Optional chaining operator is used here because the API requests don't
   // return the expected result in the native version. Instead, API requests
   // only return the result, without including response properties like the headers.
-
-
   const allowHeader = response.headers?.get('allow');
   const allowedMethods = allowHeader?.allow || allowHeader || '';
   const permissions = {};
@@ -304,15 +319,14 @@ export const canUser = (requestedAction, resource, id) => async ({
     update: 'PUT',
     delete: 'DELETE'
   };
-
   for (const [actionName, methodName] of Object.entries(methods)) {
     permissions[actionName] = allowedMethods.includes(methodName);
   }
-
   for (const action of retrievedActions) {
     dispatch.receiveUserPermission(`${action}/${resourcePath}`, permissions[action]);
   }
 };
+
 /**
  * Checks whether the current user can perform the given action on the given
  * REST resource.
@@ -321,27 +335,24 @@ export const canUser = (requestedAction, resource, id) => async ({
  * @param {string} name     Entity name.
  * @param {string} recordId Record's id.
  */
-
 export const canUserEditEntityRecord = (kind, name, recordId) => async ({
   dispatch
 }) => {
   const configs = await dispatch(getOrLoadEntitiesConfig(kind));
   const entityConfig = configs.find(config => config.name === name && config.kind === kind);
-
   if (!entityConfig) {
     return;
   }
-
   const resource = entityConfig.__unstable_rest_base;
   await dispatch(canUser('update', resource, recordId));
 };
+
 /**
  * Request autosave data from the REST API.
  *
  * @param {string} postType The type of the parent post.
  * @param {number} postId   The id of the parent post.
  */
-
 export const getAutosaves = (postType, postId) => async ({
   dispatch,
   resolveSelect
@@ -353,11 +364,11 @@ export const getAutosaves = (postType, postId) => async ({
   const autosaves = await apiFetch({
     path: `/${restNamespace}/${restBase}/${postId}/autosaves?context=edit`
   });
-
   if (autosaves && autosaves.length) {
     dispatch.receiveAutosaves(postId, autosaves);
   }
 };
+
 /**
  * Request autosave data from the REST API.
  *
@@ -367,24 +378,22 @@ export const getAutosaves = (postType, postId) => async ({
  * @param {string} postType The type of the parent post.
  * @param {number} postId   The id of the parent post.
  */
-
 export const getAutosave = (postType, postId) => async ({
   resolveSelect
 }) => {
   await resolveSelect.getAutosaves(postType, postId);
 };
+
 /**
  * Retrieve the frontend template used for a given link.
  *
  * @param {string} link Link.
  */
-
 export const __experimentalGetTemplateForLink = link => async ({
   dispatch,
   resolveSelect
 }) => {
   let template;
-
   try {
     // This is NOT calling a REST endpoint but rather ends up with a response from
     // an Ajax function which has a different shape from a WP_REST_Response.
@@ -395,26 +404,22 @@ export const __experimentalGetTemplateForLink = link => async ({
     }).then(({
       data
     }) => data);
-  } catch (e) {// For non-FSE themes, it is possible that this request returns an error.
+  } catch (e) {
+    // For non-FSE themes, it is possible that this request returns an error.
   }
-
   if (!template) {
     return;
   }
-
   const record = await resolveSelect.getEntityRecord('postType', 'wp_template', template.id);
-
   if (record) {
     dispatch.receiveEntityRecords('postType', 'wp_template', [record], {
       'find-template': link
     });
   }
 };
-
 __experimentalGetTemplateForLink.shouldInvalidate = action => {
   return (action.type === 'RECEIVE_ITEMS' || action.type === 'REMOVE_ITEMS') && action.invalidateCache && action.kind === 'postType' && action.name === 'wp_template';
 };
-
 export const __experimentalGetCurrentGlobalStylesId = () => async ({
   dispatch,
   resolveSelect
@@ -423,12 +428,10 @@ export const __experimentalGetCurrentGlobalStylesId = () => async ({
     status: 'active'
   });
   const globalStylesURL = activeThemes?.[0]?._links?.['wp:user-global-styles']?.[0]?.href;
-
   if (globalStylesURL) {
     const globalStylesObject = await apiFetch({
       url: globalStylesURL
     });
-
     dispatch.__experimentalReceiveCurrentGlobalStylesId(globalStylesObject.id);
   }
 };
@@ -440,7 +443,6 @@ export const __experimentalGetCurrentThemeBaseGlobalStyles = () => async ({
   const themeGlobalStyles = await apiFetch({
     path: `/wp/v2/global-styles/themes/${currentTheme.stylesheet}`
   });
-
   dispatch.__experimentalReceiveThemeBaseGlobalStyles(currentTheme.stylesheet, themeGlobalStyles);
 };
 export const __experimentalGetCurrentThemeGlobalStylesVariations = () => async ({
@@ -451,13 +453,12 @@ export const __experimentalGetCurrentThemeGlobalStylesVariations = () => async (
   const variations = await apiFetch({
     path: `/wp/v2/global-styles/themes/${currentTheme.stylesheet}/variations`
   });
-
   dispatch.__experimentalReceiveThemeGlobalStyleVariations(currentTheme.stylesheet, variations);
 };
+
 /**
  * Fetches and returns the revisions of the current global styles theme.
  */
-
 export const getCurrentThemeGlobalStylesRevisions = () => async ({
   resolveSelect,
   dispatch
@@ -465,7 +466,6 @@ export const getCurrentThemeGlobalStylesRevisions = () => async ({
   const globalStylesId = await resolveSelect.__experimentalGetCurrentGlobalStylesId();
   const record = globalStylesId ? await resolveSelect.getEntityRecord('root', 'globalStyles', globalStylesId) : undefined;
   const revisionsURL = record?._links?.['version-history']?.[0]?.href;
-
   if (revisionsURL) {
     const resetRevisions = await apiFetch({
       url: revisionsURL
@@ -474,11 +474,9 @@ export const getCurrentThemeGlobalStylesRevisions = () => async ({
     dispatch.receiveThemeGlobalStyleRevisions(globalStylesId, revisions);
   }
 };
-
 getCurrentThemeGlobalStylesRevisions.shouldInvalidate = action => {
   return action.type === 'SAVE_ENTITY_RECORD_FINISH' && action.kind === 'root' && !action.error && action.name === 'globalStyles';
 };
-
 export const getBlockPatterns = () => async ({
   dispatch
 }) => {
@@ -513,15 +511,15 @@ export const getNavigationFallbackId = () => async ({
   });
   const record = fallback?._embedded?.self;
   dispatch.receiveNavigationFallbackId(fallback?.id);
-
   if (record) {
     // If the fallback is already in the store, don't invalidate navigation queries.
     // Otherwise, invalidate the cache for the scenario where there were no Navigation
     // posts in the state and the fallback created one.
     const existingFallbackEntityRecord = select.getEntityRecord('postType', 'wp_navigation', fallback?.id);
     const invalidateNavigationQueries = !existingFallbackEntityRecord;
-    dispatch.receiveEntityRecords('postType', 'wp_navigation', record, undefined, invalidateNavigationQueries); // Resolve to avoid further network requests.
+    dispatch.receiveEntityRecords('postType', 'wp_navigation', record, undefined, invalidateNavigationQueries);
 
+    // Resolve to avoid further network requests.
     dispatch.finishResolution('getEntityRecord', ['postType', 'wp_navigation', fallback?.id]);
   }
 };