@wordpress/core-data 7.48.0 → 7.48.2-next.v.202606191442.0

package/src/utils/save-crdt-doc.js

@@ -0,0 +1,64 @@
+/**
+ * WordPress dependencies
+ */
+import apiFetch from '@wordpress/api-fetch';
+
+/**
+ * Internal dependencies
+ */
+import { getSyncManager } from '../sync';
+
+const SYNC_SAVE_API_PATH = '/wp-sync/v1/save';
+const saveCRDTDocQueues = new Map();
+
+async function serializeAndSaveCRDTDoc( objectType, objectId, room ) {
+	const serializedDoc = await getSyncManager()?.createPersistedCRDTDoc(
+		objectType,
+		objectId
+	);
+
+	if ( ! serializedDoc ) {
+		return;
+	}
+
+	await apiFetch( {
+		path: SYNC_SAVE_API_PATH,
+		method: 'POST',
+		data: {
+			room,
+			doc: serializedDoc,
+		},
+	} );
+}
+
+/**
+ * Persist the current CRDT document through the sync /save endpoint.
+ *
+ * @param {import('@wordpress/sync').ObjectType} objectType Object type.
+ * @param {import('@wordpress/sync').ObjectID}   objectId   Object ID.
+ */
+export async function saveCRDTDoc( objectType, objectId ) {
+	const room = `${ objectType }:${ objectId }`;
+
+	// Saves are chained per-room, which forms a queue.
+	// Without a queue, two /save calls might fire close together with a risk
+	// that the older serialized CRDT snapshot completes after the newer one and
+	// overwrites it with stale data.
+	// Wait for the prior request chain to complete before firing the next save.
+	const previousSave = saveCRDTDocQueues.get( room ) || Promise.resolve();
+
+	const currentSave = previousSave
+		// A failed save should reject its caller, but not block later saves.
+		.catch( () => {} )
+		.then( () => serializeAndSaveCRDTDoc( objectType, objectId, room ) );
+
+	saveCRDTDocQueues.set( room, currentSave );
+
+	try {
+		await currentSave;
+	} finally {
+		if ( saveCRDTDocQueues.get( room ) === currentSave ) {
+			saveCRDTDocQueues.delete( room );
+		}
+	}
+}

package/src/utils/test/clear-unchanged-edits.js

@@ -0,0 +1,42 @@
+/**
+ * Internal dependencies
+ */
+import clearUnchangedEdits from '../clear-unchanged-edits';
+
+describe( 'clearUnchangedEdits', () => {
+	it( 'sets edits matching the persisted record to undefined', () => {
+		const result = clearUnchangedEdits(
+			{ title: 'Hello', status: 'draft' },
+			{ title: 'Hello', status: 'publish' }
+		);
+
+		expect( result ).toEqual( { title: undefined, status: 'draft' } );
+	} );
+
+	it( 'unwraps the persisted value from its `raw` subfield', () => {
+		const result = clearUnchangedEdits(
+			{ title: 'Hello', content: 'World' },
+			{
+				title: { raw: 'Hello', rendered: '<p>Hello</p>' },
+				content: { raw: 'Changed', rendered: '<p>Changed</p>' },
+			}
+		);
+
+		expect( result ).toEqual( { title: undefined, content: 'World' } );
+	} );
+
+	it( 'compares deeply for object values', () => {
+		const result = clearUnchangedEdits(
+			{ meta: { a: 1 }, other: { b: 1 } },
+			{ meta: { a: 1 }, other: { b: 2 } }
+		);
+
+		expect( result ).toEqual( { meta: undefined, other: { b: 1 } } );
+	} );
+
+	it( 'keeps all edits when there is no persisted record', () => {
+		const result = clearUnchangedEdits( { title: 'Hello' }, undefined );
+
+		expect( result ).toEqual( { title: 'Hello' } );
+	} );
+} );

package/src/utils/test/crdt-blocks.ts

@@ -196,7 +196,40 @@ describe( 'crdt-blocks', () => {
 			expect( content.toString() ).toBe( 'Updated content' );
 		} );
 
