re-add faulty getRunningOperationPromises

but have it throw in development

Author: phryneas

packages/toolkit/src/query/core/buildInitiate.ts

@@ -15,6 +15,7 @@ import type { ApiEndpointQuery } from './module'
 import type { BaseQueryError, QueryReturnValue } from '../baseQueryTypes'
 import type { QueryResultSelectorResult } from './buildSelectors'
 import type { Dispatch } from 'redux'
+import { isNotNullish } from '../utils/isNotNullish'
 
 declare module './module' {
   export interface ApiEndpointQuery<
@@ -218,6 +219,37 @@ export function buildInitiate({
     getRunningMutationThunk,
     getRunningQueriesThunk,
     getRunningMutationsThunk,
+    getRunningOperationPromises,
+    removalWarning,
+  }
+
+  /** @deprecated to be removed in 2.0 */
+  function removalWarning(): never {
+    throw new Error(
+      `This method had to be removed due to a conceptual bug in RTK.
+       Please see https://github.com/reduxjs/redux-toolkit/pull/2481 for details.
+       See https://redux-toolkit.js.org/rtk-query/usage/server-side-rendering for new guidance on SSR.`
+    )
+  }
+
+  /** @deprecated to be removed in 2.0 */
+  function getRunningOperationPromises() {
+    if (
+      typeof process !== 'undefined' &&
+      process.env.NODE_ENV === 'development'
+    ) {
+      removalWarning()
+    } else {
+      const extract = <T>(
+        v: Map<Dispatch<AnyAction>, Record<string, T | undefined>>
+      ) =>
+        Array.from(v.values()).flatMap((queriesForStore) =>
+          queriesForStore ? Object.values(queriesForStore) : []
+        )
+      return [...extract(runningQueries), ...extract(runningMutations)].filter(
+        isNotNullish
+      )
+    }
   }
 
   function getRunningQueryThunk(endpointName: string, queryArgs: any) {
@@ -251,16 +283,12 @@ export function buildInitiate({
 
   function getRunningQueriesThunk() {
     return (dispatch: Dispatch) =>
-      Object.values(runningQueries.get(dispatch) || {}).filter(
-        <T>(t: T | undefined): t is T => !!t
-      )
+      Object.values(runningQueries.get(dispatch) || {}).filter(isNotNullish)
   }
 
   function getRunningMutationsThunk() {
     return (dispatch: Dispatch) =>
-      Object.values(runningMutations.get(dispatch) || {}).filter(
-        <T>(t: T | undefined): t is T => !!t
-      )
+      Object.values(runningMutations.get(dispatch) || {}).filter(isNotNullish)
   }
 
   function middlewareWarning(getState: () => RootState<{}, string, string>) {

packages/toolkit/src/query/core/module.ts

@@ -142,14 +142,22 @@ declare module '../apiTypes' {
       util: {
         /**
          * This method had to be removed due to a conceptual bug in RTK.
-         * Please see https://redux-toolkit.js.org/rtk-query/usage/server-side-rendering for details.
+         *
+         * Despite TypeScript errors, it will continue working in the "buggy" way it did
+         * before in production builds and will be removed in the next major release.
+         *
+         * Nonetheless, you should immediately replace it with the new recommended approach.
+         * See https://redux-toolkit.js.org/rtk-query/usage/server-side-rendering for new guidance on SSR.
+         *
+         * Please see https://github.com/reduxjs/redux-toolkit/pull/2481 for details.
          * @deprecated
          */
         getRunningOperationPromises: never // this is now types as `never` to immediately throw TS errors on use, but still allow for a comment
 
         /**
          * This method had to be removed due to a conceptual bug in RTK.
-         * Please see https://redux-toolkit.js.org/rtk-query/usage/server-side-rendering for details.
+         * It has been replaced by `api.util.getRunningQueryThunk` and `api.util.getRunningMutationThunk`.
+         * Please see https://github.com/reduxjs/redux-toolkit/pull/2481 for details.
          * @deprecated
          */
         getRunningOperationPromise: never // this is now types as `never` to immediately throw TS errors on use, but still allow for a comment
@@ -541,6 +549,8 @@ export const coreModule = (): Module<CoreModule> => ({
       getRunningMutationsThunk,
       getRunningQueriesThunk,
       getRunningQueryThunk,
+      getRunningOperationPromises,
+      removalWarning,
     } = buildInitiate({
       queryThunk,
       mutationThunk,
@@ -549,16 +559,9 @@ export const coreModule = (): Module<CoreModule> => ({
       context,
     })
 
-    function removedSSRHelper(): never {
-      throw new Error(
-        `This method had to be removed due to a conceptual bug in RTK.
-         Please see https://redux-toolkit.js.org/rtk-query/usage/server-side-rendering for details.`
-      )
-    }
-
     safeAssign(api.util, {
-      getRunningOperationPromises: removedSSRHelper as any,
-      getRunningOperationPromise: removedSSRHelper as any,
+      getRunningOperationPromises: getRunningOperationPromises as any,
+      getRunningOperationPromise: removalWarning as any,
       getRunningMutationThunk,
       getRunningMutationsThunk,
       getRunningQueryThunk,

packages/toolkit/src/query/utils/isNotNullish.ts

@@ -0,0 +1,3 @@
+export function isNotNullish<T>(v: T | null | undefined): v is T {
+  return v != null
+}

packages/toolkit/src/tests/injectableCombineReducers.example.ts

@@ -0,0 +1,63 @@
+/* eslint-disable import/first */
+// @ts-nocheck
+
+// reducer.ts or whatever
+
+import { combineSlices } from '@reduxjs/toolkit'
+
+import { sliceA } from 'fileA'
+import { sliceB } from 'fileB'
+import { lazySliceC } from 'fileC'
+import type { lazySliceD } from 'fileD'
+
+import { anotherReducer } from 'somewhere'
+
+export interface LazyLoadedSlices {}
+
+export const rootReducer = combineSlices(sliceA, sliceB, {
+  another: anotherReducer,
+}).withLazyLoadedSlices<LazyLoadedSlices>()
+/*
+ results in a return type of
+ {
+    [sliceA.name]: SliceAState,
+    [sliceB.name]: SliceBState,
+    another: AnotherState,
+    [lazySliceC.name]?: SliceCState, // see fileC.ts to understand why this appears here
+    [lazySliceD.name]?: SliceDState, // see fileD.ts to understand why this appears here
+ }
+ */
+
+// fileC.ts
+// "naive" approach
+
+import { rootReducer, RootState } from './reducer'
+import { createSlice } from '@reduxjs/toolkit'
+
+interface SliceCState {
+  foo: string
+}
+
+declare module './reducer' {
+  export interface LazyLoadedSlices {
+    [lazySliceC.name]: SliceCState
+  }
+}
+
+export const lazySliceC = createSlice({
+  /* ... */
+})
+/**
+ * Synchronously call `injectSlice` in file.
+ */
+rootReducer.injectSlice(lazySliceC)
+
+// might want to add code for HMR as well here
+
+// this will still error - `lazySliceC` is optional here
+const naiveSelectFoo = (state: RootState) => state.lazySliceC.foo
+
+const selectFoo = rootReducer.withSlice(lazySliceC).selector((state) => {
+  // `lazySlice` is guaranteed to not be `undefined` here.
+  return state.lazySlice.foo
+})