Add a type parameter to Persistence

packages/firestore/src/core/firestore_client.ts

@@ -76,6 +76,8 @@ export class FirestoreClient {
   // undefined checks.
   private eventMgr: EventManager;
   private garbageCollector: GarbageCollector;
+  // Note that localStore will end up with the same type parameter as
+  // persistence because the LocalStore constructor enforces this.
   private persistence: Persistence;
   private localStore: LocalStore;
   private remoteStore: RemoteStore;

packages/firestore/src/core/sync_engine.ts

@@ -41,7 +41,6 @@ import { ObjectMap } from '../util/obj_map';
 import { Deferred } from '../util/promise';
 import { SortedMap } from '../util/sorted_map';
 import { isNullOrUndefined } from '../util/types';
-
 import { Query } from './query';
 import { SnapshotVersion } from './snapshot_version';
 import { TargetIdGenerator } from './target_id_generator';

packages/firestore/src/local/indexeddb_mutation_queue.ts

@@ -38,9 +38,10 @@ import {
 } from './indexeddb_schema';
 import { LocalSerializer } from './local_serializer';
 import { MutationQueue } from './mutation_queue';
-import { PersistenceTransaction } from './persistence';
 import { PersistencePromise } from './persistence_promise';
 import { SimpleDb, SimpleDbStore } from './simple_db';
+import { IndexedDbTransaction } from './indexeddb_persistence';
+import { PersistenceTransaction } from './persistence';
 
 /** A mutation queue for a specific user, backed by IndexedDB. */
 export class IndexedDbMutationQueue implements MutationQueue {
@@ -564,7 +565,7 @@ function mutationsStore(
   txn: PersistenceTransaction
 ): SimpleDbStore<DbMutationBatchKey, DbMutationBatch> {
   return SimpleDb.getStore<DbMutationBatchKey, DbMutationBatch>(
-    txn,
+    (txn as IndexedDbTransaction).simpleDbTransaction,
     DbMutationBatch.store
   );
 }
@@ -576,7 +577,7 @@ function documentMutationsStore(
   txn: PersistenceTransaction
 ): SimpleDbStore<DbDocumentMutationKey, DbDocumentMutation> {
   return SimpleDb.getStore<DbDocumentMutationKey, DbDocumentMutation>(
-    txn,
+    (txn as IndexedDbTransaction).simpleDbTransaction,
     DbDocumentMutation.store
   );
 }
@@ -588,7 +589,7 @@ function mutationQueuesStore(
   txn: PersistenceTransaction
 ): SimpleDbStore<DbMutationQueueKey, DbMutationQueue> {
   return SimpleDb.getStore<DbMutationQueueKey, DbMutationQueue>(
-    txn,
+    (txn as IndexedDbTransaction).simpleDbTransaction,
     DbMutationQueue.store
   );
 }

packages/firestore/src/local/indexeddb_persistence.ts

@@ -34,7 +34,7 @@ import {
 } from './indexeddb_schema';
 import { LocalSerializer } from './local_serializer';
 import { MutationQueue } from './mutation_queue';
-import { Persistence } from './persistence';
+import { Persistence, PersistenceTransaction } from './persistence';
 import { PersistencePromise } from './persistence_promise';
 import { QueryCache } from './query_cache';
 import { RemoteDocumentCache } from './remote_document_cache';
@@ -59,6 +59,12 @@ const UNSUPPORTED_PLATFORM_ERROR_MSG =
   ' IndexedDB or is known to have an incomplete implementation. Offline' +
   ' persistence has been disabled.';
 
+export class IndexedDbTransaction extends PersistenceTransaction {
+  constructor(readonly simpleDbTransaction: SimpleDbTransaction) {
+    super();
+  }
+}
+
 /**
  * An IndexedDB-backed instance of Persistence. Data is stored persistently
  * across sessions.
@@ -176,7 +182,7 @@ export class IndexedDbPersistence implements Persistence {
 
   runTransaction<T>(
     action: string,
-    operation: (transaction: SimpleDbTransaction) => PersistencePromise<T>
+    operation: (transaction: IndexedDbTransaction) => PersistencePromise<T>
   ): Promise<T> {
     if (this.persistenceError) {
       return Promise.reject(this.persistenceError);
@@ -186,10 +192,17 @@ export class IndexedDbPersistence implements Persistence {
 
     // Do all transactions as readwrite against all object stores, since we
     // are the only reader/writer.
-    return this.simpleDb.runTransaction('readwrite', ALL_STORES, txn => {
-      // Verify that we still have the owner lease as part of every transaction.
-      return this.ensureOwnerLease(txn).next(() => operation(txn));
-    });
+    return this.simpleDb.runTransaction(
+      'readwrite',
+      ALL_STORES,
+      simpleDbTxn => {
+        // Verify that we still have the owner lease as part of every transaction.
+        const txn = new IndexedDbTransaction(simpleDbTxn);
+        return this.ensureOwnerLease(txn.simpleDbTransaction).next(() =>
+          operation(txn)
+        );
+      }
+    );
   }
 
   static isAvailable(): boolean {
@@ -326,12 +339,16 @@ export class IndexedDbPersistence implements Persistence {
     // would increase the chances of us not refreshing on time if the queue is
     // backed up for some reason.
     this.ownerLeaseRefreshHandle = setInterval(() => {
-      const txResult = this.runTransaction('Refresh owner timestamp', txn => {
-        // NOTE: We don't need to validate the current owner contents, since
-        // runTransaction does that automatically.
-        const store = txn.store<DbOwnerKey, DbOwner>(DbOwner.store);
-        return store.put('owner', new DbOwner(this.ownerId, Date.now()));
-      });
+      const txResult = this.simpleDb.runTransaction(
+        'readwrite',
+        ALL_STORES,
+        txn => {
+          // NOTE: We don't need to validate the current owner contents, since
+          // runTransaction does that automatically.
+          const store = txn.store<DbOwnerKey, DbOwner>(DbOwner.store);
+          return store.put('owner', new DbOwner(this.ownerId, Date.now()));
+        }
+      );
 
       txResult.catch(reason => {
         // Probably means we lost the lease. Report the error and stop trying to

packages/firestore/src/local/indexeddb_query_cache.ts

@@ -34,11 +34,12 @@ import {
   DbTargetKey
 } from './indexeddb_schema';
 import { LocalSerializer } from './local_serializer';
-import { PersistenceTransaction } from './persistence';
 import { PersistencePromise } from './persistence_promise';
 import { QueryCache } from './query_cache';
 import { QueryData } from './query_data';
 import { SimpleDb, SimpleDbStore } from './simple_db';
+import { IndexedDbTransaction } from './indexeddb_persistence';
+import { PersistenceTransaction } from './persistence';
 
 export class IndexedDbQueryCache implements QueryCache {
   constructor(private serializer: LocalSerializer) {}
@@ -52,7 +53,7 @@ export class IndexedDbQueryCache implements QueryCache {
   /**
    * A cached copy of the metadata for the query cache.
    */
-  private metadata = null;
+  private metadata: DbTargetGlobal = null;
 
   /** The garbage collector to notify about potential garbage keys. */
   private garbageCollector: GarbageCollector | null = null;
@@ -297,6 +298,8 @@ export class IndexedDbQueryCache implements QueryCache {
     this.garbageCollector = gc;
   }
 
+  // TODO(gsoltis): we can let the compiler assert that txn !== null if we
+  // drop null from the type bounds on txn.
   containsKey(
     txn: PersistenceTransaction | null,
     key: DocumentKey
@@ -335,7 +338,10 @@ export class IndexedDbQueryCache implements QueryCache {
 function targetsStore(
   txn: PersistenceTransaction
 ): SimpleDbStore<DbTargetKey, DbTarget> {
-  return SimpleDb.getStore<DbTargetKey, DbTarget>(txn, DbTarget.store);
+  return SimpleDb.getStore<DbTargetKey, DbTarget>(
+    (txn as IndexedDbTransaction).simpleDbTransaction,
+    DbTarget.store
+  );
 }
 
 /**
@@ -345,7 +351,7 @@ function globalTargetStore(
   txn: PersistenceTransaction
 ): SimpleDbStore<DbTargetGlobalKey, DbTargetGlobal> {
   return SimpleDb.getStore<DbTargetGlobalKey, DbTargetGlobal>(
-    txn,
+    (txn as IndexedDbTransaction).simpleDbTransaction,
     DbTargetGlobal.store
   );
 }
@@ -357,7 +363,7 @@ function documentTargetStore(
   txn: PersistenceTransaction
 ): SimpleDbStore<DbTargetDocumentKey, DbTargetDocument> {
   return SimpleDb.getStore<DbTargetDocumentKey, DbTargetDocument>(
-    txn,
+    (txn as IndexedDbTransaction).simpleDbTransaction,
     DbTargetDocument.store
   );
 }

packages/firestore/src/local/indexeddb_remote_document_cache.ts

@@ -20,11 +20,12 @@ import { Document, MaybeDocument } from '../model/document';
 import { DocumentKey } from '../model/document_key';
 
 import { DbRemoteDocument, DbRemoteDocumentKey } from './indexeddb_schema';
+import { IndexedDbTransaction } from './indexeddb_persistence';
 import { LocalSerializer } from './local_serializer';
-import { PersistenceTransaction } from './persistence';
 import { PersistencePromise } from './persistence_promise';
 import { RemoteDocumentCache } from './remote_document_cache';
 import { SimpleDb, SimpleDbStore } from './simple_db';
+import { PersistenceTransaction } from './persistence';
 
 export class IndexedDbRemoteDocumentCache implements RemoteDocumentCache {
   constructor(private serializer: LocalSerializer) {}
@@ -89,7 +90,7 @@ function remoteDocumentsStore(
   txn: PersistenceTransaction
 ): SimpleDbStore<DbRemoteDocumentKey, DbRemoteDocument> {
   return SimpleDb.getStore<DbRemoteDocumentKey, DbRemoteDocument>(
-    txn,
+    (txn as IndexedDbTransaction).simpleDbTransaction,
     DbRemoteDocument.store
   );
 }

packages/firestore/src/local/memory_mutation_queue.ts

@@ -27,9 +27,9 @@ import { SortedSet } from '../util/sorted_set';
 
 import { GarbageCollector } from './garbage_collector';
 import { MutationQueue } from './mutation_queue';
-import { PersistenceTransaction } from './persistence';
 import { PersistencePromise } from './persistence_promise';
 import { DocReference } from './reference_set';
+import { PersistenceTransaction } from './persistence';
 
 export class MemoryMutationQueue implements MutationQueue {
   /**

packages/firestore/src/local/memory_persistence.ts

@@ -41,7 +41,9 @@ export class MemoryPersistence implements Persistence {
    * will make the in-memory persistence layer behave as if it were actually
    * persisting values.
    */
-  private mutationQueues: { [user: string]: MutationQueue } = {};
+  private mutationQueues: {
+    [user: string]: MutationQueue;
+  } = {};
   private remoteDocumentCache = new MemoryRemoteDocumentCache();
   private queryCache = new MemoryQueryCache();
 
@@ -85,9 +87,12 @@ export class MemoryPersistence implements Persistence {
     operation: (transaction: PersistenceTransaction) => PersistencePromise<T>
   ): Promise<T> {
     debug(LOG_TAG, 'Starting transaction:', action);
-    return operation(new MemoryPersistenceTransaction()).toPromise();
+    return operation(new MemoryTransaction()).toPromise();
   }
 }
 
-/** Dummy class since memory persistence doesn't actually use transactions. */
-class MemoryPersistenceTransaction implements PersistenceTransaction {}
+/**
+ * Memory persistence is not actually transactional, but future implementations
+ * may have transaction-scoped state.
+ */
+export class MemoryTransaction implements PersistenceTransaction {}

packages/firestore/src/local/memory_query_cache.ts

@@ -22,12 +22,12 @@ import { DocumentKey } from '../model/document_key';
 import { ObjectMap } from '../util/obj_map';
 
 import { GarbageCollector } from './garbage_collector';
-import { PersistenceTransaction } from './persistence';
 import { PersistencePromise } from './persistence_promise';
 import { QueryCache } from './query_cache';
 import { QueryData } from './query_data';
 import { ReferenceSet } from './reference_set';
 import { assert } from '../util/assert';
+import { PersistenceTransaction } from './persistence';
 
 export class MemoryQueryCache implements QueryCache {
   /**

packages/firestore/src/local/memory_remote_document_cache.ts

@@ -22,10 +22,9 @@ import {
 } from '../model/collections';
 import { Document, MaybeDocument } from '../model/document';
 import { DocumentKey } from '../model/document_key';
-
-import { PersistenceTransaction } from './persistence';
 import { PersistencePromise } from './persistence_promise';
 import { RemoteDocumentCache } from './remote_document_cache';
+import { PersistenceTransaction } from './persistence';
 
 export class MemoryRemoteDocumentCache implements RemoteDocumentCache {
   private docs = maybeDocumentMap();

packages/firestore/src/local/persistence.ts

@@ -17,7 +17,6 @@
 import { User } from '../auth/user';
 
 import { MutationQueue } from './mutation_queue';
-import { PersistenceTransaction } from './persistence';
 import { PersistencePromise } from './persistence_promise';
 import { QueryCache } from './query_cache';
 import { RemoteDocumentCache } from './remote_document_cache';
@@ -29,7 +28,7 @@ import { RemoteDocumentCache } from './remote_document_cache';
  * pass it to your callback. You then pass it to any method that operates
  * on persistence.
  */
-export interface PersistenceTransaction {}
+export abstract class PersistenceTransaction {}
 
 /**
  * Persistence is the lowest-level shared interface to persistent storage in

packages/firestore/src/local/simple_db.ts

@@ -14,14 +14,12 @@
  * limitations under the License.
  */
 
-import { assert, fail } from '../util/assert';
+import { assert } from '../util/assert';
 import { debug } from '../util/log';
 import { AnyDuringMigration } from '../util/misc';
-
 import { PersistencePromise } from './persistence_promise';
 import { SCHEMA_VERSION } from './indexeddb_schema';
 import { Deferred } from '../util/promise';
-import { PersistenceTransaction } from './persistence';
 import { Code, FirestoreError } from '../util/error';
 
 const LOG_TAG = 'SimpleDb';
@@ -150,14 +148,10 @@ export class SimpleDb {
 
   /** Helper to get a typed SimpleDbStore from a transaction. */
   static getStore<KeyType extends IDBValidKey, ValueType>(
-    txn: PersistenceTransaction,
+    txn: SimpleDbTransaction,
     store: string
   ): SimpleDbStore<KeyType, ValueType> {
-    if (txn instanceof SimpleDbTransaction) {
-      return txn.store<KeyType, ValueType>(store);
-    } else {
-      return fail('Invalid transaction object provided!');
-    }
+    return txn.store<KeyType, ValueType>(store);
   }
 
   constructor(private db: IDBDatabase) {}
@@ -534,25 +528,19 @@ export class SimpleDbStore<KeyType extends IDBValidKey, ValueType> {
   }
 
   private cursor(options: IterateOptions): IDBRequest {
-    let direction = 'next';
+    let direction: IDBCursorDirection = 'next';
     if (options.reverse) {
       direction = 'prev';
     }
     if (options.index) {
       const index = this.store.index(options.index);
       if (options.keysOnly) {
-        return index.openKeyCursor(
-          options.range,
-          direction as AnyDuringMigration
-        );
+        return index.openKeyCursor(options.range, direction);
       } else {
-        return index.openCursor(options.range, direction as AnyDuringMigration);
+        return index.openCursor(options.range, direction);
       }
     } else {
-      return this.store.openCursor(
-        options.range,
-        direction as AnyDuringMigration
-      );
+      return this.store.openCursor(options.range, direction);
     }
   }
 }

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

@@ -65,7 +65,7 @@ describe('EagerGarbageCollector', () => {
         expect(referenceSet.isEmpty()).to.equal(false);
 
         referenceSet.removeReferencesForId(2);
-        return gc.collectGarbage(true).toPromise();
+        return gc.collectGarbage(null).toPromise();
       })
       .then(garbage => {
         expectSetToEqual(garbage, [key3]);

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

@@ -24,7 +24,10 @@ import { IndexedDbPersistence } from '../../../src/local/indexeddb_persistence';
 import { LocalStore, LocalWriteResult } from '../../../src/local/local_store';
 import { LocalViewChanges } from '../../../src/local/local_view_changes';
 import { NoOpGarbageCollector } from '../../../src/local/no_op_garbage_collector';
-import { Persistence } from '../../../src/local/persistence';
+import {
+  Persistence,
+  PersistenceTransaction
+} from '../../../src/local/persistence';
 import {
   documentKeySet,
   DocumentMap,
@@ -270,7 +273,7 @@ describe('LocalStore w/ IndexedDB Persistence', () => {
   genericLocalStoreTests(persistenceHelpers.testIndexedDbPersistence);
 });
 
-function genericLocalStoreTests(
+function genericLocalStoreTests<TransactionType extends PersistenceTransaction>(
   getPersistence: () => Promise<Persistence>
 ): void {
   let persistence: Persistence;