Add support for syncing post meta

Author: chriszarate

packages/core-data/src/utils/crdt-meta.ts

@@ -0,0 +1,63 @@
+/**
+ * WordPress dependencies
+ */
+import { applyFilters } from '@wordpress/hooks';
+
+/**
+ * Internal dependencies
+ */
+import { type Type } from '../entity-types';
+
+const metaDecisionCache: Map< string, Map< string, boolean > > = new Map();
+
+/**
+ * Given a meta key and post type definition, return a decision on whether to
+ * sync the meta property.
+ *
+ * @param {string} metaKey  The meta key.
+ * @param {Type}   postType The post type definition.
+ * @return {boolean} Whether to sync the meta property.
+ */
+export function shouldSyncMetaForPostType(
+	metaKey: string,
+	postType: Type
+): boolean {
+	if ( ! metaDecisionCache.has( postType.slug ) ) {
+		metaDecisionCache.set( postType.slug, new Map() );
+	}
+
+	const decisionMap = metaDecisionCache.get( postType.slug )!;
+
+	if ( decisionMap.has( metaKey ) ) {
+		return decisionMap.get( metaKey )!;
+	}
+
+	/**
+	 * In order to be available to the sync module, meta properties must be
+	 * registered against the post type and made available via the REST API
+	 * (`'show_in_rest' => true`).
+	 *
+	 * Of the registered meta properties, by default we do not sync "hidden" meta
+	 * fields (leading underscore in the meta key). This filter allows third-party
+	 * code to override that behavior.
+	 *
+	 * @param {boolean} shouldSync   Whether to sync the meta property.
+	 * @param {string}  metaKey      Meta key.
+	 * @param {string}  postTypeSlug The post type slug.
+	 * @param {Type}    postType     The post type definition.
+	 * @return {boolean} Whether to sync this meta property to sync.
+	 */
+	const shouldSync = Boolean(
+		applyFilters(
+			'sync.shouldSyncMeta',
+			! metaKey.startsWith( '_' ),
+			metaKey,
+			postType.slug,
+			postType
+		)
+	);
+
+	decisionMap.set( metaKey, shouldSync );
+
+	return shouldSync;
+}

packages/core-data/src/utils/crdt.ts

@@ -21,6 +21,7 @@ import { type Post } from '../entity-types/post';
 import { type Type } from '../entity-types';
 import { CRDT_RECORD_MAP_KEY } from '../sync';
 import type { WPBlockSelection, WPSelection } from '../types';
