@horizon/client/lib/auth.js

'use strict';

exports.__esModule = true;
exports.TokenStorage = undefined;

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

exports.authEndpoint = authEndpoint;
exports.clearAuthTokens = clearAuthTokens;

var _queryParse = require('./util/query-parse');

var _queryParse2 = _interopRequireDefault(_queryParse);

var _Observable = require('rxjs/Observable');

var _map = require('rxjs/operator/map');

var _fetch = require('./util/fetch.js');

var _fetch2 = _interopRequireDefault(_fetch);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var HORIZON_JWT = 'horizon-jwt';

/** @this Horizon **/
function authEndpoint(name) {
  var _this = this;

  var endpointForName = function endpointForName(methods) {
    if (methods.hasOwnProperty(name)) {
      return methods[name];
    } else {
      throw new Error('Unconfigured auth type: ' + name);
    }
  };
  if (!this._authMethods) {
    var _context;

    console.log('No auth methods, have to fetch');
    return (_context = (0, _fetch2.default)(this._horizonPath + '/auth_methods').do(function (authMethods) {
      _this._authMethods = authMethods;
    }), _map.map).call(_context, endpointForName);
  } else {
    var _context2;

    return (_context2 = _Observable.Observable.of(this._authMethods), _map.map).call(_context2, endpointForName);
  }
}

// Simple shim to make a Map look like local/session storage

var FakeStorage = function () {
  function FakeStorage() {
    (0, _classCallCheck3.default)(this, FakeStorage);
    this._storage = new Map();
  }

  FakeStorage.prototype.setItem = function setItem(a, b) {
    return this._storage.set(a, b);
  };

  FakeStorage.prototype.getItem = function getItem(a) {
    return this._storage.get(a);
  };

  FakeStorage.prototype.removeItem = function removeItem(a) {
    return this._storage.delete(a);
  };

  return FakeStorage;
}();

function getStorage() {
  try {
    if ((typeof window === 'undefined' ? 'undefined' : (0, _typeof3.default)(window)) !== 'object' || window.localStorage === undefined) {
      return new FakeStorage();
    }
    window.localStorage.setItem('$$fake', 1);
    window.localStorage.removeItem('$$fake');
    return window.localStorage;
  } catch (error) {
    if (window.sessionStorage === undefined) {
      return new FakeStorage();
    } else {
      return window.sessionStorage;
    }
  }
}

var TokenStorage = exports.TokenStorage = function () {
  function TokenStorage() {
    var authType = arguments.length <= 0 || arguments[0] === undefined ? 'unauthenticated' : arguments[0];
    (0, _classCallCheck3.default)(this, TokenStorage);

    this._storage = getStorage();
    this._authType = authType;
  }

  TokenStorage.prototype.set = function set(jwt) {
    return this._storage.setItem(HORIZON_JWT, jwt);
  };

  TokenStorage.prototype.get = function get() {
    return this._storage.getItem(HORIZON_JWT);
  };

  TokenStorage.prototype.remove = function remove() {
    return this._storage.removeItem(HORIZON_JWT);
  };

  TokenStorage.prototype.setAuthFromQueryParams = function setAuthFromQueryParams() {
    var parsed = (0, _queryParse2.default)(window.location.search);
    if (parsed.horizon_auth != null) {
      this.set(parsed.horizon_auth);
    }
  };

  // Handshake types are implemented here


  TokenStorage.prototype.handshake = function handshake() {
    // If we have a token, we should send it rather than requesting a
    // new one
    var token = this.get();
    if (token != null) {
      return { method: 'token', token: token };
    } else if (this._authType === 'token') {
      throw new Error('Attempting to authenticate with a token, but no token is present');
    } else {
      return { method: this._authType };
    }
  };

  // Whether there is an auth token for the provided authType


  TokenStorage.prototype.hasAuthToken = function hasAuthToken() {
    return Boolean(this.get());
  };

  return TokenStorage;
}();

function clearAuthTokens() {
  return getStorage().removeItem(HORIZON_JWT);
}
//# sourceMappingURL=auth.js.map