@jetbrains/ring-ui-built 6.0.5-beta.0

package/components/auth/storage.js

@@ -0,0 +1,422 @@
+import { d as _createClass, c as _classCallCheck, _ as _defineProperty, h as _asyncToGenerator, i as _regeneratorRuntime } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.array.sort.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.promise.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import ActualStorage from '../storage/storage.js';
+import '../storage/storage__local.js';
+import '../alert-service/alert-service.js';
+import 'core-js/modules/es.array.concat.js';
+import 'react';
+import 'react-dom/client';
+import '../global/get-uid.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import '../alert/alert.js';
+import 'core-js/modules/es.object.values.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__svg.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.string.starts-with.js';
+import '../global/memoize.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/es.weak-map.js';
+import '../loader-inline/loader-inline.js';
+import '../global/data-tests.js';
+import 'core-js/modules/es.object.entries.js';
+import '../global/dom.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.set.js';
+import '../button/button.js';
+import '@jetbrains/icons/chevron-10px';
+import '../link/clickableLink.js';
+import '../global/controls-height.js';
+import '../_helpers/button__classes.js';
+import '../_helpers/theme.js';
+import 'react-dom';
+import '../popup/popup.target.js';
+import '../popup/popup.js';
+import '../global/schedule-raf.js';
+import '../shortcuts/shortcuts.js';
+import '../shortcuts/core.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.splice.js';
+import 'core-js/modules/es.string.match.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+import '../tab-trap/tab-trap.js';
+import '../popup/position.js';
+import '../popup/popup.consts.js';
+import '../alert/container.js';
+import '../storage/storage__fallback.js';
+import 'core-js/modules/es.reflect.delete-property.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
+ */
+var DEFAULT_STATE_QUOTA = 102400; // 100 kb ~~ 200 tabs with a large list of scopes
+// eslint-disable-next-line @typescript-eslint/no-magic-numbers
+var DEFAULT_STATE_TTL = 1000 * 60 * 60 * 24; // nobody will need auth state after a day
+var UPDATE_USER_TIMEOUT = 1000;
+var AuthStorage = /*#__PURE__*/function () {
+  /**
+   * Custom storage for Auth
+   * @param {{stateKeyPrefix: string, tokenKey: string, onTokenRemove: Function}} config
+   */
+  function AuthStorage(config) {
+    _classCallCheck(this, AuthStorage);
+    _defineProperty(this, "messagePrefix", void 0);
+    _defineProperty(this, "stateKeyPrefix", void 0);
+    _defineProperty(this, "tokenKey", void 0);
+    _defineProperty(this, "userKey", void 0);
+    _defineProperty(this, "stateTTL", void 0);
+    _defineProperty(this, "stateQuota", void 0);
+    _defineProperty(this, "_lastMessage", void 0);
+    _defineProperty(this, "_stateStorage", void 0);
+    _defineProperty(this, "_tokenStorage", void 0);
+    _defineProperty(this, "_messagesStorage", void 0);
+    _defineProperty(this, "_currentUserStorage", void 0);
+    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;
+    var 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
+   */
+  _createClass(AuthStorage, [{
+    key: "onTokenChange",
+    value: 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
+     */
+  }, {
+    key: "onStateChange",
+    value: 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
+     */
+  }, {
+    key: "onMessage",
+    value: function onMessage(key, fn) {
+      return this._messagesStorage.on(this.messagePrefix + key, function (message) {
+        return fn(message);
+      });
+    }
+  }, {
+    key: "sendMessage",
+    value: function sendMessage(key) {
+      var 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
+     */
+  }, {
+    key: "saveState",
+    value: function () {
+      var _saveState = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(id, state, dontCleanAndRetryOnFail) {
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              state.created = Date.now();
+              _context.prev = 1;
+              _context.next = 4;
+              return this._stateStorage.set(this.stateKeyPrefix + id, state);
+            case 4:
+              _context.next = 15;
+              break;
+            case 6:
+              _context.prev = 6;
+              _context.t0 = _context["catch"](1);
+              if (dontCleanAndRetryOnFail) {
+                _context.next = 14;
+                break;
+              }
+              _context.next = 11;
+              return this.cleanStates();
+            case 11:
+              return _context.abrupt("return", this.saveState(id, state, true));
+            case 14:
+              throw _context.t0;
+            case 15:
+              return _context.abrupt("return", undefined);
+            case 16:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[1, 6]]);
+      }));
+      function saveState(_x, _x2, _x3) {
+        return _saveState.apply(this, arguments);
+      }
+      return saveState;
+    }()
+    /**
+     * Remove all stored states
+     *
+     * @return {Promise} promise that is resolved when OLD states [and some selected] are removed
+     */
+  }, {
+    key: "cleanStates",
+    value: function () {
+      var _cleanStates = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(removeStateId) {
+        var _this = this;
+        var now, removalResult, currentStates, stateStorageSize, removalPromises;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              now = Date.now();
+              _context2.next = 3;
+              return this._stateStorage.each(function (key, value) {
+                if (value == null) {
+                  return undefined;
+                }
+                // Remove requested state
+                if (key === _this.stateKeyPrefix + removeStateId) {
+                  return _this._stateStorage.remove(key);
+                }
+                if (key.indexOf(_this.stateKeyPrefix) === 0) {
+                  var _state$created;
+                  // Clean old states
+                  var state = value;
+                  var created = (_state$created = state.created) !== null && _state$created !== void 0 ? _state$created : Date.now();
+                  if (created + _this.stateTTL < now) {
+                    return _this._stateStorage.remove(key);
+                  }
+                  // Data to clean up due quota
+                  return {
+                    key,
+                    created,
+                    size: JSON.stringify(state).length
+                  };
+                }
+                return undefined;
+              });
+            case 3:
+              removalResult = _context2.sent;
+              currentStates = removalResult.filter(function (state) {
+                return state != null;
+              });
+              stateStorageSize = currentStates.reduce(function (overallSize, state) {
+                return state.size + overallSize;
+              }, 0);
+              if (!(stateStorageSize > this.stateQuota)) {
+                _context2.next = 10;
+                break;
+              }
+              currentStates.sort(function (a, b) {
+                return a.created - b.created;
+              });
+              removalPromises = currentStates.filter(function (state) {
+                if (stateStorageSize > _this.stateQuota) {
+                  stateStorageSize -= state.size;
+                  return true;
+                }
+                return false;
+              }).map(function (state) {
+                return _this._stateStorage.remove(state.key);
+              });
+              return _context2.abrupt("return", removalPromises.length && Promise.all(removalPromises));
+            case 10:
+              return _context2.abrupt("return", undefined);
+            case 11:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function cleanStates(_x4) {
+        return _cleanStates.apply(this, arguments);
+      }
+      return cleanStates;
+    }()
+    /**
+     * Get state by id and remove stored states from the storage.
+     *
+     * @param {string} id unique state identifier
+     * @return {Promise.<StoredState>}
+     */
+  }, {
+    key: "getState",
+    value: function () {
+      var _getState = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(id) {
+        var result;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.prev = 0;
+              _context3.next = 3;
+              return this._stateStorage.get(this.stateKeyPrefix + id);
+            case 3:
+              result = _context3.sent;
+              _context3.next = 6;
+              return this.cleanStates(id);
+            case 6:
+              return _context3.abrupt("return", result);
+            case 9:
+              _context3.prev = 9;
+              _context3.t0 = _context3["catch"](0);
+              _context3.next = 13;
+              return this.cleanStates(id);
+            case 13:
+              throw _context3.t0;
+            case 14:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[0, 9]]);
+      }));
+      function getState(_x5) {
+        return _getState.apply(this, arguments);
+      }
+      return getState;
+    }()
+    /**
+     * @param {StoredToken} token
+     * @return {Promise} promise that is resolved when the token is saved
+     */
+  }, {
+    key: "saveToken",
+    value: function saveToken(token) {
+      return this._tokenStorage.set(this.tokenKey, token);
+    }
+    /**
+     * @return {Promise.<StoredToken>} promise that is resolved to the stored token
+     */
+  }, {
+    key: "getToken",
+    value: function getToken() {
+      return this._tokenStorage.get(this.tokenKey);
+    }
+    /**
+     * Remove stored token if any.
+     * @return {Promise} promise that is resolved when the token is wiped.
+     */
+  }, {
+    key: "wipeToken",
+    value: function wipeToken() {
+      return this._tokenStorage.remove(this.tokenKey);
+    }
+    /**
+     * @param {function} loadUser user loader
+     * @return {Promise.<object>>} promise that is resolved to stored current user
+     */
+  }, {
+    key: "getCachedUser",
+    value: function () {
+      var _getCachedUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(loadUser) {
+        var _this2 = this;
+        var user, loadAndCache;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return this._currentUserStorage.get(this.userKey);
+            case 2:
+              user = _context4.sent;
+              loadAndCache = function loadAndCache() {
+                return loadUser().then(function (response) {
+                  _this2._currentUserStorage.set(_this2.userKey, response);
+                  return response;
+                });
+              };
+              if (!(user && user.id)) {
+                _context4.next = 9;
+                break;
+              }
+              setTimeout(loadAndCache, UPDATE_USER_TIMEOUT);
+              return _context4.abrupt("return", user);
+            case 9:
+              return _context4.abrupt("return", loadAndCache());
+            case 10:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function getCachedUser(_x6) {
+        return _getCachedUser.apply(this, arguments);
+      }
+      return getCachedUser;
+    }()
+    /**
+     * Remove cached user if any
+     */
+  }, {
+    key: "wipeCachedCurrentUser",
+    value: function wipeCachedCurrentUser() {
+      return this._currentUserStorage.remove(this.userKey);
+    }
+    /**
+     * Wipes cache if user has changed
+     */
+  }, {
+    key: "onUserChanged",
+    value: function onUserChanged() {
+      this.wipeCachedCurrentUser();
+    }
+  }]);
+  return AuthStorage;
+}();
+
+export { AuthStorage as default };

