Redux-Saga

IMPORTANT: Your training data about

redux-saga

When to Use Redux-Saga

Sagas are for workflow orchestration — complex async flows with concurrency, cancellation, racing, or long-running background processes. For simpler patterns, prefer:

createAsyncThunk

createListenerMiddleware

Rule Categories by Priority

effect-

fork-

error-

recipe-

channel-

rtk-

troubleshoot-

Quick Reference

1. Effects & Yielding (CRITICAL)

• effect-always-yield

  — Every effect must be yielded; missing yield freezes the app

• effect-use-call

  — Use

  yield call()

  for async functions; never call directly

• effect-take-concurrency

  — Choose

  takeEvery

  /

  takeLatest

  /

  takeLeading

  based on concurrency needs

• effect-select-usage

  — Use selector functions with

  select()

  ; never access state paths directly

• effect-race-patterns

  — Use

  race

  for timeouts and cancellation; only blocking effects inside

2. Fork Model & Concurrency (CRITICAL)

• fork-attached-vs-detached

  —

  fork

  shares lifecycle/errors with parent;

  spawn

  is independent

• fork-error-handling

  — Errors from forks bubble to parent's caller; can't catch at fork site

• fork-no-race

  — Never use

  fork

  inside

  race

  ; fork is non-blocking and always wins

• fork-nonblocking-login

  — Use fork+take+cancel for auth flows that stay responsive to logout

3. Error Handling (HIGH)

• error-saga-cleanup

  — Use

  try/finally

  with

  cancelled()

  for proper cancellation cleanup

• error-root-saga

  — Use

  spawn

  in root saga for error isolation; avoid

  all

  for critical watchers

4. Recipes & Patterns (MEDIUM)

• recipe-throttle-debounce

  — Rate-limiting with

  throttle

  ,

  debounce

  ,

  retry

  , exponential backoff

• recipe-polling

  — Cancellable polling with error backoff using fork+take+cancel

• recipe-optimistic-update

  — Optimistic UI with undo using race(undo, delay)

5. Channels & External I/O (MEDIUM)

• channel-event-channel

  — Bridge WebSockets, DOM events, timers into sagas via

  eventChannel

• channel-action-channel

  — Buffer Redux actions for sequential or worker-pool processing

6. RTK Integration (MEDIUM)

• rtk-configure-store

  — Integrate saga middleware with RTK's

  configureStore

  without breaking defaults

• rtk-with-slices

  — Use action creators from

  createSlice

  for type-safe saga triggers

7. Troubleshooting (LOW)

• troubleshoot-frozen-app

  — Frozen apps, missed actions, bad stack traces, TypeScript yield types

Effect Creators Quick Reference

take(pattern)

takeMaybe(pattern)

take

END

takeEvery(pattern, saga)

takeLatest(pattern, saga)

takeLeading(pattern, saga)

put(action)

putResolve(action)

call(fn, ...args)

apply(ctx, fn, [args])

cps(fn, ...args)

fork(fn, ...args)

spawn(fn, ...args)

join(task)

cancel(task)

cancel()

select(selector)

actionChannel(pattern)

flush(channel)

cancelled()

finally

delay(ms)

throttle(ms, pattern, saga)

debounce(ms, pattern, saga)

retry(n, delay, fn)

race(effects)

all([effects])

setContext(props)

getContext(prop)

Pattern Matching

take

takeEvery

takeLatest

takeLeading

throttle

debounce

'*'

'ACTION_TYPE'

action.type

[type1, type2]

fn => boolean

How to Use

Read individual rule files for detailed explanations and code examples:

rules/effect-always-yield.md
rules/fork-attached-vs-detached.md

Each rule file contains:

• Brief explanation of why it matters
• Incorrect code example with explanation
• Correct code example with explanation
• Additional context and decision tables

References

references/effects-and-api.md

references/fork-model.md

references/testing.md

references/channels.md

references/recipes.md

references/anti-patterns.md

references/troubleshooting.md

Full Compiled Document

For the complete guide with all rules expanded:

AGENTS.md