Re-reselect

From v5, reselect provides the ability to natively implement custom memoization/caching solutions via createSelector options. Most of the features re-reselect used to enable should be now natively available in reselect. re-reselect will try to support reselect v5+ for backward compatibility reasons.

re-reselect is a lightweight wrapper around Reselect meant to enhance selectors with deeper memoization and cache management.

Switching between different arguments using standard reselect selectors causes cache invalidation since default reselect cache has a limit of one.

re-reselect forwards different calls to different reselect selectors stored in cache, so that computed/memoized values are retained.

re-reselect selectors work as normal reselect selectors but they are able to determine when creating a new selector or querying a cached one on the fly, depending on the supplied arguments.

Useful to:

• Retain selector's cache when sequentially called with one/few different arguments (example)
• Join similar selectors into one
• Share selectors with props across multiple component instances (see reselect example and re-reselect solution)
• Instantiate selectors on runtime
• Enhance reselect with custom caching strategies

1import {createCachedSelector} from 're-reselect';
2
3// Normal reselect routine: declare "inputSelectors" and "resultFunc"
4const getUsers = state => state.users;
5const getLibraryId = (state, libraryName) => state.libraries[libraryName].id;
6
7const getUsersByLibrary = createCachedSelector(
8  // inputSelectors
9  getUsers,
10  getLibraryId,
11
12  // resultFunc
13  (users, libraryId) => expensiveComputation(users, libraryId),
14)(
15  // re-reselect keySelector (receives selectors' arguments)
16  // Use "libraryName" as cacheKey
17  (_state_, libraryName) => libraryName
18);
19
20// Cached selectors behave like normal selectors:
21// 2 reselect selectors are created, called and cached
22const reactUsers = getUsersByLibrary(state, 'react');
23const vueUsers = getUsersByLibrary(state, 'vue');
24
25// This 3rd call hits the cache
26const reactUsersAgain = getUsersByLibrary(state, 'react');
27// reactUsers === reactUsersAgain
28// "expensiveComputation" called twice in total

Table of contents

• Installation
• Why? + example
  • re-reselect solution
  • Other viable solutions
• Examples
• FAQ
• API
  • createCachedSelector
  • createStructuredCachedSelector
  • keySelector
  • options
  • selector instance
• About re-reselect
• Todo's
• Contributors

Installation

1npm install reselect
2npm install re-reselect

Why? + example

Let's say getData is a reselect selector.

1getData(state, itemId, 'dataA');
2getData(state, itemId, 'dataB');
3getData(state, itemId, 'dataA');

The 3rd argument invalidates reselect cache on each call, forcing getData to re-evaluate and return a new value.

re-reselect solution

re-reselect selectors keep a cache of reselect selectors stored by cacheKey.

cacheKey is the return value of the keySelector function. It's by default a string or number but it can be anything depending on the chosen cache strategy (see cache objects docs).

keySelector is a custom function which:

• takes the same arguments as the selector itself (in the example: state, itemId, dataType)
• returns a cacheKey

A unique persisting reselect selector instance stored in cache is used to compute data for a given cacheKey (1:1).

Back to the example, we might setup re-reselect to retrieve data by querying one of the cached selectors using the 3rd argument as cacheKey, allowing cache invalidation only when state or itemId change (but not dataType):

1const getData = createCachedSelector(
2  state => state,
3  (state, itemId) => itemId,
4  (state, itemId, dataType) => dataType,
5  (state, itemId, dataType) => expensiveComputation(state, itemId, dataType)
6)(
7  (state, itemId, dataType) => dataType // Use dataType as cacheKey
8);

Replacing a selector with a cached selector is invisible to the consuming application since the API is the same.

When a cached selector is called, the following happens behind the scenes:

1. Evaluate the cacheKey for the current call by executing keySelector
2. Retrieve from cache the reselect selector stored under the given cacheKey
3. Return found selector or create a new one if no selector was found
4. Call returned selector with provided arguments

Other viable solutions

1- Declare a different selector for each different call

Easy, but doesn't scale. See "join similar selectors" example.

2- Declare a makeGetPieceOfData selector factory as explained in Reselect docs

The solution suggested in Reselect docs is fine, but it has a few downsides:

• Bloats your code by exposing both get selectors and makeGet selector factories
• Needs to import/call the selector factory instead of directly using the selector
• Two different instances, given the same arguments, will individually store and recompute the same result (read this)

3- Wrap your makeGetPieceOfData selector factory into a memoizer function and call the returning memoized selector

This is what re-reselect actually does. 😀

Examples

• Join similar selectors
• Avoid selector factories
• Cache API calls
• Programmatic keySelector composition
• Usage with Selectorator

FAQ

1import {createSelector} from '@veksa/reselect';
2
3export const getMyData = createSelector(
4  selectorA,
5  selectorB,
6  selectorC,
7  (A, B, C) => doSomethingWith(A, B, C)
8);

1import {createCachedSelector} from 're-reselect';
2
3export const getMyData = createCachedSelector(
4  selectorA,
5  selectorB,
6  selectorC,
7  (A, B, C) => doSomethingWith(A, B, C)
8)(
9  (state, arg1, arg2) => arg2 // Use arg2 as cacheKey
10);

1const myData = getMyData(state, 'foo', 'bar');

