Skip to content

chore(deps): update dependency @reduxjs/toolkit to v2.14.0 - #856

Open
renovate[bot] wants to merge 1 commit into
mainfrom
renovate/reduxjs-toolkit-2.x-lockfile
Open

chore(deps): update dependency @reduxjs/toolkit to v2.14.0#856
renovate[bot] wants to merge 1 commit into
mainfrom
renovate/reduxjs-toolkit-2.x-lockfile

Conversation

@renovate

@renovate renovate Bot commented Oct 7, 2026 •
edited
Loading

Copy link
Copy Markdown
Contributor

Note

This PR body was truncated due to platform limits.

This PR contains the following updates:

Package Change Age Confidence
@reduxjs/toolkit (source) 2.10.1 → 2.14.0 age confidence

Release Notes

reduxjs/redux-toolkit (@​reduxjs/toolkit)

v2.14.0

Compare Source

This feature release speeds up the dispatch path and RTK Query's Api type checking, shrinks createSlice in esbuild bundles, adds RTK-owned Draft and Patch types so emitted declarations no longer reference Immer, adds removeMany({ where }) and selectByIds to the entity adapter, adds RTK Query cache entry selectors and a DevTools action sanitizer, and fixes a very long list of RTK Query lifecycle, polling, upsert, timer, hook and fetchBaseQuery bugs.

Note that we just announced our roadmap to Redux Toolkit 3.0, which includes both a large set of planned 2.x features and improvements, and planned 3.0 breaking changes. The fixes and updates in this release help pave the way for all of those efforts. We'd also appreciate feedback on the linked RTK Query usage patterns and 3.0 planned breaking changes discussion threads.

Changelog

Dispatch Performance

Every dispatched action runs through every reducer and middleware, so small costs on that path add up. We added a benchmark harness for the dispatch path and used it to find several places where RTK did work for actions it didn't care about.

createAction(...).match now compares action.type before calling isAction, so a non-matching action costs a property read. createReducer no longer allocates arrays on every dispatch to collect case and matcher reducers. Since createSlice builds its reducer with createReducer, every slice reducer gets this improvement.

The listener middleware used to copy its listener list and call every predicate for every action. It now keeps a snapshot that is rebuilt only when listeners are added or removed, and that snapshot knows which action types have type or actionCreator listeners. If an action's type isn't in that set and there are no matcher or predicate listeners, the middleware skips the loop entirely.

The RTK Query root reducer now returns the existing state for actions that none of its slices handle, instead of running all five slice reducers. It also skips rewriting a query's provided tags when the new tags are the same as the stored ones, so re-fetching a query that returns the same tags no longer creates new provided state.

Some numbers from the PR benchmarks (Node 26, ops/sec unless noted):

Scenario Before After
Listener middleware, 200 listeners, unrelated action 108K 5.34M
Listener middleware, 200 actionCreator listeners, matching action 100K 612K
createSlice, 20 slices, unrelated action 320K 394K
RTKQ store, unrelated action 352K 468K
RTKQ re-dispatch of a fulfilled query with unchanged tags, 1000 entries (ms per dispatch) 2.50 0.55

The listener middleware numbers are the biggest change, because the old cost grew with the number of listeners. Apps with a handful of listeners will see much smaller gains.

The RTK Query middleware also does less work keeping the store's subscriptions state in sync (#​5499). It used to JSON-copy the whole subscriptions object and diff it with Immer every 500ms while subscriptions were changing. It now records which cache keys changed and writes one patch per key. Keys that didn't change keep their object references, so the Redux DevTools no longer receive a full copy of subscriptions on every sync. Polls, refetch() calls and tag invalidation refetches don't add subscribers, so they no longer schedule a sync at all. The visible difference: a cache key that only ever had subscribe: false requests no longer shows up as an empty {} in subscriptions.

Smaller createSlice Bundles With esbuild

