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

package/components/auth/token-validator.js

@@ -0,0 +1,267 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass, 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.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import ExtendableError from 'es6-error';
+import { CODE } from '../http/http.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.promise.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.reflect.delete-property.js';
+import '../global/url.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.string.replace.js';
+
+var TokenValidationError = /*#__PURE__*/function (_ExtendableError) {
+  _inherits(TokenValidationError, _ExtendableError);
+  var _super = _createSuper(TokenValidationError);
+  function TokenValidationError(message, cause) {
+    var _this;
+    _classCallCheck(this, TokenValidationError);
+    _this = _super.call(this, message);
+    _defineProperty(_assertThisInitialized(_this), "cause", void 0);
+    _defineProperty(_assertThisInitialized(_this), "authRedirect", void 0);
+    _this.cause = cause;
+    _this.authRedirect = true;
+    return _this;
+  }
+  return _createClass(TokenValidationError);
+}(ExtendableError);
+var TokenValidator = /*#__PURE__*/function () {
+  function TokenValidator(config, getUser, storage) {
+    _classCallCheck(this, TokenValidator);
+    _defineProperty(this, "_getUser", void 0);
+    _defineProperty(this, "_config", void 0);
+    _defineProperty(this, "_storage", void 0);
+    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
+   */
+  _createClass(TokenValidator, [{
+    key: "validateTokenLocally",
+    value:
+    /**
+     * Check token validity against all conditions.
+     * @returns {Promise.<string>}
+     */
+    function validateTokenLocally() {
+      return this._getValidatedToken([TokenValidator._validateExistence, TokenValidator._validateExpiration, this._validateScopes.bind(this)]);
+    }
+    /**
+     * Check token validity against all conditions.
+     * @returns {Promise.<string>}
+     */
+  }, {
+    key: "validateToken",
+    value: function 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
+     */
+  }, {
+    key: "_validateScopes",
+    value:
+    /**
+     * Check scopes
+     * @param {StoredToken} storedToken
+     * @return {Promise.<StoredToken>}
+     * @private
+     */
+    function _validateScopes(storedToken) {
+      var _this$_config = this._config,
+        scope = _this$_config.scope,
+        optionalScopes = _this$_config.optionalScopes;
+      var requiredScopes = optionalScopes ? scope.filter(function (scopeId) {
+        return !optionalScopes.includes(scopeId);
+      }) : scope;
+      var hasAllScopes = requiredScopes.every(function (scopeId) {
+        var _storedToken$scopes;
+        return (_storedToken$scopes = storedToken.scopes) === null || _storedToken$scopes === void 0 ? void 0 : _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}
+     */
+  }, {
+    key: "_validateAgainstUser",
+    value:
+    /**
+     * Check scopes
+     * @param {StoredToken} storedToken
+     * @return {Promise.<StoredToken>}
+     * @private
+     */
+    function () {
+      var _validateAgainstUser2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(storedToken) {
+        var response, _errorResponse$data, _errorResponse$data2;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              _context.next = 3;
+              return this._getUser(storedToken.accessToken);
+            case 3:
+              return _context.abrupt("return", _context.sent);
+            case 6:
+              _context.prev = 6;
+              _context.t0 = _context["catch"](0);
+              response = {};
+              _context.prev = 9;
+              _context.next = 12;
+              return _context.t0.response.json();
+            case 12:
+              response = _context.sent;
+              _context.next = 17;
+              break;
+            case 15:
+              _context.prev = 15;
+              _context.t1 = _context["catch"](9);
+            case 17:
+              if (!(_context.t0.status === CODE.UNAUTHORIZED || TokenValidator.shouldRefreshToken(response.error))) {
+                _context.next = 19;
+                break;
+              }
+              throw new TokenValidator.TokenValidationError(response.error || _context.t0.message, (_errorResponse$data = _context.t0.data) !== null && _errorResponse$data !== void 0 && _errorResponse$data.error ? new Error((_errorResponse$data2 = _context.t0.data) === null || _errorResponse$data2 === void 0 ? void 0 : _errorResponse$data2.error) : undefined);
+            case 19:
+              throw _context.t0;
+            case 20:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[0, 6], [9, 15]]);
+      }));
+      function _validateAgainstUser(_x) {
+        return _validateAgainstUser2.apply(this, arguments);
+      }
+      return _validateAgainstUser;
+    }()
+    /**
+     * 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
+     */
+  }, {
+    key: "_getValidatedToken",
+    value: function () {
+      var _getValidatedToken2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(validators) {
+        var storedToken, i;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return this._storage.getToken();
+            case 2:
+              storedToken = _context2.sent;
+              if (!(storedToken == null)) {
+                _context2.next = 5;
+                break;
+              }
+              throw new TokenValidator.TokenValidationError('Token not found');
+            case 5:
+              i = 0;
+            case 6:
+              if (!(i < validators.length)) {
+                _context2.next = 12;
+                break;
+              }
+              _context2.next = 9;
+              return validators[i](storedToken);
+            case 9:
+              i++;
+              _context2.next = 6;
+              break;
+            case 12:
+              return _context2.abrupt("return", storedToken.accessToken);
+            case 13:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function _getValidatedToken(_x2) {
+        return _getValidatedToken2.apply(this, arguments);
+      }
+      return _getValidatedToken;
+    }()
+  }], [{
+    key: "_epoch",
+    value: function _epoch() {
+      var milliseconds = 1000.0;
+      return Math.round(Date.now() / milliseconds);
+    }
+    /**
+     * @const {number}
+     */
+    // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+  }, {
+    key: "_validateExistence",
+    value: function _validateExistence(storedToken) {
+      if (!storedToken || !storedToken.accessToken) {
+        throw new TokenValidator.TokenValidationError('Token not found');
+      }
+    }
+    /**
+     * Check expiration
+     * @param {StoredToken} storedToken
+     * @return {Promise.<StoredToken>}
+     * @private
+     */
+  }, {
+    key: "_validateExpiration",
+    value: function _validateExpiration(_ref) {
+      var expires = _ref.expires,
+        lifeTime = _ref.lifeTime;
+      var REFRESH_BEFORE_RATIO = 6;
+      var refreshBefore = lifeTime ? Math.ceil(lifeTime / REFRESH_BEFORE_RATIO) : TokenValidator.DEFAULT_REFRESH_BEFORE;
+      if (expires && expires < TokenValidator._epoch() + refreshBefore) {
+        throw new TokenValidator.TokenValidationError('Token expired');
+      }
+    }
+  }, {
+    key: "shouldRefreshToken",
+    value: function shouldRefreshToken(error) {
+      return error === 'invalid_grant' || error === 'invalid_request' || error === 'invalid_token';
+    }
+  }]);
+  return TokenValidator;
+}();
+_defineProperty(TokenValidator, "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
+ */
+_defineProperty(TokenValidator, "TokenValidationError", TokenValidationError);
+
+export { TokenValidationError, TokenValidator as default };

package/components/auth/window-flow.d.ts

@@ -0,0 +1,26 @@
+import { LoginFlow } from './auth__core';
+import AuthRequestBuilder from './request-builder';
+import AuthStorage from './storage';
+export default class WindowFlow implements LoginFlow {
+    private _timeoutId;
+    private _requestBuilder;
+    private _storage;
+    reject?: (reason: unknown) => void;
+    private _loginWindow?;
+    private _promise?;
+    constructor(requestBuilder: AuthRequestBuilder, storage: AuthStorage);
+    /**
+     * Opens window with the given URL
+     * @param {string} url
+     * @private
+     */
+    private _openWindow;
+    /**
+     * Initiates authorization in window
+     */
+    private _load;
+    checkIsClosed: () => void;
+    _reset: () => void;
+    stop(): void;
+    authorize(): Promise<string>;
+}

package/components/auth/window-flow.js

@@ -0,0 +1,153 @@
+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.concat.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.promise.js';
+import AuthResponseParser from './response-parser.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'es6-error';
+import '../global/url.js';
+import 'core-js/modules/es.string.match.js';
+
+var NAVBAR_HEIGHT = 50;
+var CLOSED_CHECK_INTERVAL = 200;
+var WindowFlow = /*#__PURE__*/function () {
+  function WindowFlow(requestBuilder, storage) {
+    var _this = this;
+    _classCallCheck(this, WindowFlow);
+    _defineProperty(this, "_timeoutId", undefined);
+    _defineProperty(this, "_requestBuilder", void 0);
+    _defineProperty(this, "_storage", void 0);
+    _defineProperty(this, "reject", void 0);
+    _defineProperty(this, "_loginWindow", void 0);
+    _defineProperty(this, "_promise", void 0);
+    _defineProperty(this, "checkIsClosed", function () {
+      var _this$_loginWindow;
+      if ((_this$_loginWindow = _this._loginWindow) !== null && _this$_loginWindow !== void 0 && _this$_loginWindow.closed) {
+        _this.stop();
+        return;
+      }
+      _this._timeoutId = window.setTimeout(_this.checkIsClosed, CLOSED_CHECK_INTERVAL);
+    });
+    _defineProperty(this, "_reset", function () {
+      _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
+   */
+  _createClass(WindowFlow, [{
+    key: "_openWindow",
+    value: function _openWindow(url) {
+      var height = 700;
+      var width = 750;
+      var screenHalves = 2;
+      var top = (window.screen.height - height - NAVBAR_HEIGHT) / screenHalves;
+      var left = (window.screen.width - width) / screenHalves;
+      return window.open(url, 'HubLoginWindow', "height=".concat(height, ", width=").concat(width, ", left=").concat(left, ", top=").concat(top));
+    }
+    /**
+     * Initiates authorization in window
+     */
+  }, {
+    key: "_load",
+    value: function () {
+      var _load2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var _this2 = this;
+        var authRequest;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return this._requestBuilder.prepareAuthRequest(
+              // eslint-disable-next-line camelcase
+              {
+                request_credentials: 'required',
+                auth_mode: 'bypass_to_login'
+              }, {
+                nonRedirect: true
+              });
+            case 2:
+              authRequest = _context.sent;
+              return _context.abrupt("return", new Promise(function (resolve, reject) {
+                _this2.reject = reject;
+                var cleanRun;
+                var cleanUp = function cleanUp() {
+                  var _this2$_loginWindow;
+                  if (cleanRun) {
+                    return;
+                  }
+                  cleanRun = true;
+                  /* eslint-disable @typescript-eslint/no-use-before-define */
+                  removeStateListener();
+                  removeTokenListener();
+                  /* eslint-enable @typescript-eslint/no-use-before-define */
+                  (_this2$_loginWindow = _this2._loginWindow) === null || _this2$_loginWindow === void 0 ? void 0 : _this2$_loginWindow.close();
+                  clearTimeout(_this2._timeoutId);
+                };
+                var removeTokenListener = _this2._storage.onTokenChange(function (token) {
+                  if (token) {
+                    cleanUp();
+                    resolve(token.accessToken);
+                  }
+                });
+                var removeStateListener = _this2._storage.onStateChange(authRequest.stateId, function (state) {
+                  if (state && state.error) {
+                    cleanUp();
+                    reject(new AuthResponseParser.AuthError(state));
+                  }
+                });
+                if (_this2._loginWindow == null || _this2._loginWindow.closed) {
+                  _this2._loginWindow = _this2._openWindow(authRequest.url);
+                } else {
+                  _this2._loginWindow.location.href = authRequest.url;
+                }
+                _this2.checkIsClosed();
+              }));
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function _load() {
+        return _load2.apply(this, arguments);
+      }
+      return _load;
+    }()
+  }, {
+    key: "stop",
+    value: function stop() {
+      if (this._loginWindow != null) {
+        this._loginWindow.close();
+      }
+      if (this.reject) {
+        this.reject('Authorization window closed');
+      }
+      this._reset();
+    }
+  }, {
+    key: "authorize",
+    value: function authorize() {
+      if (this._promise != null && this._loginWindow != null && !this._loginWindow.closed) {
+        this._loginWindow.focus();
+        return this._promise;
+      }
+      this._promise = this._load();
+      this._promise.then(this._reset, this._reset);
+      return this._promise;
+    }
+  }]);
+  return WindowFlow;
+}();
+
+export { WindowFlow as default };

package/components/auth-dialog/auth-dialog.d.ts

@@ -0,0 +1,60 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+/**
+ * @name Auth Dialog
+ */
+export interface AuthDialogProps {
+    className?: string | undefined;
+    title?: string | null | undefined;
+    errorMessage?: string | null | undefined;
+    serviceImage?: string | null | undefined;
+    serviceName?: string | null | undefined;
+    loginCaption: string;
+    loginToCaption: string;
+    show: boolean;
+    cancelOnEsc: boolean;
+    confirmLabel: string;
+    cancelLabel: string;
+    tryAgainLabel: string;
+    onConfirm: () => void;
+    onCancel: () => void;
+    onTryAgain?: () => void;
+}
+export default class AuthDialog extends Component<AuthDialogProps> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        title: PropTypes.Requireable<string>;
+        errorMessage: PropTypes.Requireable<string>;
+        serviceImage: PropTypes.Requireable<string>;
+        serviceName: PropTypes.Requireable<string>;
+        loginCaption: PropTypes.Requireable<string>;
+        loginToCaption: PropTypes.Requireable<string>;
+        show: PropTypes.Requireable<boolean>;
+        cancelOnEsc: PropTypes.Requireable<boolean>;
+        confirmLabel: PropTypes.Requireable<string>;
+        cancelLabel: PropTypes.Requireable<string>;
+        tryAgainLabel: PropTypes.Requireable<string>;
+        onConfirm: PropTypes.Requireable<(...args: any[]) => any>;
+        onCancel: PropTypes.Requireable<(...args: any[]) => any>;
+        onTryAgain: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        loginCaption: string;
+        loginToCaption: string;
+        tryAgainLabel: string;
+        show: boolean;
+        cancelOnEsc: boolean;
+        confirmLabel: string;
+        cancelLabel: string;
+        onConfirm: () => void;
+        onCancel: () => void;
+    };
+    state: {
+        retrying: boolean;
+    };
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    onEscPress: () => void;
+    onRetryPress: () => Promise<void>;
+    render(): React.JSX.Element;
+}