Add experimentalForceOwningTab for Web Worker support

packages/firebase/index.d.ts

@@ -6226,6 +6226,15 @@ declare namespace firebase.firestore {
      * multiple tabs, please use `synchronizeTabs: true` instead.
      */
     experimentalTabSynchronization?: boolean;
+
+    /**
+     * Whether to force enabling persistence for the client even if another
+     * client is already running with persistence enabled. This cannot be used
+     * with `synchronizeTabs:true` and is primarily intended for use with Web
+     * Workers. Setting this to 'true' will enable persistence, but cause other
+     * tabs using persistence to fail.
+     */
+    experimentalForce?: boolean;
   }
 
   export type LogLevel = 'debug' | 'error' | 'silent';

packages/firestore-types/index.d.ts

@@ -122,6 +122,14 @@ export interface PersistenceSettings {
    * multiple tabs, please use `synchronizeTabs: true` instead.
    */
   experimentalTabSynchronization?: boolean;
+
+  /**
+   * Whether to force enable persistence for the client. This cannot be used
+   * with `synchronizeTabs:true` and is primarily intended for use with Web
+   * Workers. Setting this to 'true' will enable persistence, but cause other
+   * tabs using persistence to fail.
+   */
+  experimentalForce?: boolean;
 }
 
 export type LogLevel = 'debug' | 'error' | 'silent';

packages/firestore/src/api/database.ts

@@ -386,6 +386,7 @@ export class Firestore implements firestore.FirebaseFirestore, FirebaseService {
     }
 
     let synchronizeTabs = false;
+    let experimentalForce = false;
 
     if (settings) {
       if (settings.experimentalTabSynchronization !== undefined) {
@@ -402,12 +403,16 @@ export class Firestore implements firestore.FirebaseFirestore, FirebaseService {
           : settings.experimentalTabSynchronization,
         DEFAULT_SYNCHRONIZE_TABS
       );
+      experimentalForce = settings.experimentalForce
+        ? settings.experimentalForce
+        : false;
     }
 
     return this.configureClient(
       new IndexedDbPersistenceSettings(
         this._settings.cacheSizeBytes,
-        synchronizeTabs
+        synchronizeTabs,
+        experimentalForce
       )
     );
   }

packages/firestore/src/core/firestore_client.ts

