Merge pull request #28 from kouhin/feature/async

(Refactoring) use async.js instead of async/await

Author: kouhin

.babelrc

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

package.json

@@ -3,6 +3,7 @@
  "version": "1.0.0",
  "description": "Loads async data for Redux apps focusing on preventing duplicated requests and dealing with async dependencies.",
  "main": "lib/index.js",
+ "jsnext:main": "src/index.js",
  "repository": {
  "type": "git",
  "url": "https://github.com/kouhin/redux-dataloader.git"
@@ -12,17 +13,14 @@
  },
  "homepage": "https://github.com/kouhin/redux-dataloader",
  "scripts": {
- "clean": "rimraf lib dist coverage",
- "build": "npm run clean && npm run build:commonjs && npm run build:umd",
- "build:commonjs": "babel src --out-dir lib",
- "build:umd": "webpack",
+ "clean": "rimraf lib coverage",
+ "build": "babel src --out-dir lib",
  "prepublish": "npm run clean && npm run lint && npm test && npm run build",
  "test": "mocha test/*.js --opts mocha.opts",
  "test:cov": "babel-node $(npm bin)/isparta cover $(npm bin)/_mocha test/*.js -- --opts mocha.opts",
  "lint": "eslint src test"
  },
  "files": [
- "dist",
  "lib",
  "src"
  ],
@@ -42,29 +40,26 @@
  "license": "MIT",
  "devDependencies": {
  "babel-cli": "^6.18.0",
- "babel-core": "^6.21.0",
+ "babel-core": "^6.20.0",
  "babel-eslint": "^7.1.1",
  "babel-loader": "^6.2.10",
  "babel-plugin-transform-runtime": "^6.15.0",
- "babel-polyfill": "^6.20.0",
  "babel-preset-es2015": "^6.18.0",
- "babel-preset-react": "^6.16.0",
  "babel-preset-stage-0": "^6.16.0",
  "chai": "^3.5.0",
- "eslint-config-airbnb-deps": "^13.0.0",
+ "eslint-config-airbnb-deps": "^14.0.0",
  "isparta": "^4.0.0",
  "istanbul": "^0.4.5",
  "mocha": "^3.2.0",
+ "redux": "^3.6.0",
  "rimraf": "^2.5.4",
- "sinon": "^1.17.6",
- "webpack": "^1.14.0"
+ "sinon": "^1.17.6"
  },
  "dependencies": {
- "babel-runtime": "^6.20.0",
+ "async": "^2.1.4",
  "lodash": "^4.17.2"
  },
  "eslintConfig": {
- "parser": "babel-eslint",
  "extends": "eslint-config-airbnb",
  "env": {
  "browser": true,
@@ -79,19 +74,11 @@
  "import/no-extraneous-dependencies": [
  "error",
  {
- "devDependencies": true
+ "devDependencies": [
+ "**/*.test.js"
+ ]
  }
  ]
  }
- },
- "babel": {
- "presets": [
- "es2015",
- "react",
- "stage-0"
- ],
- "plugins": [
- "transform-runtime"
- ]
  }
 }

src/Task.js

@@ -0,0 +1,87 @@
+import asyncify from 'async/asyncify';
+import retry from 'async/retry';
+import assign from 'lodash/assign';
+
+import { loadFailure, loadSuccess } from './actions';
+import { isAction } from './utils';
+import { DEFAULT_OPTIONS } from './constants';
+
+export default class Task {
+ constructor(context, monitoredAction, params = {}) {
+ if (!isAction(monitoredAction)) {
+ throw new Error('action must be a plain object');
+ }
+
+ this.context = assign({}, context, {
+ action: monitoredAction,
+ });
+
+ this.params = assign({}, {
+ success({ action }) {
+ throw new Error('success() is not implemented', action.type);
+ },
+ error({ action }) {
+ throw new Error('error() is not implemented', action.type);
+ },
+ loading({ action }) {
+ return action;
+ },
+ shouldFetch() {
+ return true;
+ },
+ fetch({ action }) {
+ throw new Error('Not implemented', action);
+ },
+ }, params);
+ }
+
+ execute(options = {}, callback) {
+ const opts = assign({}, DEFAULT_OPTIONS, options);
+
+ const context = this.context;
+ const dispatch = context.dispatch;
+ const {
+ success,
+ error,
+ loading,
+ shouldFetch,
+ fetch,
+ } = this.params;
+
+ const disableInternalAction = options.disableInternalAction;
+
+ if (!shouldFetch(context)) {
+ callback(null, null); // load nothing
+ if (!disableInternalAction) {
+ const successAction = loadSuccess(context.action);
+ dispatch(successAction);
+ }
+ return;
+ }
+
+ dispatch(loading(context));
+
+ // Retry
+ const asyncFetch = asyncify(fetch);
+ retry({
+ times: opts.retryTimes,
+ interval: opts.retryWait,
+ }, (retryCb) => {
+ asyncFetch(context, retryCb);
+ }, (err, result) => {
+ if (err) {
+ const errorAction = error(context, err);
+ if (!disableInternalAction) {
+ dispatch(loadFailure(context.action, err));
+ }
+ callback(null, dispatch(errorAction));
+ return;
+ }
+ const successAction = success(context, result);
+ callback(null, dispatch(successAction));
+ if (!disableInternalAction) {
+ dispatch(loadSuccess(context.action, result));
+ }
+ });
+ }
+}

