@jetbrains/ring-ui 4.1.1 → 4.1.2

package/dist/auth/storage.js

@@ -0,0 +1,280 @@
+import ActualStorage from '../storage/storage.js';
+import '../storage/storage__local.js';
+import '../alert-service/alert-service.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'react';
+import 'react-dom';
+import '../global/get-uid.js';
+import '../alert/alert.js';
+import 'classnames';
+import 'prop-types';
+import '@jetbrains/icons/exception';
+import '@jetbrains/icons/checkmark';
+import '@jetbrains/icons/warning';
+import '@jetbrains/icons/close';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon.js';
+import '../icon/icon__svg.js';
+import '../global/memoize.js';
+import '../loader-inline/loader-inline.js';
+import '../global/theme.js';
+import '../global/data-tests.js';
+import '../_helpers/inject-styles.js';
+import '../global/conic-gradient.js';
+import 'conic-gradient';
+import '../global/supports-css.js';
+import '../global/inject-styles.js';
+import '../global/radial-gradient-mask.js';
+import '../global/dom.js';
+import '../alert/container.js';
+import '../storage/storage__fallback.js';
+import 'deep-equal';
+
+/**
+ * @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;
+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 || ActualStorage;
+    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) {
+    let message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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();
+  }
+
+}
+
+export { AuthStorage as default };

package/dist/auth/token-validator.js

@@ -0,0 +1,176 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import ExtendableError from 'es6-error';
+import { CODE } from '../http/http.js';
+import '../global/url.js';
+
+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
+
+
+  /**
+   * 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(_ref) {
+    let {
+      expires,
+      lifeTime
+    } = _ref;
+    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;
+  }
+
+}
+
+_defineProperty(TokenValidator, "DEFAULT_REFRESH_BEFORE", 10 * 60);
+
+_defineProperty(TokenValidator, "TokenValidationError", class TokenValidationError extends ExtendableError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.authRedirect = true;
+  }
+
+});
+
+export { TokenValidator as default };

package/dist/auth/window-flow.js

@@ -0,0 +1,133 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import AuthResponseParser from './response-parser.js';
+import 'es6-error';
+import '../global/url.js';
+
+const NAVBAR_HEIGHT = 50;
+const CLOSED_CHECK_INTERVAL = 200;
+class WindowFlow {
+  constructor(requestBuilder, storage) {
+    _defineProperty(this, "_timeoutId", null);
+
+    _defineProperty(this, "checkIsClosed", () => {
+      if (this._loginWindow.closed) {
+        this.stop();
+        return;
+      }
+
+      this._timeoutId = setTimeout(this.checkIsClosed, CLOSED_CHECK_INTERVAL);
+    });
+
+    _defineProperty(this, "_reset", () => {
+      this._promise = null;
+      this._loginWindow = null;
+      clearTimeout(this._timeoutId);
+    });
+
+    this._requestBuilder = requestBuilder;
+    this._storage = storage;
+
+    this._reset();
+  }
+  /**
+   * Opens window with the given URL
+   * @param {string} url
+   * @private
+   */
+
+
+  _openWindow(url) {
+    const height = 700;
+    const width = 750;
+    const screenHalves = 2;
+    const top = (window.screen.height - height - NAVBAR_HEIGHT) / screenHalves;
+    const left = (window.screen.width - width) / screenHalves;
+    return window.open(url, 'HubLoginWindow', `height=${height}, width=${width}, left=${left}, top=${top}`);
+  }
+  /**
+   * Initiates authorization in window
+   */
+
+
+  async _load() {
+    const authRequest = await this._requestBuilder.prepareAuthRequest( // eslint-disable-next-line camelcase
+    {
+      request_credentials: 'required',
+      auth_mode: 'bypass_to_login'
+    }, {
+      nonRedirect: true
+    });
+    return new Promise((resolve, reject) => {
+      this.reject = reject;
+      let cleanRun;
+
+      const cleanUp = () => {
+        if (cleanRun) {
+          return;
+        }
+
+        cleanRun = true;
+        /* eslint-disable no-use-before-define */
+
+        removeStateListener();
+        removeTokenListener();
+        /* eslint-enable no-use-before-define */
+
+        this._loginWindow.close();
+
+        clearTimeout(this._timeoutId);
+      };
+
+      const removeTokenListener = this._storage.onTokenChange(token => {
+        if (token) {
+          cleanUp();
+          resolve(token.accessToken);
+        }
+      });
+
+      const removeStateListener = this._storage.onStateChange(authRequest.stateId, state => {
+        if (state && state.error) {
+          cleanUp();
+          reject(new AuthResponseParser.AuthError(state));
+        }
+      });
+
+      if (this._loginWindow === null || this._loginWindow.closed === true) {
+        this._loginWindow = this._openWindow(authRequest.url);
+      } else {
+        this._loginWindow.location = authRequest.url;
+      }
+
+      this.checkIsClosed();
+    });
+  }
+
+  stop() {
+    if (this._loginWindow !== null) {
+      this._loginWindow.close();
+    }
+
+    if (this.reject) {
+      this.reject('Authorization window closed');
+    }
+
+    this._reset();
+  }
+
+  authorize() {
+    if (this._promise !== null && this._loginWindow !== null && this._loginWindow.closed !== true) {
+      this._loginWindow.focus();
+
+      return this._promise;
+    }
+
+    this._promise = this._load();
+
+    this._promise.then(this._reset, this._reset);
+
+    return this._promise;
+  }
+
+}
+
+export { WindowFlow as default };