Writing one redux Reducer and passing one initial object - reducers

Question

I have gone through the Redux document and figured out that we can write only one reducer for whole app, if we are able to design the initial object.
If i am true, is this implementation is valid , i have adopted only one reducer and designed my object with my requirements.
This is my code
import merge from 'lodash/object/merge';
const initialState = {
user: {isLoggedIn: false, showSignIn: false, showSignUp: false},
exams: {},
subjects: {isfetched: false},
units: {},
classRooms: [],
pricePlansSelected: {},
plansActiveState: { tabActive: 'popular' },
trackCPCClick: {},
pricingPlans: {},
popularPlans: {isfetched: false},
customPlans: {isfetched: false},
unitsForCustomSelection: {},
appliedCoupon: { code: '', applied: false},
examAttempts: {isfetched: false},
examAttemptSelected: {}
};
export default function entities(state = initialState, action) {
return merge({}, state, action);
}

Answer 1

While it is technically true that Redux stores use one reducer, breaking up your reducers into readable and maintainable pieces is fundamental to good Redux development. The best way to do this is to create a new reducer function for each piece of state and then use combineReducers() to combine all of those pieces back into one reducer function.
Using a few pieces of your state, you could nicely divide it up like this:
import { combineReducers } from 'redux'
const userState = {isLoggedIn: false, showSignIn: false, showSignUp: false};
function userReducer(state = userState, action) {
//build new piece of state based on action here
}
const subjectState = {isfetched: false};
function subjectReducer(state = subjectState, action) {
//build new piece of state based on action here
}
const appState = combineReducers({
user: userReducer,
subject: subjectReducer
});
export default appState;
The main problem with the code that you have posted is that you need to account for all possible action types within your reducer functions. Otherwise your entire app could only ever have one action that rebuilt the whole app state with its data every time. You can account for different action types any way that you'd like, but the main convention has been to use a switch. Also note that while you use lodash merge for your state creation, you can also use Object.assign() or the spread operator (...three dots) to do the same thing, if you are compiling with something like babel.
So with that in mind, one of your reducer functions would look something like this:
function userReducer(state = userState, action) {
switch (action.type) {
case 'LOAD_USER':
return action.result; //assumes action.result is same structure as user piece of state
case 'LOG_IN':
return {...state, isLoggedIn: true}
default:
return state;
}
}
Because your reducers are broken up into maintainable pieces, your actions only have to return the data that corresponds to that particular piece of state and not the entire application.