@wordpress/core-data 7.41.0 → 7.41.2-next.v.202603161435.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,
 				] );
 		}
 
@@ -991,9 +996,11 @@ export const getDefaultTemplateId =
 			template.id = id;
 			registry.batch( () => {
 				dispatch.receiveDefaultTemplateId( query, id );
-				dispatch.receiveEntityRecords( 'postType', template.type, [
-					template,
-				] );
+				dispatch.receiveEntityRecords(
+					'postType',
+					template.type,
+					template
+				);
 				// Avoid further network requests.
 				dispatch.finishResolution( 'getEntityRecord', [
 					'postType',
@@ -1034,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 );
+				}
 
-				// 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 ) {
+				// 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
+					);
+
+					// 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 ) => [
@@ -1113,14 +1129,17 @@ export const getRevisions =
 							name,
 							recordKey,
 							record[ key ],
+							normalizedQuery,
 						] );
 
 					dispatch.finishResolutions(
 						'getRevision',
 						resolutionsArgs
 					);
-				}
-			} );
+				} );
+			}
+		} finally {
+			dispatch.__unstableReleaseStoreLock( lock );
 		}
 	};
 
@@ -1145,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
@@ -1170,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

@@ -17,6 +17,7 @@ const {
 	CRDT_DOC_META_PERSISTENCE_KEY,
 	CRDT_RECORD_MAP_KEY,
 	LOCAL_EDITOR_ORIGIN,
+	LOCAL_UNDO_IGNORED_ORIGIN,
 	retrySyncConnection,
 } = unlock( syncPrivateApis );
 
@@ -25,6 +26,7 @@ export {
 	CRDT_DOC_META_PERSISTENCE_KEY,
 	CRDT_RECORD_MAP_KEY,
 	LOCAL_EDITOR_ORIGIN,
+	LOCAL_UNDO_IGNORED_ORIGIN,
 	retrySyncConnection,
 };
 

package/src/test/private-actions.js

