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

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

@@ -9,9 +9,11 @@ import { get } from 'lodash';
 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.
@@ -20,17 +22,35 @@ import { selectorArgsToStateKey } from './utils';
  * @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( 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.
@@ -42,7 +62,7 @@ export function getIsResolving( state, selectorName, args ) {
  * @return {boolean} Whether resolution has been triggered.
  */
 export function hasStartedResolution( state, selectorName, args ) {
-	return getIsResolving( state, selectorName, args ) !== undefined;
+	return getResolutionState( state, selectorName, args ) !== undefined;
 }
 
 /**
@@ -56,7 +76,38 @@ export function hasStartedResolution( state, selectorName, args ) {
  * @return {boolean} Whether resolution has completed.
  */
 export function hasFinishedResolution( state, selectorName, args ) {
-	return getIsResolving( state, selectorName, args ) === false;
+	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;
 }
 
 /**
@@ -70,7 +121,9 @@ export function hasFinishedResolution( state, selectorName, args ) {
  * @return {boolean} Whether resolution is in progress.
  */
 export function isResolving( state, selectorName, args ) {
-	return getIsResolving( state, selectorName, args ) === true;
+	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,8 +131,10 @@ 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',
+				} );
 			}
 		);
 
@@ -134,14 +144,18 @@ describe( 'reducer', () => {
 				selectorName: 'getFoo',
 				args: [ 1, undefined ],
 			} );
-			expect( started.getFoo.get( [ 1 ] ) ).toBe( true );
+			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 ] ) ).toBe( false );
+			expect( finished.getFoo.get( [ 1 ] ) ).toEqual( {
+				status: 'finished',
+			} );
 		} );
 	} );
 
@@ -153,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', () => {
@@ -169,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', () => {
@@ -191,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', () => {
@@ -211,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(
@@ -252,8 +280,12 @@ 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',
+				} );
 			}
 		);
 
@@ -266,8 +298,12 @@ describe( 'reducer', () => {
 					[ 2, undefined, undefined ],
 				],
 			} );
-			expect( started.getFoo.get( [ 1 ] ) ).toBe( true );
-			expect( started.getFoo.get( [ 2 ] ) ).toBe( true );
+			expect( started.getFoo.get( [ 1 ] ) ).toEqual( {
+				status: 'resolving',
+			} );
+			expect( started.getFoo.get( [ 2 ] ) ).toEqual( {
+				status: 'resolving',
+			} );
 
 			const finished = reducer( started, {
 				type: 'FINISH_RESOLUTIONS',
@@ -277,8 +313,12 @@ describe( 'reducer', () => {
 					[ 2, undefined ],
 				],
 			} );
-			expect( finished.getFoo.get( [ 1 ] ) ).toBe( false );
-			expect( finished.getFoo.get( [ 2 ] ) ).toBe( false );
+			expect( finished.getFoo.get( [ 1 ] ) ).toEqual( {
+				status: 'finished',
+			} );
+			expect( finished.getFoo.get( [ 2 ] ) ).toEqual( {
+				status: 'finished',
+			} );
 		} );
 	} );
 } );

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

@@ -1,117 +1,327 @@
 /**
- * External dependencies
+ * WordPress dependencies
  */
-import EquivalentKeyMap from 'equivalent-key-map';
+import { createRegistry } from '@wordpress/data';
 
-/**
- * Internal dependencies
- */
-import {
-	getIsResolving,
-	hasStartedResolution,
-	hasFinishedResolution,
-	isResolving,
-} from '../selectors';
+jest.useRealTimers();
+const testStore = {
+	reducer: ( state = null, action ) => {
+		if ( action.type === 'RECEIVE' ) {
+			return action.items;
+		}
+
+		return state;
+	},
+	selectors: {
+		getFoo: ( state ) => state,
+	},
+};
+
+async function resolve( registry, selector ) {
+	try {
+		await registry.resolveSelect( 'store' )[ selector ]();
+	} catch ( e ) {}
+}
 
 describe( 'getIsResolving', () => {
+	let registry;
+	beforeEach( () => {
+		registry = createRegistry();
+		registry.registerStore( 'testStore', testStore );
+	} );
+
 	it( 'should return undefined if no state by reducerKey, selectorName', () => {
-		const state = {};
-		const result = getIsResolving( state, 'getFoo', [] );
+		const result = registry
+			.select( 'testStore' )
+			.getIsResolving( 'getFoo', [] );
 
 		expect( result ).toBe( undefined );
 	} );
 
 	it( 'should return undefined if state by reducerKey, selectorName, but not args', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], true ] ] ),
