init

Author: Andrey Kogut

.babelrc

@@ -0,0 +1,3 @@
+{
+  "presets": ["es2015"]
+}

.gitignore

@@ -0,0 +1,3 @@
+node_modules
+*.log
+lib

.npmignore

@@ -0,0 +1 @@
+src

README.md

@@ -0,0 +1,118 @@
+redux-async-flow
+================
+
+This [redux middleware](http://rackt.github.io/redux/docs/advanced/Middleware.html) allows dispatching async actions, that may include:
+- promise
+- array of promises, that will be chained
+- functions returning promises
+- array of functions returning prommises, that will be chained
+- array of other async actions, that will be chained
+- functions returning anything, that will be chained
+- array of functions returning anything, that will be chained
+
+It will handle errors in promises, dispatching ERROR actions. Exceptions, that occured in your reducer *won't be swallowed* and will be thrown.
+
+
+Example
+-------
+
+Lets say, you have some functions, returning promises for web api requests:
+
+```js
+const apiLogin = password => new Promise((resolve, reject) => {
+    setTimeout(() => {
+        resolve(15921);
+    }, 1000);
+});
+
+const apiPullUserProfile = userId => new Promise((resolve, reject) => {
+    if (userId === 15921) {
+        setTimeout(() => {
+            resolve({
+                avatarUrl: "https://img.example.org/15921/Gc2xcYMvRieoA8.png"
+            });
+        }, 1000);
+    }
+});
+
+const apiPullAvatar = avatarUrl => new Promise((resolve, reject) => {
+    if (avatarUrl === "https://img.example.org/15921/Gc2xcYMvRieoA8.png") {
+        setTimeout(() => {
+            resolve("Done");
+        }, 1000);
+    }
+});
+```
+
+You can make corresponding actions creators:
+```js
+const startLoggingIn = password => ({
+    types:   ["LOGGING_IN_STARTED", "LOGGING_IN_SUCCESS", "LOGGING_IN_ERROR"],
+    payload: apiLogin(password)
+});
+
+const startPullingProfile = userId => ({
+    types:   ["PULLING_PROFILE_STARTED", "PULLING_PROFILE_SUCCESS", "PULLING_PROFILE_ERROR"],
+    payload: apiLogin(userId)
+});
+
+const startPullingAvatar = avatarUrl => ({
+    types:   ["PULLING_AVATAR_STARTED", "PULLING_AVATAR_SUCCESS", "PULLING_AVATAR_ERROR"],
+    payload: apiLogin(avatarUrl)
+});
+```
+
+Now you can make one action creator to rule them all:
+```js
+const startEverything = password => ({
+    types:   ["EVERYTHING_STARTED", "EVERYTHING_SUCCESS", "EVERYTHING_ERROR"],
+    payload: [
+        startLoggingIn(password),
+        startPullingProfile,
+        startPullingAvatar
+    ]
+});
+```
+
+That will results in creating actions in the following order:
+```
+{ type: EVERYTHING_STARTED }
+{ type: LOGGING_IN_STARTED }
+{ type: LOGGING_IN_SUCCESS, payload: 15921 /* userId */ }
+{ type: PULLING_PROFILE_STARTED }
+{ type: PULLING_PROFILE_SUCCESS, payload: "https://img.example.org/15921/Gc2xcYMvRieoA8.png" /* avatarUrl */ }
+{ type: PULLING_AVATAR_STARTED }
+{ type: PULLING_AVATAR_SUCCESS, payload: /* avatar */ }
+{ type: EVERYTHING_SUCCESS }
+```
+
+You can transform data in the midle of chain, lets replace `https` with `http`:
+```js
+const startEverything = password => ({
+    types:   ["EVERYTHING_STARTED", "EVERYTHING_SUCCESS", "EVERYTHING_ERROR"],
+    payload: [
+        startLoggingIn(password),
+        startPullingProfile,
+        url => url.replace("https", "http"),
+        startPullingAvatar
+    ]
+});
+
+// Or even asynchronously:
+
+const startEverything = password => ({
+    types:   ["EVERYTHING_STARTED", "EVERYTHING_SUCCESS", "EVERYTHING_ERROR"],
+    payload: [
+        startLoggingIn(password),
+        startPullingProfile,
+        url => new Promise((resolve, reject) => {
+            setTimeout(() => {
+                resolve(url.replace("https", "http"));
+            }, 500);
+        }),
+        startPullingAvatar
+    ]
+});
+```
+
+Any questions, propositions, pull requests are welcome in [issues](https://github.com/andykog/redux-async-flow/issues).

package.json

@@ -0,0 +1,27 @@
+{
+  "name": "redux-async-flow",
+  "version": "0.0.3",
+  "description": "Async middleware for Redux",
+  "main": "lib/index.js",
+  "scripts": {
+    "prepublish": "rimraf lib && babel src --out-dir lib"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/andykog/redux-async-flow.git"
+  },
+  "keywords": [
+    "redux",
+    "async",
+    "promise",
+    "middleware"
+  ],
+  "author": "Andrey Kogut <mail@andreykogut.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "babel": "^6.3.13",
+    "babel-cli": "^6.3.13",
+    "babel-core": "^6.3.13",
+    "rimraf": "^2.4.4"
+  }
+}

src/index.js

@@ -0,0 +1,120 @@
+"use strict";
+
+const isPromise = maybePromise => maybePromise && typeof maybePromise.then === 'function';
+
+const isAsyncAction = maybeAsync => maybeAsync && maybeAsync.types instanceof Array;
+
+const isDispatchError = maybeDispatchError => maybeDispatchError && maybeDispatchError.__isDispatchError === true;
+
+const dispatchedPromise = (promise, types, dispatch) => {
+
+    const [START, SUCCESS, FAIL] = types;
+
+    dispatch({
+        type: START,
+        meta: {
+            async: true
+        }
+    });
+
+    return promise.then(
+        result => {
+            try {
+                dispatch({
+                    type: SUCCESS,
+                    payload: result,
+                    meta: {
+                        resolves: START
+                    }
+                });
+            } catch(dispatchError) {
+                dispatchError.__isDispatchError = true;
+                throw dispatchError;
+            }
+            return result;
+        },
+        error => {
+            try {
+                dispatch({
+                    type: FAIL,
+                    payload: error,
+                    error: true,
+                    meta: {
+                        resolves: START
+                    }
+                });
+            } catch(dispatchError) {
+                dispatchError.__isDispatchError = true;
+                throw dispatchError;
+            }
+            throw error;
+        }
+    );
+
+};
+
+
+const promisifiedDispatchedAsyncAction = (asyncAction, dispatch) => {
+
+    const payload = typeof asyncAction.payload === "function" ? asyncAction.payload() : asyncAction.payload;
+
+    if (isPromise(payload)) {
+
+        return dispatchedPromise(payload, asyncAction.types, dispatch)
+
+    } else if (isAsyncAction(payload)) {
+
+        return dispatchedPromise(
+            promisifiedDispatchedAsyncAction(payload, dispatch),
+            payload.types,
+            dispatch
+        );
+
+    } else if (payload instanceof Array) {
+
+        return dispatchedPromise(
+            payload.reduce(
+                (acc, nextPart) => acc.then(
+                    previousResult => {
+                        nextPart = typeof nextPart === "function" ? nextPart(previousResult) : nextPart;
+                        if (isPromise(nextPart)) {
+                            return nextPart;
+                        } else if (isAsyncAction(nextPart)) {
+                            return promisifiedDispatchedAsyncAction(nextPart, dispatch)
+                        } else {
+                            return nextPart;
+                        }
+                    }
+                ),
+                Promise.resolve()
+            ),
+            asyncAction.types,
+            dispatch
+        );
+
+    } else {
+
+        return(Promise.resolve(payload));
+
+    }
+
+};
+
+export default ({ dispatch }) => next => action => {
+
+    if (isAsyncAction(action)) {
+
+        promisifiedDispatchedAsyncAction(action, dispatch)
+            .catch(error => {
+                if (isDispatchError(error)) {
+                    throw error;
+                }
+            });
+
+    } else {
+
+        next(action);
+
+    }
+
+};