@jetbrains/ring-ui 4.1.12 → 5.0.0-beta.11

package/components/auth/storage.js

@@ -1,239 +1,224 @@
 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
+// eslint-disable-next-line @typescript-eslint/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;
-      }
+    messagePrefix;
+    stateKeyPrefix;
+    tokenKey;
+    userKey;
+    stateTTL;
+    stateQuota;
+    _lastMessage;
+    _stateStorage;
+    _tokenStorage;
+    _messagesStorage;
+    _currentUserStorage;
+    /**
+     * 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'
+        });
     }
-    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);
+    /**
+     * 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);
         }
-
-        // 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 => {
+        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, 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) {
+                // Clean old states
+                const state = value;
+                const created = 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;
+        });
+        const currentStates = removalResult.filter((state) => state != null);
+        let stateStorageSize = currentStates.
+            reduce((overallSize, state) => state.size + overallSize, 0);
         if (stateStorageSize > this.stateQuota) {
-          stateStorageSize -= state.size;
-          return true;
+            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();
         }
-
-        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;
+    /**
+     * Remove cached user if any
+     */
+    wipeCachedCurrentUser() {
+        return this._currentUserStorage.remove(this.userKey);
     }
-  }
-
-  /**
-   * @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();
+    /**
+     * Wipes cache if user has changed
+     */
+    onUserChanged() {
+        this.wipeCachedCurrentUser();
     }
-  }
-
-  /**
-   * Remove cached user if any
-   */
-  wipeCachedCurrentUser() {
-    return this._currentUserStorage.remove(this.userKey);
-  }
-
-  /**
-   * Wipes cache if user has changed
-   */
-  onUserChanged() {
-    this.wipeCachedCurrentUser();
-  }
 }
-

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>;
+}