feature: create async thunk and create action

Author: mrnkr

lib/redux_toolkit.dart

@@ -1,4 +1,6 @@
 library redux_toolkit;
 
 export 'package:reselect/reselect.dart';
+export './src/action.dart';
+export './src/async_thunk.dart';
 export './src/create_reducer.dart';

lib/src/action.dart

@@ -0,0 +1,11 @@
+abstract class PayloadAction<Payload, Meta, Error> {
+  final Payload payload;
+  final Meta meta;
+  final Error error;
+
+  const PayloadAction({
+    this.payload,
+    this.meta,
+    this.error,
+  });
+}

lib/src/async_thunk.dart

@@ -0,0 +1,36 @@
+import 'dart:async';
+import 'package:redux/redux.dart';
+import 'package:redux_thunk/redux_thunk.dart';
+
+import './action.dart';
+
+class Pending<T, M> extends PayloadAction<dynamic, M, dynamic> {
+  const Pending(M meta) : super(meta: meta);
+}
+
+class Fulfilled<T, P, M> extends PayloadAction<P, M, dynamic> {
+  const Fulfilled(P payload, M meta) : super(payload: payload, meta: meta);
+}
+
+class Rejected<T, M, E> extends PayloadAction<dynamic, M, E> {
+  const Rejected(M meta, E error) : super(meta: meta, error: error);
+}
+
+abstract class AsyncThunk<Self, State, Payload, Result> implements CallableThunkAction<State> {
+  final Payload payload;
+  
+  const AsyncThunk([this.payload]);
+
+  Future<Result> run();
+
+  @override
+  Future<void> call(Store<State> store) async {
+    store.dispatch(Pending<Self, Payload>(payload));
+    try {
+      final result = await run();
+      store.dispatch(Fulfilled<Self, Result, Payload>(result, payload));
+    } catch (err) {
+      store.dispatch(Rejected<Self, Payload, dynamic>(payload, err));
+    }
+  }
+}

lib/src/create_reducer.dart

@@ -1,8 +1,8 @@
 import 'package:redux/redux.dart';
 
