Add optional thunk configuration object

etc/redux-toolkit.api.md

@@ -102,7 +102,7 @@ export function createAction<P = void, T extends string = string>(type: T): Payl
 export function createAction<PA extends PrepareAction<any>, T extends string = string>(type: T, prepareAction: PA): PayloadActionCreator<ReturnType<PA>['payload'], T, PA>;
 
 // @alpha (undocumented)
-export function createAsyncThunk<ActionType extends string, Returned, ActionParams = void, TA extends AsyncThunksArgs<any, any, any> = AsyncThunksArgs<unknown, unknown, Dispatch>>(type: ActionType, payloadCreator: (args: ActionParams, thunkArgs: TA) => Promise<Returned> | Returned): {
+export function createAsyncThunk<ActionType extends string | ThunkActionCreatorConfig, Returned, ActionParams = void, TA extends AsyncThunksArgs<any, any, any> = AsyncThunksArgs<unknown, unknown, Dispatch>>(config: ActionType, payloadCreator: (args: ActionParams, thunkArgs: TA) => Promise<Returned> | Returned): {
     (args: ActionParams): (dispatch: TA["dispatch"], getState: TA["getState"], extra: TA["extra"]) => Promise<any>;
     pending: import("./createAction").ActionCreatorWithPreparedPayload<[string, ActionParams], undefined, string, never, {
         args: ActionParams;

src/createAsyncThunk.test.ts

@@ -11,6 +11,46 @@ describe('createAsyncThunk', () => {
     expect(thunkActionCreator.rejected.type).toBe('testType/rejected')
   })
 
+  it('should accept a config object', () => {
+    const thunkActionCreator = createAsyncThunk(
+      { type: 'testType' },
+      async () => 42
+    )
+
+    expect(thunkActionCreator.fulfilled.type).toBe('testType/fulfilled')
+    expect(thunkActionCreator.pending.type).toBe('testType/pending')
+    expect(thunkActionCreator.finished.type).toBe('testType/finished')
+    expect(thunkActionCreator.rejected.type).toBe('testType/rejected')
+  })
+
+  it('should rethrow error', async () => {
+    const dispatch = jest.fn()
+
+    const args = 123
+    let generatedRequestId = ''
+
+    const error = new Error('Panic!')
+
+    const thunkActionCreator = createAsyncThunk(
+      { type: 'testType', rethrow: true },
+      async (args: number, { requestId }) => {
+        generatedRequestId = requestId
+        throw error
+      }
+    )
+
+    const thunkFunction = thunkActionCreator(args)
+
+    await expect(thunkFunction(dispatch, undefined, undefined)).rejects.toThrow(
+      error
+    )
+
+    expect(dispatch).toHaveBeenNthCalledWith(
+      2,
+      thunkActionCreator.rejected(error, generatedRequestId, args)
+    )
+  })
+
   it('works without passing arguments to the payload creator', async () => {
     const thunkActionCreator = createAsyncThunk('testType', async () => 42)
 

src/createAsyncThunk.ts

@@ -9,15 +9,37 @@ type AsyncThunksArgs<S, E, D extends Dispatch = Dispatch> = {
   requestId: string
 }
 
+interface ThunkActionCreatorConfig {
+  type: string
+  rethrow?: boolean
+}
+
+type ActionType = string | ThunkActionCreatorConfig
+
+function isConfig(type: ActionType): type is ThunkActionCreatorConfig {
+  return (type as ThunkActionCreatorConfig).type !== undefined
+}
+
+function buildOptions(
+  config: string | ThunkActionCreatorConfig
+): ThunkActionCreatorConfig {
+  return isConfig(config)
+    ? config
+    : {
+        type: config,
+        rethrow: false
+      }
+}
+
 /**
  *
- * @param type
+ * @param config
  * @param payloadCreator
  *
  * @alpha
  */
 export function createAsyncThunk<
-  ActionType extends string,
+  ActionType extends string | ThunkActionCreatorConfig,
   Returned,
   ActionParams = void,
   TA extends AsyncThunksArgs<any, any, any> = AsyncThunksArgs<
@@ -26,12 +48,14 @@ export function createAsyncThunk<
     Dispatch
   >
 >(
-  type: ActionType,
+  config: ActionType,
   payloadCreator: (
     args: ActionParams,
     thunkArgs: TA
   ) => Promise<Returned> | Returned
 ) {
+  const { type, rethrow } = buildOptions(config)
+
   const fulfilled = createAction(
     type + '/fulfilled',
     (result: Returned, requestId: string, args: ActionParams) => {
@@ -96,6 +120,7 @@ export function createAsyncThunk<
       } catch (err) {
         // TODO Errors aren't serializable
         dispatch(rejected(err, requestId, args))
+        if (rethrow) throw err
       } finally {
         // TODO IS there really a benefit from a "finished" action?
         dispatch(finished(requestId, args))