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

package/src/resolvers.js

@@ -7,33 +7,14 @@ import { find, includes, get, hasIn, compact, uniq } from 'lodash';
  * WordPress dependencies
  */
 import { addQueryArgs } from '@wordpress/url';
-import { controls } from '@wordpress/data';
-import { apiFetch } from '@wordpress/data-controls';
-/**
- * Internal dependencies
- */
-import { regularFetch } from './controls';
-import { STORE_NAME } from './name';
+import apiFetch from '@wordpress/api-fetch';
 
 /**
  * Internal dependencies
  */
-import {
-	receiveUserQuery,
-	receiveCurrentTheme,
-	receiveCurrentUser,
-	receiveEntityRecords,
-	receiveThemeSupports,
-	receiveEmbedPreview,
-	receiveUserPermission,
-	receiveAutosaves,
-} from './actions';
+import { STORE_NAME } from './name';
 import { getKindEntities, DEFAULT_ENTITY_KEY } from './entities';
 import { ifNotResolved, getNormalizedCommaSeparable } from './utils';
-import {
-	__unstableAcquireStoreLock,
-	__unstableReleaseStoreLock,
-} from './locks';
 
 /**
  * Requests authors from the REST API.
@@ -41,22 +22,22 @@ import {
  * @param {Object|undefined} query Optional object of query parameters to
  *                                 include with request.
  */
-export function* getAuthors( query ) {
+export const getAuthors = ( query ) => async ( { dispatch } ) => {
 	const path = addQueryArgs(
 		'/wp/v2/users/?who=authors&per_page=100',
 		query
 	);
-	const users = yield apiFetch( { path } );
-	yield receiveUserQuery( path, users );
-}
+	const users = await apiFetch( { path } );
+	dispatch.receiveUserQuery( path, users );
+};
 
 /**
  * Requests the current user from the REST API.
  */
-export function* getCurrentUser() {
-	const currentUser = yield apiFetch( { path: '/wp/v2/users/me' } );
-	yield receiveCurrentUser( currentUser );
-}
+export const getCurrentUser = () => async ( { dispatch } ) => {
+	const currentUser = await apiFetch( { path: '/wp/v2/users/me' } );
+	dispatch.receiveCurrentUser( currentUser );
+};
 
 /**
  * Requests an entity's record from the REST API.
@@ -67,18 +48,22 @@ export function* getCurrentUser() {
  * @param {Object|undefined} query Optional object of query parameters to
  *                                 include with request.
  */
