Update to Flux Standard Action v0.6.0

- Uses FSA's isError() to check for failed actions
- `success()` and `error()` have been renamed to `next()` and
`throw()`, which are inspired by the ES6 generator interface.

Author: acdlite

.eslintrc

@@ -10,6 +10,7 @@
   "rules": {
     "padded-blocks": 0,
     "no-use-before-define": [2, "nofunc"],
-    "no-unused-expressions": 0
+    "no-unused-expressions": 0,
+    "no-reserved-keys": 0
   }
 }

README.md

@@ -39,14 +39,14 @@ createAction('ADD_TODO')('Use Redux');
 
 Wraps a reducer so that only handles Flux Standard Actions of a certain type.
 
-If a single reducer is passed, it is used to handle both successful and failed actions. You can use this form if you know a certain action will always be a success, like the increment example above.
+If a single reducer is passed, it is used to handle both normal actions and failed actions. (A failed action is analogous to a rejected promise.) You can use this form if you know a certain type of action will never fail, like the increment example above.
 
-Otherwise, you can specify reducers for `success` and `error`:
+Otherwise, you can specify separate reducers for `next()` and `throw()`. This API is inspired by the ES6 generator interface.
 
 ```js
 handleAction('FETCH_DATA', {
-  success(state, action) {...}
-  error(state, action) {...}
+  next(state, action) {...}
+  throw(state, action) {...}
 });
 ```
 

package.json

@@ -34,6 +34,7 @@
     "mocha": "^2.2.5"
   },
   "dependencies": {
+    "flux-standard-action": "^0.6.0",
     "reduce-reducers": "^0.1.0"
   }
 }

src/__tests__/handleAction-test.js

@@ -1,4 +1,4 @@
-import { handleAction} from '../';
+import { handleAction } from '../';
 
 describe('handleAction()', () => {
   const type = 'TYPE';
@@ -11,12 +11,6 @@ describe('handleAction()', () => {
         expect(reducer(prevState, { type })).to.equal(prevState);
       });
 
-      it('returns previous state if status defined but not one of "error" or "success"', () => {
-        const reducer = handleAction(type, () => null);
-        expect(reducer(prevState, { type, status: 'pending' }))
-          .to.equal(prevState);
-      });
-
       it('accepts single function as handler', () => {
         const reducer = handleAction(type, (state, action) => ({
           counter: state.counter + action.payload
@@ -32,13 +26,13 @@ describe('handleAction()', () => {
   describe('map of handlers form', () => {
     describe('resulting reducer', () => {
       it('returns previous state if type does not match', () => {
-        const reducer = handleAction('NOTTYPE', { success: () => null });
+        const reducer = handleAction('NOTTYPE', { next: () => null });
         expect(reducer(prevState, { type })).to.equal(prevState);
       });
 
-      it('uses `success()` if status is undefined', () => {
+      it('uses `next()` if action does not represent an error', () => {
         const reducer = handleAction(type, {
-          success: (state, action) => ({
+          next: (state, action) => ({
             counter: state.counter + action.payload
           })
         });
@@ -48,43 +42,24 @@ describe('handleAction()', () => {
           });
       });
 
-      it('uses `success()` if status is "success"', () => {
-        const reducer = handleAction(type, {
-          success: (state, action) => ({
-            counter: state.counter + action.payload
-          })
-        });
-        expect(reducer(prevState, { type, payload: 7, status: 'success' }))
-          .to.deep.equal({
-            counter: 10
-          });
-      });
-
-      it('uses `error()` if status is "error"', () => {
+      it('uses `throw()` if action represents an error', () => {
         const reducer = handleAction(type, {
-          error: (state, action) => ({
+          throw: (state, action) => ({
             counter: state.counter + action.payload
           })
         });
-        expect(reducer(prevState, { type, payload: 7, status: 'error' }))
+        expect(reducer(prevState, { type, payload: 7, error: true }))
           .to.deep.equal({
             counter: 10
           });
       });
 
-      it('returns previous state if status defined but not one of "error" or "success"', () => {
-        const reducer = handleAction(type, { success: () => null });
-        expect(reducer(prevState, { type, status: 'pending' }))
+      it('returns previous state if matching handler is not function', () => {
+        const reducer = handleAction(type, { next: null, error: 123 });
+        expect(reducer(prevState, { type, payload: 123 })).to.equal(prevState);
+        expect(reducer(prevState, { type, payload: 123, error: true }))
           .to.equal(prevState);
       });
-
-      it('throws if matching handler is not function', () => {
-        const reducer = handleAction(type, { success: null, error: 123 });
-        expect(() => reducer(prevState, { type, status: 'success' }))
-          .to.throw(/is not a function/);
-        expect(() => reducer(prevState, { type, status: 'error' }))
-          .to.throw(/is not a function/);
-      });
     });
   });
 });

src/handleAction.js

@@ -1,38 +1,24 @@
-// Map of action statuses to reducer property names
-const statusMappings = {
-  'error': 'error',
-  'success': 'success'
-};
+import { isError } from 'flux-standard-action';
 
 function isFunction(val) {
   return typeof val === 'function';
 }
 
-// Default action status, if none is specified
-const defaultStatus = 'success';
-
 export default function handleAction(type, reducers) {
   return (state, action) => {
     // If action type does not match, return previous state
     if (action.type !== type) return state;
 
-    // If status is undefined, use default status
-    const status = typeof action.status !== 'undefined'
-      ? action.status
-      : defaultStatus;
-
-    // Get reducer key that corresponds to status
-    const handlerKey = statusMappings[status];
-
-    // If status does not correspond to a reducer key, return previous state
-    if (!handlerKey) return state;
+    const handlerKey = isError(action) ? 'throw' : 'next';
 
     // If function is passed instead of map, use as reducer
     if (isFunction(reducers)) return reducers(state, action);
 
-    // Call reducer
-    // Throws if reducer is not a function
+    // Otherwise, assume an action map was passed
     const reducer = reducers[handlerKey];
-    return reducer(state, action);
+
+    return isFunction(reducer)
+      ? reducer(state, action)
+      : state;
   };
 }