react-jwt-store/lib/index.js

React JWT store

'use strict';

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

var _xtend = require('xtend');

var _xtend2 = _interopRequireDefault(_xtend);

var _cookieMonster = require('cookie-monster');

var _cookieMonster2 = _interopRequireDefault(_cookieMonster);

var _jwtDecode = require('jwt-decode');

var _jwtDecode2 = _interopRequireDefault(_jwtDecode);

var _events = require('events');

var _events2 = _interopRequireDefault(_events);

var _localStorage = require('local-storage');

var _localStorage2 = _interopRequireDefault(_localStorage);

var EventEmitter = _events2['default'].EventEmitter;
var noop = function noop() {};

module.exports = function (options) {
  var user = undefined;
  var token = undefined;

  options = (0, _xtend2['default'])({ cookie: 'XSRF-TOKEN' }, options);

  var logger = options.logger || {
    info: noop,
    warn: noop
  };

  var decodeToken = function decodeToken(token) {
    if (token) {
      try {
        return (0, _jwtDecode2['default'])(token);
      } catch (e) {
        logger.warn('[JWT store] Invalid JWT: ' + token);
        return void 0;
      }
    }
  };

  if (options.localStorageKey) {
    try {
      token = _localStorage2['default'].get(options.localStorageKey);
    } catch (e) {
      logger.warn('[JWT store] Unable to get token', e);
    }
  } else {
    token = _cookieMonster2['default'].get && _cookieMonster2['default'].get(options.cookie);
  }
  logger.info('[JWT store] created store with token', token);

  var tokenStore = (0, _xtend2['default'])({
    getToken: function getToken() {
      return token;
    },

    getUser: function getUser() {
      return user;
    },

    getUserId: function getUserId() {
      return user ? user.id : void 0;
    },

    setToken: function setToken(newToken) {
      logger.info('[JWT store] setting new token', newToken);
      token = newToken;
      user = decodeToken(token);
      this.emit('Token received', token, user);
    },

    refreshToken: function refreshToken() {
      if (options.refresh) {
        logger.info('[JWT store] refreshing token', token);

        options.refresh(token).then(tokenStore.setToken.bind(tokenStore));
      }
    }
  }, EventEmitter.prototype);

  var refreshToken = function refreshToken() {
    if (!token && options.refresh) {
      tokenStore.refreshToken();
    } else {
      user = decodeToken(token);
    }

    var expDate = user ? new Date(user.exp * 1000 - expiryWindow) : null;
    if (expDate && expDate < new Date() && options.refresh) {
      tokenStore.refreshToken();
    }
  };

  var refreshInterval = options.refreshInterval ? options.refreshInterval : 60 * 1000; // default to checking every minute

  var expiryWindow = options.expiryWindow ? options.expiryWindow : 2 * refreshInterval; // default to refreshing if we're two refreshInterval's away from expiration

  if (options.listeners) {
    Object.keys(options.listeners).forEach(function (key) {
      tokenStore.on(key, options.listeners[key]);
    });
  }

  if (options.refresh) {
    refreshToken();
    setInterval(refreshToken, refreshInterval);
  }

  if (token) {
    tokenStore.setToken(token);
  }

  return tokenStore;
};