@wordpress/core-data 7.52.0 → 7.53.0

package/src/test/actions.js

@@ -1,13 +1,5 @@
-/**
- * WordPress dependencies
- */
 import apiFetch from '@wordpress/api-fetch';
-
 jest.mock( '@wordpress/api-fetch' );
-
-/**
- * Internal dependencies
- */
 import {
 	editEntityRecord,
 	clearEntityRecordEdits,
@@ -32,6 +24,7 @@ jest.mock( '../batch', () => {
 
 jest.mock( '../sync', () => ( {
 	getSyncManager: jest.fn(),
+	CRDT_AUTOSAVE_SNAPSHOT_KEY: 'crdt_snapshot',
 	LOCAL_EDITOR_ORIGIN: 'local-editor',
 	LOCAL_UNDO_IGNORED_ORIGIN: 'local-undo-ignored',
 } ) );
@@ -1187,6 +1180,91 @@ describe( 'saveEntityRecord', () => {
 		expect( result ).toBe( updatedRecord );
 	} );
 
+	it( 'resets persisted edits using the pre-prePersist edits so the record is clean after saving', async () => {
+		const persistedRecord = {
+			id: 10,
+			meta: {
+				plugin_value: 'persisted',
+				_crdt_document: 'old-doc',
+			},
+		};
+		// Mirrors a store meta edit: `mergedEdits` snapshots the full edited
+		// meta, including the load-time CRDT document.
+		const edits = {
+			id: 10,
+			meta: {
+				plugin_value: 'edited',
+				_crdt_document: 'old-doc',
+			},
+		};
+		const configs = [
+			{
+				name: 'post',
+				kind: 'postType',
+				baseURL: '/wp/v2/posts',
+				syncConfig: {},
+				// Mirrors prePersistPostType, which injects a freshly
+				// serialized CRDT snapshot into the request meta.
+				__unstablePrePersist: async ( _persisted, saveEdits ) => ( {
+					meta: {
+						...saveEdits.meta,
+						_crdt_document: 'new-doc',
+					},
+				} ),
+			},
+		];
+		const syncManager = {
+			update: jest.fn(),
+		};
+		const select = {
+			getRawEntityRecord: () => persistedRecord,
+		};
+		const resolveSelect = { getEntitiesConfig: jest.fn( () => configs ) };
+		const updatedRecord = {
+			id: 10,
+			meta: {
+				plugin_value: 'edited',
+				// The server may also mutate meta on save (e.g. a plugin
+				// normalizing a value in a save hook).
+				server_value: 'server-mutated',
+				_crdt_document: 'new-doc',
+			},
+		};
+		apiFetch.mockImplementation( () => updatedRecord );
+		getSyncManager.mockReturnValue( syncManager );
+
+		await saveEntityRecord(
+			'postType',
+			'post',
+			edits
+		)( { select, dispatch, resolveSelect } );
+
+		expect( apiFetch ).toHaveBeenCalledWith( {
+			path: '/wp/v2/posts/10',
+			method: 'PUT',
+			data: {
+				...edits,
+				meta: {
+					plugin_value: 'edited',
+					_crdt_document: 'new-doc',
+				},
+			},
+		} );
+
+		// The persisted edits passed to the reducer must be the original
+		// edits, not the prePersist-augmented request payload. Otherwise the
+		// injected CRDT snapshot makes the comparison against the state edits
+		// fail and the record stays dirty after a successful save.
+		expect( dispatch.receiveEntityRecords ).toHaveBeenCalledWith(
+			'postType',
+			'post',
+			updatedRecord,
+			undefined,
+			true,
+			edits
+		);
+	} );
+
 	it( 'syncs direct save changes before pre-persisting the record', async () => {
 		const persistedRecord = {
 			id: 10,
@@ -1633,6 +1711,176 @@ describe( 'saveEntityRecord', () => {
 
 		expect( result ).toBe( postType );
 	} );
+
+	describe( 'autosave CRDT snapshots', () => {
+		const persistedRecord = {
+			id: 10,
+			title: 'Test post',
+			content: 'Test content',
+		};
+		let select;
+		let resolveSelect;
+		let syncManager;
+
+		beforeEach( () => {
+			dispatch.receiveAutosaves = jest.fn();
+			select = {
+				getRawEntityRecord: () => persistedRecord,
+			};
+			syncManager = {
+				getEntitySnapshot: jest.fn( () => 'ENCODED_SNAPSHOT' ),
+				update: jest.fn(),
+			};
+			getSyncManager.mockReturnValue( syncManager );
+			apiFetch.mockImplementation( () => ( {
+				id: 20,
+				parent: 10,
+				author: 2,
+				modified_gmt: '2026-07-21T10:00:00',
+			} ) );
+		} );
+
+		afterEach( () => {
+			getSyncManager.mockReset();
+		} );
+
+		function makeResolveSelect( entityConfig ) {
+			return {
+				getEntitiesConfig: jest.fn( () => [ entityConfig ] ),
+			};
+		}
+
+		function getAutosaveRequestData() {
+			return apiFetch.mock.calls[ 0 ][ 0 ].data;
+		}
+
+		it( 'sends the current CRDT snapshot with the autosave request', async () => {
+			resolveSelect = makeResolveSelect( {
+				name: 'post',
+				kind: 'postType',
+				baseURL: '/wp/v2/posts',
+				syncConfig: {},
+			} );
+
+			await saveEntityRecord( 'postType', 'post', persistedRecord, {
+				isAutosave: true,
+			} )( { select, dispatch, resolveSelect } );
+
+			expect( syncManager.getEntitySnapshot ).toHaveBeenCalledWith(
+				'postType/post',
+				10
+			);
+			expect( getAutosaveRequestData() ).toEqual(
+				expect.objectContaining( {
+					crdt_snapshot: 'ENCODED_SNAPSHOT',
+				} )
+			);
+		} );
+
+		it( 'omits the snapshot for entities without a sync config', async () => {
+			resolveSelect = makeResolveSelect( {
+				name: 'post',
+				kind: 'postType',
+				baseURL: '/wp/v2/posts',
+			} );
+
+			await saveEntityRecord( 'postType', 'post', persistedRecord, {
+				isAutosave: true,
+			} )( { select, dispatch, resolveSelect } );
+
+			expect( syncManager.getEntitySnapshot ).not.toHaveBeenCalled();
+			expect( getAutosaveRequestData() ).not.toHaveProperty(
+				'crdt_snapshot'
+			);
+			expect( dispatch.receiveAutosaves ).toHaveBeenCalled();
+		} );
+
+		it( 'omits the snapshot when the entity is not loaded in the sync manager', async () => {
+			resolveSelect = makeResolveSelect( {
+				name: 'post',
+				kind: 'postType',
+				baseURL: '/wp/v2/posts',
+				syncConfig: {},
+			} );
+			syncManager.getEntitySnapshot.mockReturnValue( undefined );
+
+			await saveEntityRecord( 'postType', 'post', persistedRecord, {
+				isAutosave: true,
+			} )( { select, dispatch, resolveSelect } );
+
+			expect( getAutosaveRequestData() ).not.toHaveProperty(
+				'crdt_snapshot'
+			);
+		} );
+
+		it( 'captures the snapshot before the request is sent', async () => {
+			resolveSelect = makeResolveSelect( {
+				name: 'post',
+				kind: 'postType',
+				baseURL: '/wp/v2/posts',
+				syncConfig: {},
+			} );
+
+			// A snapshot captured after the request would describe content
+			// the autosave did not include, which could wrongly suppress the
+			// notice. Assert the ordering directly.
+			const callOrder = [];
+			syncManager.getEntitySnapshot.mockImplementation( () => {
+				callOrder.push( 'snapshot' );
+				return 'ENCODED_SNAPSHOT';
+			} );
+			apiFetch.mockImplementation( () => {
+				callOrder.push( 'fetch' );
+				return { id: 20, parent: 10 };
+			} );
+
+			await saveEntityRecord( 'postType', 'post', persistedRecord, {
+				isAutosave: true,
+			} )( { select, dispatch, resolveSelect } );
+
+			expect( callOrder ).toEqual( [ 'snapshot', 'fetch' ] );
+		} );
+
+		it( 'applies direct record changes to the CRDT before capturing the snapshot', async () => {
+			resolveSelect = makeResolveSelect( {
+				name: 'post',
+				kind: 'postType',
+				baseURL: '/wp/v2/posts',
+				syncConfig: {},
+			} );
+
+			// A direct caller can pass content that never went through
+			// `editEntityRecord`, so it is not yet in the CRDT. If the
+			// snapshot were captured first, it would describe a state
+			// without this content and wrongly suppress the recovery
+			// notice on reload.
+			const callOrder = [];
+			syncManager.update = jest.fn( () => {
+				callOrder.push( 'update' );
+			} );
+			syncManager.getEntitySnapshot.mockImplementation( () => {
+				callOrder.push( 'snapshot' );
+				return 'ENCODED_SNAPSHOT';
+			} );
+
+			const record = {
+				id: 10,
+				content: 'Directly autosaved content',
+			};
+
+			await saveEntityRecord( 'postType', 'post', record, {
+				isAutosave: true,
+			} )( { select, dispatch, resolveSelect } );
+
+			expect( syncManager.update ).toHaveBeenCalledWith(
+				'postType/post',
+				10,
+				record,
+				'local-undo-ignored'
+			);
+			expect( callOrder ).toEqual( [ 'update', 'snapshot' ] );
+		} );
+	} );
 } );
 
 describe( 'receiveUserPermission', () => {

package/src/test/deprecated-entity-logging.js

@@ -1,12 +1,5 @@
-/**
- * WordPress dependencies
- */
 import deprecated from '@wordpress/deprecated';
 import { createRegistry } from '@wordpress/data';
-
-/**
- * Internal dependencies
- */
 import { store as coreDataStore } from '../index';
 
 jest.mock( '@wordpress/deprecated' );

package/src/test/entities.js

@@ -1,8 +1,4 @@
-/**
- * WordPress dependencies
- */
 import apiFetch from '@wordpress/api-fetch';
-
 jest.mock( '@wordpress/api-fetch' );
 jest.mock( '../sync', () => ( {
 	...jest.requireActual( '../sync' ),
@@ -12,10 +8,6 @@ jest.mock( '../utils/crdt', () => ( {
 	...jest.requireActual( '../utils/crdt' ),
 	applyPostChangesToCRDTDoc: jest.fn(),
 } ) );
-
-/**
- * Internal dependencies
- */
 import {
 	getMethodName,
 	rootEntitiesConfig,

package/src/test/entity-provider.js

@@ -1,11 +1,4 @@
-/**
- * External dependencies
- */
 import { act, render } from '@testing-library/react';
-
-/**
- * WordPress dependencies
- */
 import {
 	createBlock,
 	registerBlockType,
@@ -16,10 +9,6 @@ import { RichText, useBlockProps } from '@wordpress/block-editor';
 import { createRegistry, RegistryProvider } from '@wordpress/data';
 import { registerCoreBlocks } from '@wordpress/block-library';
 import { unregisterFormatType } from '@wordpress/rich-text';
-
-/**
- * Internal dependencies
- */
 import { store as coreDataStore } from '../index';
 import useEntityBlockEditor from '../hooks/use-entity-block-editor';
 

package/src/test/private-actions.js

@@ -1,13 +1,11 @@
-/**
- * WordPress dependencies
- */
 import apiFetch from '@wordpress/api-fetch';
-
-/**
- * Internal dependencies
- */
+import { store as blockEditorStore } from '@wordpress/block-editor';
+import { createRegistry } from '@wordpress/data';
+import { store as noticesStore } from '@wordpress/notices';
+import { store as coreStore } from '..';
 import { editMediaEntity, setCollaborationSupported } from '../private-actions';
 import { getSyncManager, hasSyncManager } from '../sync';
+import { unlock } from '../lock-unlock';
 
 jest.mock( '@wordpress/api-fetch' );
 jest.mock( '../sync', () => ( {
@@ -248,3 +246,295 @@ describe( 'setCollaborationSupported', () => {
 		} );
 	} );
 } );
+
+describe( 'saveDirtyEntities', () => {
+	beforeEach( () => {
+		apiFetch.mockReset();
+	} );
+
+	const postTypeConfig = {
+		kind: 'postType',
+		name: 'post',
+		baseURL: '/wp/v2/posts',
+		transientEdits: { blocks: true, selection: true },
+		mergedEdits: { meta: true },
+	};
+
+	const postId = 44;
+
+	const post = {
+		id: postId,
+		type: 'post',
+		title: 'bar',
+		content: 'bar',
+		excerpt: 'crackers',
+		status: 'draft',
+	};
+
+	const postEntityRecord = {
+		key: postId,
+		kind: 'postType',
+		name: 'post',
+		title: 'bar',
+	};
+
+	function createRegistryWithStoresAndEditedPost() {
+		const registry = createRegistry();
+
+		registry.register( blockEditorStore );
+		registry.register( coreStore );
+		registry.register( noticesStore );
+
+		registry.dispatch( coreStore ).addEntities( [ postTypeConfig ] );
+
+		registry
+			.dispatch( coreStore )
+			.receiveEntityRecords( 'postType', 'post', post );
+
+		registry
+			.dispatch( coreStore )
+			.editEntityRecord( 'postType', 'post', postId, {
+				content: 'new bar',
+			} );
+
+		return registry;
+	}
+
+	const hasEdits = ( registry ) =>
+		registry
+			.select( coreStore )
+			.hasEditsForEntityRecord( 'postType', 'post', postId );
+
+	const getContent = ( registry ) =>
+		registry
+			.select( coreStore )
+			.getEditedEntityRecord( 'postType', 'post', postId ).content;
+
+	const getMethod = ( options ) =>
+		options.headers?.[ 'X-HTTP-Method-Override' ] ||
+		options.method ||
+		'GET';
+
+	it( 'saves modified entities', async () => {
+		apiFetch.mockImplementation( async ( options ) => {
+			const method = getMethod( options );
+			const { path, data } = options;
+
+			if (
+				method === 'PUT' &&
+				path.startsWith( `/wp/v2/posts/${ postId }` )
+			) {
+				return { ...post, ...data };
+			}
+
+			throw {
+				code: 'unknown_path',
+				message: `Unknown path: ${ method } ${ path }`,
+			};
+		} );
+
+		const registry = createRegistryWithStoresAndEditedPost();
+
+		expect( hasEdits( registry ) ).toBe( true );
+
+		await unlock( registry.dispatch( coreStore ) ).saveDirtyEntities( {
+			dirtyEntityRecords: [ postEntityRecord ],
+		} );
+
+		expect( getContent( registry ) ).toBe( 'new bar' );
+		expect( hasEdits( registry ) ).toBe( false );
+
+		const notices = registry.select( noticesStore ).getNotices();
+		expect( notices ).toMatchObject( [
+			{
+				status: 'success',
+				content: 'Site updated.',
+			},
+		] );
+	} );
+
+	it( 'shows a notice to convey errors', async () => {
+		apiFetch.mockImplementation( async ( options ) => {
+			const method = getMethod( options );
+			const { path } = options;
+
+			throw {
+				code: 'unknown_path',
+				message: `Unknown path: ${ method } ${ path }`,
+			};
+		} );
+
+		const registry = createRegistryWithStoresAndEditedPost();
+
+		expect( hasEdits( registry ) ).toBe( true );
+
+		await unlock( registry.dispatch( coreStore ) ).saveDirtyEntities( {
+			dirtyEntityRecords: [ postEntityRecord ],
+		} );
+
+		expect( getContent( registry ) ).toBe( 'new bar' );
+		expect( hasEdits( registry ) ).toBe( true );
+
+		const notices = registry.select( noticesStore ).getNotices();
+		expect( notices[ 0 ].status ).toBe( 'error' );
+		expect( notices[ 0 ].content ).toMatch( /^Unknown path/ );
+	} );
+
+	it( 'derives error messages depending on failure scenario', async () => {
+		const registry = createRegistryWithStoresAndEditedPost();
+
+		// Throw an object with a `message` property
+		apiFetch.mockImplementation( async () => {
+			throw {
+				message: 'Lorem ipsum',
+			};
+		} );
+
+		await unlock( registry.dispatch( coreStore ) ).saveDirtyEntities( {
+			dirtyEntityRecords: [ postEntityRecord ],
+		} );
+
+		expect(
+			registry.select( noticesStore ).getNotices().at( -1 )
+		).toMatchObject( {
+			status: 'error',
+			content: 'Lorem ipsum',
+		} );
+
+		// Throw an object with an empty `message` property
+		apiFetch.mockImplementation( async () => {
+			throw {
+				message: '',
+			};
+		} );
+
+		await unlock( registry.dispatch( coreStore ) ).saveDirtyEntities( {
+			dirtyEntityRecords: [ postEntityRecord ],
+		} );
+
+		expect(
+			registry.select( noticesStore ).getNotices().at( -1 )
+		).toMatchObject( {
+			status: 'error',
+			content: 'Saving failed.',
+		} );
+
+		// Throw an actual error
+		apiFetch.mockImplementation( async () => {
+			throw new Error( 'Dolor sit amet' );
+		} );
+
+		await unlock( registry.dispatch( coreStore ) ).saveDirtyEntities( {
+			dirtyEntityRecords: [ postEntityRecord ],
+		} );
+
+		expect(
+			registry.select( noticesStore ).getNotices().at( -1 )
+		).toMatchObject( {
+			status: 'error',
+			content: 'Dolor sit amet',
+		} );
+
+		// Throw a string
+		apiFetch.mockImplementation( async () => {
+			throw 'Consectetur adipiscing elit';
+		} );
+
+		await unlock( registry.dispatch( coreStore ) ).saveDirtyEntities( {
+			dirtyEntityRecords: [ postEntityRecord ],
+		} );
+
+		expect(
+			registry.select( noticesStore ).getNotices().at( -1 )
+		).toMatchObject( {
+			status: 'error',
+			content: 'Consectetur adipiscing elit',
+		} );
+
+		// Throw an object implementing `toString`
+		apiFetch.mockImplementation( async () => {
+			throw {
+				toString() {
+					return 'Sed do eiusmod tempor incididunt';
+				},
+			};
+		} );
+
+		await unlock( registry.dispatch( coreStore ) ).saveDirtyEntities( {
+			dirtyEntityRecords: [ postEntityRecord ],
+		} );
+
+		expect(
+			registry.select( noticesStore ).getNotices().at( -1 )
+		).toMatchObject( {
+			status: 'error',
+			content: 'Sed do eiusmod tempor incididunt',
+		} );
+
+		// Throw something with no clear message
+		apiFetch.mockImplementation( async () => {
+			throw {};
+		} );
+
+		await unlock( registry.dispatch( coreStore ) ).saveDirtyEntities( {
+			dirtyEntityRecords: [ postEntityRecord ],
+		} );
+
+		expect(
+			registry.select( noticesStore ).getNotices().at( -1 )
+		).toMatchObject( {
+			status: 'error',
+			content: 'Saving failed.',
+		} );
+	} );
+
+	it( 'aborts if `onSave` fails', async () => {
+		apiFetch.mockImplementation( async () => {
+			throw {
+				code: 'unknown_path',
+				message: 'Unknown path',
+			};
+		} );
+
+		const registry = createRegistryWithStoresAndEditedPost();
+
+		await unlock( registry.dispatch( coreStore ) ).saveDirtyEntities( {
+			dirtyEntityRecords: [ postEntityRecord ],
+			async onSave() {
+				throw new Error( 'oh no' );
+			},
+		} );
+
+		expect( hasEdits( registry ) ).toBe( true );
+
+		const notices = registry.select( noticesStore ).getNotices();
+		expect( notices ).toMatchObject( [
+			{
+				status: 'error',
+				content: 'oh no',
+			},
+		] );
+	} );
+
+	it( 'honors the `successNoticeContent` prop', async () => {
+		apiFetch.mockImplementation( async ( options ) => {
+			const { data } = options;
+			return { ...post, ...data };
+		} );
+
+		const registry = createRegistryWithStoresAndEditedPost();
+
+		await unlock( registry.dispatch( coreStore ) ).saveDirtyEntities( {
+			dirtyEntityRecords: [ postEntityRecord ],
+			successNoticeContent: 'eureka',
+		} );
+
+		const notices = registry.select( noticesStore ).getNotices();
+		expect( notices ).toMatchObject( [
+			{
+				status: 'success',
+				content: 'eureka',
+			},
+		] );
+	} );
+} );

package/src/test/private-selectors.js

@@ -1,6 +1,3 @@
-/**
- * Internal dependencies
- */
 import { getUndoManager } from '../private-selectors';
 import { getSyncManager } from '../sync';
 

package/src/test/reducer.js

@@ -1,11 +1,4 @@
-/**
- * External dependencies
- */
 import deepFreeze from 'deep-freeze';
-
-/**
- * Internal dependencies
- */
 import {
 	entities,
 	embedPreviews,

package/src/test/resolvers.js

@@ -1,22 +1,10 @@
-/**
- * WordPress dependencies
- */
 import triggerFetch from '@wordpress/api-fetch';
-
-/**
- * Internal dependencies
- */
 import { getSyncManager } from '../sync';
-
 jest.mock( '@wordpress/api-fetch' );
 jest.mock( '../sync', () => ( {
 	getSyncManager: jest.fn(),
 	LOCAL_UNDO_IGNORED_ORIGIN: 'local-undo-ignored',
 } ) );
-
-/**
- * Internal dependencies
- */
 import {
 	getEntityRecord,
 	getEntityRecords,