createSlice references asyncThunkCreator so that create.asyncThunk works in the reducers callback. esbuild couldn't tell that the asyncThunkCreator object was free of side effects, so it always bundled createAsyncThunk along with createSlice. webpack already dropped it. We've marked it as pure, and an esbuild bundle that imports only createSlice is now about 1 kB smaller (brotli).

Faster RTK Query Api Type Checking

The Api type combines every registered module (core, React hooks, and any third-party modules) by running UnionToIntersection over the module names. TanStack Table hit the same cost with the same design, and found that writing out the known intersection and adding variance annotations helped a lot.

We've done the same thing here: Api uses the core module type directly, and ApiModules has in out variance annotations. On a test app with one ~50-endpoint createApi, type instantiations dropped 22% and check time dropped about 25% on TS 6, and about 18% on the TS 7 native preview. Third-party modules like ngrx-rtk-query saw 7-8% fewer instantiations. There are no runtime changes.

RTK-Owned Draft and Patch Types

RTK used to re-export Immer's Draft type, and used Immer's types in signatures like CaseReducer and PatchCollection. That meant the .d.ts files TypeScript generated for your slices referenced immer. With a package manager layout where immer isn't hoisted, those declarations failed to build with TS2883 (#​5516). Re-exporting doesn't fix that, so RTK now declares its own Draft, WritableDraft and Patch types with the same shapes as Immer's. Emitted declarations now point at @reduxjs/toolkit instead. Our type tests check that RTK's Draft and Immer's Draft stay interchangeable, so code that mixes castDraft or current with RTK's types keeps working. We also bumped the immer dependency to ^11.2.9.

There are a few other type additions in this release:

  • ApiRootState replaces RTK Query's RootState type, which is now deprecated. RootState will be removed in 3.0.
  • TypedAddListenerAction and TypedRemoveListenerAction describe the actions that addListener and removeListener actually dispatch. The default payload type of TypedAddListener and TypedRemoveListener is now the listener options object, so addListener.match(action) no longer claims action.payload has fields like id and unsubscribe that don't exist at runtime.
  • dispatch(removeListener(...)) is typed as returning boolean and dispatch(clearAllListeners()) as returning void, matching the runtime.
  • UseQueryStateDefaultResult and UseInfiniteQueryStateDefaultResult are exported from @reduxjs/toolkit/query/react, for wrapping hooks with a generic selectFromResult.
RTK Query Cache Entry Selectors

We've had requests for a way to list everything in the cache for an endpoint (#​2995). api.util.selectEntriesForEndpoint(state, endpointName) returns all cache entries for one query or infinite query endpoint, and api.util.selectAllQueryEntries(state) returns them for every endpoint. Each item has the entry's fields plus its queryCacheKey, and is typed for its endpoint. Both selectors are memoized. There's also a new exported QueryCacheEntry<Definition> type.

const postEntries = api.util.selectEntriesForEndpoint(state, 'getPost')
const loadedPostIds = postEntries
  .filter((entry) => entry.status === 'fulfilled')
  .map((entry) => entry.originalArgs)
DevTools Action Sanitizer

All RTK Query requests use the same few action types, so the Redux DevTools show a long list of api/executeQuery/fulfilled actions, and you have to open each one to see which endpoint it was for. The new createApiActionSanitizer(api) returns a function for the DevTools actionSanitizer option that renames those actions for display, like api/executeQuery/fulfilled (getPosts). The dispatched actions aren't modified.

import { configureStore } from '@reduxjs/toolkit'
import { createApiActionSanitizer } from '@reduxjs/toolkit/query'
import { api } from './api'

export const store = configureStore({
  reducer: {
    [api.reducerPath]: api.reducer,
  },
  middleware: (getDefaultMiddleware) =>
    getDefaultMiddleware().concat(api.middleware),
  devTools: {
    actionSanitizer: createApiActionSanitizer(api),
  },
})

See the createApiActionSanitizer docs for combining sanitizers for multiple APIs.

Entity Adapter Additions

