@cloudbase/oauth 2.4.5-beta.0 → 2.5.1-beta.0

package/src/oauth2client/oauth2client.ts

@@ -1,6 +1,6 @@
-import { ErrorType } from './consts';
+import { ErrorType } from './consts'
 
-import { AuthClient, SimpleStorage } from './interface';
+import { AuthClient, SimpleStorage } from './interface'
 
 import {
   Credentials,
@@ -9,15 +9,15 @@ import {
   RequestFunction,
   OAuth2ClientOptions,
   AuthClientRequestOptions,
-} from './models';
+} from './models'
 
-import { uuidv4 } from '../utils/uuid';
+import { uuidv4 } from '../utils/uuid'
 
-import { SinglePromise } from '../utils/function/single-promise';
+import { SinglePromise } from '../utils/function/single-promise'
 
-const RequestIdHeaderName = 'x-request-id';
-const DeviceIdHeaderName = 'x-device-id';
-const DeviceIdSectionName = 'device_id';
+const RequestIdHeaderName = 'x-request-id'
+const DeviceIdHeaderName = 'x-device-id'
+const DeviceIdSectionName = 'device_id'
 
 export interface ToResponseErrorOptions {
   error?: ErrorType;
@@ -26,75 +26,76 @@ export interface ToResponseErrorOptions {
   details?: any | null;
 }
 
-export const defaultRequest: RequestFunction = async <T>(
+
+export const defaultRequest: RequestFunction = async function <T>(
   url: string,
-  options?: RequestOptions,
-): Promise<T> => {
-  let result: T | null = null;
-  let responseError: ResponseError | null = null;
+  options?: RequestOptions
+): Promise<T> {
+  let result: T | null = null
+  let responseError: ResponseError | null = null
   try {
     // Objects must be copied to prevent modification of data such as body.
-    const copyOptions = Object.assign({}, options);
+    const copyOptions = Object.assign({}, options)
     if (!copyOptions.method) {
-      copyOptions.method = 'GET';
+      copyOptions.method = 'GET'
     }
     if (copyOptions.body && typeof copyOptions.body !== 'string') {
-      copyOptions.body = JSON.stringify(copyOptions.body);
+      copyOptions.body = JSON.stringify(copyOptions.body)
     }
-    const responseResult: Response = await fetch(url, copyOptions);
-    const jsonResponse = await responseResult.json();
+    const responseResult: Response = await fetch(url, copyOptions)
+    const jsonResponse = await responseResult.json()
     if (jsonResponse?.error) {
-      responseError = jsonResponse as ResponseError;
-      responseError.error_uri = new URL(url).pathname;
+      responseError = jsonResponse as ResponseError
+      responseError.error_uri = new URL(url).pathname
     } else {
-      result = jsonResponse as T;
+      result = jsonResponse as T
     }
   } catch (error) {
     responseError = {
       error: ErrorType.UNREACHABLE,
       error_description: error.message,
       error_uri: new URL(url).pathname,
-    };
+    }
   }
   if (responseError) {
-    throw responseError;
+    throw responseError
   } else {
-    return result;
+    return result
   }
-};
+}
 
 export const toResponseError = (
   error: ResponseError | Error,
   options?: ToResponseErrorOptions,
 ): ResponseError => {
-  let responseError: ResponseError;
-  const formatOptions: ToResponseErrorOptions = options || {};
+  let responseError: ResponseError
+  const formatOptions: ToResponseErrorOptions = options || {}
   if (error instanceof Error) {
     responseError = {
       error: formatOptions.error || ErrorType.LOCAL,
       error_description: formatOptions.error_description || error.message,
       error_uri: formatOptions.error_uri,
       details: formatOptions.details || error.stack,
-    };
+    }
   } else {
-    const formatError: ToResponseErrorOptions = error || {};
+    const formatError: ToResponseErrorOptions = error || {}
     responseError = {
       error: formatOptions.error || formatError.error || ErrorType.LOCAL,
       error_description:
         formatOptions.error_description || formatError.error_description,
       error_uri: formatOptions.error_uri || formatError.error_uri,
       details: formatOptions.details || formatError.details,
-    };
+    }
   }
