@wordpress/core-data 4.9.0 → 4.12.0

package/src/hooks/use-resource-permissions.ts

@@ -0,0 +1,120 @@
+/**
+ * Internal dependencies
+ */
+import { store as coreStore } from '../';
+import { Status } from './constants';
+import useQuerySelect from './use-query-select';
+
+interface GlobalResourcePermissionsResolution {
+	/** Can the current user create new resources of this type? */
+	canCreate: boolean;
+}
+interface SpecificResourcePermissionsResolution {
+	/** Can the current user update resources of this type? */
+	canUpdate: boolean;
+	/** Can the current user delete resources of this type? */
+	canDelete: boolean;
+}
+interface ResolutionDetails {
+	/** Resolution status */
+	status: Status;
+	/**
+	 * Is the data still being resolved?
+	 */
+	isResolving: boolean;
+}
+
+/**
+ * Is the data resolved by now?
+ */
+type HasResolved = boolean;
+
+type ResourcePermissionsResolution< IdType > = [
+	HasResolved,
+	ResolutionDetails &
+		GlobalResourcePermissionsResolution &
+		( IdType extends void ? SpecificResourcePermissionsResolution : {} )
+];
+
+/**
+ * Resolves resource permissions.
+ *
+ * @param  resource The resource in question, e.g. media.
+ * @param  id       ID of a specific resource entry, if needed, e.g. 10.
+ *
+ * @example
+ * ```js
+ * import { useResourcePermissions } from '@wordpress/core-data';
+ *
+ * function PagesList() {
+ *   const { canCreate, isResolving } = useResourcePermissions( 'pages' );
+ *
+ *   if ( isResolving ) {
+ *     return 'Loading ...';
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       {canCreate ? (<button>+ Create a new page</button>) : false}
+ *       // ...
+ *     </div>
+ *   );
+ * }
+ *
+ * // Rendered in the application:
+ * // <PagesList />
+ * ```
+ *
+ * In the above example, when `PagesList` is rendered into an
+ * application, the appropriate permissions and the resolution details will be retrieved from
+ * the store state using `canUser()`, or resolved if missing.
+ *
+ * @return Entity records data.
+ * @template IdType
+ */
+export default function __experimentalUseResourcePermissions< IdType = void >(
+	resource: string,
+	id?: IdType
+): ResourcePermissionsResolution< IdType > {
+	return useQuerySelect(
+		( resolve ) => {
+			const { canUser } = resolve( coreStore );
+			const create = canUser( 'create', resource );
+			if ( ! id ) {
+				return [
+					create.hasResolved,
+					{
+						status: create.status,
+						isResolving: create.isResolving,
+						canCreate: create.hasResolved && create.data,
+					},
+				];
+			}
+
+			const update = canUser( 'update', resource, id );
+			const _delete = canUser( 'delete', resource, id );
+			const isResolving =
+				create.isResolving || update.isResolving || _delete.isResolving;
+			const hasResolved =
+				create.hasResolved && update.hasResolved && _delete.hasResolved;
+
+			let status = Status.Idle;
+			if ( isResolving ) {
+				status = Status.Resolving;
+			} else if ( hasResolved ) {
+				status = Status.Success;
+			}
+			return [
+				hasResolved,
+				{
+					status,
+					isResolving,
+					canCreate: hasResolved && create.data,
+					canUpdate: hasResolved && update.data,
+					canDelete: hasResolved && _delete.data,
+				},
+			];
+		},
+		[ resource, id ]
+	);
+}

package/src/index.js

@@ -68,6 +68,9 @@ export const store = createReduxStore( STORE_NAME, storeConfig() );
 register( store );
 
 export { default as EntityProvider } from './entity-provider';
+export { default as useEntityRecord } from './hooks/use-entity-record';
+export { default as useEntityRecords } from './hooks/use-entity-records';
+export { default as __experimentalUseResourcePermissions } from './hooks/use-resource-permissions';
 export * from './entity-provider';
 export * from './entity-types';
 export * from './fetch';

package/src/reducer.js

@@ -1,7 +1,7 @@
 /**
  * External dependencies
  */
-import { keyBy, map, groupBy, flowRight, isEqual, get } from 'lodash';
+import { map, groupBy, flowRight, isEqual, get } from 'lodash';
 
 /**
  * WordPress dependencies
@@ -55,7 +55,14 @@ export function users( state = { byId: {}, queries: {} }, action ) {
 			return {
 				byId: {
 					...state.byId,
-					...keyBy( action.users, 'id' ),
+					// Key users by their ID.
+					...action.users.reduce(
+						( newUsers, user ) => ( {
+							...newUsers,
+							[ user.id ]: user,
+						} ),
+						{}
+					),
 				},
 				queries: {
 					...state.queries,

package/src/resolvers.js

@@ -1,7 +1,7 @@
 /**
  * External dependencies
  */