adapter.removeMany now accepts a { where } object, and removes every entity whose fields match all the given values (#​5524):

postsAdapter.removeMany(state, { where: { authorId: 5 } })

The match object is typed as Partial<T>, and values are compared with ===. A where object with no keys removes nothing, so a filter built at runtime that ends up empty can't clear the collection by accident. Use removeAll for that. There's also a new exported RemoveManyFilter<T> type.

getSelectors() now includes selectByIds(state, ids), which returns the entities for the given ids in the order of ids, skipping ids that don't exist.

removeMany is also faster. It used to filter the Immer draft of the ids array, which reads every element through the draft proxy. It now filters a plain copy against a Set of removed ids.

RTK Query Fixes

Lifecycles: cacheDataLoaded now only resolves for a response from a request that started while that lifecycle was waiting. A late response from before a removeQueryResult no longer resolves the next lifecycle on the same key with discarded data. Re-triggering a mutation with the same fixedCacheKey now ends the previous onCacheEntryAdded lifecycle, so its cacheEntryRemoved cleanup runs instead of leaking. If that earlier trigger is still in flight, its cacheDataLoaded now rejects instead of never settling. Thanks to @​hamarshehmhmd for the analysis in #​5539. getCacheEntry() in a mutation's onQueryStarted now finds the entry for fixedCacheKey mutations instead of always returning uninitialized.

Synchronous throws from onQueryStarted and onCacheEntryAdded are now caught and logged with console.error. Before, a sync throw in onQueryStarted escaped the pending dispatch and failed the request without ever calling queryFn. We also added a dev warning when updateCachedData is called before the entry has any data, since that call does nothing.

Polling: Polling now stops after the last unsubscribe even if the subscription cleanup hasn't run yet (thanks to @​LeulTew for the original fix in #​5444). A due poll re-reads skipPollingIfUnfocused instead of using the value from when the timer was set, and skips the poll if a request for that entry is already pending. pollingInterval values above 2^31-1 ms are now clamped with a dev warning, since larger values overflow setTimeout and fire after 1ms. Removing a cache entry with removeQueryResult now stops its poll timer right away, and switching a subscriber to a slower pollingInterval now reschedules the pending poll instead of letting the old, faster one fire once more. We also fixed a stale internal poll record that could block updatePollingInterval, and fetchBaseQuery now clears its timeout timer when the request finishes.

Upserts: A failed upsertQueryData over an existing entry (for example, from a responseSchema validation error) no longer leaves that entry stuck in pending. upsertQueryEntries now skips bad entries one at a time instead of failing the whole batch: unknown or mutation endpoint names and throwing providesTags callbacks are skipped, with dev warnings.

Timers and multiple stores: resetApiState now clears the subscription sync timer and the state for delayed tag invalidation, so work scheduled before the reset can't fire afterward. A keepUnusedDataFor removal timer is now cleared when the key gets a new subscriber or is removed with removeQueryResult, so an old timer can't remove a newer entry for the same key. Repeated initiate(arg, { subscribe: false }) calls that hit the cache no longer push back the keepUnusedDataFor removal, which could keep unused data around indefinitely (#​4480, thanks @​veksa!). setupListeners now works with more than one store. Before, only the first store got focus and online events.

Hooks: A query that failed before it ever got data now reports isLoading: true when it refetches, instead of having isLoading, isError and data all falsy while the request is pending (#​4449, thanks @​AnimeshPandey!). This undoes a change from 2.2.4 (#​4364) that kept isLoading false when a second hook subscribed to an errored entry. If a parent renders null while isLoading is true and a child mounts the same query, the parent now unmounts the child on each refetch, and the two can loop. Render the child based on data or isError instead. Query args containing NaN no longer cause an endless refetch loop when the query errors. This was a regression from 2.9.0, where arg comparison treated NaN as never equal to itself (#​5338, thanks @​aagostino31!). fetchNextPage() and fetchPreviousPage() no longer send a request when the infinite query hook's arg is skipToken, and initiate(skipToken) no longer sends a request for any query or infinite query endpoint (#​5028, thanks @​haigou-web!).

fetchBaseQuery: A null body no longer throws Cannot read properties of null before the request is sent (thanks @​dfedoryshchev!). An explicit content-type header is now kept for ArrayBuffer, typed array and Blob bodies, which broke presigned S3 and GCS uploads. It's still removed for FormData and for a JSON content type on a non-JSON body, and that JSON content type check is now case-insensitive (thanks @​tad-bit-better!). A custom responseHandler that throws or rejects with a falsy value like undefined now produces a PARSING_ERROR, instead of being treated as a successful response (#​5480, thanks @​JunaidAhamed-7777!). A timeout that fires while the response body is being read is now reported as TIMEOUT_ERROR instead of PARSING_ERROR (thanks @​Gurmehar-git!).

Other RTKQ fixes: An overlapping refetch now stays registered as the running query, so later calls join it and aborting it works (thanks @​tedy69!). Apps with many createApi middlewares could hit a "Maximum call stack size exceeded" error when the middlewares registered themselves on the first query. Registration no longer restarts dispatch from the start of the middleware chain (thanks @​PabloJoan!). api.enhanceEndpoints({ endpoints }) now logs an error in development when it names an endpoint that doesn't exist, which usually means a typo.

RTK Query thunk actions now include startedTimeStamp and a per-store seq counter in the fulfilled and rejected-with-value meta, matching the request's pending action, so you can tell which request a response belongs to and in what order requests started. Rejections for aborted requests and unhandled errors don't include these fields yet.

Other Fixes

The listener middleware's take(), condition() and delay() no longer leave their timers running after the listener is cancelled or the action arrives first.

The autoBatchEnhancer raf fallback no longer throws a cancelAnimationFrame ReferenceError in test environments that delete window globals during teardown (thanks @​msutkowski!).

RTK Query hooks now log a dev warning when they render with a different store than the one they first subscribed to. If you swap the store passed to <Provider>, give the Provider a key that changes with the store so the tree remounts.

The serializability check middleware now reports a circular reference in state or actions as a non-serializable value, instead of overflowing the stack (thanks @​OskarEichler!).

@types/react is now declared as an optional peer dependency. RTK's React entry points import React types, and with pnpm's isolated linker or a global virtual store, TypeScript couldn't find them and those types became any (thanks @​unrevised6419!).

What's Changed

Full Changelog: reduxjs/redux-toolkit@v2.13.0...v2.14.0

v2.13.0

Compare Source

This feature release updates our build tooling to TSDown and PNPM, adds official TypeScript 7 support, and includes a long list of bugfixes across RTK Query, createAsyncThunk, createEntityAdapter, and combineSlices.

Changelog

Build Tooling Updates

We've fully modernizing modernized our build tooling across all of the Redux repos. That included switching from Yarn to PNPM, ESLint to Oxlint, Prettier to Oxfmt, and TSUp to TSDown.

The part that matters for users is that we now build the package with TSDown instead of tsup. The package layout, exports definitions, and exported APIs are all unchanged from 2.12. We've checked the new build with attw, and verified that CJS and ESM entry points load in both dev and prod builds, and that the legacy-esm artifacts still target ES2017. The contents of the bundles do look a bit different (smaller CJS artifacts, slightly different helper output in the legacy-esm files). If you see any behavior differences that look build-related, please file an issue!

This is also our first release published via the updated PNPM-based workflow, still using NPM Trusted Publishing. We've also added pkg.pr.new previews for every commit, so you can try out a PR build before it's released.

Docs Updates

We've shipped a new combined Redux libraries docs site! The core docs site at https://redux.js.org now contains the docs for all of our libraries: Redux core and usage guides, Redux Toolkit, React Redux, and Reselect. The prior standalone docs sites for RTK, R-R, and Reselect now redirect to their respective sections of the combined docs. We've also done a major cleanup pass on the docs, deduplicating pages that had similarities (like the Next.js or RTK2 migration pages that lived in both the core and RTK docs), and updating outdated content (modernizing example code snippets, deleting dead links, and making RTK and hooks the default patterns shown). The RTK content now lives at https://redux.js.org/toolkit/ .

TypeScript 7 Support

TS 7.0 (the native Go port) is now out! We fixed the remaining type errors in RTK when checked by TS 7.0 and 7.1, and TS 7.0 is now part of our CI test matrix.

Per our TS support policy of matching DefinitelyTyped's support window, we've also updated our support matrix to TS 5.6+. As always, RTK may still work with earlier versions, but we no longer test against them.

RTK Query Fixes

useQueryState (and thus useQuery) was passing a new inline selector to useSelector on every render, and also reading the store directly during render. The selector is now memoized, and the direct store read is gone. This also fixes a bug where isSuccess could flip from false to true on an unrelated re-render while a query was refetching after an error. isSuccess now correctly stays false in that case.

data now reflects cache updates made via updateQueryData while a refetch is in flight, instead of showing the previous result.

Polling now reads the current cache state when each poll fires, rather than the state at the time the poll was scheduled. This means skipPollingIfUnfocused respects focus loss that happens after scheduling, and polls stop if their cache entry was removed.

We fixed a race where a duplicate query request rejected by the thunk condition could cause queued tag invalidations to run too early and be lost, leaving stale data in the cache.

Tags with falsy ids like 0 now invalidate and clean up correctly.

Lazy query hooks now re-subscribe correctly when effects restart while the hook state is preserved, such as with Fast Refresh or <Activity>.

Infinite queries no longer trigger onQueryStarted when fetching past the end of the list, and the infinite query hook result type now includes the page error flags.

fetchBaseQuery only treats a URL as absolute if it starts with a scheme.

We also fixed an error when rehydrating state for an endpoint name that has no definition.

Other Fixes

createAsyncThunk no longer swallows aborts that happen before the pending action is dispatched, and now correctly sets rejectedWithValue when rejectWithValue is called with a falsy payload.

createEntityAdapter's setAll now keeps the last item when given duplicate IDs, matching setMany. The sorted adapter's updateMany now merges multiple updates for the same ID before applying them.

combineSlices now keeps its internal state proxy cache per instance, so multiple combined reducers no longer interfere with each other.

The immutability check middleware now handles circular references in state.

The dynamic middleware now caches its composed middleware chains when the list of middleware hasn't changed.

What's Changed

Full Changelog: reduxjs/redux-toolkit@v2.12.0...v2.13.0

v2.12.0

Compare Source

This feature release adds RTK usage skills files (via TanStack Intent) exports the RTK Query hook options types for reusability, fixes issues with infinite query status flags and batching handling, and makes some small TS improvements.

Changelog

Skills Files

We've generated agent skill files that are now included in the RTK package itself in a skills folder. They cover using and migrating to modern RTK, client and server state management, and handling side effects. You can point your agent at these skills yourself, or use TanStack Intent to pick them up.

TypeScript Improvements

The types for our RTK Query hook options are now exported, which lets you stop using Parameters to extract those types for use in your own code.

The types for listener middleware matchers were tweaked to allow interface-based type guards, not just type-based definitions.

The internal IgnorePaths type was renamed to IgnoredPaths for consistency.

We now use the built-in NoInfer util that comes with TS 5.4+.

Fixes

We fixed handling of the isSuccess status flag when switching infinite query cache entries. This should prevent accidental UI flashes that were occurring due to this flag accidentally flipping.

We've added a 100ms timeout fallback to the autoBatch enhancer's requestAnimationFrame timer. We had several reports that rAF didn't work correctly when used in background tabs / opened windows, and that RTK never updated the UI. This should ensure that the updates flush correctly.

What's Changed

Full Changelog: reduxjs/redux-toolkit@v2.11.2...v2.12.0

v2.11.2

Compare Source

This bugfix release updates the AbortSignal handling to fall back if DOMException isn't available (such as RN environments), and updates the TypedUseInfiniteQueryHookResult type to correctly include fetchNextPage/fetchPreviousPage fields.

Changelog

Bugfixes

The AbortSignal changes in 2.11.1 used DOMException in a couple places to match the expected behavior of AbortSignal, but turns out that's not available in environments like React Native. We've updated the logic to fall back to a plain Error if DOMException isn't available.

The TypedUseInfiniteQueryHookResult type wasn't correctly including the fetchNextPage/fetchPreviousPage fields, and now it does.

What's Changed

Full Changelog: reduxjs/redux-toolkit@v2.11.1...v2.11.2

v2.11.1

Compare Source

This bugfix release fixes an issue with our internal AbortSignal handling that was reported as causing an error in a rare reset situation. We've also restructured our publishing process to use NPM Trusted Publishing, and updated our TS support matrix to only support TS 5.4+.

Changelog

Publishing Changes

We've previously done most of our releases semi-manually locally, with various release process CLI tools. With the changes to NPM publishing security and the recent wave of NPM attacks, we've updated our publishing process to solely use NPM Trusted Publishing via workflows. We've also done a hardening pass on our own CI setup.

We had done a couple releases via CI workflows previously, and later semi-manual releases caused PNPM to warn that RTK was no longer trusted. This release should be trusted and will resolve that issue.

Thanks to the e18e folks and their excellent guide at https://e18e.dev/docs/publishing for making this process easier!

TS Support Matrix Updates

We've previously mentioned rolling changes to our TS support matrix in release notes, but didn't officially document our support policy. We've added a description of the support policy (last 2 years of TS releases, matching DefinitelyTyped) and the current oldest TS version we support in the docs:

As of today, we've updated the support matrix to be TS 5.4+ . As always, it's possible RTK will work if you're using an earlier version of TS, but we don't test against earlier versions and don't support any issues with those versions.

We have run an initial test with the upcoming TS 7.0 native tsgo release. We found a couple minor issues with our own TS build and test setup, but no obvious issues with using RTK with TS 7.0.

Bug Fixes

A user reported a rare edge case where the combination of resetApiState and retry() could lead to an error calling an AbortController. We've restructured our AbortController handling logic to avoid that (and simplified a bit of our internals in the process).

What's Changed

Full Changelog: reduxjs/redux-toolkit@v2.11.0...v2.11.1

v2.11.0

Compare Source

This feature release upgrades our Immer dependency to v11 to pick up the additional recent performance optimizations, adds a new refetchCachedPages option to allow only fetching the first cached page, and fixes an issue with regex ignore paths in the immutability middleware.

Changelog

Immer v11 Performance Improvements

As described in the release notes for v2.10.0, we recently put significant effort into profiling Immer, and contributed several PRs that aimed to optimize its update performance.

v2.10.0 updated to use Immer 10.2.0, which added the first smaller set of perf updates. That included a new Immer option to disable "strict iteration" to speed up iterating copied objects, and we specifically applied that change in RTK under the assumption that standard plain JS objects as Redux state shouldn't have unusual keys anyway. Overall, this appears to boost Immer update perf by ~+20% over v10.1 depending on update scenario.

Immer v11.0.0 was just released and contains the second perf PR, a major internal architectural rewrite to change the update finalization implementation from a recursive tree traversal to a set of targeted updates based on accessed and updated fields. Based on the benchmarks in the PR, this adds another ~+5% perf boost over the improvements in v10.2, again with variations depending on update scenario. In practice, the actual improvement may be better than that - the benchmarks list includes some array update cases which actually got a bit slower (and thus drag down the overall average), and a majority of update scenarios show anywhere from +25% to +60% faster than Immer v10.1!

As a practical example, we have an RTK Query stress test benchmark where we mount 1000 components with query hooks at once, unmount, then remount them. We ran the same benchmark steps for RTK 2.9 and Immer 10.1, and then RTK 2.10+ and Immer 11. The overall scripting time dropped by about 30% (3330ms -> 2350ms), and the amount of time spent in Immer methods and the RTK reducers dropped significantly:

<img width="2561" height="1548" alt="image" src="h

[!IMPORTANT]
✂ PR body was truncated to here.

Configuration

📅 Schedule: (UTC)

  • Branch creation
    • At any time (no schedule defined)
  • Automerge
    • At any time (no schedule defined)

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

  • If you want to rebase/retry this PR, check this box

This PR was generated by Mend Renovate. View the repository job log.

@renovate renovate Bot added the dependencies label Oct 7, 2026
@changeset-bot

changeset-bot Bot commented Oct 7, 2026 •
edited
Loading

Copy link
Copy Markdown

⚠️ No Changeset found

Latest commit: 3273c63

Merging this PR will not cause a version bump for any packages. If these changes should not result in a new version, you're good to go. If these changes should result in a version bump, you need to add a changeset.

This PR includes no changesets

When changesets are added to this PR, you'll see the packages that this PR includes changesets for and the associated semver types

Click here to learn what changesets are, and how to add one.

Click here if you're a maintainer who wants to add a changeset to this PR

@coderabbitai

coderabbitai Bot commented Oct 7, 2026 •
edited
Loading

Copy link
Copy Markdown

Important

Review skipped

Bot user detected.

To trigger a single review, invoke the @coderabbitai review command.

Run configuration
  • Source mode: Auto
  • Repository: Unavailable
  • Branch: Unavailable
  • File: No configuration file from this repository applied
  • Commit: Unavailable
  • Layers: defaults
  • Review profile: CHILL
  • Plan: Advanced
  • Run ID: ac4f0c61-28a5-4cfd-8c94-11ae99352e34

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

  • Trigger review
  • Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

Share

@renovate
renovate Bot force-pushed the renovate/reduxjs-toolkit-2.x-lockfile branch from 3238ced to a5d1543 Compare October 20, 2026 14:33
@nx-cloud

nx-cloud Bot commented Oct 20, 2026 •
edited
Loading

Copy link
Copy Markdown
Contributor

View your CI Pipeline Execution ↗ for commit 3273c63

Command Status Duration Result
nx affected -t build lint test typecheck e2e-ci ❌ Failed 2m 24s View ↗

💡 Dealing with memory or CPU issues? See memory and CPU details with the resource usage add-on ↗.

☁️ Nx Cloud last updated this comment at 2026-11-03 23:46:25 UTC

@renovate
renovate Bot force-pushed the renovate/reduxjs-toolkit-2.x-lockfile branch from a5d1543 to 528639a Compare October 22, 2026 14:37
nx-cloud[bot]

This comment was marked as outdated.

Sign in to view

@renovate
renovate Bot force-pushed the renovate/reduxjs-toolkit-2.x-lockfile branch from 528639a to a82f0df Compare October 26, 2026 21:48
nx-cloud[bot]

This comment was marked as outdated.

Sign in to view

@renovate
renovate Bot force-pushed the renovate/reduxjs-toolkit-2.x-lockfile branch from a82f0df to ca68648 Compare November 2, 2026 19:11
nx-cloud[bot]

This comment was marked as outdated.

Sign in to view

@renovate renovate Bot changed the title chore(deps): update dependency @reduxjs/toolkit to v2.13.0 chore(deps): update dependency @reduxjs/toolkit to v2.14.0 Nov 3, 2026
@renovate
renovate Bot force-pushed the renovate/reduxjs-toolkit-2.x-lockfile branch from ca68648 to 3273c63 Compare November 3, 2026 23:42
nx-cloud[bot]
nx-cloud Bot reviewed Nov 3, 2026
View reviewed changes

@nx-cloud nx-cloud Bot left a comment •
edited
Loading

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Nx Cloud is proposing a fix for your failed CI:

We fixed the TS4023 build and typecheck failure that appeared with the @reduxjs/toolkit 2.14.0 bump. The reducers in node.slice.ts now take an explicit NodeStates state and cast to plain node types instead of Draft<...>. This keeps RTK's unexported WritableNonArrayDraft out of the inferred nodeSlice declaration, so tsc can emit it.

Tip

✅ We verified this fix by re-running @forgerock/davinci-client:build, @forgerock/davinci-client:typecheck.

Suggested Fix changes 
diff --git a/packages/davinci-client/src/lib/node.slice.ts b/packages/davinci-client/src/lib/node.slice.ts
index f9d68af..d866b71 100644
--- a/packages/davinci-client/src/lib/node.slice.ts
+++ b/packages/davinci-client/src/lib/node.slice.ts
@@ -18,7 +18,7 @@ import { getCollectorErrors } from './node.utils.js';
 /**
  * Import the types
  */
-import type { Draft, PayloadAction } from '@reduxjs/toolkit';
+import type { PayloadAction } from '@reduxjs/toolkit';
 
 import type { MetadataCollector, SubmitCollector } from './collector.types.js';
 import type {
@@ -71,10 +71,10 @@ export const nodeSlice = createSlice({
      * @returns {ErrorNode} - The error node
      */
     error(
-      state,
+      state: NodeStates,
       action: PayloadAction<{ data: DavinciErrorResponse; requestId: string; httpStatus: number }>,
     ) {
-      const newState = state as Draft<ErrorNode>;
+      const newState = state as ErrorNode;
 
       // Reference to the original response from DaVinci in the cache
       newState.cache = {
@@ -117,14 +117,14 @@ export const nodeSlice = createSlice({
      * @returns {FailureNode} - The failure node
      */
     failure(
-      state,
+      state: NodeStates,
       action: PayloadAction<{
         data: DaVinciFailureResponse | unknown;
         requestId: string;
         httpStatus: number;
       }>,
     ) {
-      const newState = state as Draft<FailureNode>;
+      const newState = state as FailureNode;
 
       newState.cache = {
         key: action.payload.requestId,
@@ -172,14 +172,14 @@ export const nodeSlice = createSlice({
      * @returns {ContinueNode} - The next node
      */
     next(
-      state,
+      state: NodeStates,
       action: PayloadAction<{
         data: DaVinciNextResponse;
         requestId: string;
         httpStatus: number;
       }>,
     ) {
-      const newState = state as Draft<ContinueNode>;
+      const newState = state as ContinueNode;
 
       const collectors = nodeCollectorReducer([], {
         type: action.type,
@@ -234,14 +234,14 @@ export const nodeSlice = createSlice({
      * @returns {SuccessNode} - The success node
      */
     success(
-      state,
+      state: NodeStates,
       action: PayloadAction<{
         data: DaVinciSuccessResponse;
         requestId: string;
         httpStatus: number;
       }>,
     ) {
-      const newState = state as Draft<SuccessNode>;
+      const newState = state as SuccessNode;
 
       newState.cache = {
         key: action.payload.requestId,
@@ -277,8 +277,8 @@ export const nodeSlice = createSlice({
      * @param {PayloadAction<unknown>} action - The action to be dispatched
      * @returns {ContinueNode} - The next node
      */
-    update(state, action: ReturnType<typeof updateCollectorValues>) {
-      const newState = state as Draft<ContinueNode>;
+    update(state: NodeStates, action: ReturnType<typeof updateCollectorValues>) {
+      const newState = state as ContinueNode;
 
       newState.client.collectors = nodeCollectorReducer(newState.client.collectors, action);
 
@@ -292,12 +292,12 @@ export const nodeSlice = createSlice({
      * @returns {ContinueNode} - The next node
      */
     poll(
-      state,
+      state: NodeStates,
       action: PayloadAction<{
         requestId: string;
       }>,
     ) {
-      const newState = state as Draft<ContinueNode>;
+      const newState = state as ContinueNode;
 
       // Update retries remaining in poll collector
       newState.client.collectors = nodeCollectorReducer(newState.client.collectors, action);

Apply fix via Nx Cloud  Reject fix via Nx Cloud


Or Apply changes locally with:

npx nx-cloud apply-locally sfy1-EWkZ

Apply fix locally with your editor ↗   View interactive diff ↗



🎓 Learn more about Self-Healing CI on nx.dev

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@nx-cloud nx-cloud[bot] nx-cloud[bot] left review comments

At least 1 approving review is required to merge this pull request.

Assignees

No one assigned

Labels

dependencies

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

0 participants