src/TaskDescriptor.js

@@ -0,0 +1,31 @@
+import isEqual from 'lodash/isEqual';
+import assign from 'lodash/assign';
+
+import Task from './Task';
+import { DEFAULT_OPTIONS } from './constants';
+
+export default class TaskDescriptor {
+ constructor(pattern, params, options = {}) {
+ this.pattern = pattern;
+ this.params = params;
+ this.options = assign({}, DEFAULT_OPTIONS, options);
+ if (this.options.retryTimes < 1) {
+ this.options.retryTimes = 1;
+ }
+ }
+
+ supports(action) {
+ switch (typeof this.pattern) {
+ case 'object':
+ return isEqual(this.pattern, action);
+ case 'function':
+ return this.pattern(action) === true;
+ default:
+ return this.pattern === action.type;
+ }
+ }
+
+ newTask(context, action) {
+ return new Task(context, action, this.params);
+ }
+}

src/action.js renamed to src/actions.js

@@ -0,0 +1,9 @@
+import { fixedWait } from './waitStrategies';
+
+export const DEFAULT_OPTIONS = {
+ ttl: 10000, // Default TTL: 10s
+ retryTimes: 1,
+ retryWait: fixedWait(0),
+};
+
+export const REDUX_DATALOADER_ACTION_ID = () => {};

src/constants.js

@@ -0,0 +1,88 @@
+import findKey from 'lodash/findKey';
+import find from 'lodash/find';
+import isEqual from 'lodash/isEqual';
+import assign from 'lodash/assign';
+import flattenDeep from 'lodash/flattenDeep';
+import get from 'lodash/get';
+import isInteger from 'lodash/isInteger';
+
+import { REDUX_DATALOADER_ACTION_ID } from './constants';
+
+function findTaskKey(runningTasksMap, action) {
+ return findKey(runningTasksMap, o =>
+ (o.action.type === action.type && isEqual(o.action, action)));
+}
+
+export default function createDataLoaderMiddleware(
+ loaders = [],
+ withArgs = {},
+ middlewareOpts = {},
+) {
+ const flattenedLoaders = flattenDeep(loaders);
+ let currentId = 1;
+ const uniqueId = (prefix) => {
+ currentId += 1;
+ return `${prefix}${currentId}`;
+ };
+
+ const middleware = ({ dispatch, getState }) => {
+ middleware.cache = {};
+ const ctx = assign({}, withArgs, {
+ dispatch,
+ getState,
+ });
+
+ return next => (receivedAction) => {
+ // eslint-disable-next-line no-underscore-dangle
+ if (receivedAction._id !== REDUX_DATALOADER_ACTION_ID) {
+ return next(receivedAction);
+ }
+ return receivedAction.then((asyncAction) => {
+ // dispatch data loader request action
+ next(asyncAction);
+
+ const { action } = asyncAction.meta;
+ const taskKey = findTaskKey(middleware.cache, action);
+ if (taskKey) {
+ return middleware.cache[taskKey].promise;
+ }
+
+ const taskDescriptor = find(flattenedLoaders, loader => loader.supports(action));
+ if (!taskDescriptor) {
+ throw new Error('No loader for action', action);
+ }
+
+ // Priority: Action Meta Options > TaskDescriptor Options > Middleware Options
+ const options = assign(
+ {},
+ middlewareOpts,
+ taskDescriptor.options,
+ get(asyncAction, 'meta.options', {}),
+ );
+
+ const task = taskDescriptor.newTask(ctx, action);
+ const runningTask = new Promise((resolve, reject) => {
+ task.execute(options, (err, result) => {
+ if (err) {
+ reject(err);
+ } else {
+ resolve(result);
+ }
+ });
+ });
+
+ if (isInteger(options.ttl) && options.ttl > 0) {
+ const key = uniqueId(`${action.type}__`);
+ middleware.cache[key] = { action, promise: runningTask };
+ if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+ setTimeout(() => {
+ delete middleware.cache[key];
+ }, options.ttl);
+ }
+ }
+ return runningTask;
+ });
+ };
+ };
+ return middleware;
+}

src/createDataLoaderMiddleware.js

@@ -0,0 +1,13 @@
+import TaskDescriptor from './TaskDescriptor';
+
+/**
+ * Create a new TaskDescriptor
+ *
+ * @param {string|object|function} pattern pattern to match action
+ * @param {object} params parameters
+ * @param {object} options options
+ * @returns {TaskDescriptor} a descriptor object for creating data loader
+ */
+export default function createLoader(pattern, params, options) {
+ return new TaskDescriptor(pattern, params, options);
+}