-import { find, includes, get, compact, uniq, map, mapKeys } from 'lodash';
+import { camelCase, find, get, includes, map, mapKeys, uniq } from 'lodash';
 
 /**
  * WordPress dependencies
@@ -50,7 +50,8 @@ export const getCurrentUser =
  * @param {string}           name  Entity name.
  * @param {number|string}    key   Record's key
  * @param {Object|undefined} query Optional object of query parameters to
- *                                 include with request.
+ *                                 include with request. If requesting specific
+ *                                 fields, fields must always include the ID.
  */
 export const getEntityRecord =
 	( kind, name, key = '', query ) =>
@@ -131,7 +132,8 @@ export const getEditedEntityRecord = forwardResolver( 'getEntityRecord' );
  *
  * @param {string}  kind  Entity kind.
  * @param {string}  name  Entity name.
- * @param {Object?} query Query Object.
+ * @param {Object?} query Query Object. If requesting specific fields, fields
+ *                        must always include the ID.
  */
 export const getEntityRecords =
 	( kind, name, query = {} ) =>
@@ -304,7 +306,7 @@ export const canUser =
 		// 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 key = compact( [ action, resource, id ] ).join( '/' );
+		const key = [ action, resource, id ].filter( Boolean ).join( '/' );
 		const isAllowed = includes( allowHeader, method );
 		dispatch.receiveUserPermission( key, isAllowed );
 	};
@@ -339,11 +341,10 @@ export const canUserEditEntityRecord =
 export const getAutosaves =
 	( postType, postId ) =>
 	async ( { dispatch, resolveSelect } ) => {
-		const { rest_base: restBase } = await resolveSelect.getPostType(
-			postType
-		);
+		const { rest_base: restBase, rest_namespace: restNamespace = 'wp/v2' } =
+			await resolveSelect.getPostType( postType );
 		const autosaves = await apiFetch( {
-			path: `/wp/v2/${ restBase }/${ postId }/autosaves?context=edit`,
+			path: `/${ restNamespace }/${ restBase }/${ postId }/autosaves?context=edit`,
 		} );
 
 		if ( autosaves && autosaves.length ) {
@@ -476,16 +477,7 @@ export const getBlockPatterns =
 			path: '/wp/v2/block-patterns/patterns',
 		} );
 		const patterns = map( restPatterns, ( pattern ) =>
-			mapKeys( pattern, ( value, key ) => {
-				switch ( key ) {
-					case 'block_types':
-						return 'blockTypes';
-					case 'viewport_width':
-						return 'viewportWidth';
-					default:
-						return key;
-				}
-			} )
+			mapKeys( pattern, ( value, key ) => camelCase( key ) )
 		);
 		dispatch( { type: 'RECEIVE_BLOCK_PATTERNS', patterns } );
 	};

package/src/selectors.ts

@@ -2,7 +2,7 @@
  * External dependencies
  */
 import createSelector from 'rememo';
-import { set, map, find, get, filter, compact } from 'lodash';
+import { set, map, find, get, filter } from 'lodash';
 
 /**
  * WordPress dependencies
@@ -296,7 +296,8 @@ interface GetEntityRecord {
  * @param  kind  Entity kind.
  * @param  name  Entity name.
  * @param  key   Record's key
- * @param  query Optional query.
+ * @param  query Optional query. If requesting specific
+ *               fields, fields must always include the ID.
  *
  * @return Record.
  */
@@ -526,7 +527,8 @@ interface GetEntityRecords {
  * @param  state State tree
  * @param  kind  Entity kind.
  * @param  name  Entity name.
- * @param  query Optional terms query.
+ * @param  query Optional terms query. If requesting specific
+ *               fields, fields must always include the ID.
  *
  * @return Records.
  */
@@ -1115,7 +1117,7 @@ export function canUser(
 	resource: string,
 	id?: GenericRecordKey
 ): boolean | undefined {
-	const key = compact( [ action, resource, id ] ).join( '/' );
+	const key = [ action, resource, id ].filter( Boolean ).join( '/' );
 	return get( state, [ 'userPermissions', key ] );
 }
 

package/src/test/reducer.js

@@ -2,7 +2,6 @@
  * External dependencies
  */
 import deepFreeze from 'deep-freeze';
-import { filter } from 'lodash';
 
 /**
  * Internal dependencies
@@ -135,9 +134,11 @@ describe( 'entities', () => {
 			entities: [ { kind: 'postType', name: 'posts' } ],
 		} );
 
-		expect( filter( state.config, { kind: 'postType' } ) ).toEqual( [
-			{ kind: 'postType', name: 'posts' },
-		] );
+		expect(
+			Object.entries( state.config )
+				.filter( ( [ , cfg ] ) => cfg.kind === 'postType' )
+				.map( ( [ , cfg ] ) => cfg )
+		).toEqual( [ { kind: 'postType', name: 'posts' } ] );
 	} );
 } );