@wordpress/core-data 4.0.1-next.253d9b6e21.0 → 4.0.3

package/build-module/actions.js

@@ -1,14 +1,13 @@
 /**
  * External dependencies
  */
-import { castArray, get, isEqual, find } from 'lodash';
+import { castArray, isEqual, find } from 'lodash';
 import { v4 as uuid } from 'uuid';
 /**
  * WordPress dependencies
  */
 
-import { controls } from '@wordpress/data';
-import { apiFetch, __unstableAwaitPromise } from '@wordpress/data-controls';
+import apiFetch from '@wordpress/api-fetch';
 import { addQueryArgs } from '@wordpress/url';
 /**
  * Internal dependencies
@@ -16,9 +15,7 @@ import { addQueryArgs } from '@wordpress/url';
 
 import { receiveItems, removeItems, receiveQueriedItems } from './queried-data';
 import { getKindEntities, DEFAULT_ENTITY_KEY } from './entities';
-import { __unstableAcquireStoreLock, __unstableReleaseStoreLock } from './locks';
 import { createBatch } from './batch';
-import { getDispatch } from './controls';
 import { STORE_NAME } from './name';
 /**
  * Returns an action object used in signalling that authors have been received.
@@ -155,13 +152,15 @@ export function receiveEmbedPreview(url, preview) {
  * @param {Object}   [options]                 Delete options.
  * @param {Function} [options.__unstableFetch] Internal use only. Function to
  *                                             call instead of `apiFetch()`.
- *                                             Must return a control descriptor.
+ *                                             Must return a promise.
  */
 
