@axa-fr/oidc-client 7.22.18 → 7.22.19

package/src/requests.spec.ts

@@ -1,9 +1,7 @@
-
-import { describe, expect,it } from 'vitest';
-
+import { describe, expect, it } from 'vitest';
 
 describe('Requests test Suite', () => {
-    it('performAuthorizationRequestAsync', async () => {
-        expect(true).toBe(true);
-    });
-});
+  it('performAuthorizationRequestAsync', async () => {
+    expect(true).toBe(true);
+  });
+});

package/src/requests.ts

@@ -1,159 +1,183 @@
 import { getFromCache, setCache } from './cache.js';
 import { deriveChallengeAsync, generateRandom } from './crypto.js';
+import { ILOidcLocation } from './location';
 import { OidcAuthorizationServiceConfiguration } from './oidc.js';
 import { parseOriginalTokens } from './parseTokens.js';
 import { Fetch, StringMap } from './types.js';
-import {ILOidcLocation} from "./location";
 
 const oneHourSecond = 60 * 60;
-export const fetchFromIssuer = (fetch) => async (openIdIssuerUrl: string, timeCacheSecond = oneHourSecond, storage = window.sessionStorage, timeoutMs = 10000):
-    Promise<OidcAuthorizationServiceConfiguration> => {
+export const fetchFromIssuer =
+  fetch =>
+  async (
+    openIdIssuerUrl: string,
+    timeCacheSecond = oneHourSecond,
+    storage = window.sessionStorage,
+    timeoutMs = 10000,
+  ): Promise<OidcAuthorizationServiceConfiguration> => {
     const fullUrl = `${openIdIssuerUrl}/.well-known/openid-configuration`;
 
     const localStorageKey = `oidc.server:${openIdIssuerUrl}`;
     const data = getFromCache(localStorageKey, storage, timeCacheSecond);
     if (data) {
-        return new OidcAuthorizationServiceConfiguration(data);
+      return new OidcAuthorizationServiceConfiguration(data);
     }
     const response = await internalFetch(fetch)(fullUrl, {}, timeoutMs);
 
     if (response.status !== 200) {
-        return null;
+      return null;
     }
 
     const result = await response.json();
 
     setCache(localStorageKey, result, storage);
     return new OidcAuthorizationServiceConfiguration(result);
-};
+  };
 
