blockstack-auth/lib/authAgent.js

Blockstack Auth Library

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.AuthAgent = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _queryString = require('query-string');

var _queryString2 = _interopRequireDefault(_queryString);

var _base64url = require('base64url');

var _base64url2 = _interopRequireDefault(_base64url);

var _request = require('request');

var _request2 = _interopRequireDefault(_request);

var _jsontokens = require('jsontokens');

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var AuthAgent = exports.AuthAgent = function () {
  function AuthAgent(identityProviderURL, nameResolverURL) {
    var currentHostURL = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : window.location.origin;

    _classCallCheck(this, AuthAgent);

    this.storageLabel = 'blockstack';
    this.identityProviderURL = identityProviderURL;
    this.nameResolverURL = nameResolverURL;
    this.currentHost = currentHostURL;
  }

  _createClass(AuthAgent, [{
    key: 'isUserLoggedIn',
    value: function isUserLoggedIn() {
      return window.localStorage.getItem(this.storageLabel) ? true : false;
    }
  }, {
    key: 'requestLogin',
    value: function requestLogin() {
      var payload = {
        appURI: this.currentHost,
        issuedAt: new Date().getTime()
      };
      var authRequest = _base64url2.default.encode(JSON.stringify(payload));

      setTimeout(function () {
        window.location = this.identityProviderURL + "?authRequest=" + authRequest;
      }, 200);

      window.location = "web+blockstack:" + authRequest;
    }
  }, {
    key: 'getAuthResponseToken',
    value: function getAuthResponseToken() {
      var queryDict = _queryString2.default.parse(location.search);
      return queryDict.authResponse;
    }
  }, {
    key: 'isLoginPending',
    value: function isLoginPending() {
      return this.getAuthResponseToken() ? true : false;
    }
  }, {
    key: 'completeLogin',
    value: function completeLogin(callbackFunction) {
      var _this = this;

      var authResponseToken = this.getAuthResponseToken();
      var username = AuthAgent.getUsernameFromToken(authResponseToken);
      var requestURL = this.nameResolverURL + username;
      (0, _request2.default)(requestURL, function (error, response, body) {
        if (!error && response.statusCode == 200) {
          var profile = JSON.parse(body)[username].profile;
          var session = {
            username: username,
            profile: profile,
            authResponseToken: authResponseToken
          };
          window.localStorage.setItem(_this.storageLabel, JSON.stringify(session));
          callbackFunction(session);
        }
      });
    }
  }, {
    key: 'loadSession',
    value: function loadSession(callbackFunction) {
      var session = JSON.parse(localStorage.getItem(this.storageLabel));
      callbackFunction(session);
    }
  }, {
    key: 'logout',
    value: function logout() {
      window.localStorage.removeItem(this.storageLabel);
      window.location = this.currentHost;
    }
  }], [{
    key: 'getUsernameFromToken',
    value: function getUsernameFromToken(authResponseToken) {
      var decodedToken = (0, _jsontokens.decodeToken)(authResponseToken);
      var decodedBlockstackID = decodedToken.payload.issuer.username;
      return decodedBlockstackID.split('.')[0];
    }
  }]);

  return AuthAgent;
}();