Configurable default catch handler

README.md

@@ -32,6 +32,12 @@ Reflux.use(RefluxPromise(Q.Promise));
 // Uses bluebird
 import bluebird from "bluebird";
 Reflux.use(RefluxPromise(bluebird))
+
+// Catching and logging unhandled exceptions in action handlers
+import bluebird from "bluebird";
+Reflux.use(RefluxPromise(bluebird, function(err) {
+    console.log(err);
+}))
 ```
 
 ### Extensions to Asynchronous actions

src/index.js

@@ -1,4 +1,4 @@
-function createFunctions(Reflux, PromiseFactory) {
+function createFunctions(Reflux, PromiseFactory, catchHandler) {
 
     const _ = Reflux.utils;
 
@@ -59,9 +59,10 @@ function createFunctions(Reflux, PromiseFactory) {
             }
         });
 
-        // Ensure that the promise does trigger "Uncaught (in promise)" errors in console if no error handler is added
-        // See: https://github.com/reflux/reflux-promise/issues/4
-        createdPromise.catch(function() {});
+        // Attach promise catch handler if provided
+        if (typeof (catchHandler) === "function") {
+            createdPromise.catch(catchHandler);
+        }
 
         return createdPromise;
     }
@@ -129,9 +130,9 @@ function createFunctions(Reflux, PromiseFactory) {
 /**
  * Sets up reflux with Promise functionality
  */
-export default function(promiseFactory) {
+export default function(promiseFactory, catchHandler) {
     return function(Reflux) {
-        const { triggerPromise, promise, listenAndPromise } = createFunctions(Reflux, promiseFactory);
+        const { triggerPromise, promise, listenAndPromise } = createFunctions(Reflux, promiseFactory, catchHandler);
         Reflux.PublisherMethods.triggerAsync = triggerPromise;
         Reflux.PublisherMethods.promise = promise;
         Reflux.PublisherMethods.listenAndPromise = listenAndPromise;

test/creatingActions.js

@@ -102,3 +102,42 @@ describe('Creating actions using promises', function() {
     });
 
 });
+
+describe('Promise catch error handler', function () {
+    var actions, actionNames, errPromiseResolve;
+
+    var errPromise = Q.Promise(function(resolve, reject) {
+        // errPromise resolve function is exposed
+        errPromiseResolve = resolve;
+    });
+
+    // when errorHandler is called,
+    // errPromise gets resolved with the error object
+    var errorHandler = function(err) {
+        errPromiseResolve(err);
+    };
+
+    Reflux.use(RefluxPromise(Q.Promise, errorHandler));
+
+    actionNames = { 'foo': { asyncResult: true }};
+    actions = Reflux.createActions(actionNames);
+
+    it('should be called with error when action promise throws', function() {
+        var actionError = new Error('action error');
+        var actionPromise = Q.Promise(function(resolve, reject) {
+            throw actionError;
+            resolve('bar');
+        });
+
+        actions.foo.listenAndPromise(function() {
+            return actionPromise;
+        });
+
+        actions.foo();
+
+        return Q.all([
+            assert.isRejected(actionPromise, actionError, "actionPromsie not rejected with error"),
+            assert.becomes(errPromise, actionError, "error handler not executed with thrown error"),
+        ]);
+    });
+});