@jetbrains/ring-ui 4.1.3 → 5.0.0-beta.0

package/components/auth/storage.js

@@ -1,239 +0,0 @@
-import Storage from '../storage/storage';
-
-/**
- * @typedef {Object} StoredToken
- * @property {string} accessToken
- * @property {string[]} scopes
- * @property {number} expires
- */
-
-/**
- * @typedef {Object} StoredState
- * @property {Date} created
- * @property {string} restoreLocation
- * @property {string[]} scopes
- */
-
-const DEFAULT_STATE_QUOTA = 102400; // 100 kb ~~ 200 tabs with a large list of scopes
-// eslint-disable-next-line no-magic-numbers
-const DEFAULT_STATE_TTL = 1000 * 60 * 60 * 24; // nobody will need auth state after a day
-const UPDATE_USER_TIMEOUT = 1000;
-
-export default class AuthStorage {
-  /**
-   * Custom storage for Auth
-   * @param {{stateKeyPrefix: string, tokenKey: string, onTokenRemove: Function}} config
-   */
-  constructor(config) {
-    this.messagePrefix = config.messagePrefix || '';
-    this.stateKeyPrefix = config.stateKeyPrefix;
-    this.tokenKey = config.tokenKey;
-    this.userKey = config.userKey || 'user-key';
-    this.stateTTL = config.stateTTL || DEFAULT_STATE_TTL;
-    this._lastMessage = null;
-
-    const StorageConstructor = config.storage || Storage;
-    this.stateQuota = Math.min(
-      config.stateQuota ||
-      DEFAULT_STATE_QUOTA,
-      StorageConstructor.QUOTA || Infinity
-    );
-
-    this._stateStorage = new StorageConstructor({
-      cookieName: 'ring-state'
-    });
-    this._tokenStorage = new StorageConstructor({
-      cookieName: 'ring-token'
-    });
-    this._messagesStorage = new StorageConstructor({
-      cookieName: 'ring-message'
-    });
-    this._currentUserStorage = new StorageConstructor({
-      cookieName: 'ring-user'
-    });
-  }
-
-  /**
-   * Add token change listener
-   * @param {function(string)} fn Token change listener
-   * @return {function()} remove listener function
-   */
-  onTokenChange(fn) {
-    return this._tokenStorage.on(this.tokenKey, fn);
-  }
-
-  /**
-   * Add state change listener
-   * @param {string} stateKey State key
-   * @param {function(string)} fn State change listener
-   * @return {function()} remove listener function
-   */
-  onStateChange(stateKey, fn) {
-    return this._stateStorage.on(this.stateKeyPrefix + stateKey, fn);
-  }
-
-  /**
-   * Add state change listener
-   * @param {string} key State key
-   * @param {function(string)} fn State change listener
-   * @return {function()} remove listener function
-   */
-  onMessage(key, fn) {
-    return this._messagesStorage.on(this.messagePrefix + key, message => fn(message));
-  }
-
-  sendMessage(key, message = null) {
-    this._lastMessage = message;
-    this._messagesStorage.set(this.messagePrefix + key, message);
-  }
-
-  /**
-   * Save authentication request state.
-   *
-   * @param {string} id Unique state identifier
-   * @param {StoredState} state State to store
-   * @param {boolean=} dontCleanAndRetryOnFail If falsy then remove all stored states and try again to save state
-   */
-  async saveState(id, state, dontCleanAndRetryOnFail) {
-    state.created = Date.now();
-
-    try {
-      await this._stateStorage.set(this.stateKeyPrefix + id, state);
-    } catch (e) {
-      if (!dontCleanAndRetryOnFail) {
-        await this.cleanStates();
-        return this.saveState(id, state, true);
-      } else {
-        throw e;
-      }
-    }
-    return undefined;
-  }
-
-  /**
-   * Remove all stored states
-   *
-   * @return {Promise} promise that is resolved when OLD states [and some selected] are removed
-   */
-  async cleanStates(removeStateId) {
-    const now = Date.now();
-
-    const removalResult = await this._stateStorage.each((key, state) => {
-      // Remove requested state
-      if (key === this.stateKeyPrefix + removeStateId) {
-        return this._stateStorage.remove(key);
-      }
-
-      if (key.indexOf(this.stateKeyPrefix) === 0) {
-        // Clean old states
-        if (state.created + this.stateTTL < now) {
-          return this._stateStorage.remove(key);
-        }
-
-        // Data to clean up due quota
-        return {
-          key,
-          created: state.created,
-          size: JSON.stringify(state).length
-        };
-      }
-
-      return undefined;
-    });
-    const currentStates = removalResult.filter(state => state);
-
-    let stateStorageSize = currentStates.
-      reduce((overallSize, state) => state.size + overallSize, 0);
-
-    if (stateStorageSize > this.stateQuota) {
-      currentStates.sort((a, b) => a.created > b.created);
-
-      const removalPromises = currentStates.filter(state => {
-        if (stateStorageSize > this.stateQuota) {
-          stateStorageSize -= state.size;
-          return true;
-        }
-
-        return false;
-      }).map(state => this._stateStorage.remove(state.key));
-
-      return removalPromises.length && Promise.all(removalPromises);
-    }
-
-    return undefined;
-  }
-
-  /**
-   * Get state by id and remove stored states from the storage.
-   *
-   * @param {string} id unique state identifier
-   * @return {Promise.<StoredState>}
-   */
-  async getState(id) {
-    try {
-      const result = await this._stateStorage.get(this.stateKeyPrefix + id);
-      await this.cleanStates(id);
-      return result;
-    } catch (e) {
-      await this.cleanStates(id);
-      throw e;
-    }
-  }
-
-  /**
-   * @param {StoredToken} token
-   * @return {Promise} promise that is resolved when the token is saved
-   */
-  saveToken(token) {
-    return this._tokenStorage.set(this.tokenKey, token);
-  }
-
-  /**
-   * @return {Promise.<StoredToken>} promise that is resolved to the stored token
-   */
-  getToken() {
-    return this._tokenStorage.get(this.tokenKey);
-  }
-
-  /**
-   * Remove stored token if any.
-   * @return {Promise} promise that is resolved when the token is wiped.
-   */
-  wipeToken() {
-    return this._tokenStorage.remove(this.tokenKey);
-  }
-
-  /**
-   * @param {function} loadUser user loader
-   * @return {Promise.<object>>} promise that is resolved to stored current user
-   */
-  async getCachedUser(loadUser) {
-    const user = await this._currentUserStorage.get(this.userKey);
-    const loadAndCache = () => loadUser().then(response => {
-      this._currentUserStorage.set(this.userKey, response);
-      return response;
-    });
-
-    if (user && user.id) {
-      setTimeout(loadAndCache, UPDATE_USER_TIMEOUT);
-      return user;
-    } else {
-      return loadAndCache();
-    }
-  }
-
-  /**
-   * Remove cached user if any
-   */
-  wipeCachedCurrentUser() {
-    return this._currentUserStorage.remove(this.userKey);
-  }
-
-  /**
-   * Wipes cache if user has changed
-   */
-  onUserChanged() {
-    this.wipeCachedCurrentUser();
-  }
-}
-

