@wordpress/core-data 7.41.2-next.v.202603102151.0 → 7.42.0

package/src/resolvers.js

@@ -24,6 +24,7 @@ import {
 	ALLOWED_RESOURCE_ACTIONS,
 	RECEIVE_INTERMEDIATE_RESULTS,
 	isNumericID,
+	normalizeQueryForResolution,
 } from './utils';
 import { fetchBlockPatterns } from './fetch';
 import { restoreSelection, getSelectionHistory } from './utils/crdt-selection';
@@ -229,18 +230,26 @@ export const getEntityRecord =
 								query
 							);
 						},
-						// Save the current entity record, whether or not it has unsaved
-						// edits. This is used to trigger a persisted CRDT document.
-						saveRecord: () => {
+						// Persist the CRDT document.
+						//
+						// TODO: Currently, persisted CRDT documents are stored in post meta.
+						// This effectively means that only post entities support CRDT
+						// persistence. As we add support for syncing additional entity,
+						// we'll need to revisit where persisted CRDT documents are stored.
+						persistCRDTDoc: () => {
 							resolveSelect
 								.getEditedEntityRecord( kind, name, key )
 								.then( ( editedRecord ) => {
-									// Don't trigger a save if the record is still an auto-draft.
-									const { status } = editedRecord;
-									if ( 'auto-draft' === status ) {
+									// Don't persist the CRDT document if the record is still an
+									// auto-draft or if the entity does not support meta.
+									const { meta, status } = editedRecord;
+									if ( 'auto-draft' === status || ! meta ) {
 										return;
 									}
 
+									// Trigger a save to persist the CRDT document. The entity's
+									// pre-persist hooks will create the persisted CRDT document
+									// and apply it to the record's meta.
 									dispatch.saveEntityRecord(
 										kind,
 										name,
@@ -350,18 +359,14 @@ export const getEntityRecords =
 		const key = entityConfig.key || DEFAULT_ENTITY_KEY;
 
 		function getResolutionsArgs( records, recordsQuery ) {
-			const queryArgs = Object.fromEntries(
-				Object.entries( recordsQuery ).filter( ( [ k, v ] ) => {
-					return [ 'context', '_fields' ].includes( k ) && !! v;
-				} )
-			);
+			const normalizedQuery = normalizeQueryForResolution( recordsQuery );
 			return records
 				.filter( ( record ) => record?.[ key ] )
 				.map( ( record ) => [
 					kind,
 					name,
 					record[ key ],
-					Object.keys( queryArgs ).length > 0 ? queryArgs : undefined,
+					normalizedQuery,
 				] );
 		}
 
@@ -1036,78 +1041,87 @@ export const getRevisions =
 			return;
 		}
 
-		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,
-				_fields: [
-					...new Set( [
-						...( getNormalizedCommaSeparable( query._fields ) ||
-							[] ),
-						entityConfig.revisionKey || DEFAULT_ENTITY_KEY,
-					] ),
-				].join(),
-			};
-		}
-
-		const path = addQueryArgs(
-			entityConfig.getRevisionsUrl( recordKey ),
-			query
+		const rawQuery = { ...query };
+		const lock = await dispatch.__unstableAcquireStoreLock(
+			STORE_NAME,
+			[ 'entities', 'records', kind, name, recordKey, 'revisions' ],
+			{ exclusive: false }
 		);
 
-		let records, response;
-		const meta = {};
-		const isPaginated =
-			entityConfig.supportsPagination && query.per_page !== -1;
 		try {
-			response = await apiFetch( { path, parse: ! isPaginated } );
-		} catch ( error ) {
-			// Do nothing if our request comes back with an API error.
-			return;
-		}
-
-		if ( response ) {
-			if ( isPaginated ) {
-				records = Object.values( await response.json() );
-				meta.totalItems = parseInt(
-					response.headers.get( 'X-WP-Total' )
-				);
-			} else {
-				records = Object.values( response );
+			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,
+					_fields: [
+						...new Set( [
+							...( getNormalizedCommaSeparable( query._fields ) ||
+								[] ),
+							entityConfig.revisionKey || DEFAULT_ENTITY_KEY,
+						] ),
+					].join(),
+				};
 			}
 
-			// If we request fields but the result doesn't contain the fields,
-			// explicitly set these fields as "undefined"
-			// that way we consider the query "fulfilled".
-			if ( query._fields ) {
-				records = records.map( ( record ) => {
-					query._fields.split( ',' ).forEach( ( field ) => {
-						if ( ! record.hasOwnProperty( field ) ) {
-							record[ field ] = undefined;
-						}
-					} );
+			const path = addQueryArgs(
+				entityConfig.getRevisionsUrl( recordKey ),
+				query
+			);
 
-					return record;
-				} );
+			let records, response;
+			const meta = {};
+			const isPaginated =
+				entityConfig.supportsPagination && query.per_page !== -1;
+			try {
+				response = await apiFetch( { path, parse: ! isPaginated } );
+			} catch ( error ) {
+				// Do nothing if our request comes back with an API error.
+				return;
 			}
 
-			registry.batch( () => {
-				dispatch.receiveRevisions(
-					kind,
-					name,
-					recordKey,
-					records,
-					query,
-					false,
-					meta
-				);
+			if ( response ) {
+				if ( isPaginated ) {
+					records = Object.values( await response.json() );
+					meta.totalItems = parseInt(
+						response.headers.get( 'X-WP-Total' )
+					);
+				} else {
+					records = Object.values( response );
+				}
+
+				// If we request fields but the result doesn't contain the fields,
+				// explicitly set these fields as "undefined"
+				// that way we consider the query "fulfilled".
+				if ( query._fields ) {
+					records = records.map( ( record ) => {
+						query._fields.split( ',' ).forEach( ( field ) => {
+							if ( ! record.hasOwnProperty( field ) ) {
+								record[ field ] = undefined;
+							}
+						} );
+
+						return record;
+					} );
+				}
+
+				registry.batch( () => {
+					dispatch.receiveRevisions(
+						kind,
+						name,
+						recordKey,
+						records,
+						query,
+						false,
+						meta
+					);
 
-				// When requesting all fields, the list of results can be used to
-				// resolve the `getRevision` selector in addition to `getRevisions`.
-				if ( ! query?._fields && ! query.context ) {
+					// Mark individual getRevision resolutions as done so that
+					// subsequent getRevision calls skip redundant API fetches.
 					const key = entityConfig.revisionKey || DEFAULT_ENTITY_KEY;
+					const normalizedQuery =
+						normalizeQueryForResolution( rawQuery );
 					const resolutionsArgs = records
 						.filter( ( record ) => record[ key ] )
 						.map( ( record ) => [
@@ -1115,14 +1129,17 @@ export const getRevisions =
 							name,
 							recordKey,
 							record[ key ],
+							normalizedQuery,
 						] );
 
 					dispatch.finishResolutions(
 						'getRevision',
 						resolutionsArgs
 					);
-				}
-			} );
+				} );
+			}
+		} finally {
+			dispatch.__unstableReleaseStoreLock( lock );
 		}
 	};
 
@@ -1147,7 +1164,7 @@ getRevisions.shouldInvalidate = ( action, kind, name, recordKey ) =>
  */
 export const getRevision =
 	( kind, name, recordKey, revisionKey, query ) =>
-	async ( { dispatch, resolveSelect } ) => {
+	async ( { select, dispatch, resolveSelect } ) => {
 		const configs = await resolveSelect.getEntitiesConfig( kind );
 		const entityConfig = configs.find(
 			( config ) => config.name === name && config.kind === kind
@@ -1172,21 +1189,52 @@ export const getRevision =
 				].join(),
 			};
 		}
-		const path = addQueryArgs(
-			entityConfig.getRevisionsUrl( recordKey, revisionKey ),
-			query
+
+		const lock = await dispatch.__unstableAcquireStoreLock(
+			STORE_NAME,
+			[
+				'entities',
+				'records',
+				kind,
+				name,
+				recordKey,
+				'revisions',
+				revisionKey,
+			],
+			{ exclusive: false }
 		);
 
-		let record;
 		try {
-			record = await apiFetch( { path } );
-		} catch ( error ) {
-			// Do nothing if our request comes back with an API error.
-			return;
-		}
+			if (
+				select.hasRevision( kind, name, recordKey, revisionKey, query )
+			) {
+				return;
+			}
 
-		if ( record ) {
-			dispatch.receiveRevisions( kind, name, recordKey, record, query );
+			const path = addQueryArgs(
+				entityConfig.getRevisionsUrl( recordKey, revisionKey ),
+				query
+			);
+
+			let record;
+			try {
+				record = await apiFetch( { path } );
+			} catch ( error ) {
+				// Do nothing if our request comes back with an API error.
+				return;
+			}
+
+			if ( record ) {
+				dispatch.receiveRevisions(
+					kind,
+					name,
+					recordKey,
+					record,
+					query
+				);
+			}
+		} finally {
+			dispatch.__unstableReleaseStoreLock( lock );
 		}
 	};
 

package/src/selectors.ts

@@ -1524,6 +1524,62 @@ export const getRevisions = (
 	return getQueriedItems( queriedStateRevisions, query );
 };
 
+/**
+ * Returns true if a revision has been received for the given set of parameters,
+ * or false otherwise.
+ *
+ * Note: This does not trigger a request for the revision 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 recordKey   The key of the entity record whose revision you want to check.
+ * @param revisionKey The revision's key.
+ * @param query       Optional query.
+ *
+ * @return Whether a revision has been received.
+ */
+export function hasRevision(
+	state: State,
+	kind: string,
+	name: string,
+	recordKey: EntityRecordKey,
+	revisionKey: EntityRecordKey,
+	query?: GetRecordsHttpQuery
+): boolean {
+	const queriedState =
+		state.entities.records?.[ kind ]?.[ name ]?.revisions?.[ recordKey ];
+	if ( ! queriedState ) {
+		return false;
+	}
+	const context = query?.context ?? 'default';
+
+	if ( ! query || ! query._fields ) {
+		return !! queriedState.itemIsComplete[ context ]?.[ revisionKey ];
+	}
+
+	const item = queriedState.items[ context ]?.[ revisionKey ];
+	if ( ! item ) {
+		return false;
+	}
+
+	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 a single, specific revision of a parent entity.
  *

package/src/sync.ts

@@ -12,6 +12,7 @@ import {
 import { unlock } from './lock-unlock';
 
 const {
+	ConnectionErrorCode,
 	createSyncManager,
 	Delta,
 	CRDT_DOC_META_PERSISTENCE_KEY,
@@ -22,6 +23,7 @@ const {
 } = unlock( syncPrivateApis );
 
 export {
+	ConnectionErrorCode,
 	Delta,
 	CRDT_DOC_META_PERSISTENCE_KEY,
 	CRDT_RECORD_MAP_KEY,

package/src/test/entities.js

@@ -8,6 +8,10 @@ jest.mock( '../sync', () => ( {
 	...jest.requireActual( '../sync' ),
 	getSyncManager: jest.fn(),
 } ) );
+jest.mock( '../utils/crdt', () => ( {
+	...jest.requireActual( '../utils/crdt' ),
+	applyPostChangesToCRDTDoc: jest.fn(),
+} ) );
 
 /**
  * Internal dependencies
@@ -19,7 +23,10 @@ import {
 	additionalEntityConfigLoaders,
 } from '../entities';
 import { getSyncManager } from '../sync';
-import { POST_META_KEY_FOR_CRDT_DOC_PERSISTENCE } from '../utils/crdt';
+import {
+	applyPostChangesToCRDTDoc,
+	POST_META_KEY_FOR_CRDT_DOC_PERSISTENCE,
+} from '../utils/crdt';
 
 describe( 'getMethodName', () => {
 	it( 'should return the right method name for an entity with the root kind', () => {
@@ -127,6 +134,183 @@ describe( 'prePersistPostType', () => {
 	} );
 } );
 
+describe( 'loadPostTypeEntities', () => {
+	let originalCollaborationEnabled;
+
+	beforeEach( () => {
+		apiFetch.mockReset();
+		applyPostChangesToCRDTDoc.mockReset();
+		originalCollaborationEnabled = window._wpCollaborationEnabled;
+	} );
+
+	afterEach( () => {
+		window._wpCollaborationEnabled = originalCollaborationEnabled;
+	} );
+
+	it( 'should include custom taxonomy rest_bases in synced properties when collaboration is enabled', async () => {
+		window._wpCollaborationEnabled = true;
+
+		const mockPostTypes = {
+			book: {
+				name: 'Books',
+				rest_base: 'books',
+				rest_namespace: 'wp/v2',
+				taxonomies: [ 'genre', 'audience' ],
+			},
+		};
+		const mockTaxonomies = {
+			genre: {
+				name: 'Genres',
+				rest_base: 'genres',
+				rest_namespace: 'wp/v2',
+			},
+			audience: {
+				name: 'Audiences',
+				rest_base: 'audiences',
+				rest_namespace: 'wp/v2',
+			},
+		};
+
+		apiFetch
+			.mockResolvedValueOnce( mockPostTypes )
+			.mockResolvedValueOnce( mockTaxonomies );
+
+		const postTypeLoader = additionalEntityConfigLoaders.find(
+			( loader ) => loader.kind === 'postType'
+		);
+		const entities = await postTypeLoader.loadEntities();
+		const bookEntity = entities.find( ( e ) => e.name === 'book' );
+
+		bookEntity.syncConfig.applyChangesToCRDTDoc( {}, {} );
+
+		expect( applyPostChangesToCRDTDoc ).toHaveBeenCalledWith(
+			{},
+			{},
+			expect.any( Set )
+		);
+
+		const syncedProperties = applyPostChangesToCRDTDoc.mock.calls[ 0 ][ 2 ];
+		expect( syncedProperties ).toContain( 'genres' );
+		expect( syncedProperties ).toContain( 'audiences' );
+	} );
+
+	it( 'should not fetch taxonomies when collaboration is disabled', async () => {
+		window._wpCollaborationEnabled = false;
+
+		const mockPostTypes = {
+			post: {
+				name: 'Posts',
+				rest_base: 'posts',
+				rest_namespace: 'wp/v2',
+				taxonomies: [ 'category', 'post_tag' ],
+			},
+		};
+
+		apiFetch.mockResolvedValueOnce( mockPostTypes );
+
+		const postTypeLoader = additionalEntityConfigLoaders.find(
+			( loader ) => loader.kind === 'postType'
+		);
+		const entities = await postTypeLoader.loadEntities();
+		const postEntity = entities.find( ( e ) => e.name === 'post' );
+
+		postEntity.syncConfig.applyChangesToCRDTDoc( {}, {} );
+
+		// Only one apiFetch call (post types), no taxonomy fetch.
+		expect( apiFetch ).toHaveBeenCalledTimes( 1 );
+
+		const syncedProperties = applyPostChangesToCRDTDoc.mock.calls[ 0 ][ 2 ];
+		expect( syncedProperties ).not.toContain( 'categories' );
+		expect( syncedProperties ).not.toContain( 'tags' );
+	} );
+
+	it( 'should skip taxonomy rest_base when taxonomy is not found in fetched taxonomies', async () => {
+		window._wpCollaborationEnabled = true;
+
+		const mockPostTypes = {
+			book: {
+				name: 'Books',
+				rest_base: 'books',
+				rest_namespace: 'wp/v2',
+				taxonomies: [ 'genre', 'missing_taxonomy' ],
+			},
+		};
+		const mockTaxonomies = {
+			genre: {
+				name: 'Genres',
+				rest_base: 'genres',
+				rest_namespace: 'wp/v2',
+			},
+			// 'missing_taxonomy' is intentionally absent.
+		};
+
+		apiFetch
+			.mockResolvedValueOnce( mockPostTypes )
+			.mockResolvedValueOnce( mockTaxonomies );
+
+		const postTypeLoader = additionalEntityConfigLoaders.find(
+			( loader ) => loader.kind === 'postType'
+		);
+		const entities = await postTypeLoader.loadEntities();
+		const bookEntity = entities.find( ( e ) => e.name === 'book' );
+
+		bookEntity.syncConfig.applyChangesToCRDTDoc( {}, {} );
+
+		const syncedProperties = applyPostChangesToCRDTDoc.mock.calls[ 0 ][ 2 ];
+		expect( syncedProperties ).toContain( 'genres' );
+		// missing_taxonomy has no rest_base entry, so nothing should be added for it.
+		expect( syncedProperties.size ).toBe( 16 ); // 15 base + 1 taxonomy (genres)
+	} );
+
+	it( 'should include base synced properties regardless of taxonomies', async () => {
+		window._wpCollaborationEnabled = true;
+
+		const mockPostTypes = {
+			page: {
+				name: 'Pages',
+				rest_base: 'pages',
+				rest_namespace: 'wp/v2',
+				taxonomies: [],
+			},
+		};
+
+		apiFetch
+			.mockResolvedValueOnce( mockPostTypes )
+			.mockResolvedValueOnce( {} );
+
+		const postTypeLoader = additionalEntityConfigLoaders.find(
+			( loader ) => loader.kind === 'postType'
+		);
+		const entities = await postTypeLoader.loadEntities();
+		const pageEntity = entities.find( ( e ) => e.name === 'page' );
+
+		pageEntity.syncConfig.applyChangesToCRDTDoc( {}, {} );
+
+		const syncedProperties = applyPostChangesToCRDTDoc.mock.calls[ 0 ][ 2 ];
+		const expectedBase = [
+			'author',
+			'blocks',
+			'content',
+			'comment_status',
+			'date',
+			'excerpt',
+			'featured_media',
+			'format',
+			'meta',
+			'ping_status',
+			'slug',
+			'status',
+			'sticky',
+			'template',
+			'title',
+		];
+		for ( const prop of expectedBase ) {
+			expect( syncedProperties ).toContain( prop );
+		}
+		expect( syncedProperties.size ).toBe( 15 );
+	} );
+} );
+
 describe( 'loadTaxonomyEntities', () => {
 	beforeEach( () => {
 		apiFetch.mockReset();