-const internalFetch = (fetch) => async (url:string, headers = {}, timeoutMs = 10000, numberRetry = 0) : Promise<Response> => {
+const internalFetch =
+  fetch =>
+  async (url: string, headers = {}, timeoutMs = 10000, numberRetry = 0): Promise<Response> => {
     let response;
     try {
-        const controller = new AbortController();
-        setTimeout(() => controller.abort(), timeoutMs);
-        response = await fetch(url, { ...headers, signal: controller.signal });
+      const controller = new AbortController();
+      setTimeout(() => controller.abort(), timeoutMs);
+      response = await fetch(url, { ...headers, signal: controller.signal });
     } catch (e: any) {
-        if (e.name === 'AbortError' ||
-            e.message === 'Network request failed') {
-            if (numberRetry <= 1) {
-                return await internalFetch(fetch)(url, headers, timeoutMs, numberRetry + 1);
-            } else {
-                throw e;
-            }
+      if (e.name === 'AbortError' || e.message === 'Network request failed') {
+        if (numberRetry <= 1) {
+          return await internalFetch(fetch)(url, headers, timeoutMs, numberRetry + 1);
         } else {
-            console.error(e.message);
-            throw e; // rethrow other unexpected errors
+          throw e;
         }
+      } else {
+        console.error(e.message);
+        throw e; // rethrow other unexpected errors
+      }
     }
     return response;
-};
+  };
 
 export const TOKEN_TYPE = {
-    refresh_token: 'refresh_token',
-    access_token: 'access_token',
+  refresh_token: 'refresh_token',
+  access_token: 'access_token',
 };
 
-export const performRevocationRequestAsync = (fetch) => async (url, 
-                                                               token, 
-                                                               token_type = TOKEN_TYPE.refresh_token, 
-                                                               client_id,
-                                                               extras:StringMap = {},
-                                                               timeoutMs = 10000) => {
+export const performRevocationRequestAsync =
+  fetch =>
+  async (
+    url,
+    token,
+    token_type = TOKEN_TYPE.refresh_token,
+    client_id,
+    extras: StringMap = {},
+    timeoutMs = 10000,
+  ) => {
     const details = {
-        token,
-        token_type_hint: token_type,
-        client_id,
+      token,
+      token_type_hint: token_type,
+      client_id,
     };
     for (const [key, value] of Object.entries(extras)) {
-
-        if (details[key] === undefined) {
-            details[key] = value;
-        }
+      if (details[key] === undefined) {
+        details[key] = value;
+      }
     }
 
     const formBody = [];
     for (const property in details) {
-        const encodedKey = encodeURIComponent(property);
-        const encodedValue = encodeURIComponent(details[property]);
-        formBody.push(`${encodedKey}=${encodedValue}`);
+      const encodedKey = encodeURIComponent(property);
+      const encodedValue = encodeURIComponent(details[property]);
+      formBody.push(`${encodedKey}=${encodedValue}`);
     }
     const formBodyString = formBody.join('&');
 
-    const response = await internalFetch(fetch)(url, {
+    const response = await internalFetch(fetch)(
+      url,
+      {
         method: 'POST',
         headers: {
-            'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+          'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
         },
         body: formBodyString,
-    }, timeoutMs);
+      },
+      timeoutMs,
+    );
     if (response.status !== 200) {
-        return { success: false };
+      return { success: false };
     }
     return {
-        success: true,
+      success: true,
     };
-};
-
+  };
 
 type PerformTokenRequestResponse = {
-    success: boolean;
-    status?: number;
-    data?: any;
-    demonstratingProofOfPossessionNonce?: string;
-}
-
-export const performTokenRequestAsync = (fetch:Fetch) => async (url:string, 
-                                                                details, 
-                                                                extras, 
-                                                                oldTokens,
-                                                                headersExtras = {},
-                                                                tokenRenewMode: string, 
-                                                                timeoutMs = 10000):Promise<PerformTokenRequestResponse> => {
+  success: boolean;
+  status?: number;
+  data?: any;
+  demonstratingProofOfPossessionNonce?: string;
+};
+
+export const performTokenRequestAsync =
+  (fetch: Fetch) =>
+  async (
+    url: string,
+    details,
+    extras,
+    oldTokens,
+    headersExtras = {},
+    tokenRenewMode: string,
+    timeoutMs = 10000,
+  ): Promise<PerformTokenRequestResponse> => {
     for (const [key, value] of Object.entries(extras)) {
-        if (details[key] === undefined) {
-            details[key] = value;
-        }
+      if (details[key] === undefined) {
+        details[key] = value;
+      }
     }
 
     const formBody = [];
     for (const property in details) {
-        const encodedKey = encodeURIComponent(property);
-        const encodedValue = encodeURIComponent(details[property]);
-        formBody.push(`${encodedKey}=${encodedValue}`);
+      const encodedKey = encodeURIComponent(property);
+      const encodedValue = encodeURIComponent(details[property]);
+      formBody.push(`${encodedKey}=${encodedValue}`);
     }
     const formBodyString = formBody.join('&');
-    
-    const response = await internalFetch(fetch)(url, {
+
+    const response = await internalFetch(fetch)(
+      url,
+      {
         method: 'POST',
         headers: {
-            'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
-            ...headersExtras
+          'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+          ...headersExtras,
         },
         body: formBodyString,
-    }, timeoutMs);
+      },
+      timeoutMs,
+    );
     if (response.status !== 200) {
-        return { 
-            success: false, 
-            status: response.status, 
-            demonstratingProofOfPossessionNonce:null 
-        };
+      return {
+        success: false,
+        status: response.status,
+        demonstratingProofOfPossessionNonce: null,
+      };
     }
     const tokens = await response.json();
 
     let demonstratingProofOfPossessionNonce = null;
-    if( response.headers.has(demonstratingProofOfPossessionNonceResponseHeader)){
-        demonstratingProofOfPossessionNonce = response.headers.get(demonstratingProofOfPossessionNonceResponseHeader);
+    if (response.headers.has(demonstratingProofOfPossessionNonceResponseHeader)) {
+      demonstratingProofOfPossessionNonce = response.headers.get(
+        demonstratingProofOfPossessionNonceResponseHeader,
+      );
     }
     return {
-        success: true,
-        status: response.status,
-        data: parseOriginalTokens(tokens, oldTokens, tokenRenewMode),
-        demonstratingProofOfPossessionNonce: demonstratingProofOfPossessionNonce,
+      success: true,
+      status: response.status,
+      data: parseOriginalTokens(tokens, oldTokens, tokenRenewMode),
+      demonstratingProofOfPossessionNonce: demonstratingProofOfPossessionNonce,
     };
-};
+  };
 
-export const performAuthorizationRequestAsync = (storage: any, oidcLocation: ILOidcLocation) => async (url, extras: StringMap) => {
+export const performAuthorizationRequestAsync =
+  (storage: any, oidcLocation: ILOidcLocation) => async (url, extras: StringMap) => {
     extras = extras ? { ...extras } : {};
     const codeVerifier = generateRandom(128);
     const codeChallenge = await deriveChallengeAsync(codeVerifier);
@@ -163,56 +187,60 @@ export const performAuthorizationRequestAsync = (storage: any, oidcLocation: ILO
     extras.code_challenge_method = 'S256';
     let queryString = '';
     if (extras) {
-        for (const [key, value] of Object.entries(extras)) {
-            if (queryString === '') {
-                queryString += '?';
-            } else {
-                queryString += '&';
-            }
-            queryString += `${key}=${encodeURIComponent(value)}`;
+      for (const [key, value] of Object.entries(extras)) {
+        if (queryString === '') {
+          queryString += '?';
+        } else {
+          queryString += '&';
         }
+        queryString += `${key}=${encodeURIComponent(value)}`;
+      }
     }
     oidcLocation.open(`${url}${queryString}`);
-};
+  };
 
-const demonstratingProofOfPossessionNonceResponseHeader = "DPoP-Nonce";
-export const performFirstTokenRequestAsync = (storage:any) => async (url, 
-                                                                     formBodyExtras, 
-                                                                     headersExtras, 
-                                                                     tokenRenewMode: string, 
-                                                                     timeoutMs = 10000) => {
+const demonstratingProofOfPossessionNonceResponseHeader = 'DPoP-Nonce';
+export const performFirstTokenRequestAsync =
+  (storage: any) =>
+  async (url, formBodyExtras, headersExtras, tokenRenewMode: string, timeoutMs = 10000) => {
     formBodyExtras = formBodyExtras ? { ...formBodyExtras } : {};
     formBodyExtras.code_verifier = await storage.getCodeVerifierAsync();
     const formBody = [];
     for (const property in formBodyExtras) {
-        const encodedKey = encodeURIComponent(property);
-        const encodedValue = encodeURIComponent(formBodyExtras[property]);
-        formBody.push(`${encodedKey}=${encodedValue}`);
+      const encodedKey = encodeURIComponent(property);
+      const encodedValue = encodeURIComponent(formBodyExtras[property]);
+      formBody.push(`${encodedKey}=${encodedValue}`);
     }
     const formBodyString = formBody.join('&');
-    const response = await internalFetch(fetch)(url, {
+    const response = await internalFetch(fetch)(
+      url,
+      {
         method: 'POST',
         headers: {
-            'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
-            ...headersExtras,
+          'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+          ...headersExtras,
         },
         body: formBodyString,
-    }, timeoutMs);
+      },
+      timeoutMs,
+    );
     await Promise.all([storage.setCodeVerifierAsync(null), storage.setStateAsync(null)]);
     if (response.status !== 200) {
-        return { success: false, status: response.status };
+      return { success: false, status: response.status };
     }
-    let demonstratingProofOfPossessionNonce:string= null;
-    if( response.headers.has(demonstratingProofOfPossessionNonceResponseHeader)){
-        demonstratingProofOfPossessionNonce = response.headers.get(demonstratingProofOfPossessionNonceResponseHeader);
+    let demonstratingProofOfPossessionNonce: string = null;
+    if (response.headers.has(demonstratingProofOfPossessionNonceResponseHeader)) {
+      demonstratingProofOfPossessionNonce = response.headers.get(
+        demonstratingProofOfPossessionNonceResponseHeader,
+      );
     }
     const tokens = await response.json();
     return {
-        success: true,
-        data: {
-            state: formBodyExtras.state,
-            tokens: parseOriginalTokens(tokens, null, tokenRenewMode),
-            demonstratingProofOfPossessionNonce,
-        },
+      success: true,
+      data: {
+        state: formBodyExtras.state,
+        tokens: parseOriginalTokens(tokens, null, tokenRenewMode),
+        demonstratingProofOfPossessionNonce,
+      },
     };
-};
+  };

package/src/route-utils.spec.ts

@@ -1,24 +1,22 @@
-import { describe, expect,it } from 'vitest';
+import { describe, expect, it } from 'vitest';
 
 import { getPath } from './route-utils';
 
 describe('Route test Suite', () => {
-    it.each([['http://example.com/pathname', '/pathname'], 
-      ['http://example.com:3000/pathname/?search=test#hash', '/pathname#hash'], 
-      ['http://example.com:3000/pathname/#hash?search=test', '/pathname#hash'], 
-      ['http://example.com:3000/pathname#hash?search=test', '/pathname#hash'], 
-      ['capacitor://localhost/index.html', '/index.html'], 
-      ['capacitor://localhost/pathname#hash?search=test', '/pathname#hash'], 
-      ['http://example.com:3000/', '']])(
-        'getPath should return the full path of an url',
-        (uri, expected) => {
-    
-          const path = getPath(uri);
-          expect(path).toBe(expected);
-        },
-    );
+  it.each([
+    ['http://example.com/pathname', '/pathname'],
+    ['http://example.com:3000/pathname/?search=test#hash', '/pathname#hash'],
+    ['http://example.com:3000/pathname/#hash?search=test', '/pathname#hash'],
+    ['http://example.com:3000/pathname#hash?search=test', '/pathname#hash'],
+    ['capacitor://localhost/index.html', '/index.html'],
+    ['capacitor://localhost/pathname#hash?search=test', '/pathname#hash'],
+    ['http://example.com:3000/', ''],
+  ])('getPath should return the full path of an url', (uri, expected) => {
+    const path = getPath(uri);
+    expect(path).toBe(expected);
+  });
 
-    it('wrong uri format', () => {
-        expect(() => getPath("urimybad/toto.com")).toThrowError();
-    });
-});
+  it('wrong uri format', () => {
+    expect(() => getPath('urimybad/toto.com')).toThrowError();
+  });
+});

package/src/route-utils.ts

@@ -1,26 +1,26 @@
 export const getLocation = (href: string) => {
   const match = href.match(
     // eslint-disable-next-line no-useless-escape
-      /^([a-z][\w-]+\:)\/\/(([^:\/?#]*)(?:\:([0-9]+))?)([\/]{0,1}[^?#]*)(\?[^#]*|)(#.*|)$/,
+    /^([a-z][\w-]+\:)\/\/(([^:\/?#]*)(?:\:([0-9]+))?)([\/]{0,1}[^?#]*)(\?[^#]*|)(#.*|)$/,
   );
   if (!match) {
-      throw new Error('Invalid URL');
+    throw new Error('Invalid URL');
   }
 
   let search = match[6];
   let hash = match[7];
 
-    if (hash) {
-        const splits = hash.split('?');
-        if (splits.length === 2) {
-            hash = splits[0];
-            search = splits[1];
-        }
+  if (hash) {
+    const splits = hash.split('?');
+    if (splits.length === 2) {
+      hash = splits[0];
+      search = splits[1];
     }
+  }
 
-    if (search.startsWith('?')) {
-        search = search.slice(1);
-    }
+  if (search.startsWith('?')) {
+    search = search.slice(1);
+  }
 
   return (
     match && {
@@ -41,12 +41,12 @@ export const getPath = (href: string) => {
   let { path } = location;
 
   if (path.endsWith('/')) {
-      path = path.slice(0, -1);
+    path = path.slice(0, -1);
   }
   let { hash } = location;
 
   if (hash === '#_=_') {
-      hash = '';
+    hash = '';
   }
 
   if (hash) {
@@ -57,23 +57,26 @@ export const getPath = (href: string) => {
 };
 
 export const getParseQueryStringFromLocation = (href: string) => {
-    const location = getLocation(href);
-    const { search } = location;
+  const location = getLocation(href);
+  const { search } = location;
 
-    return parseQueryString(search);
+  return parseQueryString(search);
 };
 
-const parseQueryString = (queryString:string) => {
-    const params:any = {}; let temp; let i; let l;
+const parseQueryString = (queryString: string) => {
+  const params: any = {};
+  let temp;
+  let i;
+  let l;
 
-    // Split into key/value pairs
-    const queries = queryString.split('&');
+  // Split into key/value pairs
+  const queries = queryString.split('&');
 
-    // Convert the array of strings into an object
-    for (i = 0, l = queries.length; i < l; i++) {
-        temp = queries[i].split('=');
-        params[decodeURIComponent(temp[0])] = decodeURIComponent(temp[1]);
-    }
+  // Convert the array of strings into an object
+  for (i = 0, l = queries.length; i < l; i++) {
+    temp = queries[i].split('=');
+    params[decodeURIComponent(temp[0])] = decodeURIComponent(temp[1]);
+  }
 
-    return params;
+  return params;
 };