-export function* deleteEntityRecord(kind, name, recordId, query, {
-  __unstableFetch = null
-} = {}) {
-  const entities = yield getKindEntities(kind);
+export const deleteEntityRecord = (kind, name, recordId, query, {
+  __unstableFetch = apiFetch
+} = {}) => async ({
+  dispatch
+}) => {
+  const entities = await dispatch(getKindEntities(kind));
   const entity = find(entities, {
     kind,
     name
@@ -169,21 +168,21 @@ export function* deleteEntityRecord(kind, name, recordId, query, {
   let error;
   let deletedRecord = false;
 
-  if (!entity) {
+  if (!entity || entity !== null && entity !== void 0 && entity.__experimentalNoFetch) {
     return;
   }
 
-  const lock = yield* __unstableAcquireStoreLock(STORE_NAME, ['entities', 'data', kind, name, recordId], {
+  const lock = await dispatch.__unstableAcquireStoreLock(STORE_NAME, ['entities', 'data', kind, name, recordId], {
     exclusive: true
   });
 
   try {
-    yield {
+    dispatch({
       type: 'DELETE_ENTITY_RECORD_START',
       kind,
       name,
       recordId
-    };
+    });
 
     try {
       let path = `${entity.baseURL}/${recordId}`;
@@ -192,34 +191,27 @@ export function* deleteEntityRecord(kind, name, recordId, query, {
         path = addQueryArgs(path, query);
       }
 
-      const options = {
+      deletedRecord = await __unstableFetch({
         path,
         method: 'DELETE'
-      };
-
-      if (__unstableFetch) {
-        deletedRecord = yield __unstableAwaitPromise(__unstableFetch(options));
-      } else {
-        deletedRecord = yield apiFetch(options);
-      }
-
-      yield removeItems(kind, name, recordId, true);
+      });
+      await dispatch(removeItems(kind, name, recordId, true));
     } catch (_error) {
       error = _error;
     }
 
-    yield {
+    dispatch({
       type: 'DELETE_ENTITY_RECORD_FINISH',
       kind,
       name,
       recordId,
       error
-    };
+    });
     return deletedRecord;
   } finally {
-    yield* __unstableReleaseStoreLock(lock);
+    dispatch.__unstableReleaseStoreLock(lock);
   }
-}
+};
 /**
  * Returns an action object that triggers an
  * edit to an entity record.
@@ -234,8 +226,11 @@ export function* deleteEntityRecord(kind, name, recordId, query, {
  * @return {Object} Action object.
  */
 
-export function* editEntityRecord(kind, name, recordId, edits, options = {}) {
-  const entity = yield controls.select(STORE_NAME, 'getEntity', kind, name);
+export const editEntityRecord = (kind, name, recordId, edits, options = {}) => ({
+  select,
+  dispatch
+}) => {
+  const entity = select.getEntity(kind, name);
 
   if (!entity) {
     throw new Error(`The entity being edited (${kind}, ${name}) does not have a loaded config.`);
@@ -245,8 +240,8 @@ export function* editEntityRecord(kind, name, recordId, edits, options = {}) {
     transientEdits = {},
     mergedEdits = {}
   } = entity;
-  const record = yield controls.select(STORE_NAME, 'getRawEntityRecord', kind, name, recordId);
-  const editedRecord = yield controls.select(STORE_NAME, 'getEditedEntityRecord', kind, name, recordId);
+  const record = select.getRawEntityRecord(kind, name, recordId);
+  const editedRecord = select.getEditedEntityRecord(kind, name, recordId);
   const edit = {
     kind,
     name,
@@ -264,7 +259,7 @@ export function* editEntityRecord(kind, name, recordId, edits, options = {}) {
     }, {}),
     transientEdits
   };
-  return {
+  dispatch({
     type: 'EDIT_ENTITY_RECORD',
     ...edit,
     meta: {
@@ -276,48 +271,58 @@ export function* editEntityRecord(kind, name, recordId, edits, options = {}) {
         }, {})
       }
     }
-  };
-}
+  });
+};
 /**
  * Action triggered to undo the last edit to
  * an entity record, if any.
+ *
+ * @return {undefined}
  */
 
-export function* undo() {
-  const undoEdit = yield controls.select(STORE_NAME, 'getUndoEdit');
+export const undo = () => ({
+  select,
+  dispatch
+}) => {
+  const undoEdit = select.getUndoEdit();
 
   if (!undoEdit) {
     return;
   }
 
-  yield {
+  dispatch({
     type: 'EDIT_ENTITY_RECORD',
     ...undoEdit,
     meta: {
       isUndo: true
     }
-  };
-}
+  });
+};
 /**
  * Action triggered to redo the last undoed
  * edit to an entity record, if any.
+ *
+ * @return {undefined}
  */
 
-export function* redo() {
-  const redoEdit = yield controls.select(STORE_NAME, 'getRedoEdit');
+export const redo = () => ({
+  select,
+  dispatch
+}) => {
+  const redoEdit = select.getRedoEdit();
 
   if (!redoEdit) {
     return;
   }
 
-  yield {
+  dispatch({
     type: 'EDIT_ENTITY_RECORD',
     ...redoEdit,
     meta: {
       isRedo: true
     }
-  };
-}
+  });
+};
 /**
  * Forces the creation of a new undo level.
  *
@@ -339,27 +344,30 @@ export function __unstableCreateUndoLevel() {
  * @param {boolean}  [options.isAutosave=false] Whether this is an autosave.
  * @param {Function} [options.__unstableFetch]  Internal use only. Function to
  *                                              call instead of `apiFetch()`.
- *                                              Must return a control
- *                                              descriptor.
+ *                                              Must return a promise.
  */
 
-export function* saveEntityRecord(kind, name, record, {
+export const saveEntityRecord = (kind, name, record, {
   isAutosave = false,
-  __unstableFetch = null
-} = {}) {
-  const entities = yield getKindEntities(kind);
+  __unstableFetch = apiFetch
+} = {}) => async ({
+  select,
+  resolveSelect,
+  dispatch
+}) => {
+  const entities = await dispatch(getKindEntities(kind));
   const entity = find(entities, {
     kind,
     name
   });
 
-  if (!entity) {
+  if (!entity || entity !== null && entity !== void 0 && entity.__experimentalNoFetch) {
     return;
   }
 
   const entityIdKey = entity.key || DEFAULT_ENTITY_KEY;
   const recordId = record[entityIdKey];
-  const lock = yield* __unstableAcquireStoreLock(STORE_NAME, ['entities', 'data', kind, name, recordId || uuid()], {
+  const lock = await dispatch.__unstableAcquireStoreLock(STORE_NAME, ['entities', 'data', kind, name, recordId || uuid()], {
     exclusive: true
   });
 
@@ -368,8 +376,8 @@ export function* saveEntityRecord(kind, name, record, {
     // (Function edits that should be evaluated on save to avoid expensive computations on every edit.)
     for (const [key, value] of Object.entries(record)) {
       if (typeof value === 'function') {
-        const evaluatedValue = value(yield controls.select(STORE_NAME, 'getEditedEntityRecord', kind, name, recordId));
-        yield editEntityRecord(kind, name, recordId, {
+        const evaluatedValue = value(select.getEditedEntityRecord(kind, name, recordId));
+        dispatch.editEntityRecord(kind, name, recordId, {
           [key]: evaluatedValue
         }, {
           undoIgnore: true
@@ -378,28 +386,28 @@ export function* saveEntityRecord(kind, name, record, {
       }
     }
 
-    yield {
+    dispatch({
       type: 'SAVE_ENTITY_RECORD_START',
       kind,
       name,
       recordId,
       isAutosave
-    };
+    });
     let updatedRecord;
     let error;
 
     try {
       const path = `${entity.baseURL}${recordId ? '/' + recordId : ''}`;
-      const persistedRecord = yield controls.select(STORE_NAME, 'getRawEntityRecord', kind, name, recordId);
+      const persistedRecord = select.getRawEntityRecord(kind, name, recordId);
 
       if (isAutosave) {
         // Most of this autosave logic is very specific to posts.
         // This is fine for now as it is the only supported autosave,
         // but ideally this should all be handled in the back end,
         // so the client just sends and receives objects.
-        const currentUser = yield controls.select(STORE_NAME, 'getCurrentUser');
+        const currentUser = select.getCurrentUser();
         const currentUserId = currentUser ? currentUser.id : undefined;
-        const autosavePost = yield controls.select(STORE_NAME, 'getAutosave', persistedRecord.type, persistedRecord.id, currentUserId); // Autosaves need all expected fields to be present.
+        const autosavePost = resolveSelect.getAutosave(persistedRecord.type, persistedRecord.id, currentUserId); // Autosaves need all expected fields to be present.
         // So we fallback to the previous autosave and then
         // to the actual persisted entity if the edits don't
         // have a value.
@@ -410,29 +418,21 @@ export function* saveEntityRecord(kind, name, record, {
         };
         data = Object.keys(data).reduce((acc, key) => {
           if (['title', 'excerpt', 'content'].includes(key)) {
-            // Edits should be the "raw" attribute values.
-            acc[key] = get(data[key], 'raw', data[key]);
+            acc[key] = data[key];
           }
 
           return acc;
         }, {
           status: data.status === 'auto-draft' ? 'draft' : data.status
         });
-        const options = {
+        updatedRecord = await __unstableFetch({
           path: `${path}/autosaves`,
           method: 'POST',
           data
-        };
-
-        if (__unstableFetch) {
-          updatedRecord = yield __unstableAwaitPromise(__unstableFetch(options));
-        } else {
-          updatedRecord = yield apiFetch(options);
-        } // An autosave may be processed by the server as a regular save
+        }); // An autosave may be processed by the server as a regular save
         // when its update is requested by the author and the post had
         // draft or auto-draft status.
 
-
         if (persistedRecord.id === updatedRecord.id) {
           let newRecord = { ...persistedRecord,
             ...data,
@@ -441,22 +441,21 @@ export function* saveEntityRecord(kind, name, record, {
           newRecord = Object.keys(newRecord).reduce((acc, key) => {
             // These properties are persisted in autosaves.
             if (['title', 'excerpt', 'content'].includes(key)) {
-              // Edits should be the "raw" attribute values.
-              acc[key] = get(newRecord[key], 'raw', newRecord[key]);
+              acc[key] = newRecord[key];
             } else if (key === 'status') {
               // Status is only persisted in autosaves when going from
               // "auto-draft" to "draft".
               acc[key] = persistedRecord.status === 'auto-draft' && newRecord.status === 'draft' ? newRecord.status : persistedRecord.status;
             } else {
               // These properties are not persisted in autosaves.
-              acc[key] = get(persistedRecord[key], 'raw', persistedRecord[key]);
+              acc[key] = persistedRecord[key];
             }
 
             return acc;
           }, {});
-          yield receiveEntityRecords(kind, name, newRecord, undefined, true);
+          dispatch.receiveEntityRecords(kind, name, newRecord, undefined, true);
         } else {
-          yield receiveAutosaves(persistedRecord.id, updatedRecord);
+          dispatch.receiveAutosaves(persistedRecord.id, updatedRecord);
         }
       } else {
         let edits = record;
@@ -467,37 +466,30 @@ export function* saveEntityRecord(kind, name, record, {
           };
         }
 
-        const options = {
+        updatedRecord = await __unstableFetch({
           path,
           method: recordId ? 'PUT' : 'POST',
           data: edits
-        };
-
-        if (__unstableFetch) {
-          updatedRecord = yield __unstableAwaitPromise(__unstableFetch(options));
-        } else {
-          updatedRecord = yield apiFetch(options);
-        }
-
-        yield receiveEntityRecords(kind, name, updatedRecord, undefined, true, edits);
+        });
+        dispatch.receiveEntityRecords(kind, name, updatedRecord, undefined, true, edits);
       }
     } catch (_error) {
       error = _error;
     }
 
-    yield {
+    dispatch({
       type: 'SAVE_ENTITY_RECORD_FINISH',
       kind,
       name,
       recordId,
       error,
       isAutosave
-    };
+    });
     return updatedRecord;
   } finally {
-    yield* __unstableReleaseStoreLock(lock);
+    dispatch.__unstableReleaseStoreLock(lock);
   }
-}
+};
 /**
  * Runs multiple core-data actions at the same time using one API request.
  *
@@ -521,33 +513,34 @@ export function* saveEntityRecord(kind, name, record, {
  *                   values of each function given in `requests`.
  */
 
-export function* __experimentalBatch(requests) {
+export const __experimentalBatch = requests => async ({
+  dispatch
+}) => {
   const batch = createBatch();
-  const dispatch = yield getDispatch();
   const api = {
     saveEntityRecord(kind, name, record, options) {
-      return batch.add(add => dispatch(STORE_NAME).saveEntityRecord(kind, name, record, { ...options,
+      return batch.add(add => dispatch.saveEntityRecord(kind, name, record, { ...options,
         __unstableFetch: add
       }));
     },
 
     saveEditedEntityRecord(kind, name, recordId, options) {
-      return batch.add(add => dispatch(STORE_NAME).saveEditedEntityRecord(kind, name, recordId, { ...options,
+      return batch.add(add => dispatch.saveEditedEntityRecord(kind, name, recordId, { ...options,
         __unstableFetch: add
       }));
     },
 
     deleteEntityRecord(kind, name, recordId, query, options) {
-      return batch.add(add => dispatch(STORE_NAME).deleteEntityRecord(kind, name, recordId, query, { ...options,
+      return batch.add(add => dispatch.deleteEntityRecord(kind, name, recordId, query, { ...options,
         __unstableFetch: add
       }));
     }
 
   };
   const resultPromises = requests.map(request => request(api));
-  const [, ...results] = yield __unstableAwaitPromise(Promise.all([batch.run(), ...resultPromises]));
+  const [, ...results] = await Promise.all([batch.run(), ...resultPromises]);
   return results;
-}
+};
 /**
  * Action triggered to save an entity record's edits.
  *
@@ -557,18 +550,21 @@ export function* __experimentalBatch(requests) {
  * @param {Object} options  Saving options.
  */
 
-export function* saveEditedEntityRecord(kind, name, recordId, options) {
-  if (!(yield controls.select(STORE_NAME, 'hasEditsForEntityRecord', kind, name, recordId))) {
+export const saveEditedEntityRecord = (kind, name, recordId, options) => async ({
+  select,
+  dispatch
+}) => {
+  if (!select.hasEditsForEntityRecord(kind, name, recordId)) {
     return;
   }
 
-  const edits = yield controls.select(STORE_NAME, 'getEntityRecordNonTransientEdits', kind, name, recordId);
+  const edits = select.getEntityRecordNonTransientEdits(kind, name, recordId);
   const record = {
     id: recordId,
     ...edits
   };
-  return yield* saveEntityRecord(kind, name, record, options);
-}
+  return await dispatch.saveEntityRecord(kind, name, record, options);
+};
 /**
  * Action triggered to save only specified properties for the entity.
  *
@@ -579,12 +575,15 @@ export function* saveEditedEntityRecord(kind, name, recordId, options) {
  * @param {Object} options     Saving options.
  */
 
-export function* __experimentalSaveSpecifiedEntityEdits(kind, name, recordId, itemsToSave, options) {
-  if (!(yield controls.select(STORE_NAME, 'hasEditsForEntityRecord', kind, name, recordId))) {
+export const __experimentalSaveSpecifiedEntityEdits = (kind, name, recordId, itemsToSave, options) => async ({
+  select,
+  dispatch
+}) => {
+  if (!select.hasEditsForEntityRecord(kind, name, recordId)) {
     return;
   }
 
-  const edits = yield controls.select(STORE_NAME, 'getEntityRecordNonTransientEdits', kind, name, recordId);
+  const edits = select.getEntityRecordNonTransientEdits(kind, name, recordId);
   const editsToSave = {};
 
   for (const edit in edits) {
@@ -593,8 +592,8 @@ export function* __experimentalSaveSpecifiedEntityEdits(kind, name, recordId, it
     }
   }
 
-  return yield* saveEntityRecord(kind, name, editsToSave, options);
-}
+  return await dispatch.saveEntityRecord(kind, name, editsToSave, options);
+};
 /**
  * Returns an action object used in signalling that Upload permissions have been received.
  *