@wordpress/data 6.2.1 → 6.3.1-next.a55ed9455a.0

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

@@ -32,15 +32,34 @@ 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 {unknown[]} args         Array of arguments to associate for uniqueness, each item
- *                                 is associated to a resolution.
+ * @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.
  *
- * @return {{ type: 'START_RESOLUTIONS', selectorName: string, args: unknown[] }} Action object.
+ * @return {{ type: 'START_RESOLUTIONS', selectorName: string, args: unknown[][] }} Action object.
  */
 export function startResolutions( selectorName, args ) {
 	return {
@@ -54,11 +73,11 @@ 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 {unknown[]} args         Array of arguments to associate for uniqueness, each item
- *                                 is associated to a resolution.
+ * @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.
  *
- * @return {{ type: 'FINISH_RESOLUTIONS', selectorName: string, args: unknown[] }} Action object.
+ * @return {{ type: 'FINISH_RESOLUTIONS', selectorName: string, args: unknown[][] }} Action object.
  */
 export function finishResolutions( selectorName, args ) {
 	return {
@@ -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

@@ -8,20 +8,28 @@ import type { Reducer } from 'redux';
 /**
  * Internal dependencies
  */
-import { onSubKey } from './utils';
+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,25 +42,69 @@ 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( 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( resolutionArgs, isStarting );
+				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 as unknown[] ),
+					resolutionState
+				);
+			} );
+			return nextState;
+		}
 		case 'INVALIDATE_RESOLUTION': {
 			const nextState = new EquivalentKeyMap( state );
-			nextState.delete( action.args );
+			nextState.delete( selectorArgsToStateKey( action.args ) );
 			return nextState;
 		}
 	}
@@ -79,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 );
 	}

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

@@ -3,69 +3,127 @@
  */
 import { get } from 'lodash';
 
+/**
+ * Internal dependencies
+ */
+import { selectorArgsToStateKey } from './utils';
+
 /** @typedef {Record<string, import('./reducer').State>} State */
+/** @typedef {import('./reducer').StateValue} StateValue */
+/** @typedef {import('./reducer').Status} Status */
 
 /**
- * Returns the raw `isResolving` value for a given selector name,
+ * Returns the raw resolution state value for a given selector name,
  * and arguments set. May be undefined if the selector has never been resolved
  * or not resolved for the given set of arguments, otherwise true or false for
  * resolution started and completed respectively.
  *
- * @param {State}     state        Data state.
- * @param {string}    selectorName Selector name.
- * @param {unknown[]} args         Arguments passed to selector.
+ * @param {State}      state        Data state.
+ * @param {string}     selectorName Selector name.
+ * @param {unknown[]?} args         Arguments passed to selector.
  *
- * @return {boolean | undefined} isResolving value.
+ * @return {StateValue|undefined} isResolving value.
  */