-  return responseError;
-};
+  return responseError
+}
 
 /**
  * Generate request id.
  * @return {string}
  */
 export function generateRequestId(): string {
-  return uuidv4();
+  return uuidv4()
 }
 
 
@@ -107,7 +108,7 @@ class DefaultStorage implements SimpleStorage {
      * @param {string} key
      */
   async getItem(key: string): Promise<string | null> {
-    return window.localStorage.getItem(key);
+    return window.localStorage.getItem(key)
   }
 
   /**
@@ -115,7 +116,7 @@ class DefaultStorage implements SimpleStorage {
      * @param {string} key
      */
   async removeItem(key: string): Promise<void> {
-    window.localStorage.removeItem(key);
+    window.localStorage.removeItem(key)
   }
 
   /**
@@ -124,7 +125,7 @@ class DefaultStorage implements SimpleStorage {
      * @param {string} value
      */
   async setItem(key: string, value: string): Promise<void> {
-    window.localStorage.setItem(key, value);
+    window.localStorage.setItem(key, value)
   }
 
   /**
@@ -132,7 +133,7 @@ class DefaultStorage implements SimpleStorage {
      * @param {string} key
      */
   getItemSync(key: string): string | null {
-    return window.localStorage.getItem(key);
+    return window.localStorage.getItem(key)
   }
 
   /**
@@ -140,7 +141,7 @@ class DefaultStorage implements SimpleStorage {
      * @param {string} key
      */
   removeItemSync(key: string): void {
-    window.localStorage.removeItem(key);
+    window.localStorage.removeItem(key)
   }
 
   /**
@@ -149,11 +150,11 @@ class DefaultStorage implements SimpleStorage {
      * @param {string} value
      */
   setItemSync(key: string, value: string): void {
-    window.localStorage.setItem(key, value);
+    window.localStorage.setItem(key, value)
   }
 }
 
