Merge pull request #1052 from reduxjs/feature/remove-alpha.3-deprecations

Author: markerikson

etc/rtk-query-react.api.md

@@ -20,7 +20,6 @@ export type Api<BaseQuery extends BaseQueryFn, Definitions extends EndpointDefin
         overrideExisting?: boolean;
     }): Api<BaseQuery, Definitions & NewDefinitions, ReducerPath, TagTypes, Enhancers>;
     enhanceEndpoints<NewTagTypes extends string = never>(_: {
-        addEntityTypes?: readonly NewTagTypes[];
         addTagTypes?: readonly NewTagTypes[];
         endpoints?: ReplaceTagTypes<Definitions, TagTypes | NoInfer<NewTagTypes>> extends infer NewDefinitions ? {
             [K in keyof NewDefinitions]?: Partial<NewDefinitions[K]> | ((definition: NewDefinitions[K]) => void);

src/query/createApi.ts

@@ -243,52 +243,8 @@ export function buildCreateApi<Modules extends [Module<any>, ...Module<any>[]]>(
       inject: Parameters<typeof api.injectEndpoints>[0]
     ) {
       const evaluatedEndpoints = inject.endpoints({
-        query: (x) => {
-          // remove in final release
-          if (x.onStart || x.onSuccess || x.onError) {
-            if (
-              typeof process !== 'undefined' &&
-              process.env.NODE_ENV === 'development'
-            ) {
-              console.warn(
-                '`onStart`, `onSuccess` and `onError` have been replaced by `onQueryStarted`, please change your code accordingly'
-              )
-            }
-            x.onQueryStarted ??= (arg, { queryFulfilled, ...api }) => {
-              const queryApi = { ...api, context: {} }
-              x.onStart?.(arg, queryApi)
-              return queryFulfilled.then(
-                (result) =>
-                  x.onSuccess?.(arg, queryApi, result.data, undefined),
-                (reason) => x.onError?.(arg, queryApi, reason.error, undefined)
-              )
-            }
-          }
-          return { ...x, type: DefinitionType.query } as any
-        },
-        mutation: (x) => {
-          // remove in final release
-          if (x.onStart || x.onSuccess || x.onError) {
-            if (
-              typeof process !== 'undefined' &&
-              process.env.NODE_ENV === 'development'
-            ) {
-              console.warn(
-                '`onStart`, `onSuccess` and `onError` have been replaced by `onQueryStarted`, please change your code accordingly'
-              )
-            }
-            x.onQueryStarted ??= (arg, { queryFulfilled, ...api }) => {
-              const queryApi = { ...api, context: {} }
-              x.onStart?.(arg, queryApi)
-              return queryFulfilled.then(
-                (result) =>
-                  x.onSuccess?.(arg, queryApi, result.data, undefined),
-                (reason) => x.onError?.(arg, queryApi, reason.error, undefined)
-              )
-            }
-          }
-          return { ...x, type: DefinitionType.mutation } as any
-        },
+        query: (x) => ({ ...x, type: DefinitionType.query } as any),
+        mutation: (x) => ({ ...x, type: DefinitionType.mutation } as any),
       })
 
       for (const [endpointName, definition] of Object.entries(

src/query/endpointDefinitions.ts

@@ -241,22 +241,6 @@ export interface QueryExtraOptions<
    * Not to be used. A query should not invalidate tags in the cache.
    */
   invalidatesTags?: never
-  /** @deprecated please use `onQueryStarted` instead */
-  onStart?(arg: QueryArg, queryApi: QueryApi<ReducerPath, any>): void
-  /** @deprecated please use `onQueryStarted` instead */
-  onError?(
-    arg: QueryArg,
-    queryApi: QueryApi<ReducerPath, any>,
-    error: unknown,
-    meta: undefined
-  ): void
-  /** @deprecated please use `onQueryStarted` instead */
-  onSuccess?(
-    arg: QueryArg,
-    queryApi: QueryApi<ReducerPath, any>,
-    result: ResultType,
-    meta: undefined
-  ): void
 }
 
 export type QueryDefinition<
@@ -268,30 +252,6 @@ export type QueryDefinition<
 > = BaseEndpointDefinition<QueryArg, BaseQuery, ResultType> &
   QueryExtraOptions<TagTypes, ResultType, QueryArg, BaseQuery, ReducerPath>
 
-/** @deprecated please use `onQueryStarted` instead */
-export interface MutationApi<ReducerPath extends string, Context extends {}> {
-  /**
-   * The dispatch method for the store
-   */
-  dispatch: ThunkDispatch<any, any, AnyAction>
-  /**
-   * A method to get the current state
-   */
-  getState(): RootState<any, any, ReducerPath>
-  /**
-   * `extra` as provided as `thunk.extraArgument` to the `configureStore` `getDefaultMiddleware` option.
-   */
-  extra: unknown
-  /**
-   * A unique ID generated for the mutation
-   */
-  requestId: string
-  /**
-   * A variable shared between `onStart`, `onError` and `onSuccess` of one request to pass data forward between them
-   */
-  context: Context
-}
-
 export interface MutationExtraOptions<
   TagTypes extends string,
   ResultType,
@@ -355,22 +315,6 @@ export interface MutationExtraOptions<
    * Not to be used. A mutation should not provide tags to the cache.
    */
   providesTags?: never
-  /** @deprecated please use `onQueryStarted` instead */
-  onStart?(arg: QueryArg, mutationApi: MutationApi<ReducerPath, any>): void
-  /** @deprecated please use `onQueryStarted` instead */
-  onError?(
-    arg: QueryArg,
-    mutationApi: MutationApi<ReducerPath, any>,
-    error: unknown,
-    meta: BaseQueryMeta<BaseQuery>
-  ): void
-  /** @deprecated please use `onQueryStarted` instead */
-  onSuccess?(
-    arg: QueryArg,
-    mutationApi: MutationApi<ReducerPath, any>,
-    result: ResultType,
-    meta: BaseQueryMeta<BaseQuery>
-  ): void
 }
 
 export type MutationDefinition<

src/query/tests/createApi.test.ts

@@ -597,26 +597,26 @@ describe('query endpoint lifecycles - onStart, onSuccess, onError', () => {
       }),
       query: build.query<SuccessResponse, void>({
         query: () => '/success',
-        onStart: (_, api) => {
+        async onQueryStarted(_, api) {
           api.dispatch(setCount(0))
-        },
-        onSuccess: (_, api) => {
-          api.dispatch(setCount(1))
-        },
-        onError: (_, api) => {
-          api.dispatch(setCount(-1))
+          try {
+            await api.queryFulfilled
+            api.dispatch(setCount(1))
+          } catch {
+            api.dispatch(setCount(-1))
+          }
         },
       }),
       mutation: build.mutation<SuccessResponse, void>({
         query: () => ({ url: '/success', method: 'POST' }),
-        onStart: (_, api) => {
+        async onQueryStarted(_, api) {
           api.dispatch(setCount(0))
-        },
-        onSuccess: (_, api) => {
-          api.dispatch(setCount(1))
-        },
-        onError: (_, api) => {
-          api.dispatch(setCount(-1))
+          try {
+            await api.queryFulfilled
+            api.dispatch(setCount(1))
+          } catch {
+            api.dispatch(setCount(-1))
+          }
         },
       }),
     }),

src/query/tests/optimisticUpdates.test.tsx

@@ -2,12 +2,6 @@ import { createApi } from '@reduxjs/toolkit/query/react'
 import { actionsReducer, hookWaitFor, setupApiStore, waitMs } from './helpers'
 import { renderHook, act } from '@testing-library/react-hooks'
 
-interface Patch {
-  op: 'replace' | 'remove' | 'add'
-  path: (string | number)[]
-  value?: any
-}
-
 interface Post {
   id: string
   title: string
@@ -62,9 +56,15 @@ describe('basic lifecycle', () => {
     endpoints: (build) => ({
       test: build.mutation({
         query: (x) => x,
-        onStart,
-        onError,
-        onSuccess,
+        async onQueryStarted(arg, api) {
+          onStart(arg)
+          try {
+            const result = await api.queryFulfilled
+            onSuccess(result)
+          } catch (e) {
+            onError(e)
+          }
+        },
       }),
     }),
     overrideExisting: true,
@@ -89,19 +89,14 @@ describe('basic lifecycle', () => {
     expect(onStart).not.toHaveBeenCalled()
     expect(baseQuery).not.toHaveBeenCalled()
     act(() => void result.current[0]('arg'))
-    expect(onStart).toHaveBeenCalledWith('arg', expect.any(Object))
+    expect(onStart).toHaveBeenCalledWith('arg')
     expect(baseQuery).toHaveBeenCalledWith('arg', expect.any(Object), undefined)
 
     expect(onError).not.toHaveBeenCalled()
     expect(onSuccess).not.toHaveBeenCalled()
     await act(() => waitMs(5))
     expect(onError).not.toHaveBeenCalled()
-    expect(onSuccess).toHaveBeenCalledWith(
-      'arg',
-      expect.any(Object),
-      'success',
-      undefined
-    )
+    expect(onSuccess).toHaveBeenCalledWith({ data: 'success', meta: 'meta' })
   })
 
   test('error', async () => {
@@ -117,18 +112,16 @@ describe('basic lifecycle', () => {
     expect(onStart).not.toHaveBeenCalled()
     expect(baseQuery).not.toHaveBeenCalled()
     act(() => void result.current[0]('arg'))
-    expect(onStart).toHaveBeenCalledWith('arg', expect.any(Object))
+    expect(onStart).toHaveBeenCalledWith('arg')
     expect(baseQuery).toHaveBeenCalledWith('arg', expect.any(Object), undefined)
 
     expect(onError).not.toHaveBeenCalled()
     expect(onSuccess).not.toHaveBeenCalled()
     await act(() => waitMs(5))
-    expect(onError).toHaveBeenCalledWith(
-      'arg',
-      expect.any(Object),
-      { message: 'error' },
-      undefined
-    )
+    expect(onError).toHaveBeenCalledWith({
+      error: { message: 'error' },
+      isUnhandledError: true,
+    })
     expect(onSuccess).not.toHaveBeenCalled()
   })
 })
@@ -176,7 +169,7 @@ describe('updateQueryData', () => {
 
     act(() => {
       storeRef.store.dispatch(
-        api.util.patchQueryData('post', '3', returnValue.inversePatches)
+        api.util.patchQueryResult('post', '3', returnValue.inversePatches)
       )
     })