Merge

Author: schmidt-sebastian

packages/firestore/src/local/indexeddb_persistence.ts

@@ -758,16 +758,19 @@ export class IndexedDbPersistence implements Persistence {
       ? 'readwrite-idempotent'
       : 'readwrite';
 
+    let persistenceTransaction: PersistenceTransaction;
+
     // Do all transactions as readwrite against all object stores, since we
     // are the only reader/writer.
-    return this.simpleDb.runTransaction(
-      simpleDbMode,
-      ALL_STORES,
-      simpleDbTxn => {
-        if (
-          mode === 'readwrite-primary' ||
-          mode === 'readwrite-primary-idempotent'
-        ) {
+    return this.simpleDb
+      .runTransaction(simpleDbMode, ALL_STORES, simpleDbTxn => {
+        persistenceTransaction = new IndexedDbTransaction(
+          simpleDbTxn,
+          this.listenSequence.next()
+        );
+
+        if (mode === 'readwrite-primary'||
+            mode === 'readwrite-primary-idempotent') {
           // While we merely verify that we have (or can acquire) the lease
           // immediately, we wait to extend the primary lease until after
           // executing transactionOperation(). This ensures that even if the
@@ -788,12 +791,7 @@ export class IndexedDbPersistence implements Persistence {
                   PRIMARY_LEASE_LOST_ERROR_MSG
                 );
               }
-              return transactionOperation(
-                new IndexedDbTransaction(
-                  simpleDbTxn,
-                  this.listenSequence.next()
-                )
-              );
+              return transactionOperation(persistenceTransaction);
             })
             .next(result => {
               return this.acquireOrExtendPrimaryLease(simpleDbTxn).next(
@@ -802,13 +800,14 @@ export class IndexedDbPersistence implements Persistence {
             });
         } else {
           return this.verifyAllowTabSynchronization(simpleDbTxn).next(() =>
-            transactionOperation(
-              new IndexedDbTransaction(simpleDbTxn, this.listenSequence.next())
-            )
+            transactionOperation(persistenceTransaction)
           );
         }
-      }
-    );
+      })
+      .then(result => {
+        persistenceTransaction.raiseOnCommittedEvent();
+        return result;
+      });
   }
 
   /**

packages/firestore/src/local/memory_persistence.ts

@@ -180,6 +180,7 @@ export class MemoryPersistence implements Persistence {
     this.referenceDelegate.onTransactionStarted();
     return transactionOperation(txn)
       .next(result => {
+        txn.raiseOnCommittedEvent();
         return this.referenceDelegate
           .onTransactionCommitted(txn)
           .next(() => result);
@@ -203,8 +204,10 @@ export class MemoryPersistence implements Persistence {
  * Memory persistence is not actually transactional, but future implementations
  * may have transaction-scoped state.
  */
-export class MemoryTransaction implements PersistenceTransaction {
-  constructor(readonly currentSequenceNumber: ListenSequenceNumber) {}
+export class MemoryTransaction extends PersistenceTransaction {
+  constructor(readonly currentSequenceNumber: ListenSequenceNumber) {
+    super();
+  }
 }
 
 export class MemoryEagerDelegate implements ReferenceDelegate {

packages/firestore/src/local/persistence.ts

@@ -29,14 +29,25 @@ import { RemoteDocumentCache } from './remote_document_cache';
 import { ClientId } from './shared_client_state';
 
 /**
- * Opaque interface representing a persistence transaction.
+ * A base class representing a persistence transaction, encapsulating both the
+ * transaction's sequence numbers as well as a list of onCommitted listeners.
  *
  * When you call Persistence.runTransaction(), it will create a transaction and
  * pass it to your callback. You then pass it to any method that operates
  * on persistence.
  */
 export abstract class PersistenceTransaction {
+  private readonly onCommittedListeners: Array<() => {}> = [];
+
   abstract readonly currentSequenceNumber: ListenSequenceNumber;
+
+  addOnCommittedListener(listener: () => {}): void {
+    this.onCommittedListeners.push(listener);
+  }
+
+  raiseOnCommittedEvent(): void {
+    this.onCommittedListeners.forEach(listener => listener());
+  }
 }
 
 /** The different modes supported by `IndexedDbPersistence.runTransaction()`. */