-		};
-		const result = getIsResolving( state, 'getFoo', [ 'bar' ] );
+		registry.dispatch( 'testStore' ).startResolution( 'getFoo', [] );
+		const result = registry
+			.select( 'testStore' )
+			.getIsResolving( 'getFoo', [ 'bar' ] );
 
 		expect( result ).toBe( undefined );
 	} );
 
 	it( 'should return value by reducerKey, selectorName', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], true ] ] ),
-		};
-		const result = getIsResolving( state, 'getFoo', [] );
+		registry.dispatch( 'testStore' ).startResolution( 'getFoo', [] );
+		const result = registry
+			.select( 'testStore' )
+			.getIsResolving( 'getFoo', [] );
 
 		expect( result ).toBe( true );
 	} );
 
 	it( 'should normalize args ard return the right value', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], true ] ] ),
-		};
-		expect( getIsResolving( state, 'getFoo' ) ).toBe( true );
-		expect( getIsResolving( state, 'getFoo', [ undefined ] ) ).toBe( true );
-		expect(
-			getIsResolving( state, 'getFoo', [ undefined, undefined ] )
-		).toBe( true );
+		registry.dispatch( 'testStore' ).startResolution( 'getFoo', [] );
+		const { getIsResolving } = registry.select( 'testStore' );
+
+		expect( getIsResolving( 'getFoo' ) ).toBe( true );
+		expect( getIsResolving( 'getFoo', [ undefined ] ) ).toBe( true );
+		expect( getIsResolving( 'getFoo', [ undefined, undefined ] ) ).toBe(
+			true
+		);
 	} );
 } );
 
 describe( 'hasStartedResolution', () => {
+	let registry;
+	beforeEach( () => {
+		registry = createRegistry();
+		registry.registerStore( 'testStore', testStore );
+	} );
+
 	it( 'returns false if not has started', () => {
-		const state = {};
-		const result = hasStartedResolution( state, 'getFoo', [] );
+		const result = registry
+			.select( 'testStore' )
+			.hasStartedResolution( 'getFoo', [] );
 
 		expect( result ).toBe( false );
 	} );
 
 	it( 'returns true if has started', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], true ] ] ),
-		};
-		const result = hasStartedResolution( state, 'getFoo', [] );
+		registry.dispatch( 'testStore' ).startResolution( 'getFoo', [] );
+		const { hasStartedResolution } = registry.select( 'testStore' );
+		const result = hasStartedResolution( 'getFoo', [] );
 
 		expect( result ).toBe( true );
 	} );
 } );
 
 describe( 'hasFinishedResolution', () => {
+	let registry;
+	beforeEach( () => {
+		registry = createRegistry();
+		registry.registerStore( 'testStore', testStore );
+	} );
+
 	it( 'returns false if not has finished', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], true ] ] ),
-		};
-		const result = hasFinishedResolution( state, 'getFoo', [] );
+		registry.dispatch( 'testStore' ).startResolution( 'getFoo', [] );
+		const { hasFinishedResolution } = registry.select( 'testStore' );
+		const result = hasFinishedResolution( 'getFoo', [] );
 
 		expect( result ).toBe( false );
 	} );
 
 	it( 'returns true if has finished', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], false ] ] ),
-		};
-		const result = hasFinishedResolution( state, 'getFoo', [] );
+		registry.dispatch( 'testStore' ).finishResolution( 'getFoo', [] );
+		const { hasFinishedResolution } = registry.select( 'testStore' );
+		const result = hasFinishedResolution( 'getFoo', [] );
 
 		expect( result ).toBe( true );
 	} );
 } );
 
 describe( 'isResolving', () => {
+	let registry;
+	beforeEach( () => {
+		registry = createRegistry();
+		registry.registerStore( 'testStore', testStore );
+	} );
+
 	it( 'returns false if not has started', () => {
-		const state = {};
-		const result = isResolving( state, 'getFoo', [] );
+		const { isResolving } = registry.select( 'testStore' );
+		const result = isResolving( 'getFoo', [] );
 
 		expect( result ).toBe( false );
 	} );
 
 	it( 'returns false if has finished', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], false ] ] ),
-		};
-		const result = isResolving( state, 'getFoo', [] );
+		registry.dispatch( 'testStore' ).startResolution( 'getFoo', [] );
+		registry.dispatch( 'testStore' ).finishResolution( 'getFoo', [] );
+		const { isResolving } = registry.select( 'testStore' );
+		const result = isResolving( 'getFoo', [] );
 
 		expect( result ).toBe( false );
 	} );
 
 	it( 'returns true if has started but not finished', () => {
-		const state = {
-			getFoo: new EquivalentKeyMap( [ [ [], true ] ] ),
-		};
-		const result = isResolving( state, 'getFoo', [] );
+		registry.dispatch( 'testStore' ).startResolution( 'getFoo', [] );
+		const { isResolving } = registry.select( 'testStore' );
+		const result = isResolving( 'getFoo', [] );
 
 		expect( result ).toBe( true );
 	} );
 } );
