NgRx Effect behavior during concurrent 401 Unauthorized responses

Short answer

Use exhaustMap in the logout Effect. When several 401 responses arrive at once and the interceptor dispatches multiple identical logout actions, exhaustMap ignores every new action until the in-flight logout sequence (clear credentials, navigate) completes. Pair that with a single reducer that resets the auth state slice atomically, and exactly one logout sequence runs no matter how many requests fail simultaneously.

Why the other flattening operators misbehave here

• mergeMap runs every dispatched logout action concurrently, so you get multiple navigation calls and repeated redirect cycles.
• switchMap cancels the previous sequence and restarts on each new action. With rapid-fire 401s this can abort a half-finished logout and trigger the redirect logic repeatedly.
• concatMap queues the duplicates, so the redirect still executes once per action — just sequentially.
• exhaustMap drops duplicates while one sequence is active, which matches the semantics of "logout is already happening, ignore further requests to log out."

Recommended wiring

Keep the interceptor dumb: it only dispatches the action. The reducer handles the synchronous, atomic state reset; the Effect handles the asynchronous side effects.

// reducer: atomic reset, runs once per dispatched action but is idempotent
on(AuthActions.logout, () => initialAuthState)

logout$ = createEffect(() =>
  this.actions$.pipe(
    ofType(AuthActions.logout),
    exhaustMap(() =>
      this.authApi.revokeSession().pipe(
        catchError(() => of(null)), // local logout must succeed even if the API call fails
      ),
    ),
    tap(() => this.router.navigate(['/login'])),
  ),
  { dispatch: false },
);

Two details matter:

1. Make the inner observable complete. exhaustMap only blocks while the inner observable is alive. If your inner stream never completes (or errors without a catchError), either every subsequent logout is swallowed forever, or the Effect stream dies. Always terminate the error path inside the exhaustMap.
2. Reset state in the reducer, not the Effect. Reducers run synchronously when the action is dispatched, so the UI flips to the logged-out state immediately. Because the reset is idempotent (setting the slice to its initial value), the duplicate actions that do reach the reducer before the Effect filters anything are harmless — the state transition is the same.

Optional extra guard

If you want to cut noise earlier, the interceptor can check a store selector (e.g., selectIsAuthenticated) before dispatching, skipping the logout action when the user is already logged out. This is a complement, not a replacement — the exhaustMap in the Effect remains the authoritative guard for the redirect.

Verification

1. Point the app at a mock backend that returns 401 for five concurrent requests; confirm exactly one navigation to the login route occurs (spy on Router.navigate in a test).
2. Open Redux DevTools and confirm each dispatched logout action produces the same state — one meaningful transition, no flicker.
3. Log a second login after the forced logout to prove the Effect stream still processes new logout actions (i.e., the exhaustMap inner observable completed properly).

This guidance assumes a current NgRx version (13+); the operator semantics described are stable RxJS behavior and apply broadly.