@wordpress/data 6.3.0 → 6.4.0

package/src/plugins/persistence/test/index.js

@@ -10,6 +10,8 @@ import plugin, {
 	createPersistenceInterface,
 	withLazySameState,
 	migrateFeaturePreferencesToInterfaceStore,
+	migrateFeaturePreferencesToPreferencesStore,
+	migrateIndividualPreferenceToPreferencesStore,
 } from '../';
 import objectStorage from '../storage/object';
 import { createRegistry } from '../../../';
@@ -492,4 +494,407 @@ describe( 'migrateFeaturePreferencesToInterfaceStore', () => {
 			},
 		} );
 	} );
+
+	describe( 'migrateFeaturePreferencesToPreferencesStore', () => {
+		it( 'migrates multiple preferences from persisted source stores to preferences', () => {
+			const persistenceInterface = createPersistenceInterface( {
+				storageKey: 'test-username',
+			} );
+
+			const sourceStateA = {
+				preferences: {
+					features: {
+						featureA: true,
+						featureB: false,
+						featureC: true,
+					},
+				},
+			};
+
+			const sourceStateB = {
+				preferences: {
+					features: {
+						featureD: true,
+						featureE: false,
+						featureF: true,
+					},
+				},
+			};
+
+			persistenceInterface.set( 'core/test-a', sourceStateA );
+			persistenceInterface.set( 'core/test-b', sourceStateB );
+
+			migrateFeaturePreferencesToPreferencesStore(
+				persistenceInterface,
+				'core/test-a'
+			);
+
+			migrateFeaturePreferencesToPreferencesStore(
+				persistenceInterface,
+				'core/test-b'
+			);
+
+			expect( persistenceInterface.get() ).toEqual( {
+				'core/preferences': {
+					preferences: {
+						'core/test-a': {
+							featureA: true,
+							featureB: false,
+							featureC: true,
+						},
+						'core/test-b': {
+							featureD: true,
+							featureE: false,
+							featureF: true,
+						},
+					},
+				},
+				'core/test-a': {
+					preferences: {
+						features: undefined,
+					},
+				},
+				'core/test-b': {
+					preferences: {
+						features: undefined,
+					},
+				},
+			} );
+		} );
+
+		it( 'migrates multiple preferences from the persisted interface store to preferences, with interface state taking precedence over source stores', () => {
+			const persistenceInterface = createPersistenceInterface( {
+				storageKey: 'test-username',
+			} );
+
+			const sourceStateA = {
+				preferences: {
+					features: {
+						featureA: true,
+						featureB: false,
+						featureC: true,
+					},
+				},
+			};
+
+			const sourceStateB = {
+				preferences: {
+					features: {
+						featureD: true,
+						featureE: false,
+						featureF: true,
+					},
+				},
+			};
+
+			const interfaceState = {
+				preferences: {
+					features: {
+						'core/test-a': {
+							featureG: true,
+							featureH: false,
+							featureI: true,
+						},
+						'core/test-b': {
+							featureJ: true,
+							featureK: false,
+							featureL: true,
+						},
+					},
+				},
+			};
+
+			persistenceInterface.set( 'core/test-a', sourceStateA );
+			persistenceInterface.set( 'core/test-b', sourceStateB );
+			persistenceInterface.set( 'core/interface', interfaceState );
+
+			migrateFeaturePreferencesToPreferencesStore(
+				persistenceInterface,
+				'core/test-a'
+			);
+
+			migrateFeaturePreferencesToPreferencesStore(
+				persistenceInterface,
+				'core/test-b'
+			);
+
+			expect( persistenceInterface.get() ).toEqual( {
+				'core/preferences': {
+					preferences: {
+						'core/test-a': {
+							featureG: true,
+							featureH: false,
+							featureI: true,
+						},
+						'core/test-b': {
+							featureJ: true,
+							featureK: false,
+							featureL: true,
+						},
+					},
+				},
+				'core/interface': {
+					preferences: {
+						features: {
+							'core/test-a': undefined,
+							'core/test-b': undefined,
+						},
+					},
+				},
+				'core/test-a': {
+					preferences: {
+						features: undefined,
+					},
+				},
+				'core/test-b': {
+					preferences: {
+						features: undefined,
+					},
+				},
+			} );
+		} );
+
+		it( 'only migrates persisted data for the source name from source stores', () => {
+			const persistenceInterface = createPersistenceInterface( {
+				storageKey: 'test-username',
+			} );
+
+			const sourceStateA = {
+				preferences: {
+					features: {
+						featureA: true,
+						featureB: false,
+						featureC: true,
+					},
+				},
+			};
+
+			const sourceStateB = {
+				preferences: {
+					features: {
+						featureD: true,
+						featureE: false,
+						featureF: true,
+					},
+				},
+			};
+
+			persistenceInterface.set( 'core/test-a', sourceStateA );
+			persistenceInterface.set( 'core/test-b', sourceStateB );
+
+			migrateFeaturePreferencesToPreferencesStore(
+				persistenceInterface,
+				'core/test-a'
+			);
+
+			expect( persistenceInterface.get() ).toEqual( {
+				'core/preferences': {
+					preferences: {
+						'core/test-a': {
+							featureA: true,
+							featureB: false,
+							featureC: true,
+						},
+					},
+				},
+				'core/test-a': {
+					preferences: {
+						features: undefined,
+					},
+				},
+				'core/test-b': {
+					preferences: {
+						features: {
+							featureD: true,
+							featureE: false,
+							featureF: true,
+						},
+					},
+				},
+			} );
+		} );
+
+		it( 'only migrates persisted data for the source name from interface', () => {
+			const persistenceInterface = createPersistenceInterface( {
+				storageKey: 'test-username',
+			} );
+
+			const interfaceState = {
+				preferences: {
+					features: {
+						'core/test-a': {
+							featureG: true,
+							featureH: false,
+							featureI: true,
+						},
+						'core/test-b': {
+							featureJ: true,
+							featureK: false,
+							featureL: true,
+						},
+					},
+				},
+			};
+
+			persistenceInterface.set( 'core/interface', interfaceState );
+
+			migrateFeaturePreferencesToPreferencesStore(
+				persistenceInterface,
+				'core/test-a'
+			);
+
+			expect( persistenceInterface.get() ).toEqual( {
+				'core/preferences': {
+					preferences: {
+						'core/test-a': {
+							featureG: true,
+							featureH: false,
+							featureI: true,
+						},
+					},
+				},
+				'core/interface': {
+					preferences: {
+						features: {
+							'core/test-a': undefined,
+							'core/test-b': {
+								featureJ: true,
+								featureK: false,
+								featureL: true,
+							},
+						},
+					},
+				},
+			} );
+		} );
+	} );
+
+	describe( 'migrateIndividualPreferenceToPreferencesStore', () => {
+		it( 'migrates an individual preference from the source to the preferences store', () => {
+			const persistenceInterface = createPersistenceInterface( {
+				storageKey: 'test-username',
+			} );
+
+			const initialState = {
+				preferences: {
+					myPreference: '123',
+				},
+			};
+
+			persistenceInterface.set( 'core/test', initialState );
+
+			migrateIndividualPreferenceToPreferencesStore(
+				persistenceInterface,
+				'core/test',
+				'myPreference'
+			);
+
+			expect( persistenceInterface.get() ).toEqual( {
+				'core/preferences': {
+					preferences: {
+						'core/test': {
+							myPreference: '123',
+						},
+					},
+				},
+				'core/test': {
+					preferences: {
+						myPreference: undefined,
+					},
+				},
+			} );
+		} );
+
+		it( 'does not overwrite other preferences in the preferences store', () => {
+			const persistenceInterface = createPersistenceInterface( {
+				storageKey: 'test-username',
+			} );
+
+			const initialState = {
+				preferences: {
+					myPreference: '123',
+				},
+			};
+
+			persistenceInterface.set( 'core/test', initialState );
+			persistenceInterface.set( 'core/preferences', {
+				preferences: {
+					'core/other-store': {
+						preferenceA: 1,
+						preferenceB: 2,
+					},
+					'core/test': {
+						unrelatedPreference: 'unrelated-value',
+					},
+				},
+			} );
+
+			migrateIndividualPreferenceToPreferencesStore(
+				persistenceInterface,
+				'core/test',
+				'myPreference'
+			);
+
+			expect( persistenceInterface.get() ).toEqual( {
+				'core/preferences': {
+					preferences: {
+						'core/other-store': {
+							preferenceA: 1,
+							preferenceB: 2,
+						},
+						'core/test': {
+							unrelatedPreference: 'unrelated-value',
+							myPreference: '123',
+						},
+					},
+				},
+				'core/test': {
+					preferences: {
+						myPreference: undefined,
+					},
+				},
+			} );
+		} );
+
+		it( 'does not migrate data if there is already a matching preference key at the target', () => {
+			const persistenceInterface = createPersistenceInterface( {
+				storageKey: 'test-username',
+			} );
+
+			persistenceInterface.set( 'core/test', {
+				preferences: {
+					myPreference: '123',
+				},
+			} );
+
+			persistenceInterface.set( 'core/preferences', {
+				preferences: {
+					'core/test': {
+						myPreference: 'already-set',
+					},
+				},
+			} );
+
+			migrateIndividualPreferenceToPreferencesStore(
+				persistenceInterface,
+				'core/test',
+				'myPreference'
+			);
+
+			expect( persistenceInterface.get() ).toEqual( {
+				'core/preferences': {
+					preferences: {
+						'core/test': {
+							myPreference: 'already-set',
+						},
+					},
+				},
+				'core/test': {
+					preferences: {
+						myPreference: '123',
+					},
+				},
+			} );
+		} );
+	} );
 } );