-export function getIsResolving( state, selectorName, args ) {
+export function getResolutionState( state, selectorName, args ) {
 	const map = get( state, [ selectorName ] );
 	if ( ! map ) {
-		return undefined;
+		return;
 	}
 
-	return map.get( args );
+	return map.get( selectorArgsToStateKey( args ) );
+}
+
+/**
+ * Returns the raw `isResolving` value for a given selector name,
+ * and arguments set. May be undefined if the selector has never been resolved
+ * or not resolved for the given set of arguments, otherwise true or false for
+ * resolution started and completed respectively.
+ *
+ * @param {State}      state        Data state.
+ * @param {string}     selectorName Selector name.
+ * @param {unknown[]?} args         Arguments passed to selector.
+ *
+ * @return {boolean | undefined} isResolving value.
+ */
+export function getIsResolving( state, selectorName, args ) {
+	const resolutionState = getResolutionState( state, selectorName, args );
+
+	return resolutionState && resolutionState.status === 'resolving';
 }
 
 /**
  * Returns true if resolution has already been triggered for a given
  * selector name, and arguments set.
  *
- * @param {State}     state        Data state.
- * @param {string}    selectorName Selector name.
- * @param {unknown[]} [args]       Arguments passed to selector (default `[]`).
+ * @param {State}      state        Data state.
+ * @param {string}     selectorName Selector name.
+ * @param {unknown[]?} args         Arguments passed to selector.
  *
  * @return {boolean} Whether resolution has been triggered.
  */
-export function hasStartedResolution( state, selectorName, args = [] ) {
-	return getIsResolving( state, selectorName, args ) !== undefined;
+export function hasStartedResolution( state, selectorName, args ) {
+	return getResolutionState( state, selectorName, args ) !== undefined;
 }
 
 /**
  * Returns true if resolution has completed for a given selector
  * name, and arguments set.
  *
- * @param {State}     state        Data state.
- * @param {string}    selectorName Selector name.
- * @param {unknown[]} [args]       Arguments passed to selector.
+ * @param {State}      state        Data state.
+ * @param {string}     selectorName Selector name.
+ * @param {unknown[]?} args         Arguments passed to selector.
  *
  * @return {boolean} Whether resolution has completed.
  */
-export function hasFinishedResolution( state, selectorName, args = [] ) {
-	return getIsResolving( state, selectorName, args ) === false;
+export function hasFinishedResolution( state, selectorName, args ) {
+	const status = getResolutionState( state, selectorName, args )?.status;
+	return status === 'finished' || status === 'error';
+}
+
+/**
+ * Returns true if resolution has failed for a given selector
+ * name, and arguments set.
+ *
+ * @param {State}      state        Data state.
+ * @param {string}     selectorName Selector name.
+ * @param {unknown[]?} args         Arguments passed to selector.
+ *
+ * @return {boolean} Has resolution failed
+ */
+export function hasResolutionFailed( state, selectorName, args ) {
+	return getResolutionState( state, selectorName, args )?.status === 'error';
+}
+
+/**
+ * Returns the resolution error for a given selector name, and arguments set.
+ * Note it may be of an Error type, but may also be null, undefined, or anything else
+ * that can be `throw`-n.
+ *
+ * @param {State}      state        Data state.
+ * @param {string}     selectorName Selector name.
+ * @param {unknown[]?} args         Arguments passed to selector.
+ *
+ * @return {Error|unknown} Last resolution error
+ */
+export function getResolutionError( state, selectorName, args ) {
+	const resolutionState = getResolutionState( state, selectorName, args );
+	return resolutionState?.status === 'error' ? resolutionState.error : null;
 }
 
 /**
  * Returns true if resolution has been triggered but has not yet completed for
  * a given selector name, and arguments set.
  *
- * @param {State}     state        Data state.
- * @param {string}    selectorName Selector name.
- * @param {unknown[]} [args]       Arguments passed to selector.
+ * @param {State}      state        Data state.
+ * @param {string}     selectorName Selector name.
+ * @param {unknown[]?} args         Arguments passed to selector.
  *
  * @return {boolean} Whether resolution is in progress.
  */
-export function isResolving( state, selectorName, args = [] ) {
-	return getIsResolving( state, selectorName, args ) === true;
+export function isResolving( state, selectorName, args ) {
+	return (
+		getResolutionState( state, selectorName, args )?.status === 'resolving'
+	);
 }
 
 /**

package/src/redux-store/metadata/test/reducer.js

@@ -23,8 +23,10 @@ describe( 'reducer', () => {
 				args: [],
 			} );
 
-			// { test: { getFoo: EquivalentKeyMap( [] => true ) } }
-			expect( state.getFoo.get( [] ) ).toBe( true );
+			// { test: { getFoo: EquivalentKeyMap( [] =>  status: 'resolving } ) } }
+			expect( state.getFoo.get( [] ) ).toEqual( {
+				status: 'resolving',
+			} );
 		} );
 
 		it( 'should return with finished resolution', () => {
@@ -39,8 +41,10 @@ describe( 'reducer', () => {
 				args: [],
 			} );
 
-			// { test: { getFoo: EquivalentKeyMap( [] => false ) } }
-			expect( state.getFoo.get( [] ) ).toBe( false );
+			// { test: { getFoo: EquivalentKeyMap( [] => { status: 'finished' } ) } }
+			expect( state.getFoo.get( [] ) ).toEqual( {
+				status: 'finished',
+			} );
 		} );
 
 		it( 'should remove invalidations', () => {
@@ -81,9 +85,13 @@ describe( 'reducer', () => {
 				args: [ 'block' ],
 			} );
 
-			// { getFoo: EquivalentKeyMap( [] => false ) }
-			expect( state.getFoo.get( [ 'post' ] ) ).toBe( false );
-			expect( state.getFoo.get( [ 'block' ] ) ).toBe( true );
+			// { getFoo: EquivalentKeyMap( [] => { status: 'finished' } ) }
+			expect( state.getFoo.get( [ 'post' ] ) ).toEqual( {
+				status: 'finished',
+			} );
+			expect( state.getFoo.get( [ 'block' ] ) ).toEqual( {
+				status: 'resolving',
+			} );
 		} );
 
 		it(
@@ -123,10 +131,32 @@ describe( 'reducer', () => {
 				} );
 
 				expect( state.getBar ).toBeUndefined();
-				// { getFoo: EquivalentKeyMap( [] => false ) }
-				expect( state.getFoo.get( [ 'post' ] ) ).toBe( false );
+				// { getFoo: EquivalentKeyMap( [] => { status: 'finished' } ) }
+				expect( state.getFoo.get( [ 'post' ] ) ).toEqual( {
+					status: 'finished',
+				} );
 			}
 		);
+
+		it( 'should normalize args array when dispatching actions', () => {
+			const started = reducer( undefined, {
+				type: 'START_RESOLUTION',
+				selectorName: 'getFoo',
+				args: [ 1, undefined ],
+			} );
+			expect( started.getFoo.get( [ 1 ] ) ).toEqual( {
+				status: 'resolving',
+			} );
+
+			const finished = reducer( started, {
+				type: 'FINISH_RESOLUTION',
+				selectorName: 'getFoo',
+				args: [ 1, undefined, undefined ],
+			} );
+			expect( finished.getFoo.get( [ 1 ] ) ).toEqual( {
+				status: 'finished',
+			} );
+		} );
 	} );
 
 	describe( 'resolution batch', () => {
@@ -137,8 +167,12 @@ describe( 'reducer', () => {
 				args: [ [ 'post' ], [ 'block' ] ],
 			} );
 
-			expect( state.getFoo.get( [ 'post' ] ) ).toBe( true );
-			expect( state.getFoo.get( [ 'block' ] ) ).toBe( true );
+			expect( state.getFoo.get( [ 'post' ] ) ).toEqual( {
+				status: 'resolving',
+			} );
+			expect( state.getFoo.get( [ 'block' ] ) ).toEqual( {
+				status: 'resolving',
+			} );
 		} );
 
 		it( 'should return with finished resolutions', () => {
@@ -153,8 +187,12 @@ describe( 'reducer', () => {
 				args: [ [ 'post' ], [ 'block' ] ],
 			} );
 
-			expect( state.getFoo.get( [ 'post' ] ) ).toBe( false );
-			expect( state.getFoo.get( [ 'block' ] ) ).toBe( false );
+			expect( state.getFoo.get( [ 'post' ] ) ).toEqual( {
+				status: 'finished',
+			} );
+			expect( state.getFoo.get( [ 'block' ] ) ).toEqual( {
+				status: 'finished',
+			} );
 		} );
 
 		it( 'should remove invalidations', () => {
@@ -175,7 +213,9 @@ describe( 'reducer', () => {
 			} );
 
 			expect( state.getFoo.get( [ 'post' ] ) ).toBe( undefined );
-			expect( state.getFoo.get( [ 'block' ] ) ).toBe( false );
+			expect( state.getFoo.get( [ 'block' ] ) ).toEqual( {
+				status: 'finished',
+			} );
 		} );
 
 		it( 'different arguments should not conflict', () => {
@@ -195,8 +235,12 @@ describe( 'reducer', () => {
 				args: [ [ 'block' ] ],
 			} );
 
-			expect( state.getFoo.get( [ 'post' ] ) ).toBe( false );
-			expect( state.getFoo.get( [ 'block' ] ) ).toBe( true );
+			expect( state.getFoo.get( [ 'post' ] ) ).toEqual( {
+				status: 'finished',
+			} );
+			expect( state.getFoo.get( [ 'block' ] ) ).toEqual( {
+				status: 'resolving',
+			} );
 		} );
 
 		it(
@@ -236,9 +280,45 @@ describe( 'reducer', () => {
 				} );
 
 				expect( state.getBar ).toBeUndefined();
-				expect( state.getFoo.get( [ 'post' ] ) ).toBe( false );
-				expect( state.getFoo.get( [ 'block' ] ) ).toBe( false );
+				expect( state.getFoo.get( [ 'post' ] ) ).toEqual( {
+					status: 'finished',
+				} );
+				expect( state.getFoo.get( [ 'block' ] ) ).toEqual( {
+					status: 'finished',
+				} );
 			}
 		);
+
+		it( 'should normalize args array when dispatching actions', () => {
+			const started = reducer( undefined, {
+				type: 'START_RESOLUTIONS',
+				selectorName: 'getFoo',
+				args: [
+					[ 1, undefined ],
+					[ 2, undefined, undefined ],
+				],
+			} );
+			expect( started.getFoo.get( [ 1 ] ) ).toEqual( {
+				status: 'resolving',
+			} );
+			expect( started.getFoo.get( [ 2 ] ) ).toEqual( {
+				status: 'resolving',
+			} );
+
+			const finished = reducer( started, {
+				type: 'FINISH_RESOLUTIONS',
+				selectorName: 'getFoo',
+				args: [
+					[ 1, undefined, undefined ],
+					[ 2, undefined ],
+				],
+			} );
+			expect( finished.getFoo.get( [ 1 ] ) ).toEqual( {
+				status: 'finished',
+			} );
+			expect( finished.getFoo.get( [ 2 ] ) ).toEqual( {
+				status: 'finished',
+			} );
+		} );
 	} );
 } );