Cfrgtkky

The following example shows the usual implementation for the selector pattern. Then I'll discuss the problems of this implementation. After that I'll suggest another implementation that may prove useful.

Usual implementation:

Here is how the root reducer looks like along with public selectors:

// reducers/index.js

import { combineReducers } from 'redux';

import * as Items from './items';

import * as Login from './login';



export default combineReducers({

  login: Login.reducer,

  items: Items.reducer

  // more slices ...

});





// PUBLIC SELECTORS

export const getToken = state => Login.getToken(state.login);

export const getLoginError = state => Login.getError(state.login);

export const isLoginLoading = state => Login.isLoading(state.login);



export const getItems = state => Items.getToken(state.items);

export const getCurrentItem = state => Items.getError(state.items);

export const isItemsLoading = state => Items.isLoading(state.items);



// Selectors for data from other slices

// ...



// Selectors for derived data from multiple slices

export const getOwnedItems = (state) => {

  // ...

};

Here is how a slice reducer look like along with its private selectors:

// reducers/login.js

import {

  // actions ...

} from '../actions';



const defaultState = {

  // ...

};



export const reducer = (state = defaultState, action = {}) => {

  // Reducer ...

};





// PRIVATE SELECTORS

export const getToken = state => state.token;

export const getError = state => state.error;

export const isLoading = state => state.loading;

Another slice reducer and its private selectors:

// reducers/items.js

import {

  // actions ...

} from '../actions';



const defaultState = {

  // ...

};



export const reducer = (state = defaultState, action = {}) => {

  // Reducer ...

};





// PRIVATE SELECTORS

export const getItems = state => state.items;

export const getCurrentItem = state => state.currentItem;

export const isItemsLoading = state => state.isLoading;

The usage of this implementation would be like this:

import { getLoginError, isLoginLoading } from '../reducers';



const mapStateToProps = state => {

  return {

    error: getLoginError(state),

    loading: isLoginLoading(state)

  };

};

The Problem:

The previous implementation of selectors requires all public selectors to be defined in reducers/index.js. Notice that public selectors receives the full state which is managed by the root reducer defined in reducers/index.js.

Public selectors can be divided into two types. Extraction selectors just for extracting data from the state. And Derived information Selectors which computes derived information from the state. For the users all selectors are the same and their purpose is to separate the client code from the shape of the state.

First problem with the previous implementation is that all extraction selectors are written twice. Once as a public selector and another as a private selector where the public selector is calling the private one.

Second problem is that all private selectors for specific slice can only receive that slice but it is passed many times, once for each usage instance of a private selector for that slice which seems a good case for refactoring.

The following is another implementation for selectors that could prove useful:

Another implementation

The root reducer file will only provide one select() function which takes the full state and provide the public interface from which client code can retrieve data from the state.

The interface may consist of functions or collections of functions grouped under a name.
This structure allow us to provide an interface that will make implementing extraction selectors trivial in addition to the ability to provide more customized public selectors.

Please don't confuse the structure of the selector with the shape of the state. There is not coupling between the two. The public selector can still implement the same interface for the application even if the shape of the state changed.

Here is the public selectors implemented in select(state) function:

// reducers/index.js

import { combineReducers } from 'redux';

import * as Items from './items';

import * as Login from './login';



export default combineReducers({

  login: Login.reducer,

  items: Items.reducer

  // more slices ...

});





// PUBLIC SELECTORS

export const select = (state) => {

  return {

    login: Login.select(state.login),

    items: Items.select(state.items),



    // Selectors for drived data from multiple slices

    getOwnedItems: () => {

      // ...

    }

  };

};

Here is private selectors inplemented in the same way:

// reducers/login.js

import {

  // actions ...

} from '../actions';



const defaultState = {

  // ...

};



export const reducer = (state = defaultState, action = {}) => {

  // Reducer ...

};





// PRIVATE SELECTORS

export const select = (state) => {

  return {

    getToken: () => state.token,

    getError: () => state.error,

    isLoading: () => state.loading

  };

};

Again for another slice:

// reducers/items.js

import {

  // actions ...

} from '../actions';



const defaultState = {

  // ...

};



export const reducer = (state = defaultState, action = {}) => {

  // Reducer ...

};





// PRIVATE SELECTORS

export const select = (state) => {

  return {

    getItems: () => state.items,

    getCurrentItem: () => state.currentItem,

    isLoading: () => state.loading

  };

};

The usage of this implementation looks like this:

import { select } from '../reducers';



const mapStateToProps = state => {

  return {

    error: select(state).login.getError(),

    loading: select(state).login.isLoading()

  };

};

Question 1:

What are the drawbacks of this implementation?

Question 2:

Is there another way to address the problems described above?

Thank you