package/src/redux-store/index.js

@@ -330,20 +330,35 @@ function mapResolveSelectors( selectors, store ) {
 			'getCachedResolvers',
 		] ),
 		( selector, selectorName ) => ( ...args ) =>
-			new Promise( ( resolve ) => {
+			new Promise( ( resolve, reject ) => {
 				const hasFinished = () =>
 					selectors.hasFinishedResolution( selectorName, args );
+				const finalize = ( result ) => {
+					const hasFailed = selectors.hasResolutionFailed(
+						selectorName,
+						args
+					);
+					if ( hasFailed ) {
+						const error = selectors.getResolutionError(
+							selectorName,
+							args
+						);
+						reject( error );
+					} else {
+						resolve( result );
+					}
+				};
 				const getResult = () => selector.apply( null, args );
-				// trigger the selector (to trigger the resolver)
+				// Trigger the selector (to trigger the resolver)
 				const result = getResult();
 				if ( hasFinished() ) {
-					return resolve( result );
+					return finalize( result );
 				}
 
 				const unsubscribe = store.subscribe( () => {
 					if ( hasFinished() ) {
 						unsubscribe();
-						resolve( getResult() );
+						finalize( getResult() );
 					}
 				} );
 			} )
@@ -370,8 +385,8 @@ function mapResolvers( resolvers, selectors, store, resolversCache ) {
 		}
 
 		return {
-			...resolver, // copy the enumerable properties of the resolver function
-			fulfill: resolver, // add the fulfill method
+			...resolver, // Copy the enumerable properties of the resolver function.
+			fulfill: resolver, // Add the fulfill method.
 		};
 	} );
 
