The Saga is not dead - Bringing modern DX (Promises) to Redux-Saga with Saga-Toolkit

[janoist1]

Hi everyone!

I know the current trend is moving towards React Query or RTK Query, but many of us still work on complex enterprise applications where Redux-Saga is irreplaceable for handling complicated business logic, race conditions, and long-running side effects.

However, we all know the biggest pain point: Getting feedback from a Saga back to the UI.

We’ve all been there: dispatching an action, then setting up a useEffect just to watch a "status" field in the store to trigger a redirect or a notification. It feels clunky and creates unnecessary boilerplate.
To solve this, I’ve created saga-toolkit.

It’s a lightweight bridge between RTK and Saga that brings the "Promise-based" experience we love in createAsyncThunk to the world of Sagas.

Key features:

• 🚀 Awaitable Sagas: Dispatch an action and await the result directly in your component.
• 🛠️ RTK Integration: Works seamlessly with createAction and Redux Toolkit.
• ⚡ Zero Boilerplate: No more manual SUCCESS/FAILURE action definitions just for a simple return value.
• 🏗️ Type Safe: Full TypeScript support for payloads and return values.

Show me the code:
You can check out the Example Project in the repo to see it in action.

Try it out immediately:
I've also prepared a StackBlitz demo where you can see how clean the UI code becomes when you can finally unwrap() a Saga call.
I’d love to hear your thoughts! Is Redux-Saga still part of your stack in 2026? How do you handle the Saga-to-UI communication?
Check it out here: github.com

Similar discussions
I've looked into previous discussions regarding Saga-UI communication (like the common 'callback in action' pattern or older libraries like redux-saga-promise). While those exist, they often feel disconnected from the modern RTK workflow or lack first-class TypeScript support for the return values. I built this to feel like a native part of the Redux Toolkit experience.

[markerikson]

Yeah, that was always a pain point with sagas.

Out of curiosity, have you looked at the listener middleware? We specifically designed it to replace most saga use cases, improve TS support, etc:

• https://redux-toolkit.js.org/api/createListenerMiddleware

[janoist1]

The Listener Middleware is a great addition and it definitely solves the 90% use case with less overhead.

However, I’m still sticking with Sagas in mid-to-large projects for two main reasons:

1. Architectural Safety: With Sagas, I never have to worry about a feature becoming so complex (twisted cancellations, racing multiple async flows, etc.) that the tool can't handle it. It’s the security of knowing I won’t hit a wall regardless of how 'insane' the requirements get.
2. The Request-Response Pattern: This is the biggest one for me. Listeners are fundamentally 'fire-and-forget'. You can't await dispatch(action).unwrap() to get a direct return value back in the component. You're forced to sync via the store, which feels like overkill for local UI feedback (like a form success or a specific error).

I built saga-toolkit because I wanted that Saga power without the legacy DX. It closes the gap by bringing the createAsyncThunk experience to the world of Sagas. It’s about making Sagas feel like a modern, first-class citizen in the RTK ecosystem for those who need that extra control.

[hotcappuccinoworld]

Great project! Saga + RTK unwrap() is perfect for complex enterprise flows. TypeScript support is excellent.

Race condition handling? AbortController? Error boundaries?

Yes, still using Saga 2026 for 100+ saga orchestration. RTK Query can't replace that.

StackBlitz sold me! 🚀

[janoist1]

Actually, the toolkit is designed specifically to map these Saga patterns directly to the Promise lifecycle. Here is how it handles your points:

• Race conditions / Concurrency: I've implemented takeLatestAsync and takeEveryAsync helpers. For example, takeLatestAsync doesn't just cancel the previous saga task, it also automatically rejects the previous pending Promise with an 'Aborted' error, so your UI stays in sync.
• Deduplication: I also added takeAggregateAsync. It’s perfect for rapid 'Refresh' clicks—it shares the same promise result across multiple identical calls until the saga finishes.
• Abort / Cancellation: If a saga is cancelled (internally or via the toolkit's helpers), the promise is rejected. This means your unwrap() call will throw, allowing you to handle it in a standard try/catch block.
  Error Boundaries: Since it's a standard Promise-based flow, any error in the saga worker propagates to the component's unwrap(), making it fully compatible with React's error handling patterns.

You can check the API Reference in the README for the full list of these async helpers!

[whoisYeshua]

🔥 omg thank you - this is what I've always been looking for!