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

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;
@@ -244,8 +246,8 @@ export class Oidc {
     }
 
     removeEventSubscription(id){
-        const newEvents = this.events.filter(e =>  e.id === id);
-        this.events = newEvents;
+       const newEvents = this.events.filter(e =>  e.id !== id);
+       this.events = newEvents;
     }
 
     publishEvent(eventName, data){
@@ -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.`)
         }
@@ -327,79 +330,105 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
         }
         return await AuthorizationServiceConfiguration.fetchFromIssuer(authority, new FetchRequestor());
     }
-    
+
+    tryKeepExistingSessionPromise = null;
     async tryKeepExistingSessionAsync() {
-        let serviceWorker
-        if(this.tokens != null){
-            return false;
+        if(this.tryKeepExistingSessionPromise !== null){
+            return this.tryKeepExistingSessionPromise;
         }
-        this.publishEvent(eventNames.tryKeepExistingSessionAsync_begin, {});
-        try {
-            const configuration = this.configuration;
-            const oidcServerConfiguration = await this.initAsync(configuration.authority, configuration.authority_configuration);
-            serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, this.configurationName);
-            if(serviceWorker) {
-                const { tokens } = await serviceWorker.initAsync(oidcServerConfiguration, "tryKeepExistingSessionAsync");
-                if (tokens) {
-                    serviceWorker.startKeepAliveServiceWorker();
-                    const updatedTokens = await this.refreshTokensAsync(tokens.refresh_token, true);
-                    // @ts-ignore
-                    this.tokens = await setTokensAsync(serviceWorker, updatedTokens);
-                    this.serviceWorker = serviceWorker;
-                    // @ts-ignore
-                    this.timeoutId = await autoRenewTokensAsync(this, updatedTokens.refreshToken, this.tokens.expiresAt);
-                    this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {success: true, message : "tokens inside ServiceWorker are valid"});
-                    return true;
-                }
-                this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {success: false, message : "no exiting session found"});
-            } else {
-                if(configuration.service_worker_relative_url) {
-                    this.publishEvent(eventNames.service_worker_not_supported_by_browser, {
-                        message: "service worker is not supported by this browser"
+        
+        const funcAsync  =async () => {
+            let serviceWorker
+            if (this.tokens != null) {
+                return false;
+            }
+            this.publishEvent(eventNames.tryKeepExistingSessionAsync_begin, {});
+            try {
+                const configuration = this.configuration;
+                const oidcServerConfiguration = await this.initAsync(configuration.authority, configuration.authority_configuration);
+                serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, this.configurationName);
+                if (serviceWorker) {
+                    const {tokens} = await serviceWorker.initAsync(oidcServerConfiguration, "tryKeepExistingSessionAsync");
+                    if (tokens) {
+                        serviceWorker.startKeepAliveServiceWorker();
+                        const updatedTokens = await this.refreshTokensAsync(tokens.refresh_token, true);
+                        // @ts-ignore
+                        this.tokens = await setTokensAsync(serviceWorker, updatedTokens);
+                        this.serviceWorker = serviceWorker;
+                        // @ts-ignore
+                        this.timeoutId = await autoRenewTokensAsync(this, updatedTokens.refreshToken, this.tokens.expiresAt);
+                        this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {
+                            success: true,
+                            message: "tokens inside ServiceWorker are valid"
+                        });
+                        return true;
+                    }
+                    this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {
+                        success: false,
+                        message: "no exiting session found"
                     });
+                } else {
+                    if (configuration.service_worker_relative_url) {
+                        this.publishEvent(eventNames.service_worker_not_supported_by_browser, {
+                            message: "service worker is not supported by this browser"
+                        });
+                    }
+                    const session = initSession(this.configurationName);
+                    const {tokens} = await session.initAsync();
+                    if (tokens) {
+                        const updatedTokens = await this.refreshTokensAsync(tokens.refreshToken, true);
+                        // @ts-ignore
+                        this.tokens = await setTokensAsync(serviceWorker, updatedTokens);
+                        session.setTokens(this.tokens);
+                        this.session = session;
+                        // @ts-ignore
+                        this.timeoutId = await autoRenewTokensAsync(this, updatedTokens.refreshToken, this.tokens.expiresAt);
+                        this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {
+                            success: true,
+                            message: "tokens inside ServiceWorker are valid"
+                        });
+                        return true;
+                    }
                 }
-                const session = initSession(this.configurationName);
-                const {tokens} = await session.initAsync();
-                if (tokens) {
-                    const updatedTokens = await this.refreshTokensAsync(tokens.refreshToken, true);
-                    // @ts-ignore
-                    this.tokens = await setTokensAsync(serviceWorker, updatedTokens);
-                    session.setTokens(this.tokens);
-                    this.session = session;
-                    // @ts-ignore
-                    this.timeoutId = await autoRenewTokensAsync(this, updatedTokens.refreshToken, this.tokens.expiresAt);
-                    this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {success: true, message : "tokens inside ServiceWorker are valid"});
-                    return true;
+                this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {
+                    success: false,
+                    message: "no service worker"
+                });
+                return false;
+            } catch (exception) {
+                if (serviceWorker) {
+                    await serviceWorker.clearAsync();
                 }
+                this.publishEvent(eventNames.tryKeepExistingSessionAsync_error, "tokens inside ServiceWorker are invalid");
+                return false;
             }
-            this.publishEvent(eventNames.tryKeepExistingSessionAsync_end, {success: false, message : "no service worker"});
-            return false;
-        } catch (exception) {
-            if(serviceWorker){
-                await serviceWorker.clearAsync();
-            }
-            this.publishEvent(eventNames.tryKeepExistingSessionAsync_error, "tokens inside ServiceWorker are invalid");
-            return false;
         }
+        
+        this.tryKeepExistingSessionPromise = funcAsync();
+        return this.tryKeepExistingSessionPromise.then((result) => {
+            this.tryKeepExistingSessionPromise =null;
+            return result;
+        });
     }
 
-    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 +453,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 +481,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 +493,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                         reject(error);
                     }
                     if (!response) {
+                        reject("no response");
                         return;
                     }
     
@@ -490,7 +519,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 +542,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 +571,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 +586,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);
@@ -582,9 +598,17 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             return await localSilentSigninAsync(exception);
         }
      }
-     
-     loginCallbackWithAutoTokensRenewAsync():Promise<string>{
-        return loginCallbackWithAutoTokensRenewAsync(this);
+
+    loginCallbackWithAutoTokensRenewPromise:Promise<loginCallbackResult> = null;
+     loginCallbackWithAutoTokensRenewAsync():Promise<loginCallbackResult>{
+         if(this.loginCallbackWithAutoTokensRenewPromise !== null){
+             return this.loginCallbackWithAutoTokensRenewPromise;
+         }
+         this.loginCallbackWithAutoTokensRenewPromise = loginCallbackWithAutoTokensRenewAsync(this);
+         return this.loginCallbackWithAutoTokensRenewPromise.then(result =>{
+             this.loginCallbackWithAutoTokensRenewPromise = null;
+             return result;
+         })
      }
      
      userInfoAsync(){
@@ -607,13 +631,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 +657,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,18 +81,24 @@
             }
         } catch (error)
         {
-            console.log("Worker not available");
+            if(insideBrowser) {
+                console.warn("Worker not available");
+            }
         }
 
         return null;
     }());
 
     if (!workerPort) {
+        // In NextJS with SSR (Server Side Rendering) during rending in Node JS, the window object is undefined,
+        // the global object is used instead as it is the closest approximation of a browsers window object.
+        const bindContext = (typeof window === 'undefined')? global: window;
+
         return {
-            setTimeout: setTimeout.bind(window),
-            clearTimeout: clearTimeout.bind(window),
-            setInterval: setInterval.bind(window),
-            clearInterval: clearInterval.bind(window)
+            setTimeout: setTimeout.bind(bindContext),
+            clearTimeout: clearTimeout.bind(bindContext),
+            setInterval: setInterval.bind(bindContext),
+            clearInterval: clearInterval.bind(bindContext)
         };
     }