@jetbrains/ring-ui 5.1.21 → 5.1.23

package/components/auth/storage.d.ts

@@ -1,112 +0,0 @@
-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

@@ -1,224 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1,169 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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>;
-}