@axa-fr/react-oidc 6.0.0-beta14 → 6.0.0-beta17

package/src/oidc/vanilla/OidcServiceWorker.js

@@ -18,7 +18,7 @@ let database = {
     default: {
         configurationName: "default",
         tokens: null,
-        isLogin:null,
+        status:null,
         items:[],
         oidcServerConfiguration: null
     }
@@ -44,12 +44,12 @@ const extractTokenPayload=(accessToken)=> {
     return null;
 }
 
-export const computeTimeLeft = (refreshTimeBeforeTokensExpirationInSecond, expiresAt)=>{
+const computeTimeLeft = (refreshTimeBeforeTokensExpirationInSecond, expiresAt)=>{
     const currentTimeUnixSecond = new Date().getTime() /1000;
     return Math.round(((expiresAt - refreshTimeBeforeTokensExpirationInSecond) - currentTimeUnixSecond));
 }
 
-export const isTokensValid= (tokens) =>{
+const isTokensValid= (tokens) =>{
     if(!tokens){
         return false;
     }
@@ -65,7 +65,7 @@ function hideTokens(currentDatabaseElement) {
                 tokens.issued_at = currentTimeUnixSecond;
             }
             currentDatabaseElement.tokens = tokens;
-            currentDatabaseElement.isLogin = true;
+            currentDatabaseElement.status = "LOGGED_IN";
             const accessTokenPayload = extractTokenPayload(tokens.access_token);
             const secureTokens = {
                 ...tokens,
@@ -85,8 +85,8 @@ function hideTokens(currentDatabaseElement) {
             const idTokenExipreAt =(_idTokenPayload && _idTokenPayload.exp) ? _idTokenPayload.exp: Number.MAX_VALUE;
             const accessTokenExpiresAt =  (accessTokenPayload && accessTokenPayload.exp)? accessTokenPayload.exp : tokens.issuedAt + tokens.expiresIn;
             const expiresAt = idTokenExipreAt < accessTokenExpiresAt ? idTokenExipreAt : accessTokenExpiresAt;
-            secureTokens.expireAt = expiresAt;
-            
+            secureTokens.expiresAt = expiresAt;
+            tokens.expiresAt = expiresAt;
             
             const body = JSON.stringify(secureTokens)
             return new Response(body, response);
@@ -297,7 +297,7 @@ addEventListener('message', event => {
             tokens: null,
             items:[],
             oidcServerConfiguration: null,
-            isLogin:null,
+            status:null,
             configurationName: configurationName,
         };
         currentDatabase = database[configurationName];
@@ -312,7 +312,7 @@ addEventListener('message', event => {
         case "clear":
             currentDatabase.tokens = null;
             currentDatabase.items = null;
-            currentDatabase.isLogin = false;
+            currentDatabase.status = data.data.status;
             port.postMessage({configurationName});
             return;
         case "init":
@@ -333,7 +333,7 @@ addEventListener('message', event => {
             if(!currentDatabase.tokens){
                 port.postMessage({
                     tokens:null,
-                    isLogin: currentDatabase.isLogin,
+                    status: currentDatabase.status,
                     configurationName});
             } else {
                 const tokens = {
@@ -345,16 +345,11 @@ addEventListener('message', event => {
                 }
                 port.postMessage({
                     tokens,
-                    isLogin: currentDatabase.isLogin,
+                    status: currentDatabase.status,
                     configurationName
                 });
             }
             return;
-
-        /*case "getAccessTokenPayload":
-            const accessTokenPayload = extractAccessTokenPayload(currentDatabase.tokens.access_token);
-            port.postMessage({configurationName, accessTokenPayload});
-            return;*/
             
         case "setSessionState":
             currentDatabase.sessionState = data.data.sessionState;

package/src/oidc/vanilla/initSession.ts

@@ -9,22 +9,21 @@
         return Promise.resolve(JSON.parse(storage[`oidc_items.${configurationName}:${redirectUri}`]));
     }
 
-    const clearAsync=() =>{
-        storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({tokens:null});
+    const clearAsync=(status) =>{
+        storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({tokens:null, status});
         return Promise.resolve();
     }
 
     const initAsync=async () => {
         if(!storage[`oidc.${configurationName}:${redirectUri}`]){
-            storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({tokens:null});
-            return {tokens:null};
+            storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({tokens:null, status:null});
+            return {tokens:null, status:null};
         }
-        return Promise.resolve({ tokens : JSON.parse(storage[`oidc.${configurationName}:${redirectUri}`]).tokens });
+        const data = JSON.parse(storage[`oidc.${configurationName}:${redirectUri}`]);
+        return Promise.resolve({ tokens : data.tokens, status: data.status });
     }
 
     const setTokens = (tokens) => {
-        //console.log("setTokens");
-        //console.log(tokens);
         storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({tokens});
     }
 

package/src/oidc/vanilla/initWorker.ts

@@ -107,19 +107,9 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
     const unregisterAsync = async () => {
         return await registration.unregister();
     }
-
-   /* const getAccessTokenPayloadAsync=async () => {
-        const result = await sendMessageAsync(registration)({
-            type: "getAccessTokenPayload",
-            data: null,
-            configurationName
-        });
-        // @ts-ignore
-        return result.accessTokenPayload;
-    }*/
-
-    const clearAsync=() =>{
-        return sendMessageAsync(registration)({type: "clear", data: null, configurationName});
+    
+    const clearAsync=(status) =>{
+        return sendMessageAsync(registration)({type: "clear", data: {status}, configurationName});
     }
     const initAsync= async (oidcServerConfiguration, where) => {
         const result = await sendMessageAsync(registration)({
@@ -128,7 +118,7 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
             configurationName
         });
         // @ts-ignore
-        return { tokens : parseOriginalTokens(result.tokens), isLogin: result.isLogin};
+        return { tokens : parseOriginalTokens(result.tokens), status: result.status};
     }
     
     const startKeepAliveServiceWorker = () => {

package/src/oidc/vanilla/oidc.ts

@@ -48,8 +48,8 @@ const performTokenRequestAsync= async (url, details, extras) => {
         return {success:false, status: response.status}
     }
     const tokens = await response.json();
-    console.log(tokens);
-    return { success : true,
+    return { 
+        success : true,
         data: parseOriginalTokens(tokens)
     };
 }
@@ -70,7 +70,6 @@ const internalFetch = async (url, headers, numberRetry=0) => {
                 throw e;
             }
         } else {
-            
             console.error(e.message);
             throw e; // rethrow other unexpected errors
         }
@@ -156,44 +155,40 @@ const autoRenewTokens = (oidc, refreshToken, expiresAt) => {
         const timeLeft = computeTimeLeft(refreshTimeBeforeTokensExpirationInSecond, expiresAt);
         const timeInfo = { timeLeft };
         oidc.publishEvent(Oidc.eventNames.token_timer, timeInfo);
-       // if(timeLeft <= 0) {
-            const tokens = await oidc.synchroniseTokensAsync(refreshToken);
+            const {tokens, status} = await oidc.synchroniseTokensAsync(refreshToken);
             oidc.tokens= tokens;
             if(!oidc.serviceWorker){
                 await oidc.session.setTokens(oidc.tokens);
             }
             if(!oidc.tokens){
-                await oidc.destroyAsync();
-                oidc.publishEvent(eventNames.refreshTokensAsync_error, {message: `refresh token` });
+                await oidc.destroyAsync(status);
                 return;                
             }
             
             if(oidc.timeoutId) {
                 oidc.timeoutId = autoRenewTokens(oidc, tokens.refreshToken, oidc.tokens.expiresAt);
             }
-        /*} else{
-            const tokens = await oidc.syncTokensAsync();
-            oidc.tokens = tokens;
-            if(!oidc.serviceWorker){
-                await oidc.session.setTokens(oidc.tokens);
-            }
-            if(!oidc.tokens){
-                oidc.publishEvent(eventNames.refreshTokensAsync_error, {message: `sync` });
-                await oidc.destroyAsync();
-                return;
-            }
-            if(tokens && oidc.timeoutId) {
-                oidc.timeoutId = autoRenewTokens(oidc, tokens.refreshToken, tokens.expiresAt);
-            }
-        }*/
+
     }, 1000);
 }
 
 const getLoginSessionKey = (configurationName:string, redirectUri:string) => {
     return `oidc_login.${configurationName}:${redirectUri}`;
 }
+
+const setLoginParams = (configurationName:string, redirectUri:string, data) =>{
+    const sessionKey = getLoginSessionKey(configurationName, redirectUri);
+    getLoginParamsCache = data
+    sessionStorage[sessionKey] = JSON.stringify(data);
+}
+
+let getLoginParamsCache = null;
 const getLoginParams = (configurationName, redirectUri) => {
-    return JSON.parse(sessionStorage[getLoginSessionKey(configurationName, redirectUri)]);
+    const dataString = sessionStorage[getLoginSessionKey(configurationName, redirectUri)];
+    if(!getLoginParamsCache){
+        getLoginParamsCache = JSON.parse(dataString);
+    }
+    return getLoginParamsCache;
 }
 
 const userInfoAsync = async (oidc) => {
@@ -623,9 +618,8 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                     scope = configuration.scope;
                 }
 
-                const sessionKey = getLoginSessionKey(this.configurationName, redirectUri);
-                sessionStorage[sessionKey] = JSON.stringify({callbackPath: url, extras, state});
-
+                setLoginParams(this.configurationName, redirectUri, {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);
                 let storage;
@@ -700,7 +694,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                         for (const [key, oidc] of Object.entries(oidcDatabase)) {
                             //if(oidc !== this) {
                                 // @ts-ignore
-                               await oidc.logoutOtherTabAsync(idTokenPayload.sub);
+                               await oidc.logoutOtherTabAsync(this.configuration.client_id, idTokenPayload.sub);
                             //}
                         }
                         //await this.destroyAsync();
@@ -891,15 +885,20 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                 }, loginParams.state);
                 if (silent_token_response) {
                     this.publishEvent(Oidc.eventNames.token_renewed, {});
-                    return silent_token_response.tokens;
+                    return {tokens:silent_token_response.tokens, status:"LOGGED"};
                 }
             } catch (exceptionSilent) {
+                console.error(exceptionSilent);
+                this.publishEvent(eventNames.refreshTokensAsync_silent_error, {message: "exceptionSilent" ,exception: exceptionSilent.message});
                 if(exceptionSilent && exceptionSilent.message && exceptionSilent.message.startsWith("oidc")){
-                    return null;
-                }
+                    this.publishEvent(eventNames.refreshTokensAsync_error, {message: `refresh token silent` });
+                    return {tokens:null, status:"SESSION_LOST"};
+                } 
+                await sleepAsync(1000);
                 throw exceptionSilent;
             }
-            return null;
+            this.publishEvent(eventNames.refreshTokensAsync_error, {message: `refresh token silent return` });
+            return {tokens:null, status:"SESSION_LOST"};
         }
             
             if (index <=4) {
@@ -911,16 +910,18 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                         return await localsilentLoginAsync();
                     }
                     const { status, tokens } = await this.syncTokensInfoAsync(configuration, this.configurationName, this.tokens);
-                   // this.publishEvent(eventNames.refreshTokensAsync, {message: `status ${status}` });
                     switch (status) {
+                        case "SESSION_LOST":
+                            this.publishEvent(eventNames.refreshTokensAsync_error, {message: `refresh token session lost` });
+                            return {tokens:null, status:"SESSION_LOST"};
                         case "NOT_CONNECTED":
-                            return null;
+                            return {tokens:null, status:null};
                         case "TOKENS_VALID":
                         case "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID":
-                            return tokens;
+                            return {tokens, status:"LOGGED_IN"};
                         case "LOGOUT_FROM_ANOTHER_TAB":
                             this.publishEvent(eventNames.logout_from_another_tab, {"status": "session syncTokensAsync"});
-                            return null;
+                            return {tokens:null, status:"LOGGED_OUT"};
                         case "REQUIRE_SYNC_TOKENS":
                             this.publishEvent(eventNames.refreshTokensAsync_begin, {refreshToken:refreshToken, status, tryNumber: index});
                             return await localsilentLoginAsync();
@@ -946,7 +947,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                             if (tokenResponse.success) {
                                 this.publishEvent(eventNames.refreshTokensAsync_end, {success: tokenResponse.success});
                                 this.publishEvent(Oidc.eventNames.token_renewed, {});
-                                return tokenResponse.data;
+                                return {tokens: tokenResponse.data, status:"LOGGED_IN"};
                             } else {
                                 this.publishEvent(eventNames.refreshTokensAsync_silent_error, {
                                     message: "bad request",
@@ -961,7 +962,9 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                     return this.synchroniseTokensAsync(refreshToken, index+1);
                 }
             }
-        return null;
+
+        this.publishEvent(eventNames.refreshTokensAsync_error, {message: `refresh token` });
+        return {tokens:null, status:"SESSION_LOST"};
      }
 
     async syncTokensInfoAsync(configuration, configurationName, currentTokens)  {
@@ -974,10 +977,12 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
         const oidcServerConfiguration = await this.initAsync(configuration.authority, configuration.authority_configuration);
         const serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, configurationName);
         if (serviceWorker) {
-            const {isLogin, tokens} = await serviceWorker.initAsync(oidcServerConfiguration, "syncTokensAsync");
-            if (isLogin == false) {
-                return { tokens : null, status: "LOGOUT_FROM_ANOTHER_TAB"};
-            } else if (isLogin == null) {
+            const {status, tokens} = await serviceWorker.initAsync(oidcServerConfiguration, "syncTokensAsync");
+            if (status == "LOGGED_OUT") {
+                return {tokens: null, status: "LOGOUT_FROM_ANOTHER_TAB"};
+            }else if (status == "SESSIONS_LOST") {
+                    return { tokens : null, status: "SESSIONS_LOST"};
+            } else if (!status || !tokens) {
                 return { tokens : null, status: "REQUIRE_SYNC_TOKENS"};
             } else if(tokens.issuedAt !== currentTokens.issuedAt) {
                 const timeLeft = computeTimeLeft(configuration.refresh_time_before_tokens_expiration_in_second, tokens.expiresAt);
@@ -986,10 +991,13 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             }
         } else {
             const session = initSession(configurationName, configuration.redirect_uri, configuration.storage ?? sessionStorage);
-            const {tokens} = await session.initAsync();
+            const {tokens, status } = await session.initAsync();
             if (!tokens) {
-                return { tokens : null, status: "LOGOUT_FROM_ANOTHER_TAB"};
-            } else if(tokens.issuedAt !== currentTokens.issuedAt){
+                return {tokens: null, status: "LOGOUT_FROM_ANOTHER_TAB"};
+            } else if (status == "SESSIONS_LOST") {
+                    return { tokens : null, status: "SESSIONS_LOST"};
+                }
+            else if(tokens.issuedAt !== currentTokens.issuedAt){
                 const timeLeft = computeTimeLeft(configuration.refresh_time_before_tokens_expiration_in_second, tokens.expiresAt);
                 const status = (timeLeft > 0) ? "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID" : "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_INVALID";
                 return { tokens : tokens, status };
@@ -1017,36 +1025,35 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
          return userInfoAsync(this);
      }
      
-     async destroyAsync() {
+     async destroyAsync(status) {
          timer.clearTimeout(this.timeoutId);
          this.timeoutId=null;
          if(this.checkSessionIFrame){
              this.checkSessionIFrame.stop();
          }
         if(this.serviceWorker){
-            await this.serviceWorker.clearAsync();
+            await this.serviceWorker.clearAsync(status);
         }
          if(this.session){
-             await this.session.clearAsync();
+             await this.session.clearAsync(status);
          }
          this.tokens = null;
          this.userInfo = null;
         // this.events = [];
      }
      
-     async logoutSameTabAsync(sub){
+     async logoutSameTabAsync(clientId, sub){
          // @ts-ignore
-         if(this.configuration.monitor_session && sub && this.tokens && this.tokens.idTokenPayload && this.tokens.idTokenPayload.sub === sub) {
+         if(this.configuration.monitor_session&& this.configuration.client_id === clientId && sub && this.tokens && this.tokens.idTokenPayload && this.tokens.idTokenPayload.sub === sub) {
              this.publishEvent(eventNames.logout_from_same_tab, {"message": sub});
-             await this.destroyAsync();
+             await this.destroyAsync("LOGGED_OUT");
          }
      }
 
-    async logoutOtherTabAsync(sub){
+    async logoutOtherTabAsync(clientId, sub){
         // @ts-ignore
-        if(this.configuration.monitor_session && sub && this.tokens && this.tokens.idTokenPayload && this.tokens.idTokenPayload.sub === sub) {
-            await this.destroyAsync();
-            console.log("logoutOtherTabAsync(sub)" +this.configurationName);
+        if(this.configuration.monitor_session && this.configuration.client_id === clientId && sub && this.tokens && this.tokens.idTokenPayload && this.tokens.idTokenPayload.sub === sub) {
+            await this.destroyAsync("LOGGED_OUT");
             this.publishEvent(eventNames.logout_from_another_tab, {message : "SessionMonitor", "sub": sub});
         }
     }
@@ -1069,11 +1076,11 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
         const idToken = this.tokens ? this.tokens.idToken : "";
         // @ts-ignore
         const sub = this.tokens && this.tokens.idTokenPayload ? this.tokens.idTokenPayload.sub : null;
-        await this.destroyAsync();
+        await this.destroyAsync("LOGGED_OUT");
         for (const [key, oidc] of Object.entries(oidcDatabase)) {
             if(oidc !== this) {
                 // @ts-ignore
-                await oidc.logoutSameTabAsync(sub);
+                await oidc.logoutSameTabAsync(this.configuration.client_id, sub);
             }
         }
         

package/src/oidc/vanilla/parseTokens.js

@@ -1,4 +1,7 @@
 const idTokenPayload = (token) => {
+    if(!token){
+        return null;
+    }
     const base64Url = token.split('.')[1];
     const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
     const jsonPayload = decodeURIComponent(atob(base64).split('').map(function (c) {