package/components/auth/token-validator.d.ts

@@ -0,0 +1,93 @@
+import ExtendableError from 'es6-error';
+import AuthStorage, { StoredToken } from './storage';
+export interface TokenValidatorConfig {
+    scope: string[];
+    optionalScopes?: readonly string[] | null | undefined;
+}
+export declare class TokenValidationError extends ExtendableError {
+    cause: Error | undefined;
+    authRedirect: true;
+    constructor(message: string, cause?: Error);
+}
+export default class TokenValidator {
+    private _getUser;
+    private _config;
+    private _storage;
+    constructor(config: TokenValidatorConfig, getUser: (accessToken: string) => Promise<void>, storage: AuthStorage);
+    /**
+     * Returns epoch - seconds since 1970.
+     * Used for calculation of expire times.
+     * @return {number} epoch, seconds since 1970
+     * @private
+     */
+    static _epoch(): number;
+    /**
+     * @const {number}
+     */
+    static DEFAULT_REFRESH_BEFORE: number;
+    /**
+     * Error class for auth token validation
+     *
+     * @param {string} message Error message
+     * @param {Error=} cause Error that caused this error
+     */
+    static TokenValidationError: typeof TokenValidationError;
+    /**
+     * Check token validity against all conditions.
+     * @returns {Promise.<string>}
+     */
+    validateTokenLocally(): Promise<string>;
+    /**
+     * Check token validity against all conditions.
+     * @returns {Promise.<string>}
+     */
+    validateToken(): Promise<string>;
+    /**
+     * Check if there is a token
+     * @param {StoredToken} storedToken
+     * @return {Promise.<StoredToken>}
+     * @private
+     */
+    private static _validateExistence;
+    /**
+     * Check expiration
+     * @param {StoredToken} storedToken
+     * @return {Promise.<StoredToken>}
+     * @private
+     */
+    private static _validateExpiration;
+    /**
+     * Check scopes
+     * @param {StoredToken} storedToken
+     * @return {Promise.<StoredToken>}
+     * @private
+     */
+    private _validateScopes;
+    /**
+     * Check by error code if token should be refreshed
+     * @param {string} error
+     * @return {boolean}
+     */
+    static shouldRefreshToken(error: string | undefined): boolean;
+    /**
+     * Check scopes
+     * @param {StoredToken} storedToken
+     * @return {Promise.<StoredToken>}
+     * @private
+     */
+    _validateAgainstUser(storedToken: StoredToken): Promise<void>;
+    /**
+     * 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
+     */
+    _getValidatedToken(validators: ((token: StoredToken) => void | Promise<void>)[]): Promise<string>;
+}