iguazu/lib/reduce.js

An asynchronous data flow solution for React/Redux applications

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = iguazuReduce;
exports.reduceData = reduceData;
exports.reduceErrors = reduceErrors;
exports.reducePromise = reducePromise;
exports.reducePromiseObject = reducePromiseObject;
exports.reduceStatus = reduceStatus;

var _utils = require("./utils");

/*
 * Copyright 2017 American Express
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */
function reduceData(loadResponseMap) {
  return (0, _utils.mapValues)(loadResponseMap, function (response) {
    return response.data;
  });
}

function reduceStatus(loadResponseMap) {
  var responses = Object.values(loadResponseMap);
  var loadStatusMap = (0, _utils.mapValues)(loadResponseMap, function (response) {
    return response.status;
  });
  loadStatusMap.all = responses.filter(function (response) {
    return !response.noncritical;
  }).map(function (response) {
    return response.status;
  }).every(function (s) {
    return s === 'complete';
  }) ? 'complete' : 'loading';
  return loadStatusMap;
}

function reduceErrors(loadResponseMap) {
  var responses = Object.values(loadResponseMap);
  var loadErrorMap = (0, _utils.mapValues)(loadResponseMap, function (response) {
    return response.error;
  });
  loadErrorMap.any = responses.filter(function (response) {
    return !response.noncritical;
  }).map(function (response) {
    return response.error;
  }).some(function (error) {
    return error;
  });
  return loadErrorMap;
}

function reducePromise(loadResponseMap) {
  return Promise.all(Object.values(loadResponseMap).map(function (response) {
    return response.promise;
  }));
}

function reducePromiseObject(loadResponseMap) {
  var keys = Object.keys(loadResponseMap);
  var promises = keys.map(function (key) {
    return loadResponseMap[key].promise;
  });
  return Promise.all(promises).then(function (responses) {
    return (0, _utils.zipObject)(keys, responses);
  });
}

function iguazuReduce(loadFunc) {
  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
      _ref$promiseAsObject = _ref.promiseAsObject,
      promiseAsObject = _ref$promiseAsObject === void 0 ? false : _ref$promiseAsObject;

  return function (loadInputs) {
    if ((0, _utils.isServer)() && !loadFunc.ssr) {
      return {
        status: 'loading'
      };
    }

    var loadFuncMap = loadFunc(loadInputs);
    var loadResponseMap = (0, _utils.mapValues)(loadFuncMap, function (func) {
      return func({
        isServer: (0, _utils.isServer)()
      });
    });
    var data = reduceData(loadResponseMap);
    var status = reduceStatus(loadResponseMap).all;
    var error = reduceErrors(loadResponseMap).any; // TODO: Fix this to always return as object in next major version.

    var promise = promiseAsObject ? reducePromiseObject(loadResponseMap) : reducePromise(loadResponseMap);
    (0, _utils.handlePromiseRejection)(promise);
    return {
      data: data,
      status: status,
      error: error,
      promise: promise
    };
  };
}