Add optional thunk configuration object

- User can specify a simple string for type or a config object.
- Config can choose to rethrow an error.
- Other possible use cases;
  - Prime result function to transform result before return.
  - Prime error function to transform error before return.

Author: rjstires

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))