@jetbrains/ring-ui 6.0.6-beta.0 → 6.0.6

package/components/auth/storage.d.ts

@@ -0,0 +1,112 @@
+import { StorageClass, StorageInterface } from '../storage/storage';
+import { AuthUser } from './auth__core';
+import { AuthResponse } from './response-parser';
+export interface StoredToken {
+    accessToken: string;
+    scopes?: string[];
+    expires?: number;
+    lifeTime?: number;
+    waitForRedirectTimeout?: number;
+}
+export interface AuthState extends AuthResponse {
+    restoreLocation?: string;
+    scopes?: string[];
+    nonRedirect?: boolean | null | undefined;
+    created?: number;
+}
+export interface AuthStorageConfig {
+    stateKeyPrefix?: string | null | undefined;
+    tokenKey?: string | null | undefined;
+    messagePrefix?: string | null | undefined;
+    userKey?: string | null | undefined;
+    stateTTL?: number | null | undefined;
+    storage?: StorageClass | null | undefined;
+    stateQuota?: number | null | undefined;
+}
+export default class AuthStorage<M = unknown> {
+    messagePrefix: string;
+    stateKeyPrefix: string;
+    tokenKey: string;
+    userKey: string;
+    stateTTL: number;
+    stateQuota: number;
+    private _lastMessage;
+    _stateStorage: StorageInterface;
+    _tokenStorage: StorageInterface;
+    _messagesStorage: StorageInterface;
+    private _currentUserStorage;
+    /**
+     * Custom storage for Auth
+     * @param {{stateKeyPrefix: string, tokenKey: string, onTokenRemove: Function}} config
+     */
+    constructor(config: AuthStorageConfig);
+    /**
+     * Add token change listener
+     * @param {function(string)} fn Token change listener
+     * @return {function()} remove listener function
+     */
+    onTokenChange(fn: (token: StoredToken | null) => void): () => void;
+    /**
+     * Add state change listener
+     * @param {string} stateKey State key
+     * @param {function(string)} fn State change listener
+     * @return {function()} remove listener function
+     */
+    onStateChange(stateKey: string, fn: (state: AuthState | null) => void): () => void;
+    /**
+     * Add state change listener
+     * @param {string} key State key
+     * @param {function(string)} fn State change listener
+     * @return {function()} remove listener function
+     */
+    onMessage(key: string, fn: (message: M | null) => void): () => void;
+    sendMessage(key: string, message?: M | null): void;
+    /**
+     * 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
+     */
+    saveState(id: string, state: AuthState, dontCleanAndRetryOnFail?: boolean): Promise<void>;
+    /**
+     * Remove all stored states
+     *
+     * @return {Promise} promise that is resolved when OLD states [and some selected] are removed
+     */
+    cleanStates(removeStateId?: string): Promise<0 | void[] | undefined>;
+    /**
+     * Get state by id and remove stored states from the storage.
+     *
+     * @param {string} id unique state identifier
+     * @return {Promise.<StoredState>}
+     */
+    getState(id: string): Promise<AuthState | null>;
+    /**
+     * @param {StoredToken} token
+     * @return {Promise} promise that is resolved when the token is saved
+     */
+    saveToken(token: StoredToken): Promise<StoredToken | null>;
+    /**
+     * @return {Promise.<StoredToken>} promise that is resolved to the stored token
+     */
+    getToken(): Promise<StoredToken | null>;
+    /**
+     * Remove stored token if any.
+     * @return {Promise} promise that is resolved when the token is wiped.
+     */
+    wipeToken(): Promise<void>;
+    /**
+     * @param {function} loadUser user loader
+     * @return {Promise.<object>>} promise that is resolved to stored current user
+     */
+    getCachedUser(loadUser: () => Promise<AuthUser | null>): Promise<AuthUser | null>;
+    /**
+     * Remove cached user if any
+     */
+    wipeCachedCurrentUser(): Promise<void>;
+    /**
+     * Wipes cache if user has changed
+     */
+    onUserChanged(): void;
+}

package/components/auth/storage.js

@@ -0,0 +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 @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 {
+    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'
+        });
+    }
+    /**
+     * 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, 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) {
+            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/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>;
+}

package/components/auth/token-validator.js

@@ -0,0 +1,169 @@
+import ExtendableError from 'es6-error';
+import { CODE } from '../http/http';
+export class TokenValidationError extends ExtendableError {
+    cause;
+    authRedirect;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.authRedirect = true;
+    }
+}
+export default class TokenValidator {
+    _getUser;
+    _config;
+    _storage;
+    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 @typescript-eslint/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 = TokenValidationError;
+    /**
+     * 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);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        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, errorResponse.data?.error ? new Error(errorResponse.data?.error) : undefined);
+            }
+            // 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();
+        if (storedToken == null) {
+            throw new TokenValidator.TokenValidationError('Token not found');
+        }
+        for (let i = 0; i < validators.length; i++) {
+            await validators[i](storedToken);
+        }
+        return storedToken.accessToken;
+    }
+}

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