-		it( 'preserves the local clientId when an updated block arrives with a different clientId', () => {
+		it( 'updates the clientId when an updated block arrives with a different clientId', () => {
+			const initialBlocks: Block[] = [
+				{
+					name: 'core/paragraph',
+					attributes: { content: 'Initial content' },
+					innerBlocks: [],
+					clientId: 'initial-id',
+				},
+			];
+
+			mergeCrdtBlocks( yblocks, initialBlocks, null );
+			expect( yblocks.get( 0 ).get( 'clientId' ) ).toBe( 'initial-id' );
+
+			const updatedBlocks: Block[] = [
+				{
+					name: 'core/paragraph',
+					attributes: { content: 'Updated content' },
+					innerBlocks: [],
+					clientId: 'updated-id',
+				},
+			];
+
+			mergeCrdtBlocks( yblocks, updatedBlocks, null );
+
+			expect( yblocks.length ).toBe( 1 );
+			const block = yblocks.get( 0 );
+			expect( block.get( 'clientId' ) ).toBe( 'updated-id' );
+			const content = (
+				block.get( 'attributes' ) as YBlockAttributes
+			 ).get( 'content' ) as Y.Text;
+			expect( content.toString() ).toBe( 'Updated content' );
+		} );
+
+		it( 'preserves the local clientId when requested for reparsed content blocks', () => {
 			// Simulates the Code Editor flow: the sender re-parses raw HTML on
 			// every keystroke, which mints a fresh clientId for every block.
 			// The Y.Doc's clientId should stay stable so remote peers don't
@@ -222,7 +255,9 @@ describe( 'crdt-blocks', () => {
 				},
 			];
 
-			mergeCrdtBlocks( yblocks, reparsedBlocks, null );
+			mergeCrdtBlocks( yblocks, reparsedBlocks, null, {
+				preserveClientIds: true,
+			} );
 
 			expect( yblocks.length ).toBe( 1 );
 			const block = yblocks.get( 0 );
@@ -2867,6 +2902,26 @@ describe( 'crdt-blocks', () => {
 		} );
 	} );
 
+	describe( 'mergeRichTextUpdate - rapid typing', () => {
+		it( 'appends repeated text one character at a time with cursor hints', () => {
+			const text =
+				'987654321098765432109876543210987654321098765432109876543210';
+			const yText = doc.getText( 'test' );
+			yText.insert( 0, 'p1' );
+
+			for ( let i = 1; i <= text.length; i++ ) {
+				const value = `p1${ text.slice( 0, i ) }`;
+				mergeRichTextUpdate(
+					yText,
+					value,
+					asHtmlStringIndex( value.length )
+				);
+			}
+
+			expect( yText.toString() ).toBe( `p1${ text }` );
+		} );
+	} );
+
 	describe( 'supplementary plane characters (non-emoji)', () => {
 		// Characters above U+FFFF are stored as surrogate pairs in UTF-16,
 		// so .length === 2 per character. The diff library v8 counts them

package/src/utils/test/rtc-rich-text-cursor-scope.test.js

@@ -254,8 +254,8 @@ describe( 'RTC rich-text cursor scope bug', () => {
 				},
 				'LOCAL_EDITOR_ORIGIN'
 			);
-			// SyncManager.update is deferred through yieldToEventLoop.
-			// Wait one tick so the CRDT write has been applied before inspecting it.
+			// Selection history writes are deferred. Wait one tick before
+			// inspecting the document.
 			await waitForNextTick();
 		}
 

package/src/utils/test/save-crdt-doc.js

@@ -0,0 +1,185 @@
+/**
+ * WordPress dependencies
+ */
+import apiFetch from '@wordpress/api-fetch';
+
+/**
+ * Internal dependencies
+ */
+import { getSyncManager } from '../../sync';
+import { saveCRDTDoc } from '../save-crdt-doc';
+
+jest.mock( '@wordpress/api-fetch' );
+jest.mock( '../../sync', () => ( {
+	getSyncManager: jest.fn(),
+} ) );
+
+function createDeferred() {
+	let resolve;
+	let reject;
+	const promise = new Promise( ( _resolve, _reject ) => {
+		resolve = _resolve;
+		reject = _reject;
+	} );
+
+	return { promise, resolve, reject };
+}
+
+async function flushPromises() {
+	await new Promise( ( resolve ) => setTimeout( resolve, 0 ) );
+}
+
+describe( 'saveCRDTDoc', () => {
+	let syncManager;
+
+	beforeEach( () => {
+		apiFetch.mockReset();
+		syncManager = {
+			createPersistedCRDTDoc: jest.fn(),
+		};
+		getSyncManager.mockReturnValue( syncManager );
+	} );
+
+	it( 'saves the serialized CRDT document through the sync endpoint', async () => {
+		const fetch = createDeferred();
+		syncManager.createPersistedCRDTDoc.mockResolvedValue( 'doc' );
+		apiFetch.mockImplementation( () => fetch.promise );
+
+		const save = saveCRDTDoc( 'postType/post', 1 );
+
+		await flushPromises();
+
+		fetch.resolve( {} );
+		await save;
+
+		expect( apiFetch ).toHaveBeenCalledWith( {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:1',
+				doc: 'doc',
+			},
+		} );
+	} );
+
+	it( 'does not call the sync endpoint when there is no serialized CRDT document', async () => {
+		syncManager.createPersistedCRDTDoc.mockResolvedValue( null );
+
+		await saveCRDTDoc( 'postType/post', 1 );
+
+		expect( apiFetch ).not.toHaveBeenCalled();
+	} );
+
+	it( 'serializes save requests for the same room', async () => {
+		const firstFetch = createDeferred();
+		syncManager.createPersistedCRDTDoc
+			.mockResolvedValueOnce( 'doc-1' )
+			.mockResolvedValueOnce( 'doc-2' );
+		apiFetch
+			.mockImplementationOnce( () => firstFetch.promise )
+			.mockResolvedValueOnce( {} );
+
+		const firstSave = saveCRDTDoc( 'postType/post', 1 );
+		const secondSave = saveCRDTDoc( 'postType/post', 1 );
+
+		await flushPromises();
+
+		expect( syncManager.createPersistedCRDTDoc ).toHaveBeenCalledTimes( 1 );
+		expect( apiFetch ).toHaveBeenCalledTimes( 1 );
+		expect( apiFetch ).toHaveBeenLastCalledWith( {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:1',
+				doc: 'doc-1',
+			},
+		} );
+
+		firstFetch.resolve( {} );
+		await firstSave;
+		await flushPromises();
+
+		expect( syncManager.createPersistedCRDTDoc ).toHaveBeenCalledTimes( 2 );
+		expect( apiFetch ).toHaveBeenCalledTimes( 2 );
+		expect( apiFetch ).toHaveBeenLastCalledWith( {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:1',
+				doc: 'doc-2',
+			},
+		} );
+
+		await secondSave;
+	} );
+
+	it( 'does not serialize save requests for different rooms', async () => {
+		const firstFetch = createDeferred();
+		syncManager.createPersistedCRDTDoc.mockImplementation(
+			( objectType, objectId ) => Promise.resolve( `doc-${ objectId }` )
+		);
+		apiFetch
+			.mockImplementationOnce( () => firstFetch.promise )
+			.mockResolvedValueOnce( {} );
+
+		const firstSave = saveCRDTDoc( 'postType/post', 1 );
+		const secondSave = saveCRDTDoc( 'postType/post', 2 );
+
+		await flushPromises();
+
+		expect( syncManager.createPersistedCRDTDoc ).toHaveBeenCalledTimes( 2 );
+		expect( apiFetch ).toHaveBeenCalledTimes( 2 );
+		expect( apiFetch ).toHaveBeenNthCalledWith( 1, {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:1',
+				doc: 'doc-1',
+			},
+		} );
+		expect( apiFetch ).toHaveBeenNthCalledWith( 2, {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:2',
+				doc: 'doc-2',
+			},
+		} );
+
+		await secondSave;
+		firstFetch.resolve( {} );
+		await firstSave;
+	} );
+
+	it( 'continues a same-room queue after a failed save', async () => {
+		const firstFetch = createDeferred();
+		syncManager.createPersistedCRDTDoc
+			.mockResolvedValueOnce( 'doc-1' )
+			.mockResolvedValueOnce( 'doc-2' );
+		apiFetch
+			.mockImplementationOnce( () => firstFetch.promise )
+			.mockResolvedValueOnce( {} );
+
+		const firstSave = saveCRDTDoc( 'postType/post', 1 );
+		const secondSave = saveCRDTDoc( 'postType/post', 1 );
+
+		await flushPromises();
+
+		firstFetch.reject( new Error( 'save failed' ) );
+		await expect( firstSave ).rejects.toThrow( 'save failed' );
+		await flushPromises();
+
+		expect( syncManager.createPersistedCRDTDoc ).toHaveBeenCalledTimes( 2 );
+		expect( apiFetch ).toHaveBeenCalledTimes( 2 );
+		expect( apiFetch ).toHaveBeenLastCalledWith( {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:1',
+				doc: 'doc-2',
+			},
+		} );
+
+		await secondSave;
+	} );
+} );