1// Basic usage: use a single argument as cacheKey
2createCachedSelector(
3  // ...
4)(
5  (state, arg1, arg2, arg3) => arg3
6)
7
8// Use multiple arguments and chain them into a string
9createCachedSelector(
10  // ...
11)(
12  (state, arg1, arg2, arg3) => `${arg1}:${arg3}`
13)
14
15// Extract properties from an object
16createCachedSelector(
17  // ...
18)(
19  (state, props) => `${props.a}:${props.b}`
20)

1import {createCachedSelector} from 're-reselect';
2
3export const getMyData = createCachedSelector(selectorA, selectorB, (A, B) =>
4  doSomethingWith(A, B)
5)(
6  (state, arg1) => arg1 // cacheKey
7);
8
9// Call your selector
10const myFooData = getMyData(state, 'foo');
11const myBarData = getMyData(state, 'bar');
12
13// Call getMatchingSelector method to retrieve underlying reselect selectors
14// which generated "myFooData" and "myBarData" results
15const myFooDataSelector = getMyData.getMatchingSelector(state, 'foo');
16const myBarDataSelector = getMyData.getMatchingSelector(state, 'bar');
17
18// Call reselect's selectors methods
19myFooDataSelector.recomputations();
20myFooDataSelector.resetRecomputations();

API

createCachedSelector

1import {createCachedSelector} from 're-reselect';
2
3createCachedSelector(
4  // ...reselect's `createSelector` arguments
5)(
6  keySelector | { options }
7)

Takes the same arguments as reselect's createSelector and returns a new function which accepts a keySelector or an options object.

Returns a selector instance.

createStructuredCachedSelector

1import {createStructuredCachedSelector} from 're-reselect';
2
3createStructuredCachedSelector(
4  // ...reselect's `createStructuredSelector` arguments
5)(
6  keySelector | { options }
7)

Takes the same arguments as reselect's createStructuredSelector and returns a new function which accepts a keySelector or an options object.

Returns a selector instance.

keySelector

A custom function receiving the same arguments as your selectors (and inputSelectors) and returning a cacheKey.

cacheKey is by default a string or number but can be anything depending on the chosen cache strategy (see cacheObject option).

The keySelector idea comes from Lodash's .memoize resolver.

options

keySelector

Type: function
Default: undefined

The keySelector used by the cached selector.

cacheObject

Type: object
Default: FlatObjectCache

An optional custom cache strategy object to handle the caching behaviour. Read more about re-reselect's custom cache here.

keySelectorCreator

Type: function
Default: undefined

An optional function with the following signature returning the keySelector used by the cached selector.

1type keySelectorCreator = (selectorInputs: {
2  inputSelectors: InputSelector[];
3  resultFunc: ResultFunc;
4  keySelector: KeySelector;
5}) => KeySelector;

This allows the ability to dynamically generate keySelectors on runtime based on provided inputSelectors/resultFunc supporting key selectors composition. It overrides any provided keySelector.

See programmatic keySelector composition example.

selectorCreator

Type: function
Default: reselect's createSelector

An optional function describing a custom version of createSelector.

re-reselect selector instance

createCachedSelector and createStructuredCachedSelector return a selector instance which extends the API of a standard reselect selector.

The followings are advanced methods and you won't need them for basic usage!

selector.getMatchingSelector(selectorArguments)

Retrieve the selector responding to the given arguments.

selector.removeMatchingSelector(selectorArguments)

Remove from the cache the selector responding to the given arguments.

selector.cache

Get the cacheObject instance being used by the selector (for advanced caching operations like this).

selector.clearCache()

Clear whole selector cache.

selector.dependencies

Get an array containing the provided inputSelectors. Refer to relevant discussion on Reselect repo.

selector.resultFunc

Get resultFunc for easily testing composed selectors.

selector.recomputations()

Return the number of times the selector's result function has been recomputed.

selector.resetRecomputations()

Reset recomputations count.

selector.keySelector

Get keySelector for utility compositions or testing.

About re-reselect

• re-reselect your whole redux state
• Understanding reselect and re-reselect
• React re-reselect: Better memoization and cache management
• Advanced Redux patterns: selectors
• Be selective with your state
• A swift developer’s React Native experience
• 5 key Redux libraries to improve code reuse
• Rematch's docs
• Redux re-reselect playground

Todo's

• Improve tests readability
• Port to native TS based on reselect v5 approach
• Find out whether re-reselect should be deprecated in favour of reselect memoization/cache options

Contributors

Thanks to you all (emoji key):

Andrea Carraro 💻 📖 🚇 ⚠️ 👀	Stepan Burguchev 💻 🤔 💬 👀 ⚠️	Sergei Grishchenko 💻 🤔 ⚠️ 🔧	Mateusz Burzyński 💻 🚇	Mitch Robb 💻 ⚠️	Stephane Rufer 💻 ⚠️	Tracy Mullen 💻 ⚠️
Sushain Cherivirala 💻	Steve Mao 📖	Gaurav Lahoti 🐛	Lon 🐛	bratushka 💻	Anders D. Johnson 📖	Július Retzer 📖
Maarten Schumacher 🤔	Alexander Jarvis 🤔	Gregg B 💡	Ian Obermiller 👀	Kanitkorn Sujautra 📖	Brian Kraus 📖	el-dav 🐛
Augustin Riedinger 🤔	RichardForrester 🤔	Alfonso Millan 📖	parkerault 🐛	johannes 🐛	Alex de la Mare 🐛 💻	Alex Khizhnyi 💻