@firebase/app-check 0.5.12 → 0.5.13

package/dist/esm/index.esm2017.js

@@ -689,13 +689,27 @@ async function getToken$2(appCheck, forceRefresh = false) {
     let token = state.token;
     let error = undefined;
     /**
-     * If there is no token in memory, try to load token from indexedDB.
+     * If an invalid token was found in memory, clear token from
+     * memory and unset the local variable `token`.
+     */
+    if (token && !isValid(token)) {
+        setState(app, Object.assign(Object.assign({}, state), { token: undefined }));
+        token = undefined;
+    }
+    /**
+     * If there is no valid token in memory, try to load token from indexedDB.
      */
     if (!token) {
         // cachedTokenPromise contains the token found in IndexedDB or undefined if not found.
         const cachedToken = await state.cachedTokenPromise;
-        if (cachedToken && isValid(cachedToken)) {
-            token = cachedToken;
+        if (cachedToken) {
+            if (isValid(cachedToken)) {
+                token = cachedToken;
+            }
+            else {
+                // If there was an invalid token in the indexedDB cache, clear it.
+                await writeTokenToStorage(app, undefined);
+            }
         }
     }
     // Return the cached token (from either memory or indexedDB) if it's valid
@@ -716,9 +730,9 @@ async function getToken$2(appCheck, forceRefresh = false) {
     if (isDebugMode()) {
         // Avoid making another call to the exchange endpoint if one is in flight.
         if (!state.exchangeTokenPromise) {
-            state.exchangeTokenPromise = exchangeToken(getExchangeDebugTokenRequest(app, await getDebugToken()), appCheck.heartbeatServiceProvider).then(token => {
+            state.exchangeTokenPromise = exchangeToken(getExchangeDebugTokenRequest(app, await getDebugToken()), appCheck.heartbeatServiceProvider).finally(() => {
+                // Clear promise when settled - either resolved or rejected.
                 state.exchangeTokenPromise = undefined;
-                return token;
             });
             shouldCallListeners = true;
         }
@@ -730,7 +744,9 @@ async function getToken$2(appCheck, forceRefresh = false) {
         return { token: tokenFromDebugExchange.token };
     }
     /**
-     * request a new token
+     * There are no valid tokens in memory or indexedDB and we are not in
+     * debug mode.
+     * Request a new token from the exchange endpoint.
      */
     try {
         // Avoid making another call to the exchange endpoint if one is in flight.
@@ -738,9 +754,9 @@ async function getToken$2(appCheck, forceRefresh = false) {
             // state.provider is populated in initializeAppCheck()
             // ensureActivated() at the top of this function checks that
             // initializeAppCheck() has been called.
-            state.exchangeTokenPromise = state.provider.getToken().then(token => {
+            state.exchangeTokenPromise = state.provider.getToken().finally(() => {
+                // Clear promise when settled - either resolved or rejected.
                 state.exchangeTokenPromise = undefined;
-                return token;
             });
             shouldCallListeners = true;
         }
@@ -760,10 +776,30 @@ async function getToken$2(appCheck, forceRefresh = false) {
     }
     let interopTokenResult;
     if (!token) {
-        // if token is undefined, there must be an error.
-        // we return a dummy token along with the error
+        // If token is undefined, there must be an error.
+        // Return a dummy token along with the error.
         interopTokenResult = makeDummyTokenResult(error);
     }
+    else if (error) {
+        if (isValid(token)) {
+            // It's also possible a valid token exists, but there's also an error.
+            // (Such as if the token is almost expired, tries to refresh, and
+            // the exchange request fails.)
+            // We add a special error property here so that the refresher will
+            // count this as a failed attempt and use the backoff instead of
+            // retrying repeatedly with no delay, but any 3P listeners will not
+            // be hindered in getting the still-valid token.
+            interopTokenResult = {
+                token: token.token,
+                internalError: error
+            };
+        }
+        else {
+            // No invalid tokens should make it to this step. Memory and cached tokens
+            // are checked. Other tokens are from fresh exchanges. But just in case.
+            interopTokenResult = makeDummyTokenResult(error);
+        }
+    }
     else {
         interopTokenResult = {
             token: token.token
@@ -855,10 +891,24 @@ function createTokenRefresher(appCheck) {
         else {
             result = await getToken$2(appCheck, true);
         }
-        // getToken() always resolves. In case the result has an error field defined, it means the operation failed, and we should retry.
+        /**
+         * getToken() always resolves. In case the result has an error field defined, it means
+         * the operation failed, and we should retry.
+         */
         if (result.error) {
             throw result.error;
         }
+        /**
+         * A special `internalError` field reflects that there was an error
+         * getting a new token from the exchange endpoint, but there's still a
+         * previous token that's valid for now and this should be passed to 2P/3P
+         * requests for a token. But we want this callback (`this.operation` in
+         * `Refresher`) to throw in order to kick off the Refresher's retry
+         * backoff. (Setting `hasSucceeded` to false.)
+         */
+        if (result.internalError) {
+            throw result.internalError;
+        }
     }, () => {
         return true;
     }, () => {
@@ -955,7 +1005,7 @@ function internalFactory(appCheck) {
 }
 
 const name = "@firebase/app-check";
-const version = "0.5.12";
+const version = "0.5.13";
 
 /**
  * @license