fix(types): onMutateResult is always defined in onSuccess callback (#9677)

* fix(types): onMutateResult is always defined in onSuccess callback

this is guaranteed because if onMutate fails or rejects, onSuccess is never called. if onMutate is not present, the type will be unknown

* chore: fix tests

Author: TkDodo

packages/angular-query-experimental/src/__tests__/mutation-options.test-d.ts

@@ -67,9 +67,7 @@ describe('mutationOptions', () => {
         return { name: 'onMutateResult' }
       },
       onSuccess: (_data, _variables, onMutateResult) => {
-        expectTypeOf(onMutateResult).toEqualTypeOf<
-          { name: string } | undefined
-        >()
+        expectTypeOf(onMutateResult).toEqualTypeOf<{ name: string }>()
       },
     })
   })

packages/query-core/src/__tests__/mutation.test-d.tsx

@@ -0,0 +1,96 @@
+import { describe, expectTypeOf, it } from 'vitest'
+import { QueryClient } from '../queryClient'
+import { MutationObserver } from '../mutationObserver'
+
+describe('mutation', () => {
+  describe('onMutate', () => {
+    it('should have onMutateResult undefined if undefined is explicitly returned', () => {
+      new MutationObserver(new QueryClient(), {
+        mutationFn: (variables: number) => {
+          return Promise.resolve(String(variables))
+        },
+        onMutate: () => {
+          return undefined
+        },
+        onSuccess: (data, variables, onMutateResult) => {
+          expectTypeOf(data).toEqualTypeOf<string>()
+          expectTypeOf(variables).toEqualTypeOf<number>()
+          expectTypeOf(onMutateResult).toEqualTypeOf<undefined>()
+        },
+        onError: (_data, _variables, onMutateResult) => {
+          expectTypeOf(onMutateResult).toEqualTypeOf<undefined>()
+        },
+        onSettled: (_data, _error, _variables, onMutateResult) => {
+          expectTypeOf(onMutateResult).toEqualTypeOf<undefined>()
+        },
+      })
+    })
+
+    it('should have unknown onMutateResult if onMutate is left out', () => {
+      new MutationObserver(new QueryClient(), {
+        mutationFn: (variables: number) => {
+          return Promise.resolve(String(variables))
+        },
+        onSuccess: (_data, _variables, onMutateResult) => {
+          expectTypeOf(onMutateResult).toEqualTypeOf<unknown>()
+        },
+        onError: (_data, _variables, onMutateResult) => {
+          expectTypeOf(onMutateResult).toEqualTypeOf<unknown>()
+        },
+        onSettled: (_data, _error, _variables, onMutateResult) => {
+          expectTypeOf(onMutateResult).toEqualTypeOf<unknown>()
+        },
+      })
+    })
+
+    it('should infer onMutateResult', () => {
+      new MutationObserver(new QueryClient(), {
+        mutationFn: (variables: number) => {
+          return Promise.resolve(String(variables))
+        },
+        onMutate: () => {
+          return Promise.resolve({ foo: 'bar' })
+        },
+        onSuccess: (_data, _variables, onMutateResult) => {
+          expectTypeOf(onMutateResult).toEqualTypeOf<{ foo: string }>()
+        },
+        onError: (_data, _variables, onMutateResult) => {
+          expectTypeOf(onMutateResult).toEqualTypeOf<
+            { foo: string } | undefined
+          >()
+        },
+        onSettled: (_data, _error, _variables, onMutateResult) => {
+          expectTypeOf(onMutateResult).toEqualTypeOf<
+            { foo: string } | undefined
+          >()
+        },
+      })
+    })
+
+    it('should include undefined in the union if explicitly returned', () => {
+      new MutationObserver(new QueryClient(), {
+        mutationFn: (variables: number) => {
+          return Promise.resolve(String(variables))
+        },
+        onMutate: () => {
+          return Math.random() > 0.5 ? { foo: 'bar' } : undefined
+        },
+        onSuccess: (_data, _variables, onMutateResult) => {
+          expectTypeOf(onMutateResult).toEqualTypeOf<
+            { foo: string } | undefined
+          >()
+        },
+        onError: (_data, _variables, onMutateResult) => {
+          expectTypeOf(onMutateResult).toEqualTypeOf<
+            { foo: string } | undefined
+          >()
+        },
+        onSettled: (_data, _error, _variables, onMutateResult) => {
+          expectTypeOf(onMutateResult).toEqualTypeOf<
+            { foo: string } | undefined
+          >()
+        },
+      })
+    })
+  })
+})

packages/query-core/src/mutation.ts

@@ -244,7 +244,7 @@ export class Mutation<
       await this.options.onSuccess?.(
         data,
         variables,
-        this.state.context,
+        this.state.context!,
         mutationFnContext,
       )
 

packages/query-core/src/types.ts

@@ -1113,11 +1113,11 @@ export interface MutationOptions<
   onMutate?: (
     variables: TVariables,
     context: MutationFunctionContext,
-  ) => Promise<TOnMutateResult | undefined> | TOnMutateResult | undefined
+  ) => Promise<TOnMutateResult> | TOnMutateResult
   onSuccess?: (
     data: TData,
     variables: TVariables,
-    onMutateResult: TOnMutateResult | undefined,
+    onMutateResult: TOnMutateResult,
     context: MutationFunctionContext,
   ) => Promise<unknown> | unknown
   onError?: (

packages/react-query/src/__tests__/mutationOptions.test-d.tsx

@@ -63,9 +63,7 @@ describe('mutationOptions', () => {
         return { name: 'onMutateResult' }
       },
       onSuccess: (_data, _variables, onMutateResult) => {
-        expectTypeOf(onMutateResult).toEqualTypeOf<
-          { name: string } | undefined
-        >()
+        expectTypeOf(onMutateResult).toEqualTypeOf<{ name: string }>()
       },
     })
   })