package/components/auth/storage.test.js

@@ -1,178 +0,0 @@
-import AuthStorage from './storage';
-import TokenValidator from './token-validator';
-
-import MockedStorage from 'imports-loader?imports=default|storage-mock|window!../storage/storage__local';
-
-const TICK = 100;
-
-describe('Auth', () => {
-  describe('AuthStorage', () => {
-    const authStorage = new AuthStorage({
-      stateKeyPrefix: 'state',
-      tokenKey: 'token'
-    });
-    const stateId = 'unique';
-
-    afterEach(() => {
-      localStorage.clear();
-    });
-
-    describe('saveState', () => {
-      it('should be fulfilled', () => authStorage.saveState(stateId, {
-        restoreLocation: 'http://localhost:8080/hub#hash',
-        scopes: ['0-0-0-0-0']
-      }).should.be.fulfilled);
-    });
-
-    describe('getState', () => {
-      const state = {
-        restoreLocation: 'http://localhost:8080/hub#hash',
-        scopes: ['0-0-0-0-0']
-      };
-      it('should be get as it was saved', async () => {
-        await authStorage.saveState(stateId, state);
-        const newState = await authStorage.getState(stateId);
-        newState.should.deep.equal(state);
-      });
-
-      it('should be null if wasn\'t set', () => {
-        authStorage.getState(stateId).should.eventually.be.null;
-      });
-
-      it('should be null after first get', async () => {
-        await authStorage.saveState(stateId, state);
-        await authStorage.getState(stateId);
-        authStorage.getState(stateId).should.eventually.be.null;
-      });
-    });
-
-    describe('cleanStates', () => {
-      const state = {
-        restoreLocation: 'http://localhost:8080/hub#hash',
-        scopes: ['0-0-0-0-0']
-      };
-
-      it('should clean state by id', async () => {
-        await authStorage.saveState(stateId, {
-          restoreLocation: 'http://localhost:8080/hub#hash',
-          scopes: ['0-0-0-0-0']
-        });
-        await authStorage.saveState('unique2', {
-          restoreLocation: 'http://localhost:8080/hub#hash',
-          scopes: ['0-0-0-0-0', 'youtrack']
-        });
-        await authStorage.cleanStates(stateId);
-        localStorage.should.have.keys(['stateunique2']);
-      });
-
-      it('should clean state by quota', async () => {
-
-        const limitedAuthStorage = new AuthStorage({
-          stateKeyPrefix: 'state',
-          tokenKey: 'token',
-          stateQuota: 200
-        });
-
-        await limitedAuthStorage.saveState(stateId, state);
-        await limitedAuthStorage.saveState('unique2', {
-          restoreLocation: 'http://localhost:8080/hub#hash',
-          scopes: ['0-0-0-0-0', 'youtrack']
-        });
-        await limitedAuthStorage.cleanStates();
-        localStorage.should.have.keys(['stateunique2']);
-      });
-
-      it('should clean state by TTL', async () => {
-        sandbox.useFakeTimers({toFake: ['Date']});
-
-        const limitedAuthStorage = new AuthStorage({
-          stateKeyPrefix: 'state',
-          tokenKey: 'token',
-          stateTTL: 10
-        });
-
-        await limitedAuthStorage.saveState(stateId, state);
-        sandbox.clock.tick(TICK);
-        await limitedAuthStorage.cleanStates();
-        sandbox.clock.tick(TICK);
-        localStorage.should.be.empty;
-      });
-    });
-
-    const token = {
-      accessToken: 'silver-bullet',
-      scopes: ['0-0-0-0-0'],
-      // eslint-disable-next-line no-magic-numbers
-      expires: TokenValidator._epoch() + 40 * 60
-    };
-
-    describe('saveToken', () => {
-      it('should be fulfilled', () => authStorage.saveToken(token).should.be.fulfilled);
-    });
-
-    describe('getToken', () => {
-      it('should be get as it was saved', async () => {
-        await authStorage.saveToken(token);
-        authStorage.getToken().should.become(token);
-      });
-
-      it('should be null if wasn\'t saved', () => authStorage.getToken().should.eventually.be.null);
-
-      it('should be the same after several get', async () => {
-        await authStorage.saveToken(token);
-        await authStorage.getToken();
-        authStorage.getToken().should.become(token);
-      });
-
-      it('should be null after wipe', async () => {
-        await authStorage.saveToken(token);
-        await authStorage.wipeToken();
-        authStorage.getToken().should.eventually.be.null;
-      });
-    });
-
-    describe('events', () => {
-      let mockedAuthStorage;
-
-      beforeEach(() => {
-        mockedAuthStorage = new AuthStorage({
-          stateKeyPrefix: 'state',
-          tokenKey: 'loltoken',
-          storage: MockedStorage
-        });
-      });
-
-      it('onTokenChange should have been triggered', () => {
-        const clock = sandbox.useFakeTimers({toFake: ['setTimeout']});
-        const spy = sandbox.spy();
-        mockedAuthStorage.onTokenChange(spy);
-        mockedAuthStorage.saveToken(token);
-
-        clock.tick(1);
-        spy.should.have.been.calledOnce;
-      });
-
-      it('onStateChange should have been triggered', () => {
-        const clock = sandbox.useFakeTimers({toFake: ['setTimeout']});
-        const spy = sandbox.spy();
-        mockedAuthStorage.onStateChange(stateId, spy);
-        mockedAuthStorage.saveState(stateId, {});
-
-        clock.tick(1);
-        spy.should.have.been.calledOnce;
-      });
-
-      it('onMessage should have been triggered', () => {
-        const clock = sandbox.useFakeTimers({toFake: ['setTimeout']});
-        const spy = sandbox.spy();
-        mockedAuthStorage.onMessage(stateId, spy);
-        mockedAuthStorage.sendMessage(stateId, 'message');
-
-
-        clock.tick(1);
-        spy.should.have.been.calledOnce;
-        spy.should.have.been.calledWith('message');
-      });
-    });
-  });
-});

