@jetbrains/ring-ui 4.1.5 → 5.0.0-beta.2

package/components/auth/request-builder.js

@@ -1,71 +1,64 @@
 import uuid from 'simply-uuid';
-
-import {encodeURL} from '../global/url';
-
+import { encodeURL } from '../global/url';
 export default class AuthRequestBuilder {
-  /**
-   * @param {{
-   *   authorization: string,
-   *   redirectUri: string?,
-   *   requestCredentials: string?,
-   *   clientId: string?,
-   *   scopes: string[]
-   * }} config
-   * @param {AuthStorage} storage
-   */
-  constructor(config, storage) {
-    this.config = config;
-    this.storage = storage;
-  }
-
-  /**
-   * @return {string} random string used for state
-   */
-  static _uuid = uuid.generate;
-
-  /**
-   * Save state and build an auth server redirect URL.
-   *
-   * @param {object=} extraParams additional query parameters for auth request
-   * @param {object=} extraState additional state parameters to save
-   * @return {Promise.<string>} promise that is resolved to authURL
-   */
-  async prepareAuthRequest(extraParams, extraState) {
-    const stateId = AuthRequestBuilder._uuid();
-    const scopes = this.config.scopes.map(scope => encodeURIComponent(scope));
-
-    /* eslint-disable camelcase */
-    const request = Object.assign({
-      response_type: 'token',
-      state: stateId,
-      redirect_uri: this.config.redirectUri,
-      request_credentials: this.config.requestCredentials,
-      client_id: this.config.clientId,
-      scope: scopes.join(' ')
-    }, extraParams || {});
-    /* eslint-enable camelcase */
-
-    const authURL = encodeURL(this.config.authorization, request);
-
-    const state = Object.assign({
-      restoreLocation: window.location.href,
-      scopes: this.config.scopes
-    }, extraState || {});
-
-    await this._saveState(stateId, state);
-    return ({
-      url: authURL,
-      stateId
-    });
-  }
-
-  /**
-   * @param {string} id
-   * @param {StoredState} storedState
-   * @return {Promise}
-   * @private
-   */
-  _saveState(id, storedState) {
-    return this.storage.saveState(id, storedState);
-  }
+    config;
+    storage;
+    /**
+     * @param {{
+     *   authorization: string,
+     *   redirectUri: string?,
+     *   requestCredentials: string?,
+     *   clientId: string?,
+     *   scopes: string[]
+     * }} config
+     * @param {AuthStorage} storage
+     */
+    constructor(config, storage) {
+        this.config = config;
+        this.storage = storage;
+    }
+    /**
+     * @return {string} random string used for state
+     */
+    static _uuid = uuid.generate;
+    /**
+     * Save state and build an auth server redirect URL.
+     *
+     * @param {object=} extraParams additional query parameters for auth request
+     * @param {object=} extraState additional state parameters to save
+     * @return {Promise.<string>} promise that is resolved to authURL
+     */
+    async prepareAuthRequest(extraParams, extraState) {
+        const stateId = AuthRequestBuilder._uuid();
+        const scopes = this.config.scopes.map(scope => encodeURIComponent(scope));
+        /* eslint-disable camelcase */
+        const request = Object.assign({
+            response_type: 'token',
+            state: stateId,
+            redirect_uri: this.config.redirectUri,
+            request_credentials: this.config.requestCredentials,
+            client_id: this.config.clientId,
+            scope: scopes.join(' ')
+        }, extraParams || {});
+        /* eslint-enable camelcase */
+        const authURL = encodeURL(this.config.authorization, request);
+        const state = Object.assign({
+            restoreLocation: window.location.href,
+            scopes: this.config.scopes
+        }, extraState || {});
+        await this._saveState(stateId, state);
+        return ({
+            url: authURL,
+            stateId
+        });
+    }
+    /**
+     * @param {string} id
+     * @param {StoredState} storedState
+     * @return {Promise}
+     * @private
+     */
+    _saveState(id, storedState) {
+        return this.storage?.saveState(id, storedState);
+    }
 }