@@ -102,7 +102,7 @@ describe( 'editMediaEntity', () => {
 		expect( dispatch.receiveEntityRecords ).toHaveBeenCalledWith(
 			'postType',
 			'attachment',
-			[ updatedRecord ],
+			updatedRecord,
 			undefined,
 			true,
 			undefined,

package/src/test/resolvers.js

@@ -172,16 +172,69 @@ describe( 'getEntityRecord', () => {
 				editRecord: expect.any( Function ),
 				getEditedRecord: expect.any( Function ),
 				onStatusChange: expect.any( Function ),
+				persistCRDTDoc: expect.any( Function ),
 				refetchRecord: expect.any( Function ),
 				restoreUndoMeta: expect.any( Function ),
-				saveRecord: expect.any( Function ),
 			}
 		);
 	} );
 
-	it( 'saveRecord fetches edited record and saves full entity record', async () => {
-		const POST_RECORD = { id: 1, title: 'Test Post' };
-		const EDITED_RECORD = { id: 1, title: 'Edited Post' };
+	it( 'persistCRDTDoc fetches edited record and does not save full entity record when the entity does not support meta', async () => {
+		const ENTITY_RECORD = { id: 1, title: 'Test Record' };
+		const EDITED_RECORD = { id: 1, title: 'Edited Record' };
+		const ENTITY_RESPONSE = {
+			json: () => Promise.resolve( ENTITY_RECORD ),
+		};
+		const ENTITIES_WITH_SYNC = [
+			{
+				name: 'bar',
+				kind: 'foo',
+				baseURL: '/wp/v2/foo',
+				baseURLParams: { context: 'edit' },
+				syncConfig: {},
+			},
+		];
+
+		dispatch.saveEntityRecord = jest.fn();
+
+		const resolveSelectWithSync = {
+			getEntitiesConfig: jest.fn( () => ENTITIES_WITH_SYNC ),
+			getEditedEntityRecord: jest.fn( () =>
+				Promise.resolve( EDITED_RECORD )
+			),
+		};
+
+		triggerFetch.mockImplementation( () => ENTITY_RESPONSE );
+
+		await getEntityRecord(
+			'foo',
+			'bar',
+			1
+		)( {
+			dispatch,
+			registry,
+			resolveSelect: resolveSelectWithSync,
+		} );
+
+		// Extract the handlers passed to syncManager.load.
+		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
+
+		// Call persistCRDTDoc and wait for the internal promise chain.
+		handlers.persistCRDTDoc();
+		await resolveSelectWithSync.getEditedEntityRecord();
+
+		// Should have fetched the full edited entity record.
+		expect(
+			resolveSelectWithSync.getEditedEntityRecord
+		).toHaveBeenCalledWith( 'foo', 'bar', 1 );
+
+		// Should not have called saveEntityRecord.
+		expect( dispatch.saveEntityRecord ).not.toHaveBeenCalled();
+	} );
+
+	it( 'persistCRDTDoc fetches edited record and saves full entity record', async () => {
+		const POST_RECORD = { id: 1, title: 'Test Post', meta: {} };
+		const EDITED_RECORD = { id: 1, title: 'Edited Post', meta: {} };
 		const POST_RESPONSE = {
 			json: () => Promise.resolve( POST_RECORD ),
 		};
@@ -219,8 +272,8 @@ describe( 'getEntityRecord', () => {
 		// Extract the handlers passed to syncManager.load.
 		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
 
-		// Call saveRecord and wait for the internal promise chain.
-		handlers.saveRecord();
+		// Call persistCRDTDoc and wait for the internal promise chain.
+		handlers.persistCRDTDoc();
 		await resolveSelectWithSync.getEditedEntityRecord();
 
 		// Should have fetched the full edited entity record.
@@ -236,8 +289,8 @@ describe( 'getEntityRecord', () => {
 		);
 	} );
 
-	it( 'saveRecord saves even when there are no unsaved edits', async () => {
-		const POST_RECORD = { id: 1, title: 'Test Post' };
+	it( 'persistCRDTDoc saves even when there are no unsaved edits', async () => {
+		const POST_RECORD = { id: 1, title: 'Test Post', meta: {} };
 		const POST_RESPONSE = {
 			json: () => Promise.resolve( POST_RECORD ),
 		};
@@ -275,8 +328,8 @@ describe( 'getEntityRecord', () => {
 
 		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
 
-		// Call saveRecord and wait for the internal promise chain.
-		handlers.saveRecord();
+		// Call persistCRDTDoc and wait for the internal promise chain.
+		handlers.persistCRDTDoc();
 		await resolveSelectWithSync.getEditedEntityRecord();
 
 		// Should save the record even with no edits (the whole point of the fix).
@@ -336,9 +389,9 @@ describe( 'getEntityRecord', () => {
 				editRecord: expect.any( Function ),
 				getEditedRecord: expect.any( Function ),
 				onStatusChange: expect.any( Function ),
+				persistCRDTDoc: expect.any( Function ),
 				refetchRecord: expect.any( Function ),
 				restoreUndoMeta: expect.any( Function ),
-				saveRecord: expect.any( Function ),
 			}
 		);
 	} );
@@ -862,6 +915,24 @@ describe( 'canUser', () => {
 		expect( dispatch.receiveUserPermissions ).not.toHaveBeenCalled();
 	} );
 
+	it( 'receives false when the allow header is missing', async () => {
+		triggerFetch.mockImplementation( () => ( {
+			headers: new Map(),
+		} ) );
+
+		await canUser(
+			'create',
+			'media'
+		)( { dispatch, registry, resolveSelect } );
+
+		expect( dispatch.receiveUserPermissions ).toHaveBeenCalledWith( {
+			'create/media': false,
+			'read/media': false,
+			'update/media': false,
+			'delete/media': false,
+		} );
+	} );
+
 	it( 'throws an error when an entity resource object is malformed', async () => {
 		await expect(
 			canUser( 'create', { name: 'wp_block' } )( {
@@ -888,9 +959,12 @@ describe( 'canUser', () => {
 			parse: false,
 		} );
 
-		expect( dispatch.receiveUserPermissions ).toHaveBeenCalledWith(
-			expect.objectContaining( { 'create/media': false } )
-		);
+		expect( dispatch.receiveUserPermissions ).toHaveBeenCalledWith( {
+			'create/media': false,
+			'read/media': true,
+			'update/media': false,
+			'delete/media': false,
+		} );
 	} );
 
 	it( 'receives false when the user is not allowed to perform an action on entities', async () => {