createReducer on() vs Switch-Case Reducers for State Immutability

Answer

createReducer with on() does **not** give automatic deep‑immutability protection that a disciplined switch‑case reducer lacks. Both patterns rely on the handler returning a new state object; if the handler mutates the supplied state argument, the original reference will be changed in either case.

Confirmed facts

• Neither createReducer nor a hand‑written switch‑case adds runtime checks that freeze or clone state.
• Both patterns allow accidental mutation if the handler directly modifies the state argument (e.g., state.users.profile.name = 'new').
• NgRx v15+ retains the same createReducer implementation; no extra immutability guarantees were added.

Likely explanation

The on() API removes the visual noise of a switch statement and gives each action its own readable handler. This reduces boilerplate and makes deeply nested updates easier to read, especially when you combine it with a helper like Immer or explicit spread operators.

Steps to verify immutability behavior (for your own code)

1. Create a feature state with a nested slice, e.g., { users: { profile: { name: '' } } }.
2. Define two reducers for the same action:
   • createReducer(initialState, on(updateName, (state, { payload }) => ({ ...state, users: { ...state.users, profile: { ...state.users.profile, name: payload } })))
   • A switch‑case reducer that returns the same spread‑based new state.
3. In a test, dispatch the action and inspect whether Object.is(state, newState) is false (new reference) and whether the original state object remains unchanged.
4. Repeat the test with a handler that mutates directly (e.g., state.users.profile.name = payload) – both reducers will show the original reference changed, confirming that neither pattern prevents mutation by itself.

Recommendation

If your team already uses an immutable‑update library such as Immer, the safety difference between the two patterns disappears; choose createReducer for its lower boilerplate and clearer per‑action handlers. If you rely solely on manual spreads, ensure disciplined copying in every handler – the switch‑case approach offers no extra safety.

To refine the recommendation, please confirm whether your project adopts Immer (or a similar immutable‑update helper) for reducer logic.