package/components/auth/response-parser.d.ts

@@ -0,0 +1,70 @@
+import ExtendableError from 'es6-error';
+export interface AuthResponse {
+    accessToken?: string;
+    state?: string;
+    token_type?: string;
+    expiresIn?: string;
+    scope?: string;
+    error?: string | Error;
+    errorDescription?: string;
+    errorUri?: string;
+    restoreAuthState?: string;
+}
+export declare class AuthError extends ExtendableError {
+    code: string | Error | AuthError | undefined;
+    uri: string | undefined;
+    stateId: string | undefined;
+    constructor(authResponse?: AuthResponse);
+}
+/**
+ * @typedef {Object} AuthResponse
+ * @property {?string} accessToken
+ * @property {?string} state
+ * @property {?string} token_type
+ * @property {?string} expiresIn
+ * @property {?string} scope
+ * @property {?string} error
+ */
+export default class AuthResponseParser {
+    readonly _authResponse: AuthResponse;
+    constructor();
+    static AuthError: typeof AuthError;
+    static convertKey(key: string): string;
+    /**
+     * Check if the hash contains an access token.
+     * If it does, return auth response. Otherwise return undefined.
+     * Always clears the hash part of the URL.
+     *
+     * @throws {Error} if the auth server returned an error
+     * @return {?AuthResponse}
+     */
+    getAuthResponseFromURL(): AuthResponse | null;
+    /**
+     * Validates given authResponse.
+     * If it contains a token - returns the token, if an error is found - throws the error,
+     * otherwise - null
+     * Always clears the hash part of the URL.
+     *
+     * @param authResponse {AuthResponse} parsed authResponse
+     * @throws {Error} if the auth server returned an error
+     * @return {?AuthResponse}
+     */
+    validateAuthResponse(authResponse: AuthResponse): AuthResponse | null;
+    /**
+     * Reads the current accessToken from the URL.
+     * Doesn't modify URL
+     *
+     * @return {AuthResponse}
+     */
+    readAuthResponseFromURL(): AuthResponse;
+    /**
+     * @return {string} part of the URL after # sign.
+     * @private
+     */
+    getHash(): string | null;
+    /**
+     * Current page location.
+     * @return {string}
+     */
+    getLocation(): string | null;
+}

package/components/auth/response-parser.js

@@ -1,7 +1,17 @@
 import ExtendableError from 'es6-error';
-
-import {parseQueryString} from '../global/url';
-
+import { parseQueryString } from '../global/url';
+export class AuthError extends ExtendableError {
+    code;
+    uri;
+    stateId;
+    // Supports weird IE 11 failing test issue
+    constructor(authResponse = {}) {
+        super(authResponse.errorDescription);
+        this.code = authResponse.error;
+        this.uri = authResponse.errorUri;
+        this.stateId = authResponse.state;
+    }
+}
 /**
  * @typedef {Object} AuthResponse
  * @property {?string} accessToken
@@ -11,99 +21,79 @@ import {parseQueryString} from '../global/url';
  * @property {?string} scope
  * @property {?string} error
  */