-typedef CaseReducer<State, Action> = State Function(State, Action);
-typedef DefaultCaseReducer<State> = State Function(State);
-typedef BuilderCallback<State> = Function(ActionReducerMapBuilder<State>);
+typedef CaseReducer<State, Action> = State Function(State state, Action action);
+typedef DefaultCaseReducer<State> = State Function(State state);
+typedef BuilderCallback<State> = Function(ActionReducerMapBuilder<State> builder);
 
 abstract class ActionReducerMapBuilder<State> {
   ActionReducerMapBuilder<State> addCase<Action>(CaseReducer<State, Action> reducer);
@@ -47,10 +47,7 @@ Reducer<State> createReducer<State>(State initialState, BuilderCallback<State> b
   final actionReducerMap = builder.build();
 
   return (state, action) {
-    if (state == null) {
-      state = initialState;
-    }
-
+    state = state ?? initialState;
     return actionReducerMap.getReducerForAction(action.runtimeType)(state, action);
   };
 }

pubspec.yaml

@@ -8,6 +8,8 @@ environment:
 dependencies:
   redux: ^4.0.0+2
   reselect: ^0.4.0
+  redux_thunk: ^0.3.0
 
 dev_dependencies:
   test: ^1.3.0
+  mockito: ^4.1.1

test/async_thunk_test.dart

@@ -0,0 +1,42 @@
+import 'package:test/test.dart';
+import 'package:mockito/mockito.dart';
+import 'package:redux/redux.dart';
+import 'package:redux_toolkit/redux_toolkit.dart';
+
+import 'test_thunks.dart';
+
+class MockStore extends Mock implements Store<int> {}
+
+void main() {
+  group('async thunk', () {
+    Store<int> store;
+
+    setUp(() {
+      store = MockStore();
+    });
+
+    test('should dispatch Pending<StringLength, String>', () async {
+      final thunk = StringLength('hello');
+      await thunk.call(store);
+      verify(store.dispatch(argThat(isA<Pending<StringLength, String>>())));
+    });
+    
+    test('should dispatch Fulfilled<StringLength, int, String>', () async {
+      final thunk = StringLength('hello');
+      await thunk.call(store);
+      verify(store.dispatch(argThat(isA<Fulfilled<StringLength, int, String>>())));
+    });
+
+    test('should dispatch Pending<EpicFail, String>', () async {
+      final thunk = EpicFail('hello');
+      await thunk.call(store);
+      verify(store.dispatch(argThat(isA<Pending<EpicFail, String>>())));
+    });
+    
+    test('should dispatch Rejected<EpicFail, String, dynamic>', () async {
+      final thunk = EpicFail('hello');
+      await thunk.call(store);
+      verify(store.dispatch(argThat(isA<Rejected<EpicFail, String, dynamic>>())));
+    });
+  });
+}

test/create_reducer_test.dart

@@ -5,13 +5,19 @@ import 'package:test/test.dart';
 import 'test_actions.dart';
 import 'test_state.dart';
 
+class SingleTestThunk {}
+
+class DoubleTestThunk {}
+
 void main() {
-  group('Create reducer', () {
-    Reducer<TestState> reducer;
+  group('create reducer', () {
     final TestState initialState = TestState(items: List.unmodifiable([]));
+    
+    Reducer<TestState> testStateReducer;
+    Reducer<int> listReducer;
 
     setUp(() {
-      reducer = createReducer<TestState>(initialState, (builder) {
+      testStateReducer = createReducer<TestState>(initialState, (builder) {
         builder
             .addCase<RequestItemsAction>(
                 (state, action) => state.copyWith(isLoading: true))
@@ -20,15 +26,23 @@ void main() {
             .addCase<FetchItemsErrorAction>((state, action) =>
                 state.copyWith(isLoading: false, error: action.error));
       });
+
+      listReducer = createReducer<int>(0, (builder) {
+        builder
+          .addCase<Fulfilled<SingleTestThunk, String, void>>(
+            (state, action) => 1)
+          .addCase<Fulfilled<DoubleTestThunk, String, void>>(
+            (state, action) => 2);
+      });
     });
 
     test('should yield the initialState', () {
-      final result = reducer(initialState, SomeUnhandledAction());
+      final result = testStateReducer(initialState, SomeUnhandledAction());
       expect(result, equals(initialState));
     });
 
     test('should yield a loading state', () {
-      final result = reducer(initialState, RequestItemsAction());
+      final result = testStateReducer(initialState, RequestItemsAction());
       expect(result.isLoading, isTrue);
     });
 
@@ -39,7 +53,7 @@ void main() {
       ]);
 
       final prevState = initialState.copyWith(isLoading: true);
-      final result = reducer(
+      final result = testStateReducer(
           prevState,
           FetchItemsSuccessfulAction(
             payload: items,
@@ -55,7 +69,7 @@ void main() {
       ]);
 
       final prevState = initialState.copyWith(isLoading: true);
-      final result = reducer(
+      final result = testStateReducer(
           prevState,
           FetchItemsSuccessfulAction(
             payload: items,
@@ -68,7 +82,7 @@ void main() {
       final error = Exception("Hehe you failed");
 
       final prevState = initialState.copyWith(isLoading: true);
-      final result = reducer(
+      final result = testStateReducer(
           prevState,
           FetchItemsErrorAction(
             error: error,
@@ -81,13 +95,31 @@ void main() {
       final error = Exception("Hehe you failed");
 
       final prevState = initialState.copyWith(isLoading: true);
-      final result = reducer(
+      final result = testStateReducer(
           prevState,
           FetchItemsErrorAction(
             error: error,
           ));
 
       expect(result.error, equals(error));
     });
+
+    test('should yield list with only SingleTestThunk', () {
+      final result = listReducer(
+        0,
+        Fulfilled<SingleTestThunk, String, void>('SingleTestThunk', null),
+      );
+
+      expect(result, equals(1));
+    });
+    
+    test('should yield list with only DoubleTestThunk', () {
+      final result = listReducer(
+        0,
+        Fulfilled<DoubleTestThunk, String, void>('DoubleTestThunk', null),
+      );
+
+      expect(result, equals(2));
+    });
   });
 }

test/test_thunks.dart

@@ -0,0 +1,16 @@
+import 'dart:async';
+import 'package:redux_toolkit/redux_toolkit.dart';
+
+class StringLength extends AsyncThunk<StringLength, int, String, int> {
+  const StringLength(String payload) : super(payload);
+
+  @override
+  Future<int> run() => Future.sync(() => payload.length);
+}
+
+class EpicFail extends AsyncThunk<EpicFail, int, String, int> {
+  const EpicFail(String payload) : super(payload);
+
+  @override
+  Future<int> run() => Future.error(Exception('hehe'));
+}