+
+describe( 'hasResolutionFailed', () => {
+	let registry;
+
+	beforeEach( () => {
+		registry = createRegistry();
+	} );
+
+	it( 'returns false if the resolution has succeeded', async () => {
+		registry.registerStore( 'store', {
+			reducer: ( state = null, action ) => {
+				if ( action.type === 'RECEIVE' ) {
+					return action.items;
+				}
+
+				return state;
+			},
+			selectors: {
+				getFoo: ( state ) => state,
+			},
+			resolvers: {
+				getFoo: () => {},
+			},
+		} );
+
+		expect(
+			registry.select( 'store' ).hasResolutionFailed( 'getFoo' )
+		).toBeFalsy();
+
+		registry.select( 'store' ).getFoo();
+
+		expect(
+			registry.select( 'store' ).hasResolutionFailed( 'getFoo' )
+		).toBeFalsy();
+	} );
+
+	it( 'returns true if the resolution has failed', async () => {
+		registry.registerStore( 'store', {
+			reducer: ( state = null, action ) => {
+				if ( action.type === 'RECEIVE' ) {
+					return action.items;
+				}
+
+				return state;
+			},
+			selectors: {
+				getFoo: ( state ) => state,
+			},
+			resolvers: {
+				getFoo: () => {
+					throw new Error( 'cannot fetch items' );
+				},
+			},
+		} );
+
+		expect(
+			registry.select( 'store' ).hasResolutionFailed( 'getFoo' )
+		).toBeFalsy();
+
+		await resolve( registry, 'getFoo' );
+
+		expect(
+			registry.select( 'store' ).hasResolutionFailed( 'getFoo' )
+		).toBeTruthy();
+	} );
+
+	it( 'returns true if the resolution has failed even if the error is falsy', async () => {
+		registry.registerStore( 'store', {
+			reducer: ( state = null, action ) => {
+				if ( action.type === 'RECEIVE' ) {
+					return action.items;
+				}
+
+				return state;
+			},
+			selectors: {
+				getFoo: ( state ) => state,
+			},
+			resolvers: {
+				getFoo: () => {
+					throw null;
+				},
+			},
+		} );
+
+		expect(
+			registry.select( 'store' ).hasResolutionFailed( 'getFoo' )
+		).toBeFalsy();
+
+		await resolve( registry, 'getFoo' );
+
+		expect(
+			registry.select( 'store' ).hasResolutionFailed( 'getFoo' )
+		).toBeTruthy();
+	} );
+} );
+
+describe( 'getResolutionError', () => {
+	let registry;
+	let shouldFail;
+
+	beforeEach( () => {
+		shouldFail = false;
+		registry = createRegistry();
+
+		registry.registerStore( 'store', {
+			reducer: ( state = null, action ) => {
+				if ( action.type === 'RECEIVE' ) {
+					return action.items;
+				}
+
+				return state;
+			},
+			selectors: {
+				getFoo: ( state ) => state,
+			},
+			resolvers: {
+				getFoo: () => {
+					if ( shouldFail ) {
+						throw new Error( 'cannot fetch items' );
+					}
+				},
+			},
+		} );
+	} );
+
+	it( 'returns undefined if the resolution has succeeded', async () => {
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' )
+		).toBeFalsy();
+
+		registry.select( 'store' ).getFoo();
+
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' )
+		).toBeFalsy();
+	} );
+
+	it( 'returns error if the resolution has failed', async () => {
+		shouldFail = true;
+
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' )
+		).toBeFalsy();
+
+		await resolve( registry, 'getFoo' );
+
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' ).toString()
+		).toBe( 'Error: cannot fetch items' );
+	} );
+
+	it( 'returns undefined if the failed resolution succeeded after retry', async () => {
+		shouldFail = true;
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' )
+		).toBeFalsy();
+
+		await resolve( registry, 'getFoo' );
+
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' )
+		).toBeTruthy();
+
+		registry.dispatch( 'store' ).invalidateResolution( 'getFoo', [] );
+
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' )
+		).toBeFalsy();
+
+		shouldFail = false;
+		registry.select( 'store' ).getFoo();
+
+		expect(
+			registry.select( 'store' ).getResolutionError( 'getFoo' )
+		).toBeFalsy();
+	} );
+} );