-
 export default class AuthResponseParser {
-  constructor() {
-    this._authResponse = this.readAuthResponseFromURL();
-  }
-
-  static AuthError = class AuthError extends ExtendableError {
-    // Supports weird IE 11 failing test issue
-    constructor(authResponse = {}) {
-      super(authResponse.errorDescription);
-      this.code = authResponse.error;
-      this.uri = authResponse.errorUri;
-      this.stateId = authResponse.state;
+    _authResponse;
+    constructor() {
+        this._authResponse = this.readAuthResponseFromURL();
+    }
+    static AuthError = AuthError;
+    static convertKey(key) {
+        return key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+    }
+    /**
+     * Check if the hash contains an access token.
+     * If it does, return auth response. Otherwise return undefined.
+     * Always clears the hash part of the URL.
+     *
+     * @throws {Error} if the auth server returned an error
+     * @return {?AuthResponse}
+     */
+    getAuthResponseFromURL() {
+        return this.validateAuthResponse(this._authResponse);
+    }
+    /**
+     * Validates given authResponse.
+     * If it contains a token - returns the token, if an error is found - throws the error,
+     * otherwise - null
+     * Always clears the hash part of the URL.
+     *
+     * @param authResponse {AuthResponse} parsed authResponse
+     * @throws {Error} if the auth server returned an error
+     * @return {?AuthResponse}
+     */
+    validateAuthResponse(authResponse) {
+        // Check for errors
+        if (authResponse.error) {
+            throw new AuthResponseParser.AuthError(authResponse);
+        }
+        // If there is no token in the hash
+        if (!authResponse.accessToken) {
+            return null;
+        }
+        return { ...authResponse, accessToken: authResponse.accessToken };
+    }
+    /**
+     * Reads the current accessToken from the URL.
+     * Doesn't modify URL
+     *
+     * @return {AuthResponse}
+     */
+    readAuthResponseFromURL() {
+        const authResponse = {};
+        const rawAuthResponse = parseQueryString(this.getHash());
+        Object.keys(rawAuthResponse).forEach(key => {
+            if (key.indexOf('_') !== -1) {
+                authResponse[AuthResponseParser.convertKey(key)] = rawAuthResponse[key];
+                return;
+            }
+            authResponse[key] = rawAuthResponse[key];
+        });
+        return authResponse;
     }
-  };
-
-  static convertKey(key) {
-    return key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-  }
-
-  /**
-   * Check if the hash contains an access token.
-   * If it does, return auth response. Otherwise return undefined.
-   * Always clears the hash part of the URL.
-   *
-   * @throws {Error} if the auth server returned an error
-   * @return {?AuthResponse}
-   */
-  getAuthResponseFromURL() {
-    return this.validateAuthResponse(this._authResponse);
-  }
-
-  /**
-   * Validates given authResponse.
-   * If it contains a token - returns the token, if an error is found - throws the error,
-   * otherwise - null
-   * Always clears the hash part of the URL.
-   *
-   * @param authResponse {AuthResponse} parsed authResponse
-   * @throws {Error} if the auth server returned an error
-   * @return {?AuthResponse}
-   */
-  validateAuthResponse(authResponse) {
-
-    // Check for errors
-    if (authResponse.error) {
-      throw new AuthResponseParser.AuthError(authResponse);
+    /**
+     * @return {string} part of the URL after # sign.
+     * @private
+     */
+    getHash() {
+        // Because of stupid Firefox bug — https://bugzilla.mozilla.org/show_bug.cgi?id=483304
+        const location = this.getLocation();
+        return location && location.replace(/^[^#]*#?/, '');
     }
-
-    // If there is no token in the hash
-    if (!authResponse.accessToken) {
-      return null;
+    /**
+     * Current page location.
+     * @return {string}
+     */
+    getLocation() {
+        return window.location.toString();
     }
-
-    return authResponse;
-  }
-
-  /**
-   * Reads the current accessToken from the URL.
-   * Doesn't modify URL
-   *
-   * @return {AuthResponse}
-   */
-  readAuthResponseFromURL() {
-    const authResponse = {};
-    const rawAuthResponse = parseQueryString(this.getHash());
-    Object.keys(rawAuthResponse).forEach(key => {
-      if (key.indexOf('_') !== -1) {
-        authResponse[AuthResponseParser.convertKey(key)] = rawAuthResponse[key];
-        return;
-      }
-
-      authResponse[key] = rawAuthResponse[key];
-    });
-
-    return authResponse;
-  }
-
-  /**
-   * @return {string} part of the URL after # sign.
-   * @private
-   */
-  getHash() {
-    // Because of stupid Firefox bug — https://bugzilla.mozilla.org/show_bug.cgi?id=483304
-    const location = this.getLocation();
-    return location && location.replace(/^[^#]*#?/, '');
-  }
-
-  /**
-   * Current page location.
-   * @return {string}
-   */
-  getLocation() {
-    return window.location.toString();
-  }
 }

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