Only retry DOMException/DOMError

Author: schmidt-sebastian

packages/firestore/src/util/async_queue.ts

@@ -318,9 +318,10 @@ export class AsyncQueue {
   /**
    * Enqueue a retryable operation.
    *
-   * A retryable operation is rescheduled with backoff if it fails with any
-   * exception. All retryable operations are executed in order and only run
-   * if all prior operations were retried successfully.
+   * A retryable operation is rescheduled with backoff if it fails with a
+   * DOMException or a DOMError (the error types used by IndexedDB). All
+   * retryable operations are executed in order and only run if all prior
+   * operations were retried successfully.
    */
   enqueueRetryable(op: () => Promise<void>): void {
     this.verifyNotFailed();
@@ -337,8 +338,19 @@ export class AsyncQueue {
           deferred.resolve();
           this.backoff.reset();
         } catch (e) {
-          logDebug(LOG_TAG, 'Retryable operation failed: ' + e.message);
-          this.backoff.backoffAndRun(retryingOp);
+          // We only retry errors that match the ones thrown by IndexedDB (see
+          // https://developer.mozilla.org/en-US/docs/Web/API/IDBTransaction/error)
+          if (
+            (typeof DOMException !== 'undefined' &&
+              e instanceof DOMException) ||
+            (typeof DOMError !== 'undefined' && e instanceof DOMError)
+          ) {
+            logDebug(LOG_TAG, 'Operation failed with retryable error: ' + e);
+            this.backoff.backoffAndRun(retryingOp);
+          } else {
+            deferred.resolve();
+            throw e; // Failure will be handled by AsyncQueue
+          }
         }
       };
       this.enqueueAndForget(retryingOp);

packages/firestore/test/unit/specs/recovery_spec.test.ts

@@ -42,7 +42,7 @@ describeSpec(
             // Client 1 has received the WebStorage notification that the write
             // has been acknowledged, but failed to process the change. Hence,
             // we did not get a user callback. We schedule the first retry and
-            // make sure that it also does not get processed until 
+            // make sure that it also does not get processed until
             // `recoverDatabase` is called.
             .runTimer(TimerId.AsyncQueueRetry)
             .recoverDatabase()

packages/firestore/test/unit/specs/spec_test_components.ts

@@ -113,7 +113,7 @@ export class MockPersistence implements Persistence {
     ) => PersistencePromise<T>
   ): Promise<T> {
     if (this.injectFailures) {
-      return Promise.reject(new Error('Injected Failure'));
+      return Promise.reject(new DOMException('Simulated retryable error'));
     } else {
       return this.delegate.runTransaction(action, mode, transactionOperation);
     }

packages/firestore/test/unit/util/async_queue.test.ts

@@ -15,11 +15,16 @@
  * limitations under the License.
  */
 
-import { expect } from 'chai';
+import * as chaiAsPromised from 'chai-as-promised';
+
+import { expect, use } from 'chai';
 import { AsyncQueue, TimerId } from '../../../src/util/async_queue';
 import { Code } from '../../../src/util/error';
 import { getLogLevel, setLogLevel, LogLevel } from '../../../src/util/log';
 import { Deferred, Rejecter, Resolver } from '../../../src/util/promise';
+import { fail } from '../../../src/util/assert';
+
+use(chaiAsPromised);
 
 describe('AsyncQueue', () => {
   // We reuse these TimerIds for generic testing.
@@ -212,13 +217,29 @@ describe('AsyncQueue', () => {
     queue.enqueueRetryable(async () => {
       doStep(1);
       if (completedSteps.length === 1) {
-        throw new Error('Simulated retryable error');
+        throw new DOMException('Simulated retryable error');
       }
     });
     await queue.runDelayedOperationsEarly(TimerId.AsyncQueueRetry);
     expect(completedSteps).to.deep.equal([1, 1]);
   });
 
+  it("Doesn't retry internal exceptions", async () => {
+    const queue = new AsyncQueue();
+    // We use a Deferred Promise as retryable operations are scheduled only
+    // when Promise chains are resolved, which can happen after the
+    // `queue.enqueue` call below.
+    const deferred = new Deferred<void>();
+    queue.enqueueRetryable(async () => {
+      deferred.resolve();
+      throw fail('Simulated test failure');
+    });
+    await deferred.promise;
+    await expect(
+      queue.enqueue(() => Promise.resolve())
+    ).to.eventually.be.rejectedWith('Simulated test failure');
+  });
+
   it('Schedules first retryable attempt with no delay', async () => {
     const queue = new AsyncQueue();
     const completedSteps: number[] = [];
@@ -244,7 +265,7 @@ describe('AsyncQueue', () => {
     queue.enqueueRetryable(async () => {
       doStep(1);
       if (completedSteps.length === 1) {
-        throw new Error('Simulated retryable error');
+        throw new DOMException('Simulated retryable error');
       }
     });
 
@@ -270,7 +291,7 @@ describe('AsyncQueue', () => {
       doStep(1);
       if (completedSteps.length > 1) {
       } else {
-        throw new Error('Simulated retryable error');
+        throw new DOMException('Simulated retryable error');
       }
     });
     queue.enqueueRetryable(async () => {

packages/firestore/test/util/node_persistence.ts

@@ -58,3 +58,11 @@ if (process.env.USE_MOCK_PERSISTENCE === 'YES') {
 
   globalAny.Event = Event;
 }
+
+if (typeof DOMException === 'undefined') {
+  // Define DOMException as it is used in tests
+  class DOMException {
+    constructor(readonly message: string) {}
+  }
+  globalAny.DOMException = DOMException;
+}