-export const defaultStorage = new DefaultStorage();
+export const defaultStorage = new DefaultStorage()
 
 interface LocalCredentialsOptions {
   tokenSectionName: string;
@@ -166,11 +167,11 @@ interface LocalCredentialsOptions {
  * @return {boolean}
  */
 function isCredentialsExpired(credentials: Credentials): boolean {
-  let isExpired = true;
+  let isExpired = true
   if (credentials?.expires_at && credentials?.access_token) {
-    isExpired = credentials.expires_at < new Date();
+    isExpired = credentials.expires_at < new Date()
   }
-  return isExpired;
+  return isExpired
 }
 
 /**
@@ -179,21 +180,38 @@ function isCredentialsExpired(credentials: Credentials): boolean {
  * If the memory cache expires, the storage cache is automatically loaded.
  */
 export class LocalCredentials {
-  private _tokenSectionName: string;
+  private tokenSectionName: string
 
-  private _storage: SimpleStorage;
+  private storage: SimpleStorage
 
-  private _credentials: Credentials | null = null;
+  private credentials: Credentials | null = null
 
-  private _singlePromise: SinglePromise = new SinglePromise();
+  private singlePromise: SinglePromise = new SinglePromise()
 
   /**
    * constructor
    * @param {LocalCredentialsOptions} options
    */
   constructor(options: LocalCredentialsOptions) {
-    this._tokenSectionName = options.tokenSectionName;
-    this._storage = options.storage;
+    this.tokenSectionName = options.tokenSectionName
+    this.storage = options.storage
+  }
+
+  public getStorageCredentialsSync(): Credentials | null {
+    let credentials: Credentials = null
+    const tokenStr: string = this.storage.getItemSync(this.tokenSectionName,)
+    if (tokenStr !== undefined && tokenStr !== null) {
+      try {
+        credentials = JSON.parse(tokenStr)
+        if (credentials?.expires_at) {
+          credentials.expires_at = new Date(credentials.expires_at)
+        }
+      } catch (error) {
+        this.storage.removeItem(this.tokenSectionName)
+        credentials = null
+      }
+    }
+    return credentials
   }
 
   /**
@@ -202,19 +220,17 @@ export class LocalCredentials {
    */
   public async setCredentials(credentials?: Credentials): Promise<void> {
     if (credentials?.expires_in) {
-      credentials.expires_at = new Date(
-        Date.now() + (credentials.expires_in - 30) * 1000,
-      );
-      if (this._storage) {
-        const tokenStr: string = JSON.stringify(credentials);
-        await this._storage.setItem(this._tokenSectionName, tokenStr);
+      credentials.expires_at = new Date(Date.now() + (credentials.expires_in - 30) * 1000,)
+      if (this.storage) {
+        const tokenStr: string = JSON.stringify(credentials)
+        await this.storage.setItem(this.tokenSectionName, tokenStr)
       }
-      this._credentials = credentials;
+      this.credentials = credentials
     } else {
-      if (this._storage) {
-        await this._storage.removeItem(this._tokenSectionName);
+      if (this.storage) {
+        await this.storage.removeItem(this.tokenSectionName)
       }
-      this._credentials = null;
+      this.credentials = null
     }
   }
 
@@ -223,108 +239,85 @@ export class LocalCredentials {
    * @return {Promise<Credentials | null>}
    */
   public async getCredentials(): Promise<Credentials | null> {
-    return this._singlePromise.run('getCredentials', async () => {
-      if (isCredentialsExpired(this._credentials)) {
-        this._credentials = await this._getStorageCredentials();
+    return this.singlePromise.run('getCredentials', async () => {
+      if (isCredentialsExpired(this.credentials)) {
+        this.credentials = await this.getStorageCredentials()
       }
-      return this._credentials;
-    });
+      return this.credentials
+    })
   }
 
   /**
    * Get storage credentials.
    */
-  private async _getStorageCredentials(): Promise<Credentials | null> {
-    return this._singlePromise.run('_getStorageCredentials', async () => {
-      let credentials: Credentials = null;
-      const tokenStr: string = await this._storage.getItem(
-        this._tokenSectionName,
-      );
+  private async getStorageCredentials(): Promise<Credentials | null> {
+    return this.singlePromise.run('_getStorageCredentials', async () => {
+      let credentials: Credentials = null
+      const tokenStr: string = await this.storage.getItem(this.tokenSectionName,)
       if (tokenStr !== undefined && tokenStr !== null) {
         try {
-          credentials = JSON.parse(tokenStr);
+          credentials = JSON.parse(tokenStr)
           if (credentials?.expires_at) {
-            credentials.expires_at = new Date(credentials.expires_at);
+            credentials.expires_at = new Date(credentials.expires_at)
           }
         } catch (error) {
-          await this._storage.removeItem(this._tokenSectionName);
-          credentials = null;
+          await this.storage.removeItem(this.tokenSectionName)
+          credentials = null
         }
       }
-      return credentials;
-    });
+      return credentials
+    })
   }
-
-  public _getStorageCredentialsSync(): Credentials | null {
-    let credentials: Credentials = null;
-    const tokenStr: string = this._storage.getItemSync(
-      this._tokenSectionName,
-    );
-    if (tokenStr !== undefined && tokenStr !== null) {
-      try {
-        credentials = JSON.parse(tokenStr);
-        if (credentials?.expires_at) {
-          credentials.expires_at = new Date(credentials.expires_at);
-        }
-      } catch (error) {
-        this._storage.removeItem(this._tokenSectionName);
-        credentials = null;
-      }
-    }
-    return credentials
-  }
-
 }
 
 /**
  * OAuth2Client
  */
 export class OAuth2Client implements AuthClient {
-  private static _defaultRetry = 2;
-  private static _minRetry = 0;
-  private static _maxRetry = 5;
-  private static _retryInterval = 1000;
-
-  private _apiOrigin: string;
-  private _clientId: string;
-  private _retry: number;
-  private _clientSecret?: string;
-  private _baseRequest: <T>(
+  private static defaultRetry = 2
+  private static minRetry = 0
+  private static maxRetry = 5
+  private static retryInterval = 1000
+
+  private apiOrigin: string
+  private clientId: string
+  private retry: number
+  private clientSecret?: string
+  private baseRequest: <T>(
     url: string,
     options?: RequestOptions,
-  ) => Promise<T>;
-  private _localCredentials: LocalCredentials;
-  private _storage: SimpleStorage;
-  private _deviceID?: string;
-  private _tokenInURL?: boolean;
-  private _refreshTokenFunc: (refreshToken?: string) => Promise<Credentials>;
-  private _headers?: { [key: string]: string };
-  private _singlePromise: SinglePromise = new SinglePromise();
+  ) => Promise<T>
+  private localCredentials: LocalCredentials
+  private storage: SimpleStorage
+  private deviceID?: string
+  private tokenInURL?: boolean
+  private refreshTokenFunc: (refreshToken?: string) => Promise<Credentials>
+  private headers?: { [key: string]: string }
+  private singlePromise: SinglePromise = new SinglePromise()
 
   /**
    * constructor
    * @param {OAuth2ClientOptions} options
    */
   constructor(options: OAuth2ClientOptions) {
-    this._apiOrigin = options.apiOrigin;
-    this._clientId = options.clientId;
-    this._retry = this._formatRetry(options.retry, OAuth2Client._defaultRetry);
-    if (options.baseRequest != undefined) {
-      this._baseRequest = options.baseRequest;
+    this.apiOrigin = options.apiOrigin
+    this.clientId = options.clientId
+    this.retry = this.formatRetry(options.retry, OAuth2Client.defaultRetry)
+    if (options.baseRequest) {
+      this.baseRequest = options.baseRequest
     } else {
-      this._baseRequest = defaultRequest;
+      this.baseRequest = defaultRequest
     }
-    this._tokenInURL = options.tokenInURL;
-    this._headers = options.headers;
+    this.tokenInURL = options.tokenInURL
+    this.headers = options.headers
     // @ts-ignore
-    this._storage = options.storage || defaultStorage;
-    this._localCredentials = new LocalCredentials({
-      tokenSectionName: 'credentials_' + options.clientId,
-      storage: this._storage,
-    });
-    this._clientSecret = options.clientSecret;
-    this._refreshTokenFunc =
-      options.refreshTokenFunc || this._defaultRefreshTokenFunc;
+    this.storage = options.storage || defaultStorage
+    this.localCredentials = new LocalCredentials({
+      tokenSectionName: `credentials_${options.clientId}`,
+      storage: this.storage,
+    })
+    this.clientSecret = options.clientSecret
+    this.refreshTokenFunc =      options.refreshTokenFunc || this.defaultRefreshTokenFunc
   }
 
   /**
@@ -333,18 +326,19 @@ export class OAuth2Client implements AuthClient {
    * @return {Promise<void>}
    */
   public setCredentials(credentials?: Credentials): Promise<void> {
-    return this._localCredentials.setCredentials(credentials);
+    return this.localCredentials.setCredentials(credentials)
   }
 
   /**
    * getAccessToken return a validate access token
    */
   public async getAccessToken(): Promise<string> {
-    const credentials: Credentials = await this._getCredentials();
+    const credentials: Credentials = await this.getCredentials()
     if (credentials?.access_token) {
-      return Promise.resolve(credentials.access_token);
+      return Promise.resolve(credentials.access_token)
     }
-    return Promise.reject({ error: ErrorType.UNAUTHENTICATED } as ResponseError);
+    const respErr: ResponseError = { error: ErrorType.UNAUTHENTICATED }
+    return Promise.reject(respErr)
   }
 
   /**
@@ -357,72 +351,112 @@ export class OAuth2Client implements AuthClient {
     options?: AuthClientRequestOptions,
   ): Promise<T> {
     if (!options) {
-      options = {};
+      options = {}
     }
-    const retry: number = this._formatRetry(options.retry, this._retry);
-    options.headers = options.headers || {};
-    if (this._headers) {
+    const retry: number = this.formatRetry(options.retry, this.retry)
+    options.headers = options.headers || {}
+    if (this.headers) {
       options.headers = {
-        ...this._headers,
+        ...this.headers,
         ...options.headers,
-      };
+      }
     }
     if (!options.headers[RequestIdHeaderName]) {
-      options.headers[RequestIdHeaderName] = generateRequestId();
+      options.headers[RequestIdHeaderName] = generateRequestId()
     }
     if (!options.headers[DeviceIdHeaderName]) {
-      const deviceId = await this._getDeviceId();
-      options.headers[DeviceIdHeaderName] = deviceId;
+      const deviceId = await this.getDeviceId()
+      options.headers[DeviceIdHeaderName] = deviceId
     }
     if (options?.withCredentials) {
-      const credentials = await this._getCredentials();
+      const credentials = await this.getCredentials()
       if (credentials) {
-        if (this._tokenInURL) {
+        if (this.tokenInURL) {
           if (url.indexOf('?') < 0) {
-            url += '?';
+            url += '?'
           }
-          url += 'access_token=' + credentials.access_token;
+          url += `access_token=${credentials.access_token}`
         } else {
-          options.headers['Authorization'] =
-            credentials.token_type + ' ' + credentials.access_token;
+          options.headers.Authorization =            `${credentials.token_type} ${credentials.access_token}`
         }
       }
     } else {
-      if (this._clientId && url.indexOf('client_id') < 0) {
-        url += url.indexOf('?') < 0 ? '?' : '&';
-        url += 'client_id=' + this._clientId;
+      if (this.clientId && url.indexOf('client_id') < 0) {
+        url += url.indexOf('?') < 0 ? '?' : '&'
+        url += `client_id=${this.clientId}`
       }
     }
     if (url.startsWith('/')) {
-      url = this._apiOrigin + url;
+      url = this.apiOrigin + url
     }
-    let response: T | null = null;
-    const maxRequestTimes: number = retry + 1;
+    let response: T | null = null
+    const maxRequestTimes: number = retry + 1
     for (
       let requestTime = 0;
       requestTime < maxRequestTimes;
       requestTime++
     ) {
       try {
-        response = await this._baseRequest<T>(url, options);
-        break;
+        response = await this.baseRequest<T>(url, options)
+        break
       } catch (responseError) {
         if (options.withCredentials && responseError && responseError.error === ErrorType.UNAUTHENTICATED) {
-          await this.setCredentials(null);
-          return Promise.reject(responseError);
+          await this.setCredentials(null)
+          return Promise.reject(responseError)
         }
-        
+
         if (
-          requestTime === retry ||
-          !responseError ||
-          responseError.error !== 'unreachable'
+          requestTime === retry
+          || !responseError
+          || responseError.error !== 'unreachable'
         ) {
-          return Promise.reject(responseError);
+          return Promise.reject(responseError)
         }
       }
-      await this._sleep(OAuth2Client._retryInterval);
+      await this.sleep(OAuth2Client.retryInterval)
+    }
+    return response
+  }
+
+
+  /**
+   * Get credentials.
+   */
+  public async getCredentials(): Promise<Credentials | null> {
+    let credentials: Credentials = await this.localCredentials.getCredentials()
+    if (isCredentialsExpired(credentials)) {
+      if (credentials && credentials.scope === 'anonymous') {
+        credentials = await this.anonymousSignIn(credentials)
+      } else {
+        credentials = await this.refreshToken(credentials)
+      }
+    }
+    return credentials
+  }
+
+  public getCredentialsSync(): Credentials | null {
+    const credentials: Credentials = this.localCredentials.getStorageCredentialsSync()
+    return credentials
+  }
+
+  public getCredentialsAsync(): Promise<Credentials | null> {
+    return this.localCredentials.getCredentials()
+  }
+
+  public async getScope(): Promise<string> {
+    const credentials: Credentials = await this.localCredentials.getCredentials()
+    if (!credentials) {
+      return this.unAuthenticatedError('credentials not found')
+    }
+    return credentials.scope
+  }
+
+  public async getGroups(): Promise<string[]> {
+    const credentials: Credentials = await this.localCredentials.getCredentials()
+    if (!credentials) {
+      return this.unAuthenticatedError('credentials not found')
     }
-    return response;
+    return credentials.groups
   }
 
   /**
@@ -430,22 +464,22 @@ export class OAuth2Client implements AuthClient {
    * @param {number} retry
    * @return {number}
    */
-  private _checkRetry(retry: number): number {
-    let responseError: ResponseError | null = null;
+  private checkRetry(retry: number): number {
+    let responseError: ResponseError | null = null
     if (
-      typeof retry !== 'number' ||
-      retry < OAuth2Client._minRetry ||
-      retry > OAuth2Client._maxRetry
+      typeof retry !== 'number'
+      || retry < OAuth2Client.minRetry
+      || retry > OAuth2Client.maxRetry
     ) {
       responseError = {
         error: ErrorType.UNREACHABLE,
         error_description: 'wrong options param: retry',
-      };
+      }
     }
     if (responseError) {
-      throw responseError;
+      throw responseError
     }
-    return retry;
+    return retry
   }
 
   /**
@@ -454,12 +488,11 @@ export class OAuth2Client implements AuthClient {
    * @param {number} defaultVale
    * @return {number}
    */
-  private _formatRetry(retry: number, defaultVale: number): number {
+  private formatRetry(retry: number, defaultVale: number): number {
     if (typeof retry === 'undefined') {
-      return defaultVale;
-    } else {
-      return this._checkRetry(retry);
+      return defaultVale
     }
+    return this.checkRetry(retry)
   }
 
   /**
@@ -467,12 +500,12 @@ export class OAuth2Client implements AuthClient {
    * @param {number} ms
    * @return {Promise<void>}
    */
-  private async _sleep(ms: number): Promise<void> {
+  private async sleep(ms: number): Promise<void> {
     return new Promise<void>((resolve) => {
       setTimeout(() => {
-        resolve();
-      }, ms);
-    });
+        resolve()
+      }, ms)
+    })
   }
 
   /**
@@ -480,25 +513,23 @@ export class OAuth2Client implements AuthClient {
    * @param {Credentials} credentials
    * @return {Promise<Credentials>}
    */
-  private async _refreshToken(credentials: Credentials): Promise<Credentials> {
-    return this._singlePromise.run('_refreshToken', async () => {
+  private async refreshToken(credentials: Credentials): Promise<Credentials> {
+    return this.singlePromise.run('_refreshToken', async () => {
       if (!credentials || !credentials.refresh_token) {
-        return this._unAuthenticatedError('no refresh token found in credentials');
+        return this.unAuthenticatedError('no refresh token found in credentials')
       }
       try {
-        const newCredentials: Credentials = await this._refreshTokenFunc(
-          credentials.refresh_token,
-        );
-        await this._localCredentials.setCredentials(newCredentials);
+        const newCredentials: Credentials = await this.refreshTokenFunc(credentials.refresh_token,)
+        await this.localCredentials.setCredentials(newCredentials)
         return newCredentials
       } catch (error) {
         if (error.error === ErrorType.INVALID_GRANT) {
-          await this._localCredentials.setCredentials(null);
-          return this._unAuthenticatedError(error.error_description);
+          await this.localCredentials.setCredentials(null)
+          return this.unAuthenticatedError(error.error_description)
         }
-        return Promise.reject(error);
+        return Promise.reject(error)
       }
-    });
+    })
   }
 
   /**
@@ -506,29 +537,29 @@ export class OAuth2Client implements AuthClient {
    * @param {Credentials} credentials
    * @return {Promise<Credentials>}
    */
-  private async _anonymousSignIn(credentials: Credentials): Promise<Credentials> {
-    return this._singlePromise.run('_anonymous', async () => {
+  private async anonymousSignIn(credentials: Credentials): Promise<Credentials> {
+    return this.singlePromise.run('_anonymous', async () => {
       if (!credentials || credentials.scope !== 'anonymous') {
-        return this._unAuthenticatedError('no anonymous in credentials');
+        return this.unAuthenticatedError('no anonymous in credentials')
       }
       try {
         const newCredentials: Credentials = await this.request('/auth/v1/signin/anonymously', {
           method: 'POST',
           body: {
-            client_id: this._clientId,
-            client_secret: this._clientSecret,
+            client_id: this.clientId,
+            client_secret: this.clientSecret,
           },
-        });
-        await this._localCredentials.setCredentials(newCredentials);
+        })
+        await this.localCredentials.setCredentials(newCredentials)
         return newCredentials
       } catch (error) {
         if (error.error === ErrorType.INVALID_GRANT) {
-          await this._localCredentials.setCredentials(null);
-          return this._unAuthenticatedError(error.error_description);
+          await this.localCredentials.setCredentials(null)
+          return this.unAuthenticatedError(error.error_description)
         }
-        return Promise.reject(error);
+        return Promise.reject(error)
       }
-    });
+    })
   }
 
   /**
@@ -536,92 +567,48 @@ export class OAuth2Client implements AuthClient {
    * @param {string} refreshToken
    * @return {Promise<Credentials>}
    */
-  private _defaultRefreshTokenFunc(
-    refreshToken?: string,
-  ): Promise<Credentials> {
+  private defaultRefreshTokenFunc(refreshToken?: string,): Promise<Credentials> {
     if (refreshToken === undefined || refreshToken === '') {
-      return this._unAuthenticatedError('refresh token not found');
+      return this.unAuthenticatedError('refresh token not found')
     }
     return this.request('/auth/v1/token', {
       method: 'POST',
       body: {
-        client_id: this._clientId,
-        client_secret: this._clientSecret,
+        client_id: this.clientId,
+        client_secret: this.clientSecret,
         grant_type: 'refresh_token',
         refresh_token: refreshToken,
       },
-    });
+    })
   }
 
-  /**
-   * Get credentials.
-   */
-  public async _getCredentials(): Promise<Credentials | null> {
-    let credentials: Credentials = await this._localCredentials.getCredentials();
-    if (isCredentialsExpired(credentials)) {
-      if (credentials && credentials.scope === 'anonymous') {
-        credentials = await this._anonymousSignIn(credentials)
-      } else {
-        credentials = await this._refreshToken(credentials);
-      }
-    }
-    return credentials;
-  }
-
-  public getCredentialsSync(): Credentials | null {
-    const credentials: Credentials = this._localCredentials._getStorageCredentialsSync();
-    return credentials
-  }
-
-  public getCredentialsAsync(): Promise<Credentials | null> {
-    return this._localCredentials.getCredentials()
-  }
-
-  public async getScope(): Promise<string> {
-    let credentials: Credentials = await this._localCredentials.getCredentials();
-    if (credentials == null) {
-      return this._unAuthenticatedError("credentials not found")
-    }
-    return credentials.scope;
-  }
-
-  public async getGroups(): Promise<string[]> {
-    let credentials: Credentials = await this._localCredentials.getCredentials();
-    if (credentials == null) {
-      return this._unAuthenticatedError("credentials not found")
-    }
-    return credentials.groups;
-  }
-
-
   /**
    * Get deviceId
    */
-  private async _getDeviceId(): Promise<string> {
-    if (this._deviceID) {
-      return this._deviceID;
+  private async getDeviceId(): Promise<string> {
+    if (this.deviceID) {
+      return this.deviceID
     }
-    let deviceId: string = await this._storage.getItem(
-      DeviceIdSectionName,
-    );
-    if (!(typeof deviceId === 'string' &&
-      deviceId.length >= 16 &&
-      deviceId.length <= 48)) {
-      deviceId = uuidv4();
-      await this._storage.setItem(DeviceIdSectionName, deviceId);
+    let deviceId: string = await this.storage.getItem(DeviceIdSectionName,)
+    if (!(typeof deviceId === 'string'
+      && deviceId.length >= 16
+      && deviceId.length <= 48)) {
+      deviceId = uuidv4()
+      await this.storage.setItem(DeviceIdSectionName, deviceId)
     }
-    this._deviceID = deviceId;
-    return deviceId;
+    this.deviceID = deviceId
+    return deviceId
   }
   /**
    * Generate unAuthenticated error.
    * @param {string} err
    * @return {Promise<T>}
    */
-  private _unAuthenticatedError<T>(err?: string): Promise<T> {
-    return Promise.reject({
+  private unAuthenticatedError<T>(err?: string): Promise<T> {
+    const respErr: ResponseError = {
       error: ErrorType.UNAUTHENTICATED,
       error_description: err,
-    } as ResponseError);
+    }
+    return Promise.reject(respErr)
   }
 }