@wordpress/core-data 7.40.2-next.v.202602241322.0 → 7.40.2

package/src/test/entities.js

@@ -4,6 +4,14 @@
 import apiFetch from '@wordpress/api-fetch';
 
 jest.mock( '@wordpress/api-fetch' );
+jest.mock( '../sync', () => ( {
+	...jest.requireActual( '../sync' ),
+	getSyncManager: jest.fn(),
+} ) );
+jest.mock( '../utils/crdt', () => ( {
+	...jest.requireActual( '../utils/crdt' ),
+	applyPostChangesToCRDTDoc: jest.fn(),
+} ) );
 
 /**
  * Internal dependencies
@@ -14,6 +22,11 @@ import {
 	prePersistPostType,
 	additionalEntityConfigLoaders,
 } from '../entities';
+import { getSyncManager } from '../sync';
+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', () => {
@@ -45,52 +58,256 @@ describe( 'getMethodName', () => {
 } );
 
 describe( 'prePersistPostType', () => {
-	it( 'set the status to draft and empty the title when saving auto-draft posts', () => {
+	it( 'set the status to draft and empty the title when saving auto-draft posts', async () => {
 		let record = {
 			status: 'auto-draft',
 		};
 		const edits = {};
-		expect( prePersistPostType( record, edits, 'post', false ) ).toEqual( {
+		expect(
+			await prePersistPostType( record, edits, 'post', false )
+		).toEqual( {
 			status: 'draft',
 			title: '',
-			meta: {},
 		} );
 
 		record = {
 			status: 'publish',
 		};
-		expect( prePersistPostType( record, edits, 'post', false ) ).toEqual( {
-			meta: {},
-		} );
+		expect(
+			await prePersistPostType( record, edits, 'post', false )
+		).toEqual( {} );
 
 		record = {
 			status: 'auto-draft',
 			title: 'Auto Draft',
 		};
-		expect( prePersistPostType( record, edits, 'post', false ) ).toEqual( {
+		expect(
+			await prePersistPostType( record, edits, 'post', false )
+		).toEqual( {
 			status: 'draft',
 			title: '',
-			meta: {},
 		} );
 
 		record = {
 			status: 'publish',
 			title: 'My Title',
 		};
-		expect( prePersistPostType( record, edits, 'post', false ) ).toEqual( {
-			meta: {},
-		} );
+		expect(
+			await prePersistPostType( record, edits, 'post', false )
+		).toEqual( {} );
 	} );
 
-	it( 'does not set the status to draft and empty the title when saving templates', () => {
+	it( 'does not set the status to draft and empty the title when saving templates', async () => {
 		const record = {
 			status: 'auto-draft',
 			title: 'Auto Draft',
 		};
 		const edits = {};
-		expect( prePersistPostType( record, edits, 'post', true ) ).toEqual( {
-			meta: {},
+		expect(
+			await prePersistPostType( record, edits, 'post', true )
+		).toEqual( {} );
+	} );
+
+	it( 'adds meta with serialized CRDT doc when createPersistedCRDTDoc returns a value', async () => {
+		const mockSerializedDoc = 'serialized-crdt-doc-data';
+		getSyncManager.mockReturnValue( {
+			createPersistedCRDTDoc: jest
+				.fn()
+				.mockReturnValue( mockSerializedDoc ),
+		} );
+
+		const record = { id: 123, status: 'publish' };
+		const edits = {};
+		const result = await prePersistPostType( record, edits, 'post', false );
+
+		expect( result.meta ).toEqual( {
+			[ POST_META_KEY_FOR_CRDT_DOC_PERSISTENCE ]: mockSerializedDoc,
 		} );
+
+		expect( getSyncManager ).toHaveBeenCalled();
+		expect( getSyncManager().createPersistedCRDTDoc ).toHaveBeenCalledWith(
+			'postType/post',
+			123
+		);
+
+		getSyncManager.mockReset();
+	} );
+} );
+
+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 );
 	} );
 } );
 

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 ),
 			}
 		);
 	} );

package/src/test/store.js

@@ -113,6 +113,122 @@ describe( 'getEntityRecord', () => {
 	} );
 } );
 
+describe( 'getEntityRecords', () => {
+	const POSTS = [
+		createTestPost( 1 ),
+		createTestPost( 2 ),
+		createTestPost( 3 ),
+	];
+
+	let registry;
+
+	beforeEach( () => {
+		registry = createTestRegistry();
+		triggerFetch.mockReset();
+	} );
+
+	it( 'preserves collection when getEntityRecord resolves after getEntityRecords', async () => {
+		let resolveSlowFetch;
+		const slowFetchPromise = new Promise( ( resolve ) => {
+			resolveSlowFetch = resolve;
+		} );
+
+		triggerFetch.mockImplementation( ( { path } ) => {
+			// Single post fetch (e.g. /wp/v2/posts/1): return slow promise.
+			if ( /\/wp\/v2\/posts\/\d+/.test( path ) ) {
+				return slowFetchPromise;
+			}
+			// Collection fetch: return immediately.
+			return Promise.resolve( {
+				json: () => Promise.resolve( POSTS ),
+				headers: {
+					get: ( header ) => {
+						if ( header === 'X-WP-Total' ) {
+							return String( POSTS.length );
+						}
+						if ( header === 'X-WP-TotalPages' ) {
+							return '1';
+						}
+						return null;
+					},
+				},
+			} );
+		} );
+
+		const resolveSelectStore = registry.resolveSelect( coreDataStore );
+
+		// Start getEntityRecord first (slow), then getEntityRecords (fast).
+		const singlePromise = resolveSelectStore.getEntityRecord(
+			'postType',
+			'post',
+			1,
+			{ context: 'edit' }
+		);
+		await resolveSelectStore.getEntityRecords( 'postType', 'post', {
+			context: 'edit',
+		} );
+
+		// Now resolve the slow single-record fetch.
+		resolveSlowFetch( {
+			json: () => Promise.resolve( POSTS[ 0 ] ),
+			headers: { get: () => null },
+		} );
+		await singlePromise;
+
+		// Wait for all pending thunks to settle.
+		await new Promise( ( resolve ) => setTimeout( resolve, 0 ) );
+
+		const allPosts = registry
+			.select( coreDataStore )
+			.getEntityRecords( 'postType', 'post', { context: 'edit' } );
+		expect( allPosts.map( ( p ) => p.id ) ).toEqual( [ 1, 2, 3 ] );
+	} );
+
+	it( 'preserves collection when getEntityRecord is called after getEntityRecords', async () => {
+		triggerFetch.mockImplementation( ( { path } ) => {
+			// Collection fetch.
+			if ( ! /\/wp\/v2\/posts\/\d+/.test( path ) ) {
+				return Promise.resolve( {
+					json: () => Promise.resolve( POSTS ),
+					headers: {
+						get: ( header ) => {
+							if ( header === 'X-WP-Total' ) {
+								return String( POSTS.length );
+							}
+							if ( header === 'X-WP-TotalPages' ) {
+								return '1';
+							}
+							return null;
+						},
+					},
+				} );
+			}
+			// Single post fetch.
+			return Promise.resolve( {
+				json: () => Promise.resolve( POSTS[ 0 ] ),
+				headers: { get: () => null },
+			} );
+		} );
+
+		const resolveSelectStore = registry.resolveSelect( coreDataStore );
+
+		// First resolve the collection.
+		await resolveSelectStore.getEntityRecords( 'postType', 'post', {
+			context: 'edit',
+		} );
+
+		// Then resolve a single record.
+		await resolveSelectStore.getEntityRecord( 'postType', 'post', 1, {
+			context: 'edit',
+		} );
+
+		const allPosts = registry
+			.select( coreDataStore )
+			.getEntityRecords( 'postType', 'post', { context: 'edit' } );
+		expect( allPosts.map( ( p ) => p.id ) ).toEqual( [ 1, 2, 3 ] );
+	} );
+} );
+
 describe( 'clearEntityRecordEdits', () => {
 	let registry;
 

package/src/types.ts

@@ -1,12 +1,21 @@
 /**
  * WordPress dependencies
  */
