cleaned up

Author: Brian Chen

packages/firebase/index.d.ts

@@ -6226,6 +6226,14 @@ declare namespace firebase.firestore {
      * 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-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 synchronizedTabs 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 takeoverPrimary: boolean
   ) {
     this.referenceDelegate = new IndexedDbLruDelegate(this, lruParams);
     this.dbName = persistenceKey + IndexedDbPersistence.MAIN_DATABASE;
@@ -285,9 +288,11 @@ export class IndexedDbPersistence implements Persistence {
       this.window = platform.window;
       this.webStorage = this.window.localStorage;
     } else {
-      throw new FirestoreError(
-        Code.UNIMPLEMENTED,
-        'IndexedDB persistence is only available on platforms that support LocalStorage.'
+      this.window = platform.window;
+      this.webStorage = null;
+      log.error(
+        LOG_TAG,
+        'LocalStorage is unavailable. Multi-tab functionality may not be supported.'
       );
     }
   }
@@ -299,7 +304,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,
@@ -526,9 +530,11 @@ export class IndexedDbPersistence implements Persistence {
       // 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) {
+          this.webStorage.removeItem(
+            this.zombiedClientLocalStorageKey(inactiveClient.clientId)
+          );
+        }
       });
     }
   }
@@ -551,6 +557,10 @@ export class IndexedDbPersistence implements Persistence {
 
   /** Checks whether `client` is the local client. */
   private isLocalClient(client: DbPrimaryClient | null): boolean {
+    console.error('this id', this.clientId);
+    if (client) {
+      console.error('client id', client.ownerId);
+    }
     return client ? client.ownerId === this.clientId : false;
   }
 
@@ -590,6 +600,11 @@ export class IndexedDbPersistence implements Persistence {
           }
 
           if (!this.isLocalClient(currentPrimary)) {
+            if (this.takeoverPrimary) {
+              console.error('WHOOOOO LETS TAKE IT');
+              return true;
+            }
+            console.error('gg no primary for you');
             if (!currentPrimary!.allowTabSynchronization) {
               // Fail the `canActAsPrimary` check if the current leaseholder has
               // not opted into multi-tab synchronization. If this happens at
@@ -974,6 +989,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 +1010,9 @@ export class IndexedDbPersistence implements Persistence {
   }
 
   private detachWindowUnloadHook(): void {
+    if (!this.window) {
+      return;
+    }
     if (this.windowUnloadHandler) {
       assert(
         typeof this.window.removeEventListener === 'function',
@@ -1008,6 +1029,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 +1055,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 +1071,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 (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;
     }