Treat "Clear Site Data" event the same way as clearIndexedDbPersistence() from another tab.

Author: dconeybe

packages/firestore/src/core/firestore_client.ts

@@ -231,22 +231,47 @@ export async function setOfflineComponentProvider(
     }
   });
 
-  offlineComponentProvider.persistence.setDatabaseDeletedListener(() => {
-    logWarn('Terminating Firestore due to IndexedDb database deletion');
+  offlineComponentProvider.persistence.setDatabaseDeletedListener(event => {
+    let error: FirestoreError | null;
+
+    if (event.type === 'ClearSiteDataDatabaseDeletedEvent') {
+      const message =
+        `Terminating Firestore in response to "${event.type}" event ` +
+        `to prevent potential IndexedDB database corruption. ` +
+        `This situation could be caused by clicking the ` +
+        `"Clear Site Data" button in a web browser. ` +
+        `Try reloading the web page to re-initialize the ` +
+        `IndexedDB database.`;
+      // Throw FirestoreError rather than just Error so that the error will
+      // be treated as "non-retryable".
+      error = new FirestoreError('failed-precondition', message);
+      logWarn(message, event.data);
+    } else {
+      error = null;
+      logWarn(
+        `Terminating Firestore in response to "${event.type}" event`,
+        event.data
+      );
+    }
+
     client
       .terminate()
       .then(() => {
         logDebug(
-          'Terminating Firestore due to IndexedDb database deletion ' +
+          `Terminating Firestore in response to "${event.type}" event ` +
             'completed successfully'
         );
       })
       .catch(error => {
         logWarn(
-          'Terminating Firestore due to IndexedDb database deletion failed',
-          error
+          `Terminating Firestore in response to "${event.type}" event failed:`,
+            error
         );
       });
+
+    if (error) {
+      throw error;
+    }
   });
 
   client._offlineComponents = offlineComponentProvider;

packages/firestore/src/local/persistence.ts

@@ -98,7 +98,70 @@ export interface ReferenceDelegate {
   ): PersistencePromise<void>;
 }
 
-export type DatabaseDeletedListener = () => void;
+/**
+ * A {@link DatabaseDeletedListener} event indicating that the IndexedDB
+ * database received a "versionchange" event with a null value for "newVersion".
+ * This event indicates that another tab in multi-tab IndexedDB persistence mode
+ * has called `clearIndexedDbPersistence()` and requires this tab to close its
+ * IndexedDB connection in order to allow the "clear" operation to proceed.
+ */
+export class VersionChangeDatabaseDeletedEvent {
+  /** A type discriminator. */
+  readonly type = 'VersionChangeDatabaseDeletedEvent' as const;
+
+  constructor(
+    readonly data: {
+      /**
+       * The value of the "newVersion" property of the "versionchange" event
+       * that triggered this event. Its value is _always_ `null`, but is kept here
+       * for posterity.
+       */
+      eventNewVersion: null;
+    }
+  ) {}
+}
+
+/**
+ * A {@link DatabaseDeletedListener} event indicating that the "Clear Site Data"
+ * button in a web browser was (likely) clicked, deleting the IndexedDB
+ * database.
+ */
+export class ClearSiteDataDatabaseDeletedEvent {
+  /** A type discriminator. */
+  readonly type = 'ClearSiteDataDatabaseDeletedEvent' as const;
+
+  constructor(
+    readonly data: {
+      /** The IndexedDB version that was last reported by the database. */
+      lastClosedVersion: number;
+      /**
+       * The value of the "oldVersion" property of the "onupgradeneeded"
+       * IndexedDB event that triggered this event.
+       */
+      eventOldVersion: number;
+      /**
+       * The value of the "newVersion" property of the "onupgradeneeded"
+       * IndexedDB event that triggered this event.
+       */
+      eventNewVersion: number | null;
+      /**
+       * The value of the "version" property of the "IDBDatabase" object.
+       */
+      dbVersion: number;
+    }
+  ) {}
+}
+
+/**
+ * The type of the "event" parameter of {@link DatabaseDeletedListener}.
+ */
+export type DatabaseDeletedListenerEvent =
+  | VersionChangeDatabaseDeletedEvent
+  | ClearSiteDataDatabaseDeletedEvent;
+
+export type DatabaseDeletedListener = (
+  event: DatabaseDeletedListenerEvent
+) => void;
 
 /**
  * Persistence is the lowest-level shared interface to persistent storage in

packages/firestore/src/local/simple_db.ts

@@ -19,10 +19,14 @@ import { getGlobal, getUA, isIndexedDBAvailable } from '@firebase/util';
 
 import { debugAssert } from '../util/assert';
 import { Code, FirestoreError } from '../util/error';
-import { logDebug, logError, logWarn } from '../util/log';
+import { logDebug, logError } from '../util/log';
 import { Deferred } from '../util/promise';
 
-import { DatabaseDeletedListener } from './persistence';
+import {
+  ClearSiteDataDatabaseDeletedEvent,
+  DatabaseDeletedListener,
+  VersionChangeDatabaseDeletedEvent
+} from './persistence';
 import { PersistencePromise } from './persistence_promise';
 
 // References to `indexedDB` are guarded by SimpleDb.isAvailable() and getGlobal()
@@ -299,8 +303,31 @@ export class SimpleDb {
         // https://developer.mozilla.org/en-US/docs/Web/API/IDBVersionChangeRequest/setVersion
         const request = indexedDB.open(this.name, this.version);
 
+        // Store information about "Clear Site Data" being detected in the
+        // "onupgradeneeded" event and check it in the "onsuccess" event
+        // rather than throwing directly from the "onupgradeneeded" event
+        // since throwing directly from the listener results in a generic
+        // exception that cannot be distinguished from other errors.
+        const clearSiteDataEvent = {
+          event: null as ClearSiteDataDatabaseDeletedEvent | null
+        };
+
         request.onsuccess = (event: Event) => {
           const db = (event.target as IDBOpenDBRequest).result;
+
+          if (clearSiteDataEvent.event) {
+            try {
+              this.databaseDeletedListener?.(clearSiteDataEvent.event);
+            } catch (e) {
+              try {
+                db.close();
+              } finally {
+                reject(e);
+              }
+              return;
+            }
+          }
+
           resolve(db);
         };
 
@@ -353,19 +380,12 @@ export class SimpleDb {
             this.lastClosedDbVersion !== null &&
             this.lastClosedDbVersion !== event.oldVersion
           ) {
-            // This thrown error will get passed to the `onerror` callback
-            // registered above, and will then be propagated correctly.
-            throw new Error(
-              `refusing to open IndexedDB database due to potential ` +
-                `corruption of the IndexedDB database data; this corruption ` +
-                `could be caused by clicking the "clear site data" button in ` +
-                `a web browser; try reloading the web page to re-initialize ` +
-                `the IndexedDB database: ` +
-                `lastClosedDbVersion=${this.lastClosedDbVersion}, ` +
-                `event.oldVersion=${event.oldVersion}, ` +
-                `event.newVersion=${event.newVersion}, ` +
-                `db.version=${db.version}`
-            );
+            clearSiteDataEvent.event = new ClearSiteDataDatabaseDeletedEvent({
+              lastClosedVersion: this.lastClosedDbVersion,
+              eventOldVersion: event.oldVersion,
+              eventNewVersion: event.newVersion,
+              dbVersion: db.version
+            });
           }
           this.schemaConverter
             .createOrUpgrade(
@@ -399,11 +419,11 @@ export class SimpleDb {
         // Notify the listener if another tab attempted to delete the IndexedDb
         // database, such as by calling clearIndexedDbPersistence().
         if (event.newVersion === null) {
-          logWarn(
-            `Received "versionchange" event with newVersion===null; ` +
-              'notifying the registered DatabaseDeletedListener, if any'
+          this.databaseDeletedListener?.(
+            new VersionChangeDatabaseDeletedEvent({
+              eventNewVersion: event.newVersion
+            })
           );
-          this.databaseDeletedListener?.();
         }
       },
       { passive: true }