@3plus/redux-api 1.0.5 → 1.1.2

package/lib/PubSub.js

@@ -1,43 +1,20 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
-function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-var PubSub = exports["default"] = /*#__PURE__*/function () {
-  function PubSub() {
-    _classCallCheck(this, PubSub);
+export default class PubSub {
+  constructor() {
     this.container = [];
   }
-  return _createClass(PubSub, [{
-    key: "push",
-    value: function push(cb) {
-      cb instanceof Function && this.container.push(cb);
-    }
-  }, {
-    key: "resolve",
-    value: function resolve(data) {
-      var container = this.container;
-      this.container = [];
-      container.forEach(function (cb) {
-        return cb(null, data);
-      });
-    }
-  }, {
-    key: "reject",
-    value: function reject(err) {
-      var container = this.container;
-      this.container = [];
-      container.forEach(function (cb) {
-        return cb(err);
-      });
-    }
-  }]);
-}();
-module.exports = exports.default;
+  push(cb) {
+    cb instanceof Function && this.container.push(cb);
+  }
+  resolve(data) {
+    const container = this.container;
+    this.container = [];
+    container.forEach(cb => cb(null, data));
+  }
+  reject(err) {
+    const container = this.container;
+    this.container = [];
+    container.forEach(cb => cb(err));
+  }
+}

package/lib/actionFn.js

@@ -1,104 +1,78 @@
 "use strict";
 
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = actionFn;
-var _fastApply = _interopRequireDefault(require("fast-apply"));
-var _url = _interopRequireDefault(require("url"));
-var _urlTransform = _interopRequireDefault(require("./urlTransform"));
-var _merge = _interopRequireDefault(require("./utils/merge"));
-var _get = _interopRequireDefault(require("./utils/get"));
-var _fetchResolver = _interopRequireDefault(require("./fetchResolver"));
-var _PubSub = _interopRequireDefault(require("./PubSub"));
-var _createHolder = _interopRequireDefault(require("./createHolder"));
-var _helpers = require("./helpers");
-var _cache = require("./utils/cache");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
-/**
- * Constructor for create action
- * @param  {String} url          endpoint's url
- * @param  {String} name         action name
- * @param  {Object} options      action configuration
- * @param  {Object} ACTIONS      map of actions
- * @param  {[type]} fetchAdapter adapter for fetching data
- * @return {Function+Object}     action function object
- */
-function actionFn(url, name, options) {
-  var ACTIONS = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  var meta = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
-  var actionFetch = ACTIONS.actionFetch,
-    actionSuccess = ACTIONS.actionSuccess,
-    actionFail = ACTIONS.actionFail,
-    actionReset = ACTIONS.actionReset,
-    actionCache = ACTIONS.actionCache,
-    actionAbort = ACTIONS.actionAbort;
-  var pubsub = new _PubSub["default"]();
-  var requestHolder = (0, _createHolder["default"])();
+import urlTransform from "./urlTransform";
+import merge from "./utils/merge";
+import get from "./utils/get";
+import fetchResolver from "./fetchResolver";
+import PubSub from "./PubSub";
+import createHolder from "./createHolder";
+import { none, extractArgs, defaultMiddlewareArgsParser, CRUD } from "./helpers";
+import { getCacheManager } from "./utils/cache";
+export default function actionFn(url, name, options, ACTIONS = {}, meta = {}) {
+  const {
+    actionFetch,
+    actionSuccess,
+    actionFail,
+    actionReset,
+    actionCache,
+    actionAbort
+  } = ACTIONS;
+  const pubsub = new PubSub();
+  const requestHolder = createHolder();
   function getOptions(urlT, params, getState) {
-    var globalOptions = !meta.holder ? {} : meta.holder.options instanceof Function ? meta.holder.options(urlT, params, getState) : meta.holder.options;
-    var baseOptions = !(options instanceof Function) ? options : options(urlT, params, getState);
-    return (0, _merge["default"])({}, globalOptions, baseOptions, params);
+    const globalOptions = !meta.holder ? {} : meta.holder.options instanceof Function ? meta.holder.options(urlT, params, getState) : meta.holder.options;
+    const baseOptions = !(options instanceof Function) ? options : options(urlT, params, getState);
+    return merge({}, globalOptions, baseOptions, params);
   }
   function getUrl(pathvars, params, getState) {
-    var resultUrlT = (0, _urlTransform["default"])(url, pathvars, meta.urlOptions);
-    var urlT = resultUrlT;
-    var rootUrl = (0, _get["default"])(meta, "holder", "rootUrl");
+    const resultUrlT = urlTransform(url, pathvars, meta.urlOptions);
+    let urlT = resultUrlT;
+    let rootUrl = get(meta, "holder", "rootUrl");
     rootUrl = !(rootUrl instanceof Function) ? rootUrl : rootUrl(urlT, params, getState);
     if (rootUrl) {
-      var rootUrlObject = _url["default"].parse(rootUrl);
-      var urlObject = _url["default"].parse(urlT);
+      let urlObject = {};
+      try {
+        urlObject = new URL(urlT);
+      } catch (error) {
+        urlObject = {
+          pathname: urlT
+        };
+      }
+      const rootUrlObject = new URL(rootUrl);
       if (!urlObject.host) {
-        var urlPath = (rootUrlObject.path ? rootUrlObject.path.replace(/\/$/, "") : "") + "/" + (urlObject.path ? urlObject.path.replace(/^\//, "") : "");
-        urlT = "".concat(rootUrlObject.protocol, "//").concat(rootUrlObject.host).concat(urlPath);
+        const urlPath = (rootUrlObject.pathname ? rootUrlObject.pathname.replace(/\/$/, "") : "") + "/" + (urlObject.pathname ? urlObject.pathname.replace(/^\//, "") : "");
+        urlT = `${rootUrlObject.protocol}//${rootUrlObject.host}${urlPath}`;
       }
     }
     return urlT;
   }
-  function fetch(pathvars, params) {
-    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    var getState = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _helpers.none;
-    var dispatch = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : _helpers.none;
-    var urlT = getUrl(pathvars, params, getState);
-    var opts = getOptions(urlT, params, getState);
-    var id = meta.reducerName || "";
-    var cacheManager = (0, _cache.getCacheManager)(options.expire, meta.cache);
-    if (cacheManager && getState !== _helpers.none) {
-      var state = getState();
-      var cache = (0, _get["default"])(state, meta.prefix, meta.reducerName, "cache");
+  function fetch(pathvars, params, options = {}, getState = none, dispatch = none) {
+    const urlT = getUrl(pathvars, params, getState);
+    const opts = getOptions(urlT, params, getState);
+    let id = meta.reducerName || "";
+    const cacheManager = getCacheManager(options.expire, meta.cache);
+    if (cacheManager && getState !== none) {
+      const state = getState();
+      const cache = get(state, meta.prefix, meta.reducerName, "cache");
       id += "_" + cacheManager.id(pathvars, params);
-      var data = cacheManager.getData(cache && id && cache[id] !== undefined && cache[id]);
+      const data = cacheManager.getData(cache && id && cache[id] !== undefined && cache[id]);
       if (data !== undefined) {
         if (cache[id].persisted) {
           Object.defineProperty(data, "persisted", {
             value: true
           });
-          // expire persisted cache immediately after consumption
-          // because we will try to reload and persist new data
           cache[id].expire = true;
         }
         return Promise.resolve(data);
       }
     }
-    var response = meta.fetch(urlT, opts, options);
-    if (cacheManager && dispatch !== _helpers.none && id) {
-      response.then(function (data) {
+    const response = meta.fetch(urlT, opts, options);
+    if (cacheManager && dispatch !== none && id) {
+      response.then(data => {
         dispatch({
           type: actionCache,
-          id: id,
-          data: data,
+          id,
+          data,
           expire: cacheManager.expire
         });
       });
@@ -106,99 +80,70 @@ function actionFn(url, name, options) {
     return response;
   }
   function abort() {
-    var defer = requestHolder.pop();
-    var err = new Error("Application abort request");
+    const defer = requestHolder.pop();
+    const err = new Error("Application abort request");
     defer && defer.reject(err);
     return err;
   }
-
-  /**
-   * Fetch data from server
-   * @param  {Object}   pathvars    path vars for url
-   * @param  {Object}   params      fetch params
-   * @param  {Function} getState    helper meta function
-   */
-  function request(pathvars, params, options) {
-    var getState = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _helpers.none;
-    var dispatch = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : _helpers.none;
-    var response = fetch(pathvars, params, options, getState, dispatch);
-    var result = !meta.validation ? response : response.then(function (data) {
-      return new Promise(function (resolve, reject) {
-        meta.validation(data, function (err) {
-          return err ? reject(err) : resolve(data);
-        });
-      });
-    });
-    var ret = result;
-    var responseHandler = (0, _get["default"])(meta, "holder", "responseHandler");
+  function request(pathvars, params, options, getState = none, dispatch = none) {
+    const response = fetch(pathvars, params, options, getState, dispatch);
+    const result = !meta.validation ? response : response.then(data => new Promise((resolve, reject) => {
+      meta.validation(data, err => err ? reject(err) : resolve(data));
+    }));
+    let ret = result;
+    const responseHandler = get(meta, "holder", "responseHandler");
     if (responseHandler) {
       if (result && result.then) {
-        ret = result.then(function (data) {
-          var res = responseHandler(null, data);
+        ret = result.then(data => {
+          const res = responseHandler(null, data);
           if (res === undefined) {
             return data;
           } else {
             return res;
           }
-        }, function (err) {
-          return responseHandler(err);
-        });
+        }, err => responseHandler(err));
       } else {
         ret = responseHandler(result);
       }
     }
-    ret && ret["catch"] && ret["catch"](_helpers.none);
+    ret && ret.catch && ret.catch(none);
     return ret;
   }
-
-  /**
-   * Fetch data from server
-   * @param  {Object}   pathvars    path vars for url
-   * @param  {Object}   params      fetch params
-   * @param  {Function} callback)   callback execute after end request
-   */
-  function fn() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    var _extractArgs = (0, _helpers.extractArgs)(args),
-      _extractArgs2 = _slicedToArray(_extractArgs, 3),
-      pathvars = _extractArgs2[0],
-      params = _extractArgs2[1],
-      callback = _extractArgs2[2];
-    var syncing = params ? !!params.syncing : false;
+  function fn(...args) {
+    const [pathvars, params, callback] = extractArgs(args);
+    const syncing = params ? !!params.syncing : false;
     params && delete params.syncing;
     pubsub.push(callback);
-    return function () {
-      var middlewareParser = (0, _get["default"])(meta, "holder", "middlewareParser") || _helpers.defaultMiddlewareArgsParser;
-      var _middlewareParser = middlewareParser.apply(void 0, arguments),
-        dispatch = _middlewareParser.dispatch,
-        getState = _middlewareParser.getState;
-      var state = getState();
-      var isLoading = (0, _get["default"])(state, meta.prefix, meta.reducerName, "loading");
+    return (...middlewareArgs) => {
+      const middlewareParser = get(meta, "holder", "middlewareParser") || defaultMiddlewareArgsParser;
+      const {
+        dispatch,
+        getState
+      } = middlewareParser(...middlewareArgs);
+      const state = getState();
+      const isLoading = get(state, meta.prefix, meta.reducerName, "loading");
       if (isLoading) {
         return Promise.reject("isLoading-" + meta.prefix + "-" + meta.reducerName);
       }
-      var requestOptions = {
-        pathvars: pathvars,
-        params: params
+      const requestOptions = {
+        pathvars,
+        params
       };
       dispatch({
         type: actionFetch,
-        syncing: syncing,
+        syncing,
         request: requestOptions
       });
-      var fetchResolverOpts = {
-        dispatch: dispatch,
-        getState: getState,
+      const fetchResolverOpts = {
+        dispatch,
+        getState,
         request: requestOptions,
         actions: meta.actions,
         prefetch: meta.prefetch
       };
       if (Object.defineProperty) {
         Object.defineProperty(fetchResolverOpts, "requestOptions", {
-          get: function get() {
-            /* eslint no-console: 0 */
+          get() {
             console.warn("Deprecated option, use `request` option");
             return requestOptions;
           }
@@ -206,8 +151,8 @@ function actionFn(url, name, options) {
       } else {
         fetchResolverOpts.requestOptions = requestOptions;
       }
-      var result = new Promise(function (done, fail) {
-        (0, _fetchResolver["default"])(0, fetchResolverOpts, function (err) {
+      const result = new Promise((done, fail) => {
+        fetchResolver(0, fetchResolverOpts, err => {
           if (err) {
             dispatch({
               error: err,
@@ -219,42 +164,42 @@ function actionFn(url, name, options) {
             pubsub.reject(err);
             return fail(err);
           }
-          new Promise(function (resolve, reject) {
+          new Promise((resolve, reject) => {
             requestHolder.set({
-              resolve: resolve,
-              reject: reject,
+              resolve,
+              reject,
               promise: request(pathvars, params, fetchResolverOpts.request, getState, dispatch).then(resolve, reject)
             });
-          }).then(function (d) {
+          }).then(d => {
             requestHolder.pop();
-            var prevData = (0, _get["default"])(state, meta.prefix, meta.reducerName, "data");
-            var data = meta.transformer(d, prevData, {
+            const prevData = get(state, meta.prefix, meta.reducerName, "data");
+            const data = meta.transformer(d, prevData, {
               type: actionSuccess,
               request: requestOptions
             }, getState);
             dispatch({
-              data: data,
+              data,
               origData: d,
               type: actionSuccess,
               syncing: false,
               request: requestOptions
             });
             if (meta.broadcast) {
-              meta.broadcast.forEach(function (type) {
+              meta.broadcast.forEach(type => {
                 dispatch({
-                  type: type,
-                  data: data,
+                  type,
+                  data,
                   origData: d,
                   request: requestOptions
                 });
               });
             }
             if (meta.postfetch) {
-              meta.postfetch.forEach(function (postfetch) {
+              meta.postfetch.forEach(postfetch => {
                 postfetch instanceof Function && postfetch({
-                  data: data,
-                  getState: getState,
-                  dispatch: dispatch,
+                  data,
+                  getState,
+                  dispatch,
                   actions: meta.actions,
                   request: requestOptions
                 });
@@ -262,13 +207,12 @@ function actionFn(url, name, options) {
             }
             pubsub.resolve(data);
             done(data);
-            // special case where we will try to relaod data if persisted cache is consumed
             if (d && d.persisted && meta.cache && meta.cache.reloadPersisted) {
-              fn.force.apply(fn, args)(dispatch, getState);
+              fn.force(...args)(dispatch, getState);
             }
-          }, function (error) {
+          }, error => {
             dispatch({
-              error: error,
+              error,
               type: actionFail,
               loading: false,
               syncing: false,
@@ -279,141 +223,103 @@ function actionFn(url, name, options) {
           });
         });
       });
-      result["catch"](_helpers.none);
+      result.catch(none);
       return result;
     };
   }
-
-  /*
-    Pure rest request
-   */
   fn.request = function (pathvars, params, options) {
     return request(pathvars, params, options || {});
   };
-
-  /**
-   * Reset store to initial state
-   */
-  fn.reset = function (mutation) {
+  fn.reset = mutation => {
     abort();
     return mutation === "sync" ? {
       type: actionReset,
-      mutation: mutation
+      mutation
     } : {
       type: actionReset
     };
   };
-
-  /*
-    Abort request
-   */
   fn.abort = function () {
-    var error = abort();
+    const error = abort();
     return {
       type: actionAbort,
-      error: error
+      error
     };
   };
-  fn.force = function () {
-    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-      args[_key2] = arguments[_key2];
-    }
-    return function (dispatch, getState) {
-      var state = getState();
-      var isLoading = (0, _get["default"])(state, meta.prefix, meta.reducerName, "loading");
+  fn.force = function (...args) {
+    return (dispatch, getState) => {
+      const state = getState();
+      const isLoading = get(state, meta.prefix, meta.reducerName, "loading");
       if (isLoading) {
         dispatch(fn.abort());
       }
-      return fn.apply(void 0, args)(dispatch, getState);
+      return fn(...args)(dispatch, getState);
     };
   };
-
-  /**
-   * Sync store with server. In server mode works as usual method.
-   * If data have already synced, data would not fetch after call this method.
-   * @param  {Object} pathvars    path vars for url
-   * @param  {Object} params      fetch params
-   * @param  {Function} callback) callback execute after end request
-   */
-  fn.sync = function () {
-    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-      args[_key3] = arguments[_key3];
-    }
-    var _extractArgs3 = (0, _helpers.extractArgs)(args),
-      _extractArgs4 = _slicedToArray(_extractArgs3, 3),
-      pathvars = _extractArgs4[0],
-      params = _extractArgs4[1],
-      callback = _extractArgs4[2];
-    var isServer = meta.holder ? meta.holder.server : false;
-    return function (dispatch, getState) {
-      var state = getState();
-      var store = (0, _get["default"])(state, meta.prefix, name);
+  fn.sync = (...args) => {
+    const [pathvars, params, callback] = extractArgs(args);
+    const isServer = meta.holder ? meta.holder.server : false;
+    return (dispatch, getState) => {
+      const state = getState();
+      const store = get(state, meta.prefix, name);
       if (!isServer && store && store.sync) {
         callback(null, store.data);
         return;
       }
-      var modifyParams = _objectSpread(_objectSpread({}, params), {}, {
+      const modifyParams = {
+        ...params,
         syncing: true
-      });
+      };
       return fn(pathvars, modifyParams, callback)(dispatch, getState);
     };
   };
-  var helpers = meta.helpers || {};
+  let helpers = meta.helpers || {};
   if (meta.crud) {
-    helpers = _objectSpread(_objectSpread({}, _helpers.CRUD), helpers);
+    helpers = {
+      ...CRUD,
+      ...helpers
+    };
   }
-  var fnHelperCallback = function fnHelperCallback(memo, func, helpername) {
+  const fnHelperCallback = (memo, func, helpername) => {
     if (memo[helpername]) {
-      throw new Error("Helper name: \"".concat(helpername, "\" for endpoint \"").concat(name, "\" has been already reserved"));
+      throw new Error(`Helper name: "${helpername}" for endpoint "${name}" has been already reserved`);
     }
-    var _ref = func instanceof Function ? {
-        call: func
-      } : func,
-      sync = _ref.sync,
-      call = _ref.call;
-    memo[helpername] = function () {
-      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-        args[_key4] = arguments[_key4];
-      }
-      return function (dispatch, getState) {
-        var index = args.length - 1;
-        var callbackFn = args[index] instanceof Function ? args[index] : _helpers.none;
-        var helpersResult = (0, _fastApply["default"])(call, {
-          getState: getState,
-          dispatch: dispatch,
-          actions: meta.actions
-        }, args);
-        var result = new Promise(function (resolve, reject) {
-          var callback = function callback(err, data) {
-            err ? reject(err) : resolve(data);
-            callbackFn(err, data);
-          };
-          // If helper alias using async functionality
-          if (helpersResult instanceof Function) {
-            helpersResult(function (error) {
-              var newArgs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-              if (error) {
-                callback(error);
-              } else {
-                (0, _fastApply["default"])(sync ? fn.sync : fn, null, newArgs.concat(callback))(dispatch, getState);
-              }
-            });
-          } else {
-            // if helper alias is synchronous
-            var _helpersResult = _slicedToArray(helpersResult, 2),
-              pathvars = _helpersResult[0],
-              params = _helpersResult[1];
-            (0, _fastApply["default"])(sync ? fn.sync : fn, null, [pathvars, params, callback])(dispatch, getState);
-          }
-        });
-        result["catch"](_helpers.none);
-        return result;
-      };
+    const {
+      sync,
+      call
+    } = func instanceof Function ? {
+      call: func
+    } : func;
+    memo[helpername] = (...args) => (dispatch, getState) => {
+      const index = args.length - 1;
+      const callbackFn = args[index] instanceof Function ? args[index] : none;
+      const helpersResult = call.apply({
+        getState,
+        dispatch,
+        actions: meta.actions
+      }, args);
+      const result = new Promise((resolve, reject) => {
+        const callback = (err, data) => {
+          err ? reject(err) : resolve(data);
+          callbackFn(err, data);
+        };
+        if (helpersResult instanceof Function) {
+          helpersResult((error, newArgs = []) => {
+            if (error) {
+              callback(error);
+            } else {
+              (sync ? fn.sync : fn)(...newArgs.concat(callback))(dispatch, getState);
+            }
+          });
+        } else {
+          const [pathvars, params] = helpersResult;
+          (sync ? fn.sync : fn)(pathvars, params, callback)(dispatch, getState);
+        }
+      });
+      result.catch(none);
+      return result;
     };
     return memo;
   };
-  return Object.keys(helpers).reduce(function (memo, key) {
-    return fnHelperCallback(memo, helpers[key], key, helpers);
-  }, fn);
-}
-module.exports = exports.default;
+  return Object.keys(helpers).reduce((memo, key) => fnHelperCallback(memo, helpers[key], key, helpers), fn);
+}