@axa-fr/react-oidc 5.8.0-alpha0 → 5.8.0

package/src/oidc/core/default-component/ServiceWorkerInstall.component.tsx

@@ -1,6 +1,6 @@
 import React, {useEffect, useState, ComponentType} from 'react';
 import AuthenticatingError from "./AuthenticateError.component";
-import Oidc from "../../vanilla/oidc";
+import Oidc, {getLoginParams} from "../../vanilla/oidc";
 import Authenticating from "./Authenticating.component";
 
 const ServiceWorkerInstall: ComponentType<any> = ({callBackError, authenticating, configurationName }) => {
@@ -15,12 +15,9 @@ const ServiceWorkerInstall: ComponentType<any> = ({callBackError, authenticating
         let isMounted = true;
         const playCallbackAsync = async () => {
             try {
-                const params = new Proxy(new URLSearchParams(window.location.search), {
-                    // @ts-ignore
-                    get: (searchParams, prop) => searchParams.get(prop),
-                });
+                const loginParams = getLoginParams(configurationName)
                 // @ts-ignore
-                await getOidc(configurationName).loginAsync(decodeURIComponent(params.callbackPath), false);
+                await getOidc(configurationName).loginAsync(loginParams.callbackPath, loginParams.extras,false, loginParams.state);
                 if(isMounted) {
                     setLoading(false);
                 }
@@ -32,7 +29,7 @@ const ServiceWorkerInstall: ComponentType<any> = ({callBackError, authenticating
             }
         };
         playCallbackAsync();
-        return  () => {
+        return () => {
             isMounted = false;
         };
     },[]);

package/src/oidc/core/default-component/SilentCallback.component.tsx

@@ -1,5 +1,5 @@
 import React, {useEffect, ComponentType} from 'react';
-import Oidc from "../../vanilla/oidc";
+import Oidc, {getLoginParams} from "../../vanilla/oidc";
 import {OidcSecure} from "../../OidcSecure";
 
 const CallBack = ({configurationName}) =>{
@@ -23,7 +23,8 @@ const CallBack = ({configurationName}) =>{
 }
 
 const CallbackManager: ComponentType<any> = ({configurationName }) => {
-    return <OidcSecure configurationName={configurationName}>
+    const loginParams = getLoginParams(configurationName);
+    return <OidcSecure configurationName={configurationName} state={loginParams.state} extras={loginParams.extras}>
         <CallBack configurationName={configurationName}/>
     </OidcSecure>;
 };

package/src/oidc/vanilla/initSession.ts

@@ -1,35 +1,35 @@
 export const initSession = (configurationName) => {
 
     const saveItemsAsync =(items) =>{
-        sessionStorage.items = JSON.stringify(items);
+        sessionStorage[`oidc_items.${configurationName}`] = JSON.stringify(items);
         return Promise.resolve();
     }
 
     const loadItemsAsync=() =>{
-        return Promise.resolve(JSON.parse(sessionStorage.items));
+        return Promise.resolve(JSON.parse(sessionStorage[`oidc_items.${configurationName}`]));
     }
 
     const clearAsync=() =>{
-        sessionStorage[configurationName] = JSON.stringify({tokens:null});
+        sessionStorage[`oidc.${configurationName}`] = JSON.stringify({tokens:null});
         return Promise.resolve();
     }
 
     const initAsync=async () => {
-        if(!sessionStorage[configurationName]){
-            sessionStorage[configurationName] = JSON.stringify({tokens:null});
+        if(!sessionStorage[`oidc.${configurationName}`]){
+            sessionStorage[`oidc.${configurationName}`] = JSON.stringify({tokens:null});
         }
-        return Promise.resolve({ tokens : JSON.parse(sessionStorage[configurationName]).tokens });
+        return Promise.resolve({ tokens : JSON.parse(sessionStorage[`oidc.${configurationName}`]).tokens });
     }
 
     const setTokens = (tokens) => {
-        sessionStorage[configurationName] = JSON.stringify({tokens});
+        sessionStorage[`oidc.${configurationName}`] = JSON.stringify({tokens});
     }
 
     const getTokens = () => {
-        if(!sessionStorage[configurationName]){
+        if(!sessionStorage[`oidc.${configurationName}`]){
             return null;
         }
-        return JSON.stringify({ tokens : JSON.parse(sessionStorage[configurationName]).tokens });
+        return JSON.stringify({ tokens : JSON.parse(sessionStorage[`oidc.${configurationName}`]).tokens });
     }
 
     return { saveItemsAsync, loadItemsAsync, clearAsync, initAsync, setTokens, getTokens };

package/src/oidc/vanilla/oidc.ts

@@ -45,7 +45,7 @@ const extractAccessTokenPayload = tokens => {
     }
     const accessToken = tokens.accessToken;
     try{
-        if (!accessToken || countLetter(accessToken,'.') === 2) {
+        if (!accessToken || countLetter(accessToken,'.') != 2) {
             return null;
         }
         return JSON.parse(atob(accessToken.split('.')[1]));
@@ -59,6 +59,11 @@ export interface StringMap {
     [key: string]: string;
 }
 
+export interface loginCallbackResult {
+    state: string,
+    callbackPath: string,
+}
+
 export interface AuthorityConfiguration {
     authorization_endpoint: string;
     token_endpoint: string;
@@ -101,39 +106,36 @@ const loginCallbackWithAutoTokensRenewAsync = async (oidc) => {
     }
     oidc.publishEvent(Oidc.eventNames.token_aquired, oidc.tokens);
     oidc.timeoutId = await autoRenewTokensAsync(oidc, tokens.refreshToken, oidc.tokens.expiresAt)
-    return response.state;
-}
-
-const renewTokenAsync = async (oidc, refreshToken, extras:StringMap=null) =>{
-    const tokens = await oidc.refreshTokensAsync(refreshToken, false, extras);
-    oidc.tokens= await setTokensAsync(oidc.serviceWorker, tokens);
-    if(!oidc.serviceWorker){
-        await oidc.session.setTokens(oidc.tokens);
-    }
-    if(!oidc.tokens){
-        return null;
-    }
-    oidc.publishEvent(Oidc.eventNames.token_renewed, oidc.tokens);
-    return oidc.tokens;
+    return { state:response.state, callbackPath : response.callbackPath };
 }
 
 const autoRenewTokensAsync = async (oidc, refreshToken, expiresAt) => {
     const refreshTimeBeforeTokensExpirationInSecond = oidc.configuration.refresh_time_before_tokens_expiration_in_second ?? 60;
-    return timer.setTimeout(async () => {
+    return  timer.setTimeout(async () => {
         const currentTimeUnixSecond = new Date().getTime() /1000;
         const timeInfo = { timeLeft:((expiresAt - refreshTimeBeforeTokensExpirationInSecond)- currentTimeUnixSecond)};
         oidc.publishEvent(Oidc.eventNames.token_timer, timeInfo);
         if(currentTimeUnixSecond > (expiresAt - refreshTimeBeforeTokensExpirationInSecond)) {
-            const tokens = await renewTokenAsync(oidc, refreshToken);
-            if(tokens) {
-                oidc.timeoutId = await autoRenewTokensAsync(oidc, tokens.refreshToken, oidc.tokens.expiresAt);
+            const tokens = await oidc.refreshTokensAsync(refreshToken);
+            oidc.tokens= await setTokensAsync(oidc.serviceWorker, tokens);
+            if(!oidc.serviceWorker){
+                await oidc.session.setTokens(oidc.tokens);
+            }
+            if(!oidc.tokens){
+                return;                
             }
+            oidc.publishEvent(Oidc.eventNames.token_renewed, oidc.tokens);
+            oidc.timeoutId = await autoRenewTokensAsync(oidc, tokens.refreshToken, oidc.tokens.expiresAt);
         } else{
             oidc.timeoutId = await autoRenewTokensAsync(oidc, refreshToken, expiresAt)
         }
     }, 1000);
 }
 
+export const getLoginParams = (configurationName) => {
+    return JSON.parse(sessionStorage[`oidc_login.${configurationName}`]);
+}
+
 const userInfoAsync = async (oidc) => {
     if(oidc.userInfo != null){
         return oidc.userInfo;
@@ -257,7 +259,8 @@ export class Oidc {
         return oidcFactory(configuration, name);
     }
     static get(name="default") {
-        if(!oidcDatabase.hasOwnProperty(name)){
+        const insideBrowser = (typeof process === 'undefined');
+        if(!oidcDatabase.hasOwnProperty(name) && insideBrowser){
             throw Error(`Oidc library does seem initialized.
 Please checkout that you are using OIDC hook inside a <OidcProvider configurationName="${name}"></OidcProvider> compoment.`)
         }
@@ -383,23 +386,24 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
         }
     }
 
-    async loginAsync(callbackPath:string=undefined, extras:StringMap=null, installServiceWorker=true) {
+    async loginAsync(callbackPath:string=undefined, extras:StringMap=null, installServiceWorker=true, state:string=undefined) {
         try {
             const location = window.location;
             const url = callbackPath || location.pathname + (location.search || '') + (location.hash || '');
-            const state = url;
             this.publishEvent(eventNames.loginAsync_begin, {});
             const configuration = this.configuration
             // Security we cannot loggin from Iframe
             if (!configuration.silent_redirect_uri && isInIframe()) {
                 throw new Error("Login from iframe is forbidden");
             }
+            sessionStorage[`oidc_login.${this.configurationName}`] = JSON.stringify({callbackPath:url,extras,state});
+            
             let serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, this.configurationName);
             const oidcServerConfiguration = await this.initAsync(configuration.authority, configuration.authority_configuration);
             if(serviceWorker && installServiceWorker) {
-                const isServiceWorkerProxyActive = await serviceWorker.isServiceWorkerProxyActiveAsync()
+                const isServiceWorkerProxyActive = await serviceWorker.isServiceWorkerProxyActiveAsync();
                 if(!isServiceWorkerProxyActive) {
-                    window.location.href = configuration.redirect_uri + "/service-worker-install?callbackPath=" + encodeURIComponent(url);
+                    window.location.href = `${configuration.redirect_uri}/service-worker-install`;
                     return;
                 }
             }
@@ -424,13 +428,13 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                         extras: extras ?? configuration.extras
                     });
                     authorizationHandler.performAuthorizationRequest(oidcServerConfiguration, authRequest);
-        } catch(exception){
-                this.publishEvent(eventNames.loginAsync_error, exception);
-                throw exception;
+        } catch(exception) {
+            this.publishEvent(eventNames.loginAsync_error, exception);
+            throw exception;
         }
     }
 
-    async loginCallbackAsync() {
+    async loginCallbackAsync(){
         try {
             this.publishEvent(eventNames.loginCallbackAsync_begin, {});
             const configuration = this.configuration;
@@ -452,7 +456,6 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                 const items = await session.loadItemsAsync();
                 storage = new MemoryStorageBackend(session.saveItemsAsync, items);
             }
-            
             const promise = new Promise((resolve, reject) => {
                 const tokenHandler = new BaseTokenRequestHandler(new FetchRequestor());
                 // @ts-ignore
@@ -465,6 +468,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                         reject(error);
                     }
                     if (!response) {
+                        reject("no response");
                         return;
                     }
     
@@ -490,7 +494,12 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                     
                     try {
                         const tokenResponse =  await tokenHandler.performTokenRequest(oidcServerConfiguration, tokenRequest);
-                        resolve({tokens:tokenResponse, state: request.state});
+                        const loginParams = getLoginParams(this.configurationName);
+                        resolve({
+                            tokens:tokenResponse, 
+                            state: request.state,
+                            callbackPath : loginParams.callbackPath,
+                        });
                         this.publishEvent(eventNames.loginCallbackAsync_end, {})
                     } catch(exception){
                         this.publishEvent(eventNames.loginCallbackAsync_error, exception);
@@ -508,20 +517,8 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
         }
 
     }
-    
-    async renewTokensAsync(extras:StringMap=null)
-    {
-        // @ts-ignore
-        if(this.tokens && this.tokens.refreshToken && this.timeoutId) {
-            // @ts-ignore
-            timer.clearTimeout(this.timeoutId);
-            // @ts-ignore
-            const tokens = await renewTokenAsync(this, this.tokens.refreshToken, extras);
-            await autoRenewTokensAsync(this, tokens.refreshToken, tokens.expiresAt);
-        }
-    }
 
-    async refreshTokensAsync(refreshToken, silentEvent = false, extras:StringMap=null) {
+    async refreshTokensAsync(refreshToken, silentEvent = false) {
         const localSilentSigninAsync= async (exception=null) => {
             try {
                 const silent_token_response = await this.silentSigninAsync();
@@ -549,17 +546,11 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             }
             const tokenHandler = new BaseTokenRequestHandler(new FetchRequestor());
 
-            let extrasRequest = undefined;
-            if(extras){
-                extrasRequest = {}
-                for (let [key, value] of Object.entries(extras)) {
-                    extrasRequest[key] = value;
-                }
-            }
-            else if(configuration.token_request_extras) {
-                extrasRequest = {}
+            let extras = undefined;
+            if(configuration.token_request_extras) {
+                extras = {}
                 for (let [key, value] of Object.entries(configuration.token_request_extras)) {
-                    extrasRequest[key] = value;
+                    extras[key] = value;
                 }
             }
             
@@ -570,7 +561,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                 grant_type: GRANT_TYPE_REFRESH_TOKEN,
                 code: undefined,
                 refresh_token: refreshToken,
-                extras: extrasRequest
+                extras
                 });
             
             const oidcServerConfiguration = await this.initAsync(authority, configuration.authority_configuration);
@@ -583,7 +574,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
         }
      }
      
-     loginCallbackWithAutoTokensRenewAsync():Promise<string>{
+     loginCallbackWithAutoTokensRenewAsync():Promise<loginCallbackResult>{
         return loginCallbackWithAutoTokensRenewAsync(this);
      }
      
@@ -607,13 +598,12 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
     async logoutAsync(callbackPath: string | undefined = undefined, extras:StringMap=null) {
         const configuration = this.configuration;
         const oidcServerConfiguration = await this.initAsync(configuration.authority, configuration.authority_configuration);
-        // TODO implement real logout
         if(callbackPath && (typeof callbackPath !== 'string'))
         {
             callbackPath = undefined;
             console.warn('callbackPath path is not a string');
         }
-        const path = callbackPath || location.pathname + (location.search || '') + (location.hash || '');
+        const path = (callbackPath === null || callbackPath === undefined) ? location.pathname + (location.search || '') + (location.hash || '') : callbackPath;
         const url = window.location.origin +path;
         // @ts-ignore
         const idToken = this.tokens ? this.tokens.idToken : "";
@@ -634,4 +624,4 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
   }
   
 
-  export default Oidc;
+  export default Oidc;

package/src/oidc/vanilla/timer.ts

@@ -62,7 +62,7 @@
         } catch (error) {
             return null;
         }
-        
+        const insideBrowser = (typeof process === 'undefined');
         try {
             if (SharedWorker) {
                 worker = new SharedWorker(blobURL);
@@ -70,7 +70,9 @@
             } 
         } catch (error)
         {
-            console.log("SharedWorker not available");
+            if(insideBrowser) {
+                console.warn("SharedWorker not available");
+            }
         }
         try {
             if (Worker) {
@@ -79,7 +81,9 @@
             }
         } catch (error)
         {
-            console.log("Worker not available");
+            if(insideBrowser) {
+                console.warn("Worker not available");
+            }
         }
 
         return null;