@wordpress/core-data 7.30.1-next.836ecdcae.0 → 7.31.0

package/src/selectors.ts

@@ -36,7 +36,7 @@ export interface State {
 	blockPatternCategories: Array< unknown >;
 	currentGlobalStylesId: string;
 	currentTheme: string;
-	currentUser: ET.User< 'edit' >;
+	currentUser: ET.User< 'view' >;
 	embedPreviews: Record< string, { html: string } >;
 	entities: EntitiesState;
 	themeBaseGlobalStyles: Record< string, Object >;
@@ -49,6 +49,7 @@ export interface State {
 	userPatternCategories: Array< UserPatternCategory >;
 	defaultTemplates: Record< string, string >;
 	registeredPostMeta: Record< string, Object >;
+	templateAutoDraftId: Record< string, number | null >;
 }
 
 type EntityRecordKey = string | number;
@@ -185,7 +186,7 @@ export function getAuthors(
  *
  * @return Current user object.
  */
-export function getCurrentUser( state: State ): ET.User< 'edit' > {
+export function getCurrentUser( state: State ): ET.User< 'view' > {
 	return state.currentUser;
 }
 
@@ -358,6 +359,18 @@ export const getEntityRecord = createSelector(
 	): EntityRecord | undefined => {
 		logEntityDeprecation( kind, name, 'getEntityRecord' );
 
+		// For back-compat, we allow querying for static templates through
+		// wp_template.
+		if (
+			kind === 'postType' &&
+			name === 'wp_template' &&
+			typeof key === 'string' &&
+			// __experimentalGetDirtyEntityRecords always calls getEntityRecord
+			// with a string key, so we need that it's not a numeric ID.
+			! /^\d+$/.test( key )
+		) {
+			name = 'wp_registered_template';
+		}
 		const queriedState =
 			state.entities.records?.[ kind ]?.[ name ]?.queriedData;
 		if ( ! queriedState ) {
@@ -365,7 +378,7 @@ export const getEntityRecord = createSelector(
 		}
 		const context = query?.context ?? 'default';
 
-		if ( query === undefined ) {
+		if ( ! query || ! query._fields ) {
 			// If expecting a complete item, validate that completeness.
 			if ( ! queriedState.itemIsComplete[ context ]?.[ key ] ) {
 				return undefined;
@@ -375,30 +388,29 @@ export const getEntityRecord = createSelector(
 		}
 
 		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( '.' );
-				let value = item;
-				field.forEach( ( fieldName ) => {
-					value = value?.[ fieldName ];
-				} );
-				setNestedValue( filteredItem, field, value );
-			}
-			return filteredItem as EntityRecord;
+		if ( ! item ) {
+			return item;
 		}
 
-		return item;
+		const filteredItem = {};
+		const fields = getNormalizedCommaSeparable( query._fields ) ?? [];
+		for ( let f = 0; f < fields.length; f++ ) {
+			const field = fields[ f ].split( '.' );
+			let value = item;
+			field.forEach( ( fieldName ) => {
+				value = value?.[ fieldName ];
+			} );
+			setNestedValue( filteredItem, field, value );
+		}
+		return filteredItem as EntityRecord;
 	} ) as GetEntityRecord,
 	( state: State, kind, name, recordId, query ) => {
 		const context = query?.context ?? 'default';
+		const queriedState =
+			state.entities.records?.[ kind ]?.[ name ]?.queriedData;
 		return [
-			state.entities.records?.[ kind ]?.[ name ]?.queriedData?.items[
-				context
-			]?.[ recordId ],
-			state.entities.records?.[ kind ]?.[ name ]?.queriedData
-				?.itemIsComplete[ context ]?.[ recordId ],
+			queriedState?.items[ context ]?.[ recordId ],
+			queriedState?.itemIsComplete[ context ]?.[ recordId ],
 		];
 	}
 ) as GetEntityRecord;
@@ -421,6 +433,62 @@ getEntityRecord.__unstableNormalizeArgs = (
 	return newArgs;
 };
 
+/**
+ * Returns true if a record has been received for the given set of parameters, or false otherwise.
+ *
+ * Note: This action does not trigger a request for the entity record from the API
+ * if it's not available in the local state.
+ *
+ * @param state State tree
+ * @param kind  Entity kind.
+ * @param name  Entity name.
+ * @param key   Record's key.
+ * @param query Optional query.
+ *
+ * @return Whether an entity record has been received.
+ */
+export function hasEntityRecord(
+	state: State,
+	kind: string,
+	name: string,
+	key?: EntityRecordKey,
+	query?: GetRecordsHttpQuery
+): boolean {
+	const queriedState =
+		state.entities.records?.[ kind ]?.[ name ]?.queriedData;
+	if ( ! queriedState ) {
+		return false;
+	}
+	const context = query?.context ?? 'default';
+
+	// If expecting a complete item, validate that completeness.
+	if ( ! query || ! query._fields ) {
+		return !! queriedState.itemIsComplete[ context ]?.[ key ];
+	}
+
+	const item = queriedState.items[ context ]?.[ key ];
+	if ( ! item ) {
+		return false;
+	}
+
+	// When `query._fields` is provided, check that each requested field exists,
+	// including any nested paths, on the item; return false if any part is missing.
+	const fields = getNormalizedCommaSeparable( query._fields ) ?? [];
+	for ( let i = 0; i < fields.length; i++ ) {
+		const path = fields[ i ].split( '.' );
+		let value = item;
+		for ( let p = 0; p < path.length; p++ ) {
+			const part = path[ p ];
+			if ( ! value || ! Object.hasOwn( value, part ) ) {
+				return false;
+			}
+			value = value[ part ];
+		}
+	}
+
+	return true;
+}
+
 /**
  * Returns the Entity's record object by key. Doesn't trigger a resolver nor requests the entity records from the API if the entity record isn't available in the local state.
  *
@@ -1488,7 +1556,7 @@ export const getRevision = createSelector(
 
 		const context = query?.context ?? 'default';
 
-		if ( query === undefined ) {
+		if ( ! query || ! query._fields ) {
 			// If expecting a complete item, validate that completeness.
 			if ( ! queriedState.itemIsComplete[ context ]?.[ revisionKey ] ) {
 				return undefined;
@@ -1498,31 +1566,33 @@ export const getRevision = createSelector(
 		}
 
 		const item = queriedState.items[ context ]?.[ revisionKey ];
-		if ( item && query._fields ) {
-			const filteredItem = {};
-			const fields = getNormalizedCommaSeparable( query._fields ) ?? [];
-
-			for ( let f = 0; f < fields.length; f++ ) {
-				const field = fields[ f ].split( '.' );
-				let value = item;
-				field.forEach( ( fieldName ) => {
-					value = value?.[ fieldName ];
-				} );
-				setNestedValue( filteredItem, field, value );
-			}
+		if ( ! item ) {
+			return item;
+		}
 
-			return filteredItem;
+		const filteredItem = {};
+		const fields = getNormalizedCommaSeparable( query._fields ) ?? [];
+
+		for ( let f = 0; f < fields.length; f++ ) {
+			const field = fields[ f ].split( '.' );
+			let value = item;
+			field.forEach( ( fieldName ) => {
+				value = value?.[ fieldName ];
+			} );
+			setNestedValue( filteredItem, field, value );
 		}
 
-		return item;
+		return filteredItem;
 	},
 	( state: State, kind, name, recordKey, revisionKey, query ) => {
 		const context = query?.context ?? 'default';
+		const queriedState =
+			state.entities.records?.[ kind ]?.[ name ]?.revisions?.[
+				recordKey
+			];
 		return [
-			state.entities.records?.[ kind ]?.[ name ]?.revisions?.[ recordKey ]
-				?.items?.[ context ]?.[ revisionKey ],
-			state.entities.records?.[ kind ]?.[ name ]?.revisions?.[ recordKey ]
-				?.itemIsComplete?.[ context ]?.[ revisionKey ],
+			queriedState?.items?.[ context ]?.[ revisionKey ],
+			queriedState?.itemIsComplete?.[ context ]?.[ revisionKey ],
 		];
 	}
 );

package/src/test/actions.js

@@ -38,14 +38,14 @@ describe( 'editEntityRecord', () => {
 		const select = {
 			getEntityConfig: jest.fn(),
 		};
-		const fulfillment = () =>
+		const fulfillment = async () =>
 			editEntityRecord(
 				entityConfig.kind,
 				entityConfig.name,
 				entityConfig.id,
 				{}
 			)( { select } );
-		expect( fulfillment ).toThrow(
+		await expect( fulfillment ).rejects.toThrow(
 			`The entity being edited (${ entityConfig.kind }, ${ entityConfig.name }) does not have a loaded config.`
 		);
 		expect( select.getEntityConfig ).toHaveBeenCalledTimes( 1 );

package/src/test/entities.js

@@ -1,3 +1,10 @@
+/**
+ * WordPress dependencies
+ */
+import apiFetch from '@wordpress/api-fetch';
+
+jest.mock( '@wordpress/api-fetch' );
+
 /**
  * Internal dependencies
  */
@@ -5,6 +12,7 @@ import {
 	getMethodName,
 	rootEntitiesConfig,
 	prePersistPostType,
+	additionalEntityConfigLoaders,
 } from '../entities';
 
 describe( 'getMethodName', () => {
@@ -68,3 +76,27 @@ describe( 'prePersistPostType', () => {
 		expect( prePersistPostType( record, edits ) ).toEqual( {} );
 	} );
 } );
+
+describe( 'loadTaxonomyEntities', () => {
+	beforeEach( () => {
+		apiFetch.mockReset();
+	} );
+
+	it( 'should add supportsPagination: true to taxonomy entities', async () => {
+		const mockTaxonomies = {
+			category: {
+				name: 'Categories',
+				rest_base: 'categories',
+			},
+		};
+
+		apiFetch.mockResolvedValueOnce( mockTaxonomies );
+
+		const taxonomyLoader = additionalEntityConfigLoaders.find(
+			( loader ) => loader.kind === 'taxonomy'
+		);
+		const entities = await taxonomyLoader.loadEntities();
+
+		expect( entities[ 0 ].supportsPagination ).toBe( true );
+	} );
+} );

package/src/test/resolvers.js

@@ -79,10 +79,6 @@ describe( 'getEntityRecord', () => {
 	it( 'accepts a query that overrides default api path', async () => {
 		const query = { context: 'view', _envelope: '1' };
 
-		const select = {
-			hasEntityRecords: jest.fn( () => {} ),
-		};
-
 		// Provide response
 		triggerFetch.mockImplementation( () => POST_TYPE_RESPONSE );
 
@@ -91,7 +87,7 @@ describe( 'getEntityRecord', () => {
 			'postType',
 			'post',
 			query
-		)( { dispatch, select, registry, resolveSelect } );
+		)( { dispatch, registry, resolveSelect } );
 
 		// Trigger apiFetch, test that the query is present in the url.
 		expect( triggerFetch ).toHaveBeenCalledWith( {
@@ -241,7 +237,7 @@ describe( 'getEntityRecords', () => {
 		] );
 	} );
 
-	it( 'caches permissions but does not mark entity records as resolved when using _fields', async () => {
+	it( 'caches permissions and marks entity records as resolved when using _fields', async () => {
 		const finishResolutions = jest.fn();
 		const dispatch = Object.assign( jest.fn(), {
 			receiveEntityRecords: jest.fn(),
@@ -285,9 +281,7 @@ describe( 'getEntityRecords', () => {
 			'canUser',
 			expect.any( Array )
 		);
-
-		// But individual entity records should NOT be marked as resolved
-		expect( finishResolutions ).not.toHaveBeenCalledWith(
+		expect( finishResolutions ).toHaveBeenCalledWith(
 			'getEntityRecord',
 			expect.any( Array )
 		);
@@ -328,15 +322,112 @@ describe( 'getEntityRecords', () => {
 			'canUser',
 			expect.any( Array )
 		);
-
-		// Individual entity records should NOT be marked as resolved
-		expect( finishResolutions ).not.toHaveBeenCalledWith(
+		expect( finishResolutions ).toHaveBeenCalledWith(
 			'getEntityRecord',
 			expect.any( Array )
 		);
 	} );
 } );
 
+describe( 'taxonomy pagination', () => {
+	const registry = { batch: ( callback ) => callback() };
+	let dispatch, loadedTaxonomyEntities;
+
+	beforeEach( async () => {
+		dispatch = Object.assign( jest.fn(), {
+			receiveEntityRecords: jest.fn(),
+			__unstableAcquireStoreLock: jest.fn().mockResolvedValue( 'lock' ),
+			__unstableReleaseStoreLock: jest.fn(),
+		} );
+		triggerFetch.mockReset();
+
+		const mockTaxonomyConfig = {
+			category: {
+				name: 'Categories',
+				rest_base: 'categories',
+			},
+		};
+
+		triggerFetch.mockResolvedValueOnce( mockTaxonomyConfig );
+
+		const { additionalEntityConfigLoaders } = await import( '../entities' );
+		const taxonomyLoader = additionalEntityConfigLoaders.find(
+			( loader ) => loader.kind === 'taxonomy'
+		);
+		loadedTaxonomyEntities = await taxonomyLoader.loadEntities();
+	} );
+
+	it( 'should make paginated API calls with parse: false', async () => {
+		const resolveSelect = {
+			getEntitiesConfig: jest
+				.fn()
+				.mockResolvedValue( loadedTaxonomyEntities ),
+		};
+
+		triggerFetch.mockResolvedValueOnce( [
+			{ id: 1, name: 'Category 1' },
+			{ id: 2, name: 'Category 2' },
+		] );
+
+		await getEntityRecords( 'taxonomy', 'category', {
+			per_page: 2,
+			page: 1,
+		} )( { dispatch, registry, resolveSelect } );
+
+		expect( triggerFetch ).toHaveBeenLastCalledWith( {
+			path: '/wp/v2/categories?context=edit&per_page=2&page=1',
+			parse: false,
+		} );
+	} );
+
+	it( 'should extract pagination metadata from headers', async () => {
+		const resolveSelect = {
+			getEntitiesConfig: jest
+				.fn()
+				.mockResolvedValue( loadedTaxonomyEntities ),
+		};
+
+		const mockResponse = {
+			json: () =>
+				Promise.resolve( [
+					{ id: 1, name: 'Category 1' },
+					{ id: 2, name: 'Category 2' },
+				] ),
+			headers: {
+				get: jest.fn( ( header ) => {
+					if ( header === 'X-WP-Total' ) {
+						return '10';
+					}
+					if ( header === 'X-WP-TotalPages' ) {
+						return '5';
+					}
+					return null;
+				} ),
+			},
+		};
+
+		triggerFetch.mockResolvedValueOnce( mockResponse );
+
+		await getEntityRecords( 'taxonomy', 'category', {
+			per_page: 2,
+			page: 1,
+		} )( { dispatch, registry, resolveSelect } );
+
+		expect( dispatch.receiveEntityRecords ).toHaveBeenCalledWith(
+			'taxonomy',
+			'category',
+			[
+				{ id: 1, name: 'Category 1' },
+				{ id: 2, name: 'Category 2' },
+			],
+			{ per_page: 2, page: 1 },
+			false,
+			undefined,
+			{ totalItems: 10, totalPages: 5 }
+		);
+	} );
+} );
+
 describe( 'getEmbedPreview', () => {
 	const SUCCESSFUL_EMBED_RESPONSE = { data: '<p>some html</p>' };
 	const UNEMBEDDABLE_RESPONSE = false;