Merge pull request #52 from andrasferenczi/master

Have dispatch return a value

lib/src/store.dart

@@ -70,7 +70,7 @@ abstract class ReducerClass<State> {
 ///       counterReducer,
 ///       middleware: [loggingMiddleware],
 ///     );
-typedef void Middleware<State>(
+typedef dynamic Middleware<State>(
   Store<State> store,
   dynamic action,
   NextDispatcher next,
@@ -101,7 +101,7 @@ typedef void Middleware<State>(
 ///     );
 abstract class MiddlewareClass<State> {
   /// A [Middleware] function that intercepts a dispatched action
-  void call(Store<State> store, dynamic action, NextDispatcher next);
+  dynamic call(Store<State> store, dynamic action, NextDispatcher next);
 }
 
 /// The contract between one piece of middleware and the next in the chain. Use
@@ -111,7 +111,7 @@ abstract class MiddlewareClass<State> {
 /// Middleware can optionally pass the original action or a modified action to
 /// the next piece of middleware, or never call the next piece of middleware at
 /// all.
-typedef void NextDispatcher(dynamic action);
+typedef dynamic NextDispatcher(dynamic action);
 
 /// Creates a Redux store that holds the app state tree.
 ///
@@ -264,8 +264,7 @@ class Store<State> {
   /// intercept actions, and can modify actions or stop them from passing
   /// through to the reducer.
   dynamic dispatch(dynamic action) {
-    _dispatchers[0](action);
-    return action;
+    return _dispatchers[0](action);
   }
 
   /// Closes down the Store so it will no longer be operational. Only use this

lib/src/utils.dart

@@ -224,11 +224,11 @@ class TypedMiddleware<State, Action> implements MiddlewareClass<State> {
   TypedMiddleware(this.middleware);
 
   @override
-  void call(Store<State> store, dynamic action, NextDispatcher next) {
+  dynamic call(Store<State> store, dynamic action, NextDispatcher next) {
     if (action is Action) {
-      middleware(store, action, next);
+      return middleware(store, action, next);
     } else {
-      next(action);
+      return next(action);
     }
   }
 }

test/middleware_test.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'package:redux/redux.dart';
 import 'package:test/test.dart';
 
@@ -75,5 +76,28 @@ void main() {
 
       expect(middleware1.counter, equals(2));
     });
+
+    test('dispatch returns the value from middleware', () async {
+      final passthrough = PassThroughMiddleware<String>();
+      final thunk = ThunkMiddleware<String>();
+      Future<void> thunkAction(Store<String> store) async {
+        await Future<void>.delayed(Duration(milliseconds: 5));
+        store.dispatch("changed");
+      }
+
+      final store = Store<String>(
+        stringReducer,
+        initialState: 'hello',
+        middleware: [passthrough, thunk],
+      );
+
+      final awaitableAction = store.dispatch(thunkAction) as Future<void>;
+
+      // Did not change yet
+      expect(store.state, equals('hello'));
+      await awaitableAction;
+      // The effect has taken place
+      expect(store.state, equals('changed'));
+    });
   });
 }

test/test_data.dart

@@ -28,8 +28,7 @@ class StringReducer extends ReducerClass<String> {
 
 class IncrementMiddleware extends MiddlewareClass<String> {
   int counter = 0;
-  final _invocationsController =
-      StreamController<String>.broadcast(sync: true);
+  final _invocationsController = StreamController<String>.broadcast(sync: true);
 
   Stream<String> get invocations => _invocationsController.stream;
 
@@ -72,6 +71,24 @@ class ExtraActionIfDispatchedIncrementMiddleware extends IncrementMiddleware {
   }
 }
 
+class PassThroughMiddleware<State> implements MiddlewareClass<State> {
+  @override
+  dynamic call(Store<State> store, dynamic action, NextDispatcher next) {
+    return next(action);
+  }
+}
+
+class ThunkMiddleware<State> implements MiddlewareClass<State> {
+  @override
+  dynamic call(Store<State> store, dynamic action, NextDispatcher next) {
+    if (action is Function) {
+      return action(store);
+    } else {
+      return next(action);
+    }
+  }
+}
+
 class TestAction1 {}
 
 class TestAction2 {}