package/components/auth/token-validator.js

@@ -1,181 +0,0 @@
-import ExtendableError from 'es6-error';
-
-import {CODE} from '../http/http';
-
-export default class TokenValidator {
-  constructor(config, getUser, storage) {
-    this._getUser = getUser;
-    this._config = config;
-    this._storage = storage;
-  }
-
-  /**
-   * Returns epoch - seconds since 1970.
-   * Used for calculation of expire times.
-   * @return {number} epoch, seconds since 1970
-   * @private
-   */
-  static _epoch() {
-    const milliseconds = 1000.0;
-    return Math.round(Date.now() / milliseconds);
-  }
-
-  /**
-   * @const {number}
-   */
-  // eslint-disable-next-line no-magic-numbers
-  static DEFAULT_REFRESH_BEFORE = 10 * 60; // 20 min in s
-
-  /**
-   * Error class for auth token validation
-   *
-   * @param {string} message Error message
-   * @param {Error=} cause Error that caused this error
-   */
-  static TokenValidationError = class TokenValidationError extends ExtendableError {
-    constructor(message, cause) {
-      super(message);
-      this.cause = cause;
-      this.authRedirect = true;
-    }
-  };
-
-  /**
-   * Check token validity against all conditions.
-   * @returns {Promise.<string>}
-   */
-  validateTokenLocally() {
-    return this._getValidatedToken([
-      TokenValidator._validateExistence,
-      TokenValidator._validateExpiration,
-      this._validateScopes.bind(this)
-    ]);
-  }
-
-  /**
-   * Check token validity against all conditions.
-   * @returns {Promise.<string>}
-   */
-  validateToken() {
-    return this._getValidatedToken([
-      TokenValidator._validateExistence,
-      TokenValidator._validateExpiration,
-      this._validateScopes.bind(this),
-      this._validateAgainstUser.bind(this)
-    ]);
-  }
-
-
-  /**
-   * Check if there is a token
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-  static _validateExistence(storedToken) {
-    if (!storedToken || !storedToken.accessToken) {
-      throw new TokenValidator.TokenValidationError('Token not found');
-    }
-  }
-
-  /**
-   * Check expiration
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-  static _validateExpiration({expires, lifeTime}) {
-    const REFRESH_BEFORE_RATIO = 6;
-    const refreshBefore = lifeTime
-      ? Math.ceil(lifeTime / REFRESH_BEFORE_RATIO)
-      : TokenValidator.DEFAULT_REFRESH_BEFORE;
-
-    if (expires && expires < (TokenValidator._epoch() + refreshBefore)) {
-      throw new TokenValidator.TokenValidationError('Token expired');
-    }
-  }
-
-  /**
-   * Check scopes
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-  _validateScopes(storedToken) {
-    const {scope, optionalScopes} = this._config;
-    const requiredScopes = optionalScopes
-      ? scope.filter(scopeId => !optionalScopes.includes(scopeId))
-      : scope;
-
-    const hasAllScopes = requiredScopes.every(scopeId => storedToken.scopes.includes(scopeId));
-    if (!hasAllScopes) {
-      throw new TokenValidator.TokenValidationError('Token doesn\'t match required scopes');
-    }
-  }
-
-  /**
-   * Check by error code if token should be refreshed
-   * @param {string} error
-   * @return {boolean}
-   */
-  static shouldRefreshToken(error) {
-    return error === 'invalid_grant' ||
-      error === 'invalid_request' ||
-      error === 'invalid_token';
-  }
-
-  /**
-   * Check scopes
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-  async _validateAgainstUser(storedToken) {
-    try {
-      return await this._getUser(storedToken.accessToken);
-    } catch (errorResponse) {
-
-      let response = {};
-      try {
-        response = await errorResponse.response.json();
-      } catch (e) {
-        // Skip JSON parsing errors
-      }
-
-      if (
-        errorResponse.status === CODE.UNAUTHORIZED ||
-        TokenValidator.shouldRefreshToken(response.error)
-      ) {
-        // Token expired
-        throw new TokenValidator.TokenValidationError(response.error || errorResponse.message);
-      }
-
-      // Request unexpectedly failed
-      throw errorResponse;
-    }
-  }
-
-  /**
-   * Token Validator function
-   * @typedef {(function(StoredToken): Promise<StoredToken>)} TokenValidator
-   */
-
-  /**
-   * Gets stored token and applies provided validators
-   * @param {TokenValidator[]} validators An array of validation
-   * functions to check the stored token against.
-   * @return {Promise.<string>} promise that is resolved to access token if the stored token is valid. If it is
-   * invalid then the promise is rejected. If invalid token should be re-requested then rejection object will
-   * have {authRedirect: true}.
-   * @private
-   */
-  async _getValidatedToken(validators) {
-    const storedToken = await this._storage.getToken();
-
-    for (let i = 0; i < validators.length; i++) {
-      await validators[i](storedToken);
-    }
-
-    return storedToken.accessToken;
-  }
-}