apollo-link-refresh-token/dist/apollo-link-refresh-token.cjs.development.js

A link to refresh auth tokens on authentication errors

'use strict';

var apolloLink = require('apollo-link');
var apolloLinkError = require('apollo-link-error');

function _extends() {
  _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];

      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }

    return target;
  };

  return _extends.apply(this, arguments);
}

var getRefreshTokenLink = function getRefreshTokenLink(_ref) {
  var isUnauthenticatedError = _ref.isUnauthenticatedError,
      getAccessToken = _ref.getAccessToken,
      getRefreshToken = _ref.getRefreshToken,
      isAccessTokenValid = _ref.isAccessTokenValid,
      fetchNewAccessToken = _ref.fetchNewAccessToken,
      authorizationHeaderKey = _ref.authorizationHeaderKey,
      onSuccessfulRefresh = _ref.onSuccessfulRefresh,
      onFailedRefresh = _ref.onFailedRefresh;
  return apolloLinkError.onError(function (_ref2) {
    var graphQLErrors = _ref2.graphQLErrors,
        operation = _ref2.operation,
        forward = _ref2.forward;

    if (graphQLErrors) {
      for (var i = 0; i < graphQLErrors.length; i += 1) {
        var graphQLError = graphQLErrors[i];

        if (isUnauthenticatedError(graphQLError)) {
          var _ret = function () {
            var accessToken = getAccessToken();
            var refreshToken = getRefreshToken();

            if (!accessToken || !refreshToken || isAccessTokenValid(accessToken)) {
              return {
                v: forward(operation)
              };
            }

            return {
              v: new apolloLink.Observable(function (observer) {
                fetchNewAccessToken(refreshToken).then(function (newAccessToken) {
                  if (!newAccessToken) {
                    throw new Error('Unable to fetch new access token');
                  }

                  operation.setContext(function (_ref3) {
                    var _extends2;

                    var _ref3$headers = _ref3.headers,
                        headers = _ref3$headers === void 0 ? {} : _ref3$headers;
                    return {
                      headers: _extends({}, headers, (_extends2 = {}, _extends2[authorizationHeaderKey] = newAccessToken || undefined, _extends2))
                    };
                  });
                  onSuccessfulRefresh && onSuccessfulRefresh(refreshToken);
                }).then(function () {
                  var subscriber = {
                    next: observer.next.bind(observer),
                    error: observer.error.bind(observer),
                    complete: observer.complete.bind(observer)
                  };
                  forward(operation).subscribe(subscriber);
                })["catch"](function (error) {
                  onFailedRefresh && onFailedRefresh(error);
                  observer.error(error);
                });
              })
            };
          }();

          if (typeof _ret === "object") return _ret.v;
        }
      }
    }

    return forward(operation);
  });
};

exports.getRefreshTokenLink = getRefreshTokenLink;
//# sourceMappingURL=apollo-link-refresh-token.cjs.development.js.map