Merge pull request #1644 from reduxjs/fix-1605

Author: phryneas

packages/toolkit/src/createAsyncThunk.ts

@@ -415,6 +415,21 @@ export type AsyncThunk<
   typePrefix: string
 }
 
+/**
+ *
+ * @param typePrefix
+ * @param payloadCreator
+ * @param options
+ *
+ * @public
+ */
+// separate signature without `AsyncThunkConfig` for better inference
+export function createAsyncThunk<Returned, ThunkArg = void>(
+  typePrefix: string,
+  payloadCreator: AsyncThunkPayloadCreator<Returned, ThunkArg, {}>,
+  options?: AsyncThunkOptions<ThunkArg, {}>
+): AsyncThunk<Returned, ThunkArg, {}>
+
 /**
  *
  * @param typePrefix
@@ -425,8 +440,18 @@ export type AsyncThunk<
  */
 export function createAsyncThunk<
   Returned,
-  ThunkArg = void,
-  ThunkApiConfig extends AsyncThunkConfig = {}
+  ThunkArg,
+  ThunkApiConfig extends AsyncThunkConfig
+>(
+  typePrefix: string,
+  payloadCreator: AsyncThunkPayloadCreator<Returned, ThunkArg, ThunkApiConfig>,
+  options?: AsyncThunkOptions<ThunkArg, ThunkApiConfig>
+): AsyncThunk<Returned, ThunkArg, ThunkApiConfig>
+
+export function createAsyncThunk<
+  Returned,
+  ThunkArg,
+  ThunkApiConfig extends AsyncThunkConfig
 >(
   typePrefix: string,
   payloadCreator: AsyncThunkPayloadCreator<Returned, ThunkArg, ThunkApiConfig>,
@@ -533,7 +558,7 @@ If you want to use the AbortController to react to \`abort\` events, please cons
     return (dispatch, getState, extra) => {
       const requestId = options?.idGenerator
         ? options.idGenerator(arg)
-        : nanoid();
+        : nanoid()
 
       const abortController = new AC()
       let abortReason: string | undefined

packages/toolkit/src/tests/createAsyncThunk.typetest.ts

@@ -147,6 +147,34 @@ const anyAction = { type: 'foo' } as AnyAction
   })
 })()
 
+/**
+ * Should handle reject withvalue within a try catch block
+ *
+ * Note:
+ * this is a sample code taken from #1605
+ *
+ */
+;(async () => {
+  type ResultType = {
+    text: string
+  }
+  const demoPromise = async (): Promise<ResultType> =>
+    new Promise((resolve, _) => resolve({ text: '' }))
+  const thunk = createAsyncThunk('thunk', async (args, thunkAPI) => {
+    try {
+      const result = await demoPromise()
+      return result
+    } catch (error) {
+      return thunkAPI.rejectWithValue(error)
+    }
+  })
+  createReducer({}, (builder) =>
+    builder.addCase(thunk.fulfilled, (s, action) => {
+      expectType<ResultType>(action.payload)
+    })
+  )
+})()
+
 {
   interface Item {
     name: string
@@ -453,27 +481,49 @@ const anyAction = { type: 'foo' } as AnyAction
 {
   // return values
   createAsyncThunk<'ret', void, {}>('test', (_, api) => 'ret' as const)
+  createAsyncThunk<'ret', void, {}>('test', async (_, api) => 'ret' as const)
   createAsyncThunk<'ret', void, { fulfilledMeta: string }>('test', (_, api) =>
     api.fulfillWithValue('ret' as const, '')
   )
+  createAsyncThunk<'ret', void, { fulfilledMeta: string }>(
+    'test',
+    async (_, api) => api.fulfillWithValue('ret' as const, '')
+  )
   createAsyncThunk<'ret', void, { fulfilledMeta: string }>(
     'test',
     // @ts-expect-error has to be a fulfilledWithValue call
     (_, api) => 'ret' as const
   )
+  createAsyncThunk<'ret', void, { fulfilledMeta: string }>(
+    'test',
+    // @ts-expect-error has to be a fulfilledWithValue call
+    async (_, api) => 'ret' as const
+  )
   createAsyncThunk<'ret', void, { fulfilledMeta: string }>(
     'test', // @ts-expect-error should only allow returning with 'test'
     (_, api) => api.fulfillWithValue(5, '')
   )
+  createAsyncThunk<'ret', void, { fulfilledMeta: string }>(
+    'test', // @ts-expect-error should only allow returning with 'test'
+    async (_, api) => api.fulfillWithValue(5, '')
+  )
 
   // reject values
   createAsyncThunk<'ret', void, { rejectValue: string }>('test', (_, api) =>
     api.rejectWithValue('ret')
   )
+  createAsyncThunk<'ret', void, { rejectValue: string }>(
+    'test',
+    async (_, api) => api.rejectWithValue('ret')
+  )
   createAsyncThunk<'ret', void, { rejectValue: string; rejectedMeta: number }>(
     'test',
     (_, api) => api.rejectWithValue('ret', 5)
   )
+  createAsyncThunk<'ret', void, { rejectValue: string; rejectedMeta: number }>(
+    'test',
+    async (_, api) => api.rejectWithValue('ret', 5)
+  )
   createAsyncThunk<'ret', void, { rejectValue: string; rejectedMeta: number }>(
     'test',
     (_, api) => api.rejectWithValue('ret', 5)
@@ -483,9 +533,19 @@ const anyAction = { type: 'foo' } as AnyAction
     // @ts-expect-error wrong rejectedMeta type
     (_, api) => api.rejectWithValue('ret', '')
   )
+  createAsyncThunk<'ret', void, { rejectValue: string; rejectedMeta: number }>(
+    'test',
+    // @ts-expect-error wrong rejectedMeta type
+    async (_, api) => api.rejectWithValue('ret', '')
+  )
   createAsyncThunk<'ret', void, { rejectValue: string; rejectedMeta: number }>(
     'test',
     // @ts-expect-error wrong rejectValue type
     (_, api) => api.rejectWithValue(5, '')
   )
+  createAsyncThunk<'ret', void, { rejectValue: string; rejectedMeta: number }>(
+    'test',
+    // @ts-expect-error wrong rejectValue type
+    async (_, api) => api.rejectWithValue(5, '')
+  )
 }