@wordpress/core-data 7.48.0 → 7.48.1

package/src/private-selectors.ts

@@ -21,18 +21,6 @@ const EMPTY_OBJECT = {};
  * Returns the previous edit from the current undo offset
  * for the entity records edits history, if any.
  *
- * Known Issue: Every-time state.undoManager changes, the getUndoManager
- * private selector is called (if used within useSelect and things like that)
- * which ensures the UI is always properly reactive. But, it's not the case with
- * the custom "sync" undo manager.
- *
- * Assumption: When an undo/redo is created, other parts of the core-data state
- * are likely changing simultaneously, which will trigger the selectors again.
- *
- * This issue is acceptable based on the assumption above.
- *
- * @see https://github.com/WordPress/gutenberg/pull/72407/files#r2580214235 for more details.
- *
  * @param state State tree.
  *
  * @return The undo manager.

package/src/reducer.js

@@ -460,6 +460,22 @@ export function undoManager( state = createUndoManager() ) {
 	return state;
 }
 
+// Stores a snapshot of the sync undo manager's undo/redo availability so
+// core-data selectors can react to undo stack changes.
+export function syncUndoManagerState(
+	state = { hasRedo: false, hasUndo: false },
+	action
+) {
+	switch ( action.type ) {
+		case 'SYNC_UNDO_MANAGER_CHANGE':
+			return {
+				hasRedo: action.hasRedo,
+				hasUndo: action.hasUndo,
+			};
+	}
+	return state;
+}
+
 export function editsReference( state = {}, action ) {
 	switch ( action.type ) {
 		case 'EDIT_ENTITY_RECORD':
@@ -750,6 +766,7 @@ export default combineReducers( {
 	themeGlobalStyleRevisions,
 	entities,
 	editsReference,
+	syncUndoManagerState,
 	undoManager,
 	embedPreviews,
 	userPermissions,

package/src/resolvers.js

@@ -25,6 +25,7 @@ import {
 	RECEIVE_INTERMEDIATE_RESULTS,
 	isNumericID,
 	normalizeQueryForResolution,
+	saveCRDTDoc,
 } from './utils';
 import { fetchBlockPatterns } from './fetch';
 import { restoreSelection, getSelectionHistory } from './utils/crdt-selection';
@@ -250,9 +251,15 @@ export const getEntityRecord =
 						// persistence. As we add support for syncing additional entity,
 						// we'll need to revisit where persisted CRDT documents are stored.
 						persistCRDTDoc: () => {
-							resolveSelect
+							if (
+								! entityConfig.syncConfig?.supportsPersistence
+							) {
+								return;
+							}
+
+							return resolveSelect
 								.getEditedEntityRecord( kind, name, key )
-								.then( ( editedRecord ) => {
+								.then( async ( editedRecord ) => {
 									// 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;
@@ -260,19 +267,14 @@ export const getEntityRecord =
 										return;
 									}
 
-									// Trigger a minimal 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.
 									const entityIdKey =
 										entityConfig.key || DEFAULT_ENTITY_KEY;
-									dispatch.saveEntityRecord(
-										kind,
-										name,
-										{
-											[ entityIdKey ]:
-												editedRecord[ entityIdKey ],
-										},
-										{ __unstableSkipSyncUpdate: true }
+									const entityId =
+										editedRecord[ entityIdKey ];
+
+									await saveCRDTDoc(
+										`${ kind }/${ name }`,
+										entityId
 									);
 								} );
 						},
@@ -287,6 +289,11 @@ export const getEntityRecord =
 								);
 							}
 						},
+						onUndoStackChange: ( undoState ) => {
+							dispatch.__unstableNotifySyncUndoManagerChange(
+								undoState
+							);
+						},
 						restoreUndoMeta: ( ydoc, meta ) => {
 							const selectionHistory =
 								meta.get( 'selectionHistory' );

package/src/selectors.ts

@@ -24,6 +24,7 @@ import {
 	isNumericID,
 	getUserPermissionCacheKey,
 } from './utils';
+import { getSyncManager } from './sync';
 import type * as ET from './entity-types';
 import logEntityDeprecation from './utils/log-entity-deprecation';
 
@@ -44,6 +45,10 @@ export interface State {
 	themeGlobalStyleVariations: Record< string, string >;
 	themeGlobalStyleRevisions: Record< number, Object >;
 	undoManager: UndoManager;
+	syncUndoManagerState: {
+		hasRedo: boolean;
+		hasUndo: boolean;
+	};
 	userPermissions: Record< string, boolean >;
 	users: UserState;
 	navigationFallbackId: EntityRecordKey;
@@ -1148,6 +1153,9 @@ export function getRedoEdit( state: State ): Optional< any > {
  * @return Whether there is a previous edit or not.
  */
 export function hasUndo( state: State ): boolean {
+	if ( getSyncManager()?.undoManager ) {
+		return state.syncUndoManagerState.hasUndo;
+	}
 	return getUndoManager( state ).hasUndo();
 }
 
@@ -1160,6 +1168,9 @@ export function hasUndo( state: State ): boolean {
  * @return Whether there is a next edit or not.
  */
 export function hasRedo( state: State ): boolean {
+	if ( getSyncManager()?.undoManager ) {
+		return state.syncUndoManagerState.hasRedo;
+	}
 	return getUndoManager( state ).hasRedo();
 }
 

package/src/test/private-selectors.js

@@ -0,0 +1,66 @@
+/**
+ * Internal dependencies
+ */
+import { getUndoManager } from '../private-selectors';
+import { getSyncManager } from '../sync';
+
+jest.mock( '../sync', () => ( {
+	getSyncManager: jest.fn(),
+} ) );
+
+describe( 'getUndoManager', () => {
+	afterEach( () => {
+		getSyncManager.mockReset();
+	} );
+
+	it( 'returns the sync undo manager when one is available', () => {
+		const syncUndoManager = {
+			addRecord: jest.fn(),
+			hasRedo: jest.fn(),
+			hasUndo: jest.fn(),
+			redo: jest.fn(),
+			undo: jest.fn(),
+		};
+		const fallbackUndoManager = {
+			addRecord: jest.fn(),
+			hasRedo: jest.fn(),
+			hasUndo: jest.fn(),
+			redo: jest.fn(),
+			undo: jest.fn(),
+		};
+		getSyncManager.mockReturnValue( {
+			undoManager: syncUndoManager,
+		} );
+
+		const state = {
+			undoManager: fallbackUndoManager,
+			syncUndoManagerState: {
+				hasRedo: false,
+				hasUndo: false,
+			},
+		};
+
+		expect( getUndoManager( state ) ).toBe( syncUndoManager );
+	} );
+
+	it( 'returns the default undo manager when there is no sync undo manager', () => {
+		const fallbackUndoManager = {
+			addRecord: jest.fn(),
+			hasRedo: jest.fn(),
+			hasUndo: jest.fn(),
+			redo: jest.fn(),
+			undo: jest.fn(),
+		};
+		getSyncManager.mockReturnValue( undefined );
+
+		expect(
+			getUndoManager( {
+				undoManager: fallbackUndoManager,
+				syncUndoManagerState: {
+					hasRedo: false,
+					hasUndo: false,
+				},
+			} )
+		).toBe( fallbackUndoManager );
+	} );
+} );

package/src/test/reducer.js

@@ -12,6 +12,8 @@ import {
 	userPermissions,
 	autosaves,
 	currentUser,
+	syncUndoManagerState,
+	undoManager,
 } from '../reducer';
 
 describe( 'entities', () => {
@@ -531,3 +533,45 @@ describe( 'currentUser', () => {
 		expect( state ).toEqual( currentUserData );
 	} );
 } );
+
+describe( 'undoManager', () => {
+	it( 'returns the same reference for unrelated actions', () => {
+		const originalState = undoManager( undefined, {} );
+		const state = undoManager( originalState, {
+			type: 'UNRELATED',
+		} );
+
+		expect( state ).toBe( originalState );
+	} );
+} );
+
+describe( 'syncUndoManagerState', () => {
+	it( 'stores sync undo manager availability', () => {
+		const state = syncUndoManagerState( undefined, {
+			type: 'SYNC_UNDO_MANAGER_CHANGE',
+			hasRedo: false,
+			hasUndo: true,
+		} );
+
+		expect( state ).toEqual( {
+			hasRedo: false,
+			hasUndo: true,
+		} );
+	} );
+
+	it( 'updates sync undo manager availability', () => {
+		const state = syncUndoManagerState(
+			{ hasRedo: false, hasUndo: true },
+			{
+				type: 'SYNC_UNDO_MANAGER_CHANGE',
+				hasRedo: true,
+				hasUndo: false,
+			}
+		);
+
+		expect( state ).toEqual( {
+			hasRedo: true,
+			hasUndo: false,
+		} );
+	} );
+} );

package/src/test/resolvers.js

@@ -25,7 +25,6 @@ import {
 	getAutosaves,
 	getCurrentUser,
 } from '../resolvers';
-import { saveEntityRecord } from '../actions';
 import { RECEIVE_INTERMEDIATE_RESULTS } from '../utils';
 
 describe( 'getEntityRecord', () => {
@@ -50,6 +49,7 @@ describe( 'getEntityRecord', () => {
 			receiveEntityRecords: jest.fn(),
 			__unstableAcquireStoreLock: jest.fn(),
 			__unstableReleaseStoreLock: jest.fn(),
+			__unstableNotifySyncUndoManagerChange: jest.fn(),
 			receiveUserPermissions: jest.fn(),
 			finishResolutions: jest.fn(),
 		} );
@@ -57,6 +57,7 @@ describe( 'getEntityRecord', () => {
 
 		syncManager = {
 			load: jest.fn(),
+			update: jest.fn(),
 		};
 		getSyncManager.mockImplementation( () => syncManager );
 	} );
@@ -173,6 +174,7 @@ describe( 'getEntityRecord', () => {
 				addUndoMeta: expect.any( Function ),
 				editRecord: expect.any( Function ),
 				getEditedRecord: expect.any( Function ),
+				onUndoStackChange: expect.any( Function ),
 				onStatusChange: expect.any( Function ),
 				persistCRDTDoc: expect.any( Function ),
 				refetchRecord: expect.any( Function ),
@@ -181,7 +183,48 @@ describe( 'getEntityRecord', () => {
 		);
 	} );
 
-	it( 'persistCRDTDoc fetches edited record and does not save full entity record when the entity does not support meta', async () => {
+	it( 'notifies core-data when the sync undo manager stack changes', async () => {
+		const POST_RECORD = { id: 1, title: 'Test Post' };
+		const POST_RESPONSE = {
+			json: () => Promise.resolve( POST_RECORD ),
+		};
+		const ENTITIES_WITH_SYNC = [
+			{
+				name: 'post',
+				kind: 'postType',
+				baseURL: '/wp/v2/posts',
+				baseURLParams: { context: 'edit' },
+				syncConfig: {},
+			},
+		];
+
+		const resolveSelectWithSync = {
+			getEntitiesConfig: jest.fn( () => ENTITIES_WITH_SYNC ),
+			getEditedEntityRecord: jest.fn(),
+		};
+
+		triggerFetch.mockImplementation( () => POST_RESPONSE );
+
+		await getEntityRecord(
+			'postType',
+			'post',
+			1
+		)( {
+			dispatch,
+			registry,
+			resolveSelect: resolveSelectWithSync,
+		} );
+
+		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
+
+		handlers.onUndoStackChange( { hasRedo: false, hasUndo: true } );
+
+		expect(
+			dispatch.__unstableNotifySyncUndoManagerChange
+		).toHaveBeenCalledWith( { hasRedo: false, hasUndo: true } );
+	} );
+
+	it( 'persistCRDTDoc fetches edited post record and does not save 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 = {
@@ -189,15 +232,16 @@ describe( 'getEntityRecord', () => {
 		};
 		const ENTITIES_WITH_SYNC = [
 			{
-				name: 'bar',
-				kind: 'foo',
-				baseURL: '/wp/v2/foo',
+				name: 'post',
+				kind: 'postType',
+				baseURL: '/wp/v2/posts',
 				baseURLParams: { context: 'edit' },
-				syncConfig: {},
+				syncConfig: { supportsPersistence: true },
 			},
 		];
 
 		dispatch.saveEntityRecord = jest.fn();
+		syncManager.createPersistedCRDTDoc = jest.fn();
 
 		const resolveSelectWithSync = {
 			getEntitiesConfig: jest.fn( () => ENTITIES_WITH_SYNC ),
@@ -209,8 +253,8 @@ describe( 'getEntityRecord', () => {
 		triggerFetch.mockImplementation( () => ENTITY_RESPONSE );
 
 		await getEntityRecord(
-			'foo',
-			'bar',
+			'postType',
+			'post',
 			1
 		)( {
 			dispatch,
@@ -222,19 +266,20 @@ describe( 'getEntityRecord', () => {
 		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
 
 		// Call persistCRDTDoc and wait for the internal promise chain.
-		handlers.persistCRDTDoc();
-		await resolveSelectWithSync.getEditedEntityRecord();
+		await handlers.persistCRDTDoc();
 
 		// Should have fetched the full edited entity record.
 		expect(
 			resolveSelectWithSync.getEditedEntityRecord
-		).toHaveBeenCalledWith( 'foo', 'bar', 1 );
+		).toHaveBeenCalledWith( 'postType', 'post', 1 );
 
 		// Should not have called saveEntityRecord.
 		expect( dispatch.saveEntityRecord ).not.toHaveBeenCalled();
+		expect( syncManager.createPersistedCRDTDoc ).not.toHaveBeenCalled();
 	} );
 
-	it( 'persistCRDTDoc saves only the entity ID and omits REST-invalid fields', async () => {
+	it( 'persistCRDTDoc saves post CRDT docs through the sync endpoint', async () => {
+		const SERIALIZED_DOC = 'serialized-crdt-doc';
 		const POST_RECORD = { id: 1, title: 'Test Post', meta: {} };
 		const EDITED_RECORD = {
 			id: 1,
@@ -251,11 +296,14 @@ describe( 'getEntityRecord', () => {
 				kind: 'postType',
 				baseURL: '/wp/v2/posts',
 				baseURLParams: { context: 'edit' },
-				syncConfig: {},
+				syncConfig: { supportsPersistence: true },
 			},
 		];
 
 		dispatch.saveEntityRecord = jest.fn();
+		syncManager.createPersistedCRDTDoc = jest.fn( () =>
+			Promise.resolve( SERIALIZED_DOC )
+		);
 
 		const resolveSelectWithSync = {
 			getEntitiesConfig: jest.fn( () => ENTITIES_WITH_SYNC ),
@@ -264,7 +312,9 @@ describe( 'getEntityRecord', () => {
 			),
 		};
 
-		triggerFetch.mockImplementation( () => POST_RESPONSE );
+		triggerFetch
+			.mockImplementationOnce( () => POST_RESPONSE )
+			.mockImplementationOnce( () => [] );
 
 		await getEntityRecord(
 			'postType',
@@ -280,25 +330,31 @@ describe( 'getEntityRecord', () => {
 		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
 
 		// Call persistCRDTDoc and wait for the internal promise chain.
-		handlers.persistCRDTDoc();
-		await resolveSelectWithSync.getEditedEntityRecord();
+		await handlers.persistCRDTDoc();
 
 		// Should have fetched the full edited entity record.
 		expect(
 			resolveSelectWithSync.getEditedEntityRecord
 		).toHaveBeenCalledWith( 'postType', 'post', 1 );
 
-		// Should only send the entity ID. The pre-persist hook creates the
-		// persisted CRDT meta without round-tripping the full edited record.
-		expect( dispatch.saveEntityRecord ).toHaveBeenCalledWith(
-			'postType',
-			'post',
-			{ id: 1 },
-			{ __unstableSkipSyncUpdate: true }
+		expect( syncManager.createPersistedCRDTDoc ).toHaveBeenCalledWith(
+			'postType/post',
+			1
 		);
+		expect( triggerFetch ).toHaveBeenLastCalledWith( {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:1',
+				doc: SERIALIZED_DOC,
+			},
+		} );
+		expect( syncManager.update ).not.toHaveBeenCalled();
+		expect( dispatch.saveEntityRecord ).not.toHaveBeenCalled();
 	} );
 
-	it( 'persistCRDTDoc saves even when there are no unsaved edits', async () => {
+	it( 'persistCRDTDoc persists post CRDT docs even when there are no unsaved edits', async () => {
+		const SERIALIZED_DOC = 'serialized-crdt-doc';
 		const POST_RECORD = { id: 1, title: 'Test Post', meta: {} };
 		const POST_RESPONSE = {
 			json: () => Promise.resolve( POST_RECORD ),
@@ -309,11 +365,14 @@ describe( 'getEntityRecord', () => {
 				kind: 'postType',
 				baseURL: '/wp/v2/posts',
 				baseURLParams: { context: 'edit' },
-				syncConfig: {},
+				syncConfig: { supportsPersistence: true },
 			},
 		];
 
 		dispatch.saveEntityRecord = jest.fn();
+		syncManager.createPersistedCRDTDoc = jest.fn( () =>
+			Promise.resolve( SERIALIZED_DOC )
+		);
 
 		// Return the same record (no edits) from getEditedEntityRecord.
 		const resolveSelectWithSync = {
@@ -323,7 +382,9 @@ describe( 'getEntityRecord', () => {
 			),
 		};
 
-		triggerFetch.mockImplementation( () => POST_RESPONSE );
+		triggerFetch
+			.mockImplementationOnce( () => POST_RESPONSE )
+			.mockImplementationOnce( () => [] );
 
 		await getEntityRecord(
 			'postType',
@@ -338,95 +399,55 @@ describe( 'getEntityRecord', () => {
 		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
 
 		// Call persistCRDTDoc and wait for the internal promise chain.
-		handlers.persistCRDTDoc();
-		await resolveSelectWithSync.getEditedEntityRecord();
+		await handlers.persistCRDTDoc();
 
-		// Should save only the entity ID even with no edits.
-		expect( dispatch.saveEntityRecord ).toHaveBeenCalledWith(
-			'postType',
-			'post',
-			{ id: 1 },
-			{ __unstableSkipSyncUpdate: true }
-		);
+		expect( triggerFetch ).toHaveBeenLastCalledWith( {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:1',
+				doc: SERIALIZED_DOC,
+			},
+		} );
+		expect( syncManager.update ).not.toHaveBeenCalled();
+		expect( dispatch.saveEntityRecord ).not.toHaveBeenCalled();
 	} );
 
-	it( 'persistCRDTDoc does not replay a stale save response into the sync document', async () => {
-		const INITIAL_TITLE = 'Initial Title';
-		const SYNCED_TITLE = 'Synced Title';
-		const POST_RECORD = { id: 1, title: INITIAL_TITLE, meta: {} };
-		const EDITED_RECORD = { id: 1, title: SYNCED_TITLE, meta: {} };
-		const STALE_SAVE_RESPONSE = {
+	it( 'persistCRDTDoc does not persist entities whose sync config does not support persistence', async () => {
+		const TERM_RECORD = { id: 1, name: 'Category', meta: {} };
+		const EDITED_RECORD = {
 			id: 1,
-			title: INITIAL_TITLE,
-			meta: { _crdt_document: 'serialized-crdt-doc' },
-		};
-		const liveSyncState = {
-			isSaved: false,
-			title: SYNCED_TITLE,
+			name: 'Edited Category',
+			description: '',
+			meta: {},
 		};
-		const POST_RESPONSE = {
-			json: () => Promise.resolve( POST_RECORD ),
+		const TERM_RESPONSE = {
+			json: () => Promise.resolve( TERM_RECORD ),
 		};
 		const ENTITIES_WITH_SYNC = [
 			{
-				name: 'post',
-				kind: 'postType',
-				baseURL: '/wp/v2/posts',
+				name: 'category',
+				kind: 'taxonomy',
+				baseURL: '/wp/v2/categories',
 				baseURLParams: { context: 'edit' },
 				syncConfig: {},
-				__unstablePrePersist: jest.fn( async () => ( {
-					meta: { _crdt_document: 'serialized-crdt-doc' },
-				} ) ),
 			},
 		];
 
-		const select = {
-			getEditedEntityRecord: jest.fn( () => EDITED_RECORD ),
-			getRawEntityRecord: jest.fn( () => POST_RECORD ),
-		};
 		const resolveSelectWithSync = {
 			getEntitiesConfig: jest.fn( () => ENTITIES_WITH_SYNC ),
 			getEditedEntityRecord: jest.fn( () =>
 				Promise.resolve( EDITED_RECORD )
 			),
 		};
-		let savePromise;
-
-		syncManager.update = jest.fn(
-			( _objectType, _objectId, changes, _origin, options ) => {
-				if (
-					Object.prototype.hasOwnProperty.call( changes, 'title' )
-				) {
-					liveSyncState.title = changes.title;
-				}
-				if ( options?.isSave ) {
-					liveSyncState.isSaved = true;
-				}
-			}
-		);
-		dispatch.saveEntityRecord = jest.fn(
-			( kind, name, record, options ) => {
-				savePromise = saveEntityRecord(
-					kind,
-					name,
-					record,
-					options
-				)( {
-					select,
-					dispatch,
-					resolveSelect: resolveSelectWithSync,
-				} );
-				return savePromise;
-			}
-		);
+		dispatch.saveEntityRecord = jest.fn();
+		syncManager.createPersistedCRDTDoc = jest.fn();
 
-		triggerFetch
-			.mockImplementationOnce( () => POST_RESPONSE )
-			.mockImplementationOnce( () => STALE_SAVE_RESPONSE );
+		triggerFetch.mockImplementation( () => TERM_RESPONSE );
 
 		await getEntityRecord(
-			'postType',
-			'post',
+			'taxonomy',
+			'category',
 			1
 		)( {
 			dispatch,
@@ -436,27 +457,13 @@ describe( 'getEntityRecord', () => {
 
 		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
 
-		handlers.persistCRDTDoc();
-		await Promise.resolve();
-		await savePromise;
+		await handlers.persistCRDTDoc();
 
-		expect( dispatch.saveEntityRecord ).toHaveBeenCalledWith(
-			'postType',
-			'post',
-			{ id: 1 },
-			{ __unstableSkipSyncUpdate: true }
-		);
-		expect( syncManager.update ).toHaveBeenCalledWith(
-			'postType/post',
-			1,
-			{},
-			'local-undo-ignored',
-			{ isSave: true }
-		);
-		expect( liveSyncState ).toEqual( {
-			isSaved: true,
-			title: SYNCED_TITLE,
-		} );
+		expect(
+			resolveSelectWithSync.getEditedEntityRecord
+		).not.toHaveBeenCalled();
+		expect( dispatch.saveEntityRecord ).not.toHaveBeenCalled();
+		expect( syncManager.createPersistedCRDTDoc ).not.toHaveBeenCalled();
 	} );
 
 	it( 'provides transient properties when read/write config is supplied', async () => {
@@ -507,6 +514,7 @@ describe( 'getEntityRecord', () => {
 				addUndoMeta: expect.any( Function ),
 				editRecord: expect.any( Function ),
 				getEditedRecord: expect.any( Function ),
+				onUndoStackChange: expect.any( Function ),
 				onStatusChange: expect.any( Function ),
 				persistCRDTDoc: expect.any( Function ),
 				refetchRecord: expect.any( Function ),