-export function* getEntityRecord( kind, name, key = '', query ) {
-	const entities = yield getKindEntities( kind );
+export const getEntityRecord = ( kind, name, key = '', query ) => async ( {
+	select,
+	dispatch,
+} ) => {
+	const entities = await dispatch( getKindEntities( kind ) );
 	const entity = find( entities, { kind, name } );
-	if ( ! entity ) {
+	if ( ! entity || entity?.__experimentalNoFetch ) {
 		return;
 	}
 
-	const lock = yield* __unstableAcquireStoreLock(
+	const lock = await dispatch.__unstableAcquireStoreLock(
 		STORE_NAME,
 		[ 'entities', 'data', kind, name, key ],
 		{ exclusive: false }
 	);
+
 	try {
 		if ( query !== undefined && query._fields ) {
 			// If requesting specific fields, items and query association to said
@@ -111,27 +96,21 @@ export function* getEntityRecord( kind, name, key = '', query ) {
 			// 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 = yield controls.select(
-				STORE_NAME,
-				'hasEntityRecords',
-				kind,
-				name,
-				query
-			);
+			const hasRecords = select.hasEntityRecords( kind, name, query );
 			if ( hasRecords ) {
 				return;
 			}
 		}
 
-		const record = yield apiFetch( { path } );
-		yield receiveEntityRecords( kind, name, record, query );
+		const record = await apiFetch( { path } );
+		dispatch.receiveEntityRecords( kind, name, record, query );
 	} catch ( error ) {
 		// We need a way to handle and access REST API errors in state
 		// Until then, catching the error ensures the resolver is marked as resolved.
 	} finally {
-		yield* __unstableReleaseStoreLock( lock );
+		dispatch.__unstableReleaseStoreLock( lock );
 	}
-}
+};
 
 /**
  * Requests an entity's record from the REST API.
@@ -156,18 +135,21 @@ export const getEditedEntityRecord = ifNotResolved(
  * @param {string}  name  Entity name.
  * @param {Object?} query Query Object.
  */
-export function* getEntityRecords( kind, name, query = {} ) {
-	const entities = yield getKindEntities( kind );
+export const getEntityRecords = ( kind, name, query = {} ) => async ( {
+	dispatch,
+} ) => {
+	const entities = await dispatch( getKindEntities( kind ) );
 	const entity = find( entities, { kind, name } );
-	if ( ! entity ) {
+	if ( ! entity || entity?.__experimentalNoFetch ) {
 		return;
 	}
 
-	const lock = yield* __unstableAcquireStoreLock(
+	const lock = await dispatch.__unstableAcquireStoreLock(
 		STORE_NAME,
 		[ 'entities', 'data', kind, name ],
 		{ exclusive: false }
 	);
+
 	try {
 		if ( query._fields ) {
 			// If requesting specific fields, items and query association to said
@@ -187,7 +169,7 @@ export function* getEntityRecords( kind, name, query = {} ) {
 			...query,
 		} );
 
-		let records = Object.values( yield apiFetch( { path } ) );
+		let records = Object.values( await apiFetch( { path } ) );
 		// If we request fields but the result doesn't contain the fields,
 		// explicitely set these fields as "undefined"
 		// that way we consider the query "fullfilled".
@@ -203,7 +185,8 @@ export function* getEntityRecords( kind, name, query = {} ) {
 			} );
 		}
 
-		yield receiveEntityRecords( kind, name, records, query );
+		dispatch.receiveEntityRecords( kind, name, records, query );
+
 		// 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
@@ -213,21 +196,21 @@ export function* getEntityRecords( kind, name, query = {} ) {
 				.filter( ( record ) => record[ key ] )
 				.map( ( record ) => [ kind, name, record[ key ] ] );
 
-			yield {
+			dispatch( {
 				type: 'START_RESOLUTIONS',
 				selectorName: 'getEntityRecord',
 				args: resolutionsArgs,
-			};
-			yield {
+			} );
+			dispatch( {
 				type: 'FINISH_RESOLUTIONS',
 				selectorName: 'getEntityRecord',
 				args: resolutionsArgs,
-			};
+			} );
 		}
 	} finally {
-		yield* __unstableReleaseStoreLock( lock );
+		dispatch.__unstableReleaseStoreLock( lock );
 	}
-}
+};
 
 getEntityRecords.shouldInvalidate = ( action, kind, name ) => {
 	return (
@@ -241,39 +224,39 @@ getEntityRecords.shouldInvalidate = ( action, kind, name ) => {
 /**
  * Requests the current theme.
  */
-export function* getCurrentTheme() {
-	const activeThemes = yield apiFetch( {
+export const getCurrentTheme = () => async ( { dispatch } ) => {
+	const activeThemes = await apiFetch( {
 		path: '/wp/v2/themes?status=active',
 	} );
-	yield receiveCurrentTheme( activeThemes[ 0 ] );
-}
+	dispatch.receiveCurrentTheme( activeThemes[ 0 ] );
+};
 
 /**
  * Requests theme supports data from the index.
  */
-export function* getThemeSupports() {
-	const activeThemes = yield apiFetch( {
+export const getThemeSupports = () => async ( { dispatch } ) => {
+	const activeThemes = await apiFetch( {
 		path: '/wp/v2/themes?status=active',
 	} );
-	yield receiveThemeSupports( activeThemes[ 0 ].theme_supports );
-}
+	dispatch.receiveThemeSupports( activeThemes[ 0 ].theme_supports );
+};
 
 /**
  * Requests a preview from the from the Embed API.
  *
  * @param {string} url URL to get the preview for.
  */
-export function* getEmbedPreview( url ) {
+export const getEmbedPreview = ( url ) => async ( { dispatch } ) => {
 	try {
-		const embedProxyResponse = yield apiFetch( {
+		const embedProxyResponse = await apiFetch( {
 			path: addQueryArgs( '/oembed/1.0/proxy', { url } ),
 		} );
-		yield receiveEmbedPreview( url, embedProxyResponse );
+		dispatch.receiveEmbedPreview( url, embedProxyResponse );
 	} catch ( error ) {
 		// Embed API 404s if the URL cannot be embedded, so we have to catch the error from the apiRequest here.
-		yield receiveEmbedPreview( url, false );
+		dispatch.receiveEmbedPreview( url, false );
 	}
-}
+};
 
 /**
  * Checks whether the current user can perform the given action on the given
@@ -284,7 +267,7 @@ export function* getEmbedPreview( url ) {
  * @param {string}  resource REST resource to check, e.g. 'media' or 'posts'.
  * @param {?string} id       ID of the rest resource to check.
  */
-export function* canUser( action, resource, id ) {
+export const canUser = ( action, resource, id ) => async ( { dispatch } ) => {
 	const methods = {
 		create: 'POST',
 		read: 'GET',
@@ -301,7 +284,7 @@ export function* canUser( action, resource, id ) {
 
 	let response;
 	try {
-		response = yield apiFetch( {
+		response = await apiFetch( {
 			path,
 			// Ideally this would always be an OPTIONS request, but unfortunately there's
 			// a bug in the REST API which causes the Allow header to not be sent on
@@ -329,8 +312,8 @@ export function* canUser( action, resource, id ) {
 
 	const key = compact( [ action, resource, id ] ).join( '/' );
 	const isAllowed = includes( allowHeader, method );
-	yield receiveUserPermission( key, isAllowed );
-}
+	dispatch.receiveUserPermission( key, isAllowed );
+};
 
 /**
  * Checks whether the current user can perform the given action on the given
@@ -340,16 +323,18 @@ export function* canUser( action, resource, id ) {
  * @param {string} name     Entity name.
  * @param {string} recordId Record's id.
  */
-export function* canUserEditEntityRecord( kind, name, recordId ) {
-	const entities = yield getKindEntities( kind );
+export const canUserEditEntityRecord = ( kind, name, recordId ) => async ( {
+	dispatch,
+} ) => {
+	const entities = await dispatch( getKindEntities( kind ) );
 	const entity = find( entities, { kind, name } );
 	if ( ! entity ) {
 		return;
 	}
 
 	const resource = entity.__unstable_rest_base;
-	yield canUser( 'update', resource, recordId );
-}
+	await dispatch( canUser( 'update', resource, recordId ) );
+};
 
 /**
  * Request autosave data from the REST API.
@@ -357,20 +342,19 @@ export function* canUserEditEntityRecord( kind, name, recordId ) {
  * @param {string} postType The type of the parent post.
  * @param {number} postId   The id of the parent post.
  */
-export function* getAutosaves( postType, postId ) {
-	const { rest_base: restBase } = yield controls.resolveSelect(
-		STORE_NAME,
-		'getPostType',
-		postType
-	);
-	const autosaves = yield apiFetch( {
+export const getAutosaves = ( postType, postId ) => async ( {
+	dispatch,
+	resolveSelect,
+} ) => {
+	const { rest_base: restBase } = await resolveSelect.getPostType( postType );
+	const autosaves = await apiFetch( {
 		path: `/wp/v2/${ restBase }/${ postId }/autosaves?context=edit`,
 	} );
 
 	if ( autosaves && autosaves.length ) {
-		yield receiveAutosaves( postId, autosaves );
+		dispatch.receiveAutosaves( postId, autosaves );
 	}
-}
+};
 
 /**
  * Request autosave data from the REST API.
@@ -381,31 +365,30 @@ export function* getAutosaves( postType, postId ) {
  * @param {string} postType The type of the parent post.
  * @param {number} postId   The id of the parent post.
  */
-export function* getAutosave( postType, postId ) {
-	yield controls.resolveSelect(
-		STORE_NAME,
-		'getAutosaves',
-		postType,
-		postId
-	);
-}
+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 function* __experimentalGetTemplateForLink( link ) {
+export const __experimentalGetTemplateForLink = ( link ) => async ( {
+	dispatch,
+	resolveSelect,
+} ) => {
 	// Ideally this should be using an apiFetch call
 	// We could potentially do so by adding a "filter" to the `wp_template` end point.
 	// Also it seems the returned object is not a regular REST API post type.
 	let template;
 	try {
-		template = yield regularFetch(
-			addQueryArgs( link, {
-				'_wp-find-template': true,
-			} )
-		);
+		template = await window
+			.fetch( addQueryArgs( link, { '_wp-find-template': true } ) )
+			.then( ( res ) => res.json() )
+			.then( ( { data } ) => data );
 	} catch ( e ) {
 		// For non-FSE themes, it is possible that this request returns an error.
 	}
@@ -414,21 +397,18 @@ export function* __experimentalGetTemplateForLink( link ) {
 		return;
 	}
 
-	yield getEntityRecord( 'postType', 'wp_template', template.id );
-	const record = yield controls.select(
-		STORE_NAME,
-		'getEntityRecord',
+	const record = await resolveSelect.getEntityRecord(
 		'postType',
 		'wp_template',
 		template.id
 	);
 
 	if ( record ) {
-		yield receiveEntityRecords( 'postType', 'wp_template', [ record ], {
+		dispatch.receiveEntityRecords( 'postType', 'wp_template', [ record ], {
 			'find-template': link,
 		} );
 	}
-}
+};
 
 __experimentalGetTemplateForLink.shouldInvalidate = ( action ) => {
 	return (

package/src/selectors.js

@@ -17,7 +17,7 @@ import deprecated from '@wordpress/deprecated';
 import { STORE_NAME } from './name';
 import { getQueriedItems } from './queried-data';
 import { DEFAULT_ENTITY_KEY } from './entities';
-import { getNormalizedCommaSeparable } from './utils';
+import { getNormalizedCommaSeparable, isRawAttribute } from './utils';
 
 /**
  * Shared reference to an empty array for cases where it is important to avoid
@@ -134,40 +134,63 @@ export function getEntity( state, kind, name ) {
  *
  * @return {Object?} Record.
  */
-export function getEntityRecord( state, kind, name, key, query ) {
-	const queriedState = get( state.entities.data, [
-		kind,
-		name,
-		'queriedData',
-	] );
-	if ( ! queriedState ) {
-		return undefined;
-	}
-	const context = query?.context ?? 'default';
-
-	if ( query === undefined ) {
-		// If expecting a complete item, validate that completeness.
-		if ( ! queriedState.itemIsComplete[ context ]?.[ key ] ) {
+export const getEntityRecord = createSelector(
+	( state, kind, name, key, query ) => {
+		const queriedState = get( state.entities.data, [
+			kind,
+			name,
+			'queriedData',
+		] );
+		if ( ! queriedState ) {
 			return undefined;
 		}
+		const context = query?.context ?? 'default';
 
-		return queriedState.items[ context ][ key ];
-	}
+		if ( query === undefined ) {
+			// If expecting a complete item, validate that completeness.
+			if ( ! queriedState.itemIsComplete[ context ]?.[ key ] ) {
+				return undefined;
+			}
 
-	const item = queriedState.items[ context ]?.[ key ];
-	if ( item && query._fields ) {
-		const filteredItem = {};
-		const fields = getNormalizedCommaSeparable( query._fields );
-		for ( let f = 0; f < fields.length; f++ ) {
-			const field = fields[ f ].split( '.' );
-			const value = get( item, field );
-			set( filteredItem, field, value );
+			return queriedState.items[ context ][ key ];
 		}
-		return filteredItem;
-	}
 
-	return item;
-}
+		const item = queriedState.items[ context ]?.[ key ];
+		if ( item && query._fields ) {
+			const filteredItem = {};
+			const fields = getNormalizedCommaSeparable( query._fields );
+			for ( let f = 0; f < fields.length; f++ ) {
+				const field = fields[ f ].split( '.' );
+				const value = get( item, field );
+				set( filteredItem, field, value );
+			}
+			return filteredItem;
+		}
+
+		return item;
+	},
+	( state, kind, name, recordId, query ) => {
+		const context = query?.context ?? 'default';
+		return [
+			get( state.entities.data, [
+				kind,
+				name,
+				'queriedData',
+				'items',
+				context,
+				recordId,
+			] ),
+			get( state.entities.data, [
+				kind,
+				name,
+				'queriedData',
+				'itemIsComplete',
+				context,
+				recordId,
+			] ),
+		];
+	}
+);
 
 /**
  * Returns the Entity's record object by key. Doesn't trigger a resolver nor requests the entity from the API if the entity record isn't available in the local state.
@@ -205,19 +228,44 @@ export const getRawEntityRecord = createSelector(
 		return (
 			record &&
 			Object.keys( record ).reduce( ( accumulator, _key ) => {
-				// Because edits are the "raw" attribute values,
-				// we return those from record selectors to make rendering,
-				// comparisons, and joins with edits easier.
-				accumulator[ _key ] = get(
-					record[ _key ],
-					'raw',
-					record[ _key ]
-				);
+				if ( isRawAttribute( getEntity( state, kind, name ), _key ) ) {
+					// Because edits are the "raw" attribute values,
+					// we return those from record selectors to make rendering,
+					// comparisons, and joins with edits easier.
+					accumulator[ _key ] = get(
+						record[ _key ],
+						'raw',
+						record[ _key ]
+					);
+				} else {
+					accumulator[ _key ] = record[ _key ];
+				}
 				return accumulator;
 			}, {} )
 		);
 	},
-	( state ) => [ state.entities.data ]
+	( state, kind, name, recordId, query ) => {
+		const context = query?.context ?? 'default';
+		return [
+			state.entities.config,
+			get( state.entities.data, [
+				kind,
+				name,
+				'queriedData',
+				'items',
+				context,
+				recordId,
+			] ),
+			get( state.entities.data, [
+				kind,
+				name,
+				'queriedData',
+				'itemIsComplete',
+				context,
+				recordId,
+			] ),
+		];
+	}
 );
 
 /**
@@ -404,7 +452,10 @@ export const getEntityRecordNonTransientEdits = createSelector(
 			return acc;
 		}, {} );
 	},
-	( state ) => [ state.entities.config, state.entities.data ]
+	( state, kind, name, recordId ) => [
+		state.entities.config,
+		get( state.entities.data, [ kind, name, 'edits', recordId ] ),
+	]
 );
 
 /**
@@ -442,7 +493,29 @@ export const getEditedEntityRecord = createSelector(
 		...getRawEntityRecord( state, kind, name, recordId ),
 		...getEntityRecordEdits( state, kind, name, recordId ),
 	} ),
-	( state ) => [ state.entities.data ]
+	( state, kind, name, recordId, query ) => {
+		const context = query?.context ?? 'default';
+		return [
+			state.entities.config,
+			get( state.entities.data, [
+				kind,
+				name,
+				'queriedData',
+				'items',
+				context,
+				recordId,
+			] ),
+			get( state.entities.data, [
+				kind,
+				name,
+				'queriedData',
+				'itemIsComplete',
+				context,
+				recordId,
+			] ),
+			get( state.entities.data, [ kind, name, 'edits', recordId ] ),
+		];
+	}
 );
 
 /**