-import type { Y } from '@wordpress/sync';
+import type { ConnectionStatusDisconnected, Y } from '@wordpress/sync';
 
 /**
  * Internal dependencies
  */
-import type { SelectionType } from './utils/crdt-user-selections';
+import type {
+	SelectionType,
+	SelectionDirection,
+} from './utils/crdt-user-selections';
+
+export type { ConnectionStatus } from '@wordpress/sync';
+
+export type ConnectionError = NonNullable<
+	ConnectionStatusDisconnected[ 'error' ]
+>;
 
 export interface AnyFunction {
 	( ...args: any[] ): any;
@@ -44,6 +53,7 @@ export interface WPBlockSelection {
 export interface WPSelection {
 	selectionEnd: WPBlockSelection;
 	selectionStart: WPBlockSelection;
+	initialPosition?: number | null;
 }
 
 /**
@@ -85,6 +95,8 @@ export type SelectionInOneBlock = {
 	type: SelectionType.SelectionInOneBlock;
 	cursorStartPosition: CursorPosition;
 	cursorEndPosition: CursorPosition;
+	// The direction of the selection, indicating where the caret sits.
+	selectionDirection?: SelectionDirection;
 };
 
 export type SelectionInMultipleBlocks = {
@@ -94,6 +106,8 @@ export type SelectionInMultipleBlocks = {
 	type: SelectionType.SelectionInMultipleBlocks;
 	cursorStartPosition: CursorPosition;
 	cursorEndPosition: CursorPosition;
+	// The direction of the selection, indicating where the caret sits.
+	selectionDirection?: SelectionDirection;
 };
 
 export type SelectionWholeBlock = {
@@ -110,3 +124,8 @@ export type SelectionState =
 	| SelectionInOneBlock
 	| SelectionInMultipleBlocks
 	| SelectionWholeBlock;
+
+export interface ResolvedSelection {
+	richTextOffset: number | null;
+	localClientId: string | null;
+}

package/src/utils/block-selection-history.ts

@@ -9,7 +9,10 @@ import { Y } from '@wordpress/sync';
 /**
  * Internal dependencies
  */
-import { findBlockByClientIdInDoc } from './crdt-utils';
+import {
+	findBlockByClientIdInDoc,
+	richTextOffsetToHtmlIndex,
+} from './crdt-utils';
 import type { WPBlockSelection, WPSelection } from '../types';
 
 // Default size for selection history (not including current selection)
@@ -163,7 +166,7 @@ function convertWPBlockSelectionToSelection(
 	const offset = selection.offset ?? 0;
 	const relativePosition = Y.createRelativePositionFromTypeIndex(
 		changedYText,
-		offset
+		richTextOffsetToHtmlIndex( changedYText.toString(), offset )
 	);
 
 	return {