@firebase/app-check 0.5.12 → 0.5.13-canary.0a112bd2a

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @firebase/app-check
 
+## 0.5.13
+
+### Patch Changes
+
+- [`b3951c6e4`](https://github.com/firebase/firebase-js-sdk/commit/b3951c6e42559d8aa82711b71440f4adcdae3b56) [#6617](https://github.com/firebase/firebase-js-sdk/pull/6617) (fixes [#6373](https://github.com/firebase/firebase-js-sdk/issues/6373)) - Fix timer issues in App Check that caused the token to fail to refresh after the token expired, or caused rapid repeated requests attempting to do so.
+
+- Updated dependencies [[`fdd4ab464`](https://github.com/firebase/firebase-js-sdk/commit/fdd4ab464b59a107bdcc195df3f01e32efd89ed4)]:
+  - @firebase/util@1.7.0
+  - @firebase/component@0.5.18
+
 ## 0.5.12
 
 ### Patch Changes

package/dist/esm/index.esm.js

@@ -775,15 +775,30 @@ function getToken$2(appCheck, forceRefresh) {
                     state = getState(app);
                     token = state.token;
                     error = undefined;
-                    if (!!token) return [3 /*break*/, 2];
+                    /**
+                     * If an invalid token was found in memory, clear token from
+                     * memory and unset the local variable `token`.
+                     */
+                    if (token && !isValid(token)) {
+                        setState(app, __assign(__assign({}, state), { token: undefined }));
+                        token = undefined;
+                    }
+                    if (!!token) return [3 /*break*/, 4];
                     return [4 /*yield*/, state.cachedTokenPromise];
                 case 1:
                     cachedToken = _e.sent();
-                    if (cachedToken && isValid(cachedToken)) {
-                        token = cachedToken;
-                    }
-                    _e.label = 2;
-                case 2:
+                    if (!cachedToken) return [3 /*break*/, 4];
+                    if (!isValid(cachedToken)) return [3 /*break*/, 2];
+                    token = cachedToken;
+                    return [3 /*break*/, 4];
+                case 2: 
+                // If there was an invalid token in the indexedDB cache, clear it.
+                return [4 /*yield*/, writeTokenToStorage(app, undefined)];
+                case 3:
+                    // If there was an invalid token in the indexedDB cache, clear it.
+                    _e.sent();
+                    _e.label = 4;
+                case 4:
                     // Return the cached token (from either memory or indexedDB) if it's valid
                     if (!forceRefresh && token && isValid(token)) {
                         return [2 /*return*/, {
@@ -791,49 +806,49 @@ function getToken$2(appCheck, forceRefresh) {
                             }];
                     }
                     shouldCallListeners = false;
-                    if (!isDebugMode()) return [3 /*break*/, 7];
-                    if (!!state.exchangeTokenPromise) return [3 /*break*/, 4];
+                    if (!isDebugMode()) return [3 /*break*/, 9];
+                    if (!!state.exchangeTokenPromise) return [3 /*break*/, 6];
                     _a = state;
                     _b = exchangeToken;
                     _c = getExchangeDebugTokenRequest;
                     _d = [app];
                     return [4 /*yield*/, getDebugToken()];
-                case 3:
-                    _a.exchangeTokenPromise = _b.apply(void 0, [_c.apply(void 0, _d.concat([_e.sent()])), appCheck.heartbeatServiceProvider]).then(function (token) {
+                case 5:
+                    _a.exchangeTokenPromise = _b.apply(void 0, [_c.apply(void 0, _d.concat([_e.sent()])), appCheck.heartbeatServiceProvider]).finally(function () {
+                        // Clear promise when settled - either resolved or rejected.
                         state.exchangeTokenPromise = undefined;
-                        return token;
                     });
                     shouldCallListeners = true;
-                    _e.label = 4;
-                case 4: return [4 /*yield*/, state.exchangeTokenPromise];
-                case 5:
+                    _e.label = 6;
+                case 6: return [4 /*yield*/, state.exchangeTokenPromise];
+                case 7:
                     tokenFromDebugExchange = _e.sent();
                     // Write debug token to indexedDB.
                     return [4 /*yield*/, writeTokenToStorage(app, tokenFromDebugExchange)];
-                case 6:
+                case 8:
                     // Write debug token to indexedDB.
                     _e.sent();
                     // Write debug token to state.
                     setState(app, __assign(__assign({}, state), { token: tokenFromDebugExchange }));
                     return [2 /*return*/, { token: tokenFromDebugExchange.token }];
-                case 7:
-                    _e.trys.push([7, 9, , 10]);
+                case 9:
+                    _e.trys.push([9, 11, , 12]);
                     // Avoid making another call to the exchange endpoint if one is in flight.
                     if (!state.exchangeTokenPromise) {
                         // 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(function (token) {
+                        state.exchangeTokenPromise = state.provider.getToken().finally(function () {
+                            // Clear promise when settled - either resolved or rejected.
                             state.exchangeTokenPromise = undefined;
-                            return token;
                         });
                         shouldCallListeners = true;
                     }
                     return [4 /*yield*/, state.exchangeTokenPromise];
-                case 8:
+                case 10:
                     token = _e.sent();
-                    return [3 /*break*/, 10];
-                case 9:
+                    return [3 /*break*/, 12];
+                case 11:
                     e_1 = _e.sent();
                     if (e_1.code === "appCheck/" + "throttled" /* THROTTLED */) {
                         // Warn if throttled, but do not treat it as an error.
@@ -845,14 +860,35 @@ function getToken$2(appCheck, forceRefresh) {
                     }
                     // Always save error to be added to dummy token.
                     error = e_1;
-                    return [3 /*break*/, 10];
-                case 10:
-                    if (!!token) return [3 /*break*/, 11];
-                    // if token is undefined, there must be an error.
-                    // we return a dummy token along with the error
+                    return [3 /*break*/, 12];
+                case 12:
+                    if (!!token) return [3 /*break*/, 13];
+                    // If token is undefined, there must be an error.
+                    // Return a dummy token along with the error.
                     interopTokenResult = makeDummyTokenResult(error);
-                    return [3 /*break*/, 13];
-                case 11:
+                    return [3 /*break*/, 16];
+                case 13:
+                    if (!error) return [3 /*break*/, 14];
+                    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);
+                    }
+                    return [3 /*break*/, 16];
+                case 14:
                     interopTokenResult = {
                         token: token.token
                     };
@@ -860,10 +896,10 @@ function getToken$2(appCheck, forceRefresh) {
                     // Only do it if we got a valid new token
                     setState(app, __assign(__assign({}, state), { token: token }));
                     return [4 /*yield*/, writeTokenToStorage(app, token)];
-                case 12:
+                case 15:
                     _e.sent();
-                    _e.label = 13;
-                case 13:
+                    _e.label = 16;
+                case 16:
                     if (shouldCallListeners) {
                         notifyTokenListeners(app, interopTokenResult);
                     }
@@ -955,10 +991,24 @@ function createTokenRefresher(appCheck) {
                     result = _a.sent();
                     _a.label = 4;
                 case 4:
-                    // 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 [2 /*return*/];
             }
         });
@@ -1063,7 +1113,7 @@ function internalFactory(appCheck) {
 }
 
 var name = "@firebase/app-check";
-var version = "0.5.12";
+var version = "0.5.13-canary.0a112bd2a";
 
 /**
  * @license