+import { shouldSyncMetaForPostType } from './crdt-meta';
 
 export type PostChanges = Partial< Post > & {
 	blocks?: Block[];
@@ -42,6 +43,7 @@ const allowedPostProperties = new Set< string >( [
 	'featured_media',
 	'format',
 	'ping_status',
+	'meta',
 	'slug',
 	'status',
 	'sticky',
@@ -98,7 +100,7 @@ export function defaultApplyChangesToCRDTDoc(
 export function applyPostChangesToCRDTDoc(
 	ydoc: CRDTDoc,
 	changes: PostChanges,
-	postType: Type // eslint-disable-line @typescript-eslint/no-unused-vars
+	postType: Type
 ): void {
 	const ymap = ydoc.getMap( CRDT_RECORD_MAP_KEY );
 
@@ -146,6 +148,38 @@ export function applyPostChangesToCRDTDoc(
 				break;
 			}
 
+			// "Meta" is overloaded term; here, it refers to post meta.
+			case 'meta': {
+				let metaMap = ymap.get( 'meta' ) as Y.Map< unknown >;
+
+				// Initialize.
+				if ( ! ( metaMap instanceof Y.Map ) ) {
+					metaMap = new Y.Map();
+					setValue( metaMap );
+				}
+
+				// Iterate over each meta property in the new value and merge it if it
+				// should be synced.
+				Object.entries( newValue ?? {} ).forEach(
+					( [ metaKey, metaValue ] ) => {
+						if (
+							! shouldSyncMetaForPostType( metaKey, postType )
+						) {
+							return;
+						}
+
+						mergeValue(
+							metaMap.get( metaKey ), // current value in CRDT
+							metaValue, // new value from changes
+							( updatedMetaValue: unknown ): void => {
+								metaMap.set( metaKey, updatedMetaValue );
+							}
+						);
+					}
+				);
+				break;
+			}
+
 			case 'slug': {
 				// Do not sync an empty slug. This indicates that the post is using
 				// the default auto-generated slug.
@@ -204,11 +238,13 @@ export function defaultGetChangesFromCRDTDoc( crdtDoc: CRDTDoc ): ObjectData {
 export function getPostChangesFromCRDTDoc(
 	ydoc: CRDTDoc,
 	editedRecord: Post,
-	postType: Type // eslint-disable-line @typescript-eslint/no-unused-vars
+	postType: Type
 ): PostChanges {
 	const ymap = ydoc.getMap( CRDT_RECORD_MAP_KEY );
 
-	return Object.fromEntries(
+	let allowedMetaChanges: Post[ 'meta' ] = {};
+
+	const changes = Object.fromEntries(
 		Object.entries( ymap.toJSON() ).filter( ( [ key, newValue ] ) => {
 			if ( ! allowedPostProperties.has( key ) ) {
 				return false;
@@ -240,6 +276,24 @@ export function getPostChangesFromCRDTDoc(
 					return haveValuesChanged( currentValue, newValue );
 				}
 
+				case 'meta': {
+					allowedMetaChanges = Object.fromEntries(
+						Object.entries( newValue ?? {} ).filter(
+							( [ metaKey ] ) =>
+								shouldSyncMetaForPostType( metaKey, postType )
+						)
+					);
+
+					// Merge the allowed meta changes with the current meta values since
+					// not all meta properties are synced.
+					const mergedValue = {
+						...( currentValue as PostChanges[ 'meta' ] ),
+						...allowedMetaChanges,
+					};
+
+					return haveValuesChanged( currentValue, mergedValue );
+				}
+
 				case 'status': {
 					// Do not sync an invalid status.
 					if ( 'auto-draft' === newValue ) {
@@ -265,6 +319,17 @@ export function getPostChangesFromCRDTDoc(
 			}
 		} )
 	);
+
+	// Meta changes must be merged with the edited record since not all meta
+	// properties are synced.
+	if ( 'object' === typeof changes.meta ) {
+		changes.meta = {
+			...editedRecord.meta,
+			...allowedMetaChanges,
+		};
+	}
+
+	return changes;
 }
 
 /**

packages/core-data/src/utils/test/crdt.ts

@@ -152,6 +152,54 @@ describe( 'crdt', () => {
 			const blocks = map.get( 'blocks' );
 			expect( blocks ).toBeInstanceOf( Y.Array );
 		} );
+
+		it( 'syncs non-hidden meta fields', () => {
+			const changes = {
+				meta: {
+					some_meta: 'new value',
+				},
+			};
+
+			const metaMap = new Y.Map< unknown >();
+			metaMap.set( 'some_meta', 'old value' );
+			map.set( 'meta', metaMap );
+
+			applyPostChangesToCRDTDoc( doc, changes, mockPostType );
+
+			expect( metaMap.get( 'some_meta' ) ).toBe( 'new value' );
+		} );
+
+		it( 'does not sync hidden meta fields', () => {
+			const changes = {
+				meta: {
+					_private_meta: 'unsynced value',
+					some_meta: 'new value',
+				},
+			};
+
+			const metaMap = new Y.Map< unknown >();
+			metaMap.set( 'some_meta', 'old value' );
+			map.set( 'meta', metaMap );
+
+			applyPostChangesToCRDTDoc( doc, changes, mockPostType );
+
+			expect( metaMap.has( '_private_meta' ) ).toBe( false );
+			expect( metaMap.get( 'some_meta' ) ).toBe( 'new value' );
+		} );
+
+		it( 'initializes meta as Y.Map when not present', () => {
+			const changes = {
+				meta: {
+					custom_field: 'value',
+				},
+			};
+
+			applyPostChangesToCRDTDoc( doc, changes, mockPostType );
+
+			const metaMap = map.get( 'meta' ) as Y.Map< unknown >;
+			expect( metaMap ).toBeInstanceOf( Y.Map );
+			expect( metaMap.get( 'custom_field' ) ).toBe( 'value' );
+		} );
 	} );
 
 	describe( 'getPostChangesFromCRDTDoc', () => {
@@ -250,5 +298,30 @@ describe( 'crdt', () => {
 
 			expect( changes ).toHaveProperty( 'blocks' );
 		} );
+
+		it( 'includes meta in changes, preserving any unsynced fields', () => {
+			map.set( 'meta', {
+				_private_meta: 'ignored value',
+				public_meta: 'new value',
+			} );
+
+			const editedRecord = {
+				meta: {
+					_private_meta: 'preserved value',
+					public_meta: 'old value',
+				},
+			} as unknown as Post;
+
+			const changes = getPostChangesFromCRDTDoc(
+				doc,
+				editedRecord,
+				mockPostType
+			);
+
+			expect( changes.meta ).toEqual( {
+				_private_meta: 'preserved value', // preserved from edited record
+				public_meta: 'new value', // from CRDT
+			} );
+		} );
 	} );
 } );