@api-client/core 0.10.12 → 0.11.0

package/src/authorization/OidcAuthorization.ts

@@ -1,27 +1,34 @@
-import { IOidcTokenInfo, IOidcTokenError, ITokenInfo } from '../models/Authorization.js';
-import { Tokens } from './lib/Tokens.js';
-import { OAuth2Authorization, grantResponseMapping, reportOAuthError, resolveFunction, rejectFunction, handleTokenInfo } from './OAuth2Authorization.js';
-import { nonceGenerator } from './Utils.js';
+import { IOidcTokenInfo, IOidcTokenError, ITokenInfo } from '../models/Authorization.js'
+import { Tokens } from './lib/Tokens.js'
+import {
+  OAuth2Authorization,
+  grantResponseMapping,
+  reportOAuthError,
+  resolveFunction,
+  rejectFunction,
+  handleTokenInfo,
+} from './OAuth2Authorization.js'
+import { nonceGenerator } from './Utils.js'
 
 export class OidcAuthorization extends OAuth2Authorization {
-  override authorize(): Promise<(IOidcTokenInfo|IOidcTokenError)[]> {
-    return super.authorize();
+  override authorize(): Promise<(IOidcTokenInfo | IOidcTokenError)[]> {
+    return super.authorize() as unknown as Promise<(IOidcTokenInfo | IOidcTokenError)[]>
   }
 
   /**
    * @returns The parameters to build popup URL.
    */
   override async buildPopupUrlParams(): Promise<URL | null> {
-    const url = await super.buildPopupUrlParams();
+    const url = await super.buildPopupUrlParams()
     if (url === null) {
-      return url;
+      return url
     }
-    const type = (this.settings.responseType || grantResponseMapping[this.settings.grantType as string]);
+    const type = this.settings.responseType || grantResponseMapping[this.settings.grantType as string]
     // ID token nonce
     if (type.includes('id_token')) {
-      url.searchParams.set('nonce', nonceGenerator());
+      url.searchParams.set('nonce', nonceGenerator())
     }
-    return url;
+    return url
   }
 
   /**
@@ -30,58 +37,58 @@ export class OidcAuthorization extends OAuth2Authorization {
    */
   override validateTokenResponse(params: URLSearchParams): boolean {
     if (params.has('id_token')) {
-      return true;
+      return true
     }
-    return super.validateTokenResponse(params);
+    return super.validateTokenResponse(params)
   }
 
   /**
    * Processes the response returned by the popup or the iframe.
    */
   override async processTokenResponse(params: URLSearchParams): Promise<void> {
-    this.clearObservers();
-    const state = params.get('state');
+    this.clearObservers()
+    const state = params.get('state')
     if (!state) {
-      this[reportOAuthError]('Server did not return the state parameter.', 'no_state');
-      return;
+      this[reportOAuthError]('Server did not return the state parameter.', 'no_state')
+      return
     }
     if (state !== this.state) {
       // The authorization class (this) is created per token request so this can only have one state.
       // When the app requests for more tokens at the same time is should create multiple instances of this.
-      this[reportOAuthError]('The state value returned by the authorization server is invalid.', 'invalid_state');
-      return;
+      this[reportOAuthError]('The state value returned by the authorization server is invalid.', 'invalid_state')
+      return
     }
     if (params.has('error')) {
-      const info = this.createTokenResponseError(params);
-      this[reportOAuthError](...info);
-      return;
+      const info = this.createTokenResponseError(params)
+      this[reportOAuthError](...info)
+      return
     }
     // this is the time when the tokens are received. +- a few ms.
-    const time = Date.now();
-    const tokens: (IOidcTokenInfo|IOidcTokenError)[] | null = this.prepareTokens(params, time);
+    const time = Date.now()
+    const tokens: (IOidcTokenInfo | IOidcTokenError)[] | null = this.prepareTokens(params, time)
     if (!Array.isArray(tokens) || !tokens.length) {
-      this[reportOAuthError]('The authorization response has unknown response type configuration.', 'unknown_state');
-      return;
+      this[reportOAuthError]('The authorization response has unknown response type configuration.', 'unknown_state')
+      return
     }
-    const codeIndex = tokens.findIndex(i => i.responseType === 'code');
+    const codeIndex = tokens.findIndex((i) => i.responseType === 'code')
     if (codeIndex >= 0) {
-      const codeToken = tokens[codeIndex] as IOidcTokenInfo;
+      const codeToken = tokens[codeIndex] as IOidcTokenInfo
       try {
-        const info = await this.getCodeInfo(codeToken.code as string);
+        const info = await this.getCodeInfo(codeToken.code as string)
         if (info.error) {
           tokens[codeIndex] = {
             responseType: codeToken.responseType,
             state: codeToken.state,
             error: info.error,
             errorDescription: info.errorDescription,
-          } as IOidcTokenError;
+          } as IOidcTokenError
         } else {
-          codeToken.accessToken = info.accessToken;
-          codeToken.refreshToken = info.refreshToken;
-          codeToken.idToken = info.idToken;
-          codeToken.tokenType = info.tokenType;
-          codeToken.expiresIn = info.expiresIn;
-          codeToken.scope = Tokens.computeTokenInfoScopes(this.settings.scopes, info.scope);
+          codeToken.accessToken = info.accessToken as string | undefined
+          codeToken.refreshToken = info.refreshToken as string | undefined
+          codeToken.idToken = info.idToken as string | undefined
+          codeToken.tokenType = info.tokenType as string | undefined
+          codeToken.expiresIn = info.expiresIn as number | undefined
+          codeToken.scope = Tokens.computeTokenInfoScopes(this.settings.scopes, info.scope as string | undefined)
         }
       } catch (e) {
         tokens[codeIndex] = {
@@ -89,47 +96,52 @@ export class OidcAuthorization extends OAuth2Authorization {
           state: codeToken.state,
           error: 'unknown_state',
           errorDescription: (e as Error).message,
-        } as IOidcTokenError;
+        } as IOidcTokenError
       }
     }
-    this.finish(tokens);
+    this.finish(tokens)
   }
 
   /**
-   * Creates a token info object for each requested response type. These are created from the params received from the 
+   * Creates a token info object for each requested response type. These are created from the params received from the
    * redirect URI. This means that it might not be complete (for code response type).
    * @param params
    * @param time Timestamp when the tokens were created
    */
   prepareTokens(params: URLSearchParams, time: number): IOidcTokenInfo[] | null {
-    const { grantType, responseType='', scopes } = this.settings;
-    let type = responseType;
+    const { grantType, responseType = '', scopes } = this.settings
+    let type = responseType
     if (!type) {
-      type = grantResponseMapping[grantType as string];
+      type = grantResponseMapping[grantType as string]
     }
     if (!type) {
-      return null;
+      return null
     }
-    const types = type.split(' ').map(i => i.trim()).filter(i => !!i);
-    const result: IOidcTokenInfo[] = [];
-    types.forEach(item => {
-      const info = Tokens.createTokenInfo(item, params, time, scopes);
+    const types = type
+      .split(' ')
+      .map((i) => i.trim())
+      .filter((i) => !!i)
+    const result: IOidcTokenInfo[] = []
+    types.forEach((item) => {
+      const info = Tokens.createTokenInfo(item, params, time, scopes)
       if (info) {
-        result.push(info);
+        result.push(info)
       }
-    });
-    return result;
+    })
+    return result
   }
 
   /**
    * Finishes the authorization.
    */
-  finish(tokens: (IOidcTokenInfo|IOidcTokenError)[]): void {
+  finish(tokens: (IOidcTokenInfo | IOidcTokenError)[]): void {
     if (this[resolveFunction]) {
-      this[resolveFunction]!(tokens as any);
+      // TODO: this is a hack. These both classes should extend a single parent but not one another.
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      this[resolveFunction]!(tokens as unknown as ITokenInfo)
     }
-    this[rejectFunction] = undefined;
-    this[resolveFunction] = undefined;
+    this[rejectFunction] = undefined
+    this[resolveFunction] = undefined
   }
 
   /**
@@ -137,10 +149,10 @@ export class OidcAuthorization extends OAuth2Authorization {
    *
    * @param info Token info returned from the server.
    */
-  [handleTokenInfo](info: ITokenInfo): void {
-    const { responseType } = this.settings;
-    const token = Tokens.fromTokenInfo(info);
-    token.responseType = responseType || '';
-    this.finish([token]);
+  override [handleTokenInfo](info: ITokenInfo): void {
+    const { responseType } = this.settings
+    const token = Tokens.fromTokenInfo(info)
+    token.responseType = responseType || ''
+    this.finish([token])
   }
 }

package/src/authorization/Utils.ts

@@ -1,23 +1,23 @@
-import { IOAuth2Authorization } from "../models/Authorization.js";
+import { IOAuth2Authorization } from '../models/Authorization.js'
 
 /**
  * Checks if the URL has valid scheme for OAuth flow.
- * 
+ *
  * Do not use this to validate redirect URIs as they can use any protocol.
  *
  * @param url The url value to test
  * @throws {TypeError} When passed value is not set, empty, or not a string
  * @throws {Error} When passed value is not a valid URL for OAuth 2 flow
  */
- export function checkUrl(url: string): void {
+export function checkUrl(url: string): void {
   if (!url) {
-    throw new TypeError("the value is missing");
+    throw new TypeError('the value is missing')
   }
-  if (typeof url !== "string") {
-    throw new TypeError("the value is not a string");
+  if (typeof url !== 'string') {
+    throw new TypeError('the value is not a string')
   }
-  if (!url.startsWith("http://") && !url.startsWith("https://")) {
-    throw new Error("the value has invalid scheme");
+  if (!url.startsWith('http://') && !url.startsWith('https://')) {
+    throw new Error('the value has invalid scheme')
   }
 }
 
@@ -28,24 +28,24 @@ import { IOAuth2Authorization } from "../models/Authorization.js";
  * @throws {Error} When settings are not valid
  */
 export function sanityCheck(settings: IOAuth2Authorization): void {
-  if (["implicit", "authorization_code"].includes(settings.grantType!)) {
+  if (['implicit', 'authorization_code'].includes(settings.grantType as string)) {
     try {
-      checkUrl(settings.authorizationUri!);
+      checkUrl(settings.authorizationUri as string)
     } catch (e) {
-      throw new Error(`authorizationUri: ${(e as Error).message}`);
+      throw new Error(`authorizationUri: ${(e as Error).message}`)
     }
     if (settings.accessTokenUri) {
       try {
-        checkUrl(settings.accessTokenUri);
+        checkUrl(settings.accessTokenUri)
       } catch (e) {
-        throw new Error(`accessTokenUri: ${(e as Error).message}`);
+        throw new Error(`accessTokenUri: ${(e as Error).message}`)
       }
     }
   } else if (settings.accessTokenUri) {
     try {
-      checkUrl(settings.accessTokenUri);
+      checkUrl(settings.accessTokenUri)
     } catch (e) {
-      throw new Error(`accessTokenUri: ${(e as Error).message}`);
+      throw new Error(`accessTokenUri: ${(e as Error).message}`)
     }
   }
 }
@@ -56,9 +56,9 @@ export function sanityCheck(settings: IOAuth2Authorization): void {
  * @returns A random string.
  */
 export function randomString(): string {
-  const array = new Uint32Array(28);
-  window.crypto.getRandomValues(array);
-  return Array.from(array, (dec) => `0${dec.toString(16)}`.substr(-2)).join("");
+  const array = new Uint32Array(28)
+  window.crypto.getRandomValues(array)
+  return Array.from(array, (dec) => `0${dec.toString(16)}`.substr(-2)).join('')
 }
 
 /**
@@ -67,20 +67,19 @@ export function randomString(): string {
  * @return {String|undefined} Camel cased string or `undefined` if not transformed.
  */
 export function camel(name: string): string | undefined {
-  let i = 0;
-  let l;
-  let changed = false;
-  // eslint-disable-next-line no-cond-assign
+  let i = 0
+  let l
+  let changed = false
+
   while ((l = name[i])) {
-    if ((l === "_" || l === "-") && i + 1 < name.length) {
-      // eslint-disable-next-line no-param-reassign
-      name = name.substring(0, i) + name[i + 1].toUpperCase() + name.substring(i + 2);
-      changed = true;
+    if ((l === '_' || l === '-') && i + 1 < name.length) {
+      name = name.substring(0, i) + name[i + 1].toUpperCase() + name.substring(i + 2)
+      changed = true
     }
-    // eslint-disable-next-line no-plusplus
-    i++;
+
+    i++
   }
-  return changed ? name : undefined;
+  return changed ? name : undefined
 }
 
 /**
@@ -88,18 +87,23 @@ export function camel(name: string): string | undefined {
  * @param value The value to encode.
  */
 export async function sha256(value: string): Promise<ArrayBuffer> {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(value);
-  return window.crypto.subtle.digest("SHA-256", data);
+  const encoder = new TextEncoder()
+  const data = encoder.encode(value)
+  return window.crypto.subtle.digest('SHA-256', data)
 }
 
 /**
  * Encoded the array buffer to a base64 string value.
  */
 export function base64Buffer(buffer: ArrayBuffer): string {
-  const view = new Uint8Array(buffer);
-  const str = String.fromCharCode.apply(null, view as any);
-  return btoa(str).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+  const view = new Uint8Array(buffer)
+  const len = view.byteLength
+  let binary = ''
+  for (let i = 0; i < len; i++) {
+    binary += String.fromCharCode(view[i])
+  }
+  // const str = String.fromCharCode.apply(null, view as number[]);
+  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
 }
 
 /**
@@ -108,8 +112,8 @@ export function base64Buffer(buffer: ArrayBuffer): string {
  * @returns The code challenge string
  */
 export async function generateCodeChallenge(verifier: string): Promise<string> {
-  const hashed = await sha256(verifier);
-  return base64Buffer(hashed);
+  const hashed = await sha256(verifier)
+  return base64Buffer(hashed)
 }
 
 /**
@@ -118,9 +122,15 @@ export async function generateCodeChallenge(verifier: string): Promise<string> {
  * @returns A nonce (number used once).
  */
 export function nonceGenerator(size = 20): string {
-  const validChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-  let array = new Uint8Array(size);
-  window.crypto.getRandomValues(array);
-  array = array.map(x => validChars.charCodeAt(x % validChars.length));
-  return String.fromCharCode.apply(null, array as any);
+  const validChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
+  let array = new Uint8Array(size)
+  window.crypto.getRandomValues(array)
+  array = array.map((x) => validChars.charCodeAt(x % validChars.length))
+  const len = array.byteLength
+  let binary = ''
+  for (let i = 0; i < len; i++) {
+    binary += String.fromCharCode(array[i])
+  }
+  return binary
+  // return String.fromCharCode.apply(null, array as any);
 }

package/src/authorization/lib/IframeAuthorization.ts

@@ -1,23 +1,22 @@
-/* eslint-disable class-methods-use-this */
-export const loadHandler = Symbol('loadHandler');
-export const timeoutValue = Symbol('timeoutValue');
-export const checkInterval = Symbol('checkInterval');
-export const limitValue = Symbol('limitValue');
-export const targetValue = Symbol('targetValue');
+export const loadHandler = Symbol('loadHandler')
+export const timeoutValue = Symbol('timeoutValue')
+export const checkInterval = Symbol('checkInterval')
+export const limitValue = Symbol('limitValue')
+export const targetValue = Symbol('targetValue')
 
 /**
  * Adds the support for the iframe authorization.
- * 
- * This class creates and loads an iframe for the given URL. Then it runs a timer recursively 
- * that increases its interval multiplying its last timeout value by 2. 
+ *
+ * This class creates and loads an iframe for the given URL. Then it runs a timer recursively
+ * that increases its interval multiplying its last timeout value by 2.
  * The the timer reaches timeout it dispatches the timeout event.
- * 
+ *
  * The library takes into the account the redirects.
- * 
+ *
  * Call the `cancel()` and the `cleanUp()` functions when the authorization data is received.
  */
 export class IframeAuthorization extends EventTarget {
-  loadTimeout?: any;
+  loadTimeout?: number
 
   timedOut = false;
 
@@ -25,21 +24,21 @@ export class IframeAuthorization extends EventTarget {
 
   [limitValue]: number;
 
-  [targetValue]: HTMLElement;
+  [targetValue]: HTMLElement
 
-  frame?: HTMLIFrameElement;
+  frame?: HTMLIFrameElement
 
   /**
    * @param limit The timeout limit after which the library calls timeout if it wasn't cancelled.
    * @param target A target node where to add the iframe into.
    */
-  constructor(limit=1020, target:HTMLElement=document.body) {
-    super();
-    this[limitValue] = limit;
-    this[targetValue] = target;
+  constructor(limit = 1020, target: HTMLElement = document.body) {
+    super()
+    this[limitValue] = limit
+    this[targetValue] = target
 
-    this[loadHandler] = this[loadHandler].bind(this);
-    this[checkInterval] = this[checkInterval].bind(this);
+    this[loadHandler] = this[loadHandler].bind(this)
+    this[checkInterval] = this[checkInterval].bind(this)
   }
 
   /**
@@ -47,8 +46,8 @@ export class IframeAuthorization extends EventTarget {
    */
   cancel(): void {
     if (this.loadTimeout) {
-      clearTimeout(this.loadTimeout);
-      this.loadTimeout = undefined;
+      clearTimeout(this.loadTimeout)
+      this.loadTimeout = undefined
     }
   }
 
@@ -57,13 +56,13 @@ export class IframeAuthorization extends EventTarget {
    */
   cleanUp(): void {
     if (!this.frame) {
-      return;
+      return
     }
-    this.frame.removeEventListener('load', this[loadHandler]);
+    this.frame.removeEventListener('load', this[loadHandler])
     if (this.frame.parentElement) {
-      this.frame.parentElement.removeChild(this.frame);
+      this.frame.parentElement.removeChild(this.frame)
     }
-    this.frame = undefined;
+    this.frame = undefined
   }
 
   /**
@@ -71,18 +70,18 @@ export class IframeAuthorization extends EventTarget {
    * @param url THe resource to load.
    */
   load(url: string): void {
-    const iframe = document.createElement('iframe');
-    iframe.style.border = '0';
-    iframe.style.width = '0';
-    iframe.style.height = '0';
-    iframe.style.overflow = 'hidden';
-    iframe.addEventListener('load', this[loadHandler]);
-    iframe.id = 'oauth2-authorization-frame';
-    iframe.setAttribute('data-owner', 'oauth2-authorization');
-    iframe.setAttribute('aria-hidden', 'true');
-    this[targetValue].appendChild(iframe);
-    iframe.src = url;
-    this.frame = iframe;
+    const iframe = document.createElement('iframe')
+    iframe.style.border = '0'
+    iframe.style.width = '0'
+    iframe.style.height = '0'
+    iframe.style.overflow = 'hidden'
+    iframe.addEventListener('load', this[loadHandler])
+    iframe.id = 'oauth2-authorization-frame'
+    iframe.setAttribute('data-owner', 'oauth2-authorization')
+    iframe.setAttribute('aria-hidden', 'true')
+    this[targetValue].appendChild(iframe)
+    iframe.src = url
+    this.frame = iframe
   }
 
   /**
@@ -90,20 +89,20 @@ export class IframeAuthorization extends EventTarget {
    * @param {Event} e
    */
   [loadHandler](e: Event): void {
-    this.cancel();
+    this.cancel()
     const iframe = e.target as HTMLIFrameElement
     try {
       if (iframe.contentWindow) {
         iframe.contentWindow.addEventListener('unload', () => {
-          this.cancel();
-        });
+          this.cancel()
+        })
       }
-    } catch (_) {
+    } catch {
       // ...
     }
 
-    this[timeoutValue] = 8;
-    this.loadTimeout = setTimeout(this[checkInterval], this[timeoutValue]);
+    this[timeoutValue] = 8
+    this.loadTimeout = window.setTimeout(this[checkInterval], this[timeoutValue])
   }
 
   /**
@@ -113,16 +112,16 @@ export class IframeAuthorization extends EventTarget {
    */
   [checkInterval](): void {
     if (this.timedOut) {
-      return;
+      return
     }
     if (this[timeoutValue] >= this[limitValue]) {
-      this.cancel();
-      this.dispatchEvent(new Event('timeout'));
-      this.timedOut = true;
-      this.cleanUp();
-      return;
+      this.cancel()
+      this.dispatchEvent(new Event('timeout'))
+      this.timedOut = true
+      this.cleanUp()
+      return
     }
-    this[timeoutValue] *= 2;
-    this.loadTimeout = setTimeout(this[checkInterval], this[timeoutValue]);
+    this[timeoutValue] *= 2
+    this.loadTimeout = window.setTimeout(this[checkInterval], this[timeoutValue])
   }
 }

package/src/authorization/lib/KnownGrants.ts

@@ -1,6 +1,6 @@
-export const implicit = 'implicit';
-export const code = 'authorization_code';
-export const clientCredentials = 'client_credentials';
-export const password = 'password';
-export const jwtBearer = 'urn:ietf:params:oauth:grant-type:jwt-bearer';
-export const deviceCode = 'urn:ietf:params:oauth:grant-type:device_code';
+export const implicit = 'implicit'
+export const code = 'authorization_code'
+export const clientCredentials = 'client_credentials'
+export const password = 'password'
+export const jwtBearer = 'urn:ietf:params:oauth:grant-type:jwt-bearer'
+export const deviceCode = 'urn:ietf:params:oauth:grant-type:device_code'