@@ -73,7 +73,8 @@ const DOM_EXCEPTION_QUOTA_EXCEEDED = 22;
 export class IndexedDbPersistenceSettings {
   constructor(
     readonly cacheSizeBytes: number,
-    readonly synchronizeTabs: boolean
+    readonly synchronizeTabs: boolean,
+    readonly force: boolean
   ) {}
 
   lruParams(): LruParams {
@@ -343,7 +344,8 @@ export class FirestoreClient {
       ) {
         throw new FirestoreError(
           Code.UNIMPLEMENTED,
-          'IndexedDB persistence is only available on platforms that support LocalStorage.'
+          'IndexedDB persistence with synchronizeTabs is only available on ' +
+            'platforms that support LocalStorage.'
         );
       }
 
@@ -358,7 +360,6 @@ export class FirestoreClient {
             user
           )
         : new MemorySharedClientState();
-
       const persistence = await IndexedDbPersistence.createIndexedDbPersistence(
         {
           allowTabSynchronization: settings.synchronizeTabs,
@@ -368,7 +369,8 @@ export class FirestoreClient {
           queue: this.asyncQueue,
           serializer,
           lruParams,
-          sequenceNumberSyncer: this.sharedClientState
+          sequenceNumberSyncer: this.sharedClientState,
+          force: settings.force
         }
       );
 

packages/firestore/src/local/indexeddb_persistence.ts

@@ -197,6 +197,7 @@ export class IndexedDbPersistence implements Persistence {
     queue: AsyncQueue;
     serializer: JsonProtoSerializer;
     sequenceNumberSyncer: SequenceNumberSyncer;
+    force: boolean;
   }): Promise<IndexedDbPersistence> {
     if (!IndexedDbPersistence.isAvailable()) {
       throw new FirestoreError(
@@ -213,14 +214,15 @@ export class IndexedDbPersistence implements Persistence {
       options.lruParams,
       options.queue,
       options.serializer,
-      options.sequenceNumberSyncer
+      options.sequenceNumberSyncer,
+      options.force
     );
     await persistence.start();
     return persistence;
   }
 
   private readonly document: Document | null;
-  private readonly window: Window;
+  private readonly window: Window | null;
 
   // Technically these types should be `| undefined` because they are
   // initialized asynchronously by start(), but that would be more misleading
@@ -254,7 +256,7 @@ export class IndexedDbPersistence implements Persistence {
   private readonly queryCache: IndexedDbQueryCache;
   private readonly indexManager: IndexedDbIndexManager;
   private readonly remoteDocumentCache: IndexedDbRemoteDocumentCache;
-  private readonly webStorage: Storage;
+  private readonly webStorage: Storage | null;
   readonly referenceDelegate: IndexedDbLruDelegate;
 
   private constructor(
@@ -265,7 +267,8 @@ export class IndexedDbPersistence implements Persistence {
     lruParams: LruParams,
     private readonly queue: AsyncQueue,
     serializer: JsonProtoSerializer,
-    private readonly sequenceNumberSyncer: SequenceNumberSyncer
+    private readonly sequenceNumberSyncer: SequenceNumberSyncer,
+    private readonly force: boolean
   ) {
     this.referenceDelegate = new IndexedDbLruDelegate(this, lruParams);
     this.dbName = persistenceKey + IndexedDbPersistence.MAIN_DATABASE;
@@ -281,14 +284,19 @@ export class IndexedDbPersistence implements Persistence {
       this.indexManager,
       /*keepDocumentChangeLog=*/ this.allowTabSynchronization
     );
+    this.window = platform.window;
     if (platform.window && platform.window.localStorage) {
-      this.window = platform.window;
-      this.webStorage = this.window.localStorage;
+      this.webStorage = platform.window.localStorage;
     } else {
-      throw new FirestoreError(
-        Code.UNIMPLEMENTED,
-        'IndexedDB persistence is only available on platforms that support LocalStorage.'
-      );
+      this.webStorage = null;
+      if (force === false) {
+        log.error(
+          LOG_TAG,
+          'LocalStorage is unavailable. As a result, persistence may not work ' +
+            'reliably. In particular enablePersistence() could fail immediately ' +
+            'after refreshing the page.'
+        );
+      }
     }
   }
 
@@ -299,7 +307,6 @@ export class IndexedDbPersistence implements Persistence {
    */
   private start(): Promise<void> {
     assert(!this.started, 'IndexedDbPersistence double-started!');
-    assert(this.window !== null, "Expected 'window' to be defined");
 
     return SimpleDb.openOrCreate(
       this.dbName,
@@ -310,7 +317,7 @@ export class IndexedDbPersistence implements Persistence {
         this.simpleDb = db;
         // NOTE: This is expected to fail sometimes (in the case of another tab already
         // having the persistence lock), so it's the first thing we should do.
-        return this.updateClientMetadataAndTryBecomePrimary();
+        return this.updateClientMetadataAndTryBecomePrimary(this.force);
       })
       .then(() => {
         this.attachVisibilityHandler();
@@ -392,7 +399,9 @@ export class IndexedDbPersistence implements Persistence {
    * primary state listener if the client either newly obtained or released its
    * primary lease.
    */
-  private updateClientMetadataAndTryBecomePrimary(): Promise<void> {
+  private updateClientMetadataAndTryBecomePrimary(
+    force = false
+  ): Promise<void> {
     return this.simpleDb.runTransaction('readwrite', ALL_STORES, txn => {
       const metadataStore = clientMetadataStore(txn);
       return metadataStore
@@ -417,7 +426,7 @@ export class IndexedDbPersistence implements Persistence {
             });
           }
         })
-        .next(() => this.canActAsPrimary(txn))
+        .next(() => (force ? true : this.canActAsPrimary(txn)))
         .next(canActAsPrimary => {
           const wasPrimary = this.isPrimary;
           this.isPrimary = canActAsPrimary;
@@ -525,11 +534,13 @@ export class IndexedDbPersistence implements Persistence {
       // Ideally we'd delete the IndexedDb and LocalStorage zombie entries for
       // the client atomically, but we can't. So we opt to delete the IndexedDb
       // entries first to avoid potentially reviving a zombied client.
-      inactiveClients.forEach(inactiveClient => {
-        this.window.localStorage.removeItem(
-          this.zombiedClientLocalStorageKey(inactiveClient.clientId)
-        );
-      });
+      if (this.webStorage) {
+        inactiveClients.forEach(inactiveClient => {
+          this.webStorage!.removeItem(
+            this.zombiedClientLocalStorageKey(inactiveClient.clientId)
+          );
+        });
+      }
     }
   }
 
@@ -590,6 +601,9 @@ export class IndexedDbPersistence implements Persistence {
           }
 
           if (!this.isLocalClient(currentPrimary)) {
+            if (this.force) {
+              return true;
+            }
             if (!currentPrimary!.allowTabSynchronization) {
               // Fail the `canActAsPrimary` check if the current leaseholder has
               // not opted into multi-tab synchronization. If this happens at
@@ -974,6 +988,9 @@ export class IndexedDbPersistence implements Persistence {
    * handler.
    */
   private attachWindowUnloadHook(): void {
+    if (!this.window) {
+      return;
+    }
     if (typeof this.window.addEventListener === 'function') {
       this.windowUnloadHandler = () => {
         // Note: In theory, this should be scheduled on the AsyncQueue since it
@@ -992,6 +1009,9 @@ export class IndexedDbPersistence implements Persistence {
   }
 
   private detachWindowUnloadHook(): void {
+    if (!this.window) {
+      return;
+    }
     if (this.windowUnloadHandler) {
       assert(
         typeof this.window.removeEventListener === 'function',
@@ -1008,6 +1028,9 @@ export class IndexedDbPersistence implements Persistence {
    * cleanup logic in `shutdown()`.
    */
   private isClientZombied(clientId: ClientId): boolean {
+    if (!this.webStorage) {
+      return false;
+    }
     try {
       const isZombied =
         this.webStorage.getItem(this.zombiedClientLocalStorageKey(clientId)) !==
@@ -1031,6 +1054,9 @@ export class IndexedDbPersistence implements Persistence {
    * clients are ignored during primary tab selection.
    */
   private markClientZombied(): void {
+    if (!this.webStorage) {
+      return;
+    }
     try {
       this.webStorage.setItem(
         this.zombiedClientLocalStorageKey(this.clientId),
@@ -1044,6 +1070,9 @@ export class IndexedDbPersistence implements Persistence {
 
   /** Removes the zombied client entry if it exists. */
   private removeClientZombiedEntry(): void {
+    if (!this.webStorage) {
+      return;
+    }
     try {
       this.webStorage.removeItem(
         this.zombiedClientLocalStorageKey(this.clientId)

packages/firestore/src/local/simple_db.ts

@@ -66,7 +66,14 @@ export class SimpleDb {
       // suggests IE9 and older WebKit browsers handle upgrade
       // differently. They expect setVersion, as described here:
       // https://developer.mozilla.org/en-US/docs/Web/API/IDBVersionChangeRequest/setVersion
-      const request = window.indexedDB.open(name, version);
+
+      let request: IDBOpenDBRequest;
+      // Support Web Workers, which don't have `window` global variable.
+      if (typeof indexedDB !== 'undefined') {
+        request = indexedDB.open(name, version);
+      } else {
+        request = window.indexedDB.open(name, version);
+      }
 
       request.onsuccess = (event: Event) => {
         const db = (event.target as IDBOpenDBRequest).result;
@@ -132,6 +139,10 @@ export class SimpleDb {
 
   /** Returns true if IndexedDB is available in the current environment. */
   static isAvailable(): boolean {
+    // If IndexedDb is available directly (ex: in case of web workers).
+    if (typeof indexedDB !== 'undefined') {
+      return true;
+    }
     if (typeof window === 'undefined' || window.indexedDB == null) {
       return false;
     }

packages/firestore/test/unit/local/indexeddb_persistence.test.ts

@@ -127,7 +127,8 @@ async function withCustomPersistence(
     queue,
     serializer,
     lruParams: LruParams.DEFAULT,
-    sequenceNumberSyncer: MOCK_SEQUENCE_NUMBER_SYNCER
+    sequenceNumberSyncer: MOCK_SEQUENCE_NUMBER_SYNCER,
+    force: false
   });
 
   await fn(persistence, platform, queue);

packages/firestore/test/unit/local/persistence_test_helpers.ts

@@ -116,7 +116,8 @@ export async function testIndexedDbPersistence(
     queue,
     serializer: JSON_SERIALIZER,
     lruParams,
-    sequenceNumberSyncer: MOCK_SEQUENCE_NUMBER_SYNCER
+    sequenceNumberSyncer: MOCK_SEQUENCE_NUMBER_SYNCER,
+    force: false
   });
 }
 

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

@@ -1266,7 +1266,8 @@ class IndexedDbTestRunner extends TestRunner {
       queue: this.queue,
       serializer,
       lruParams: LruParams.DEFAULT,
-      sequenceNumberSyncer: this.sharedClientState
+      sequenceNumberSyncer: this.sharedClientState,
+      force: false
     });
   }