@@ -413,15 +428,28 @@ function mapResolvers( resolvers, selectors, store, resolversCache ) {
 					store.dispatch(
 						metadataActions.startResolution( selectorName, args )
 					);
-					await fulfillResolver(
-						store,
-						mappedResolvers,
-						selectorName,
-						...args
-					);
-					store.dispatch(
-						metadataActions.finishResolution( selectorName, args )
-					);
+					try {
+						await fulfillResolver(
+							store,
+							mappedResolvers,
+							selectorName,
+							...args
+						);
+						store.dispatch(
+							metadataActions.finishResolution(
+								selectorName,
+								args
+							)
+						);
+					} catch ( error ) {
+						store.dispatch(
+							metadataActions.failResolution(
+								selectorName,
+								args,
+								error
+							)
+						);
+					}
 				} );
 			}
 

package/src/redux-store/metadata/actions.js

@@ -32,13 +32,32 @@ export function finishResolution( selectorName, args ) {
 	};
 }
 
+/**
+ * Returns an action object used in signalling that selector resolution has
+ * failed.
+ *
+ * @param {string}        selectorName Name of selector for which resolver triggered.
+ * @param {unknown[]}     args         Arguments to associate for uniqueness.
+ * @param {Error|unknown} error        The error that caused the failure.
+ *
+ * @return {{ type: 'FAIL_RESOLUTION', selectorName: string, args: unknown[], error: Error|unknown }} Action object.
+ */
+export function failResolution( selectorName, args, error ) {
+	return {
+		type: 'FAIL_RESOLUTION',
+		selectorName,
+		args,
+		error,
+	};
+}
+
 /**
  * Returns an action object used in signalling that a batch of selector resolutions has
  * started.
  *
- * @param {string}    selectorName Name of selector for which resolver triggered.
+ * @param {string}      selectorName Name of selector for which resolver triggered.
  * @param {unknown[][]} args         Array of arguments to associate for uniqueness, each item
- *                                 is associated to a resolution.
+ *                                   is associated to a resolution.
  *
  * @return {{ type: 'START_RESOLUTIONS', selectorName: string, args: unknown[][] }} Action object.
  */
@@ -54,9 +73,9 @@ export function startResolutions( selectorName, args ) {
  * Returns an action object used in signalling that a batch of selector resolutions has
  * completed.
  *
- * @param {string}    selectorName Name of selector for which resolver triggered.
+ * @param {string}      selectorName Name of selector for which resolver triggered.
  * @param {unknown[][]} args         Array of arguments to associate for uniqueness, each item
- *                                 is associated to a resolution.
+ *                                   is associated to a resolution.
  *
  * @return {{ type: 'FINISH_RESOLUTIONS', selectorName: string, args: unknown[][] }} Action object.
  */
@@ -68,6 +87,26 @@ export function finishResolutions( selectorName, args ) {
 	};
 }
 
+/**
+ * Returns an action object used in signalling that a batch of selector resolutions has
+ * completed and at least one of them has failed.
+ *
+ * @param {string}            selectorName Name of selector for which resolver triggered.
+ * @param {unknown[]}         args         Array of arguments to associate for uniqueness, each item
+ *                                         is associated to a resolution.
+ * @param {(Error|unknown)[]} errors       Array of errors to associate for uniqueness, each item
+ *                                         is associated to a resolution.
+ * @return {{ type: 'FAIL_RESOLUTIONS', selectorName: string, args: unknown[], errors: Array<Error|unknown> }} Action object.
+ */
+export function failResolutions( selectorName, args, errors ) {
+	return {
+		type: 'FAIL_RESOLUTIONS',
+		selectorName,
+		args,
+		errors,
+	};
+}
+
 /**
  * Returns an action object used in signalling that we should invalidate the resolution cache.
  *

package/src/redux-store/metadata/reducer.ts

@@ -13,15 +13,23 @@ import { selectorArgsToStateKey, onSubKey } from './utils';
 type Action =
 	| ReturnType< typeof import('./actions').startResolution >
 	| ReturnType< typeof import('./actions').finishResolution >
+	| ReturnType< typeof import('./actions').failResolution >
 	| ReturnType< typeof import('./actions').startResolutions >
 	| ReturnType< typeof import('./actions').finishResolutions >
+	| ReturnType< typeof import('./actions').failResolutions >
 	| ReturnType< typeof import('./actions').invalidateResolution >
 	| ReturnType< typeof import('./actions').invalidateResolutionForStore >
 	| ReturnType<
 			typeof import('./actions').invalidateResolutionForStoreSelector
 	  >;
 
-export type State = EquivalentKeyMap< unknown[] | unknown, boolean >;
+type StateKey = unknown[] | unknown;
+export type StateValue =
+	| { status: 'resolving' | 'finished' }
+	| { status: 'error'; error: Error | unknown };
+
+export type Status = StateValue[ 'status' ];
+export type State = EquivalentKeyMap< StateKey, StateValue >;
 
 /**
  * Reducer function returning next state for selector resolution of
@@ -34,23 +42,64 @@ const subKeysIsResolved: Reducer< Record< string, State >, Action > = onSubKey<
 	Action
 >( 'selectorName' )( ( state = new EquivalentKeyMap(), action: Action ) => {
 	switch ( action.type ) {
-		case 'START_RESOLUTION':
+		case 'START_RESOLUTION': {
+			const nextState = new EquivalentKeyMap( state );
+			nextState.set( selectorArgsToStateKey( action.args ), {
+				status: 'resolving',
+			} );
+			return nextState;
+		}
 		case 'FINISH_RESOLUTION': {
-			const isStarting = action.type === 'START_RESOLUTION';
 			const nextState = new EquivalentKeyMap( state );
-			nextState.set( selectorArgsToStateKey( action.args ), isStarting );
+			nextState.set( selectorArgsToStateKey( action.args ), {
+				status: 'finished',
+			} );
+			return nextState;
+		}
+		case 'FAIL_RESOLUTION': {
+			const nextState = new EquivalentKeyMap( state );
+			nextState.set( selectorArgsToStateKey( action.args ), {
+				status: 'error',
+				error: action.error,
+			} );
+			return nextState;
+		}
+		case 'START_RESOLUTIONS': {
+			const nextState = new EquivalentKeyMap( state );
+			for ( const resolutionArgs of action.args ) {
+				nextState.set( selectorArgsToStateKey( resolutionArgs ), {
+					status: 'resolving',
+				} );
+			}
 			return nextState;
 		}
-		case 'START_RESOLUTIONS':
 		case 'FINISH_RESOLUTIONS': {
-			const isStarting = action.type === 'START_RESOLUTIONS';
 			const nextState = new EquivalentKeyMap( state );
 			for ( const resolutionArgs of action.args ) {
+				nextState.set( selectorArgsToStateKey( resolutionArgs ), {
+					status: 'finished',
+				} );
+			}
+			return nextState;
+		}
+		case 'FAIL_RESOLUTIONS': {
+			const nextState = new EquivalentKeyMap( state );
+			action.args.forEach( ( resolutionArgs, idx ) => {
+				const resolutionState: StateValue = {
+					status: 'error',
+					error: undefined,
+				};
+
+				const error = action.errors[ idx ];
+				if ( error ) {
+					resolutionState.error = error;
+				}
+
 				nextState.set(
-					selectorArgsToStateKey( resolutionArgs ),
-					isStarting
+					selectorArgsToStateKey( resolutionArgs as unknown[] ),
+					resolutionState
 				);
-			}
+			} );
 			return nextState;
 		}
 		case 'INVALIDATE_RESOLUTION': {
@@ -82,8 +131,10 @@ const isResolved = ( state: Record< string, State > = {}, action: Action ) => {
 				: state;
 		case 'START_RESOLUTION':
 		case 'FINISH_RESOLUTION':
+		case 'FAIL_RESOLUTION':
 		case 'START_RESOLUTIONS':
 		case 'FINISH_RESOLUTIONS':
+		case 'FAIL_RESOLUTIONS':
 		case 'INVALIDATE_RESOLUTION':
 			return subKeysIsResolved( state, action );
 	}