@axa-fr/oidc-client 7.13.16 → 7.14.0

package/src/renewTokens.ts

@@ -3,9 +3,9 @@ import {initWorkerAsync} from './initWorker.js';
 import Oidc from './oidc.js';
 import {computeTimeLeft, setTokens} from './parseTokens.js';
 import timer from './timer.js';
-import {StringMap} from './types.js';
+import {OidcConfiguration, StringMap} from './types.js';
 
-async function syncTokens(oidc, refreshToken, forceRefresh: boolean, extras: StringMap) {
+async function syncTokens(oidc:Oidc, refreshToken, forceRefresh: boolean, extras: StringMap) {
     const updateTokens = (tokens) => {
         oidc.tokens = tokens;
     };
@@ -72,7 +72,7 @@ export async function renewTokensAndStartTimerAsync(oidc, refreshToken, forceRef
     return oidc.tokens;
 }
 
-export const autoRenewTokens = (oidc, refreshToken, expiresAt, extras:StringMap = null) => {
+export const autoRenewTokens = (oidc:Oidc, refreshToken, expiresAt, extras:StringMap = null) => {
     const refreshTimeBeforeTokensExpirationInSecond = oidc.configuration.refresh_time_before_tokens_expiration_in_second;
     return timer.setTimeout(async () => {
         const timeLeft = computeTimeLeft(refreshTimeBeforeTokensExpirationInSecond, expiresAt);
@@ -81,3 +81,61 @@ export const autoRenewTokens = (oidc, refreshToken, expiresAt, extras:StringMap
         await renewTokensAndStartTimerAsync(oidc, refreshToken, false, extras);
     }, 1000);
 };
+
+export const synchroniseTokensStatus ={
+    'SESSION_LOST': 'SESSION_LOST',
+    'NOT_CONNECTED':'NOT_CONNECTED',
+    'TOKENS_VALID':'TOKENS_VALID',
+    'TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID': 'TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID',
+    'LOGOUT_FROM_ANOTHER_TAB': 'LOGOUT_FROM_ANOTHER_TAB',
+    'REQUIRE_SYNC_TOKENS': 'REQUIRE_SYNC_TOKENS'
+};
+
+export const syncTokensInfoAsync = (oidc: Oidc) => async (configuration:OidcConfiguration, configurationName: string, currentTokens, forceRefresh = false) => {
+    // Service Worker can be killed by the browser (when it wants,for example after 10 seconds of inactivity, so we retreieve the session if it happen)
+    // const configuration = this.configuration;
+    const nullNonce = { nonce: null };
+    if (!currentTokens) {
+        return { tokens: null, status: 'NOT_CONNECTED', nonce: nullNonce };
+    }
+    let nonce = nullNonce;
+    const oidcServerConfiguration = await oidc.initAsync(configuration.authority, configuration.authority_configuration);
+    const serviceWorker = await initWorkerAsync(configuration, configurationName);
+    if (serviceWorker) {
+        const { status, tokens } = await serviceWorker.initAsync(oidcServerConfiguration, 'syncTokensAsync', configuration);
+        if (status === 'LOGGED_OUT') {
+            return { tokens: null, status: 'LOGOUT_FROM_ANOTHER_TAB', nonce: nullNonce };
+        } else if (status === 'SESSIONS_LOST') {
+            return { tokens: null, status: 'SESSIONS_LOST', nonce: nullNonce };
+        } else if (!status || !tokens) {
+            return { tokens: null, status: 'REQUIRE_SYNC_TOKENS', nonce: nullNonce };
+        } 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';
+            const nonce = await serviceWorker.getNonceAsync();
+            return { tokens, status, nonce };
+        }
+        nonce = await serviceWorker.getNonceAsync();
+    } else {
+        const session = initSession(configurationName, configuration.storage ?? sessionStorage);
+        const { tokens, status } = await session.initAsync();
+        if (!tokens) {
+            return { tokens: null, status: 'LOGOUT_FROM_ANOTHER_TAB', nonce: nullNonce };
+        } else if (status === 'SESSIONS_LOST') {
+            return { tokens: null, status: 'SESSIONS_LOST', nonce: nullNonce };
+        } 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';
+            const nonce = await session.getNonceAsync();
+            return { tokens, status, nonce };
+        }
+        nonce = await session.getNonceAsync();
+    }
+
+    const timeLeft = computeTimeLeft(configuration.refresh_time_before_tokens_expiration_in_second, currentTokens.expiresAt);
+    const status = (timeLeft > 0) ? 'TOKENS_VALID' : 'TOKENS_INVALID';
+    if (forceRefresh) {
+        return { tokens: currentTokens, status: 'FORCE_REFRESH', nonce };
+    }
+    return { tokens: currentTokens, status, nonce };
+}

package/src/requests.ts

@@ -27,7 +27,7 @@ export const fetchFromIssuer = (fetch) => async (openIdIssuerUrl: string, timeCa
     return new OidcAuthorizationServiceConfiguration(result);
 };
 
-const internalFetch = (fetch) => async (url, 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();

package/src/types.ts

@@ -33,8 +33,17 @@ export type OidcConfiguration = {
     token_renew_mode?: string;
     logout_tokens_to_invalidate?:Array<LogoutToken>;
     demonstrating_proof_of_possession?:boolean;
+    demonstrating_proof_of_possession_configuration?: DemonstratingProofOfPossessionConfiguration;
 };
 
+export interface DemonstratingProofOfPossessionConfiguration {
+    generateKeyAlgorithm:  RsaHashedKeyGenParams | EcKeyGenParams,
+    digestAlgorithm: AlgorithmIdentifier,
+    importKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm,
+    signAlgorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams,
+    jwtHeaderAlgorithm: string
+}
+
 export interface StringMap {
     [key: string]: string;
 }

package/src/user.ts

@@ -1,7 +1,8 @@
 import { sleepAsync } from './initWorker.js';
 import { isTokensValid } from './parseTokens.js';
+import Oidc from "./oidc";
 
-export const userInfoAsync = (oidc) => async (noCache = false) => {
+export const userInfoAsync = (oidc:Oidc) => async (noCache = false) => {
     if (oidc.userInfo != null && !noCache) {
         return oidc.userInfo;
     }

package/src/version.ts

@@ -1 +1 @@
-export default '7.13.16';
+export default '7.14.0';