Add remaining firestore-exp functionality

.changeset/twelve-spiders-return.md

@@ -0,0 +1,2 @@
+---
+---

packages/firestore/exp/index.d.ts

@@ -91,6 +91,7 @@ export function waitForPendingWrites(
 export function enableNetwork(firestore: FirebaseFirestore): Promise<void>;
 export function disableNetwork(firestore: FirebaseFirestore): Promise<void>;
 
+// TODO(firestoreexp): Add experimentalForceOwningTab support
 export function enableIndexedDbPersistence(
   firestore: FirebaseFirestore
 ): Promise<void>;

packages/firestore/exp/index.node.ts

@@ -23,15 +23,22 @@ import { Firestore } from './src/api/database';
 export { FieldPath, documentId } from '../lite/src/api/field_path';
 
 export {
-  Firestore,
+  Firestore as FirebaseFirestore,
   initializeFirestore,
   getFirestore,
+  enableIndexedDbPersistence,
+  enableMultiTabIndexedDbPersistence,
+  clearIndexedDbPersistence,
+  waitForPendingWrites,
+  disableNetwork,
+  enableNetwork,
   terminate
 } from './src/api/database';
 
 export {
   DocumentSnapshot,
   QueryDocumentSnapshot,
+  QuerySnapshot,
   snapshotEqual
 } from './src/api/snapshot';
 
@@ -53,6 +60,9 @@ export {
   getDoc,
   getDocFromCache,
   getDocFromServer,
+  getQuery,
+  getQueryFromCache,
+  getQueryFromServer,
   onSnapshot,
   onSnapshotsInSync,
   setDoc,

packages/firestore/exp/src/api/database.ts

@@ -22,15 +22,22 @@ import { FirebaseApp, _FirebaseService } from '@firebase/app-types-exp';
 import { Provider } from '@firebase/component';
 
 import { FirebaseAuthInternalName } from '@firebase/auth-interop-types';
-import { FirestoreClient } from '../../../src/core/firestore_client';
+import {
+  FirestoreClient,
+  PersistenceSettings
+} from '../../../src/core/firestore_client';
 import { AsyncQueue } from '../../../src/util/async_queue';
 import {
   ComponentProvider,
+  IndexedDbComponentProvider,
   MemoryComponentProvider
 } from '../../../src/core/component_provider';
 
 import { Firestore as LiteFirestore } from '../../../lite/src/api/database';
 import { cast } from '../../../lite/src/api/util';
+import { Code, FirestoreError } from '../../../src/util/error';
+import { Deferred } from '../../../src/util/promise';
+import { LruParams } from '../../../src/local/lru_garbage_collector';
 
 /**
  * The root reference to the Firestore database and the entry point for the
@@ -45,10 +52,13 @@ export class Firestore extends LiteFirestore
   // Assigned via _getFirestoreClient()
   private _firestoreClientPromise?: Promise<FirestoreClient>;
 
+  protected _persistenceSettings: PersistenceSettings = { durable: false };
   // We override the Settings property of the Lite SDK since the full Firestore
   // SDK supports more settings.
   protected _settings?: firestore.Settings;
 
+  _terminated: boolean = false;
+
   constructor(
     app: FirebaseApp,
     authProvider: Provider<FirebaseAuthInternalName>
@@ -80,16 +90,72 @@ export class Firestore extends LiteFirestore
       );
 
       this._firestoreClientPromise = firestoreClient
-        .start(this._componentProvider, { durable: false })
+        .start(this._componentProvider, this._persistenceSettings)
         .then(() => firestoreClient);
     }
 
     return this._firestoreClientPromise;
   }
 
+  // TODO(firestorexp): Factor out MultiTabComponentProvider and remove
+  // `synchronizeTabs` argument
+  _enablePersistence(
+    persistenceProvider: ComponentProvider,
+    synchronizeTabs: boolean
+  ): Promise<void> {
+    if (this._firestoreClientPromise) {
+      throw new FirestoreError(
+        Code.FAILED_PRECONDITION,
+        'Firestore has already been started and persistence can no longer ' +
+          'be enabled. You can only call enable persistence before calling ' +
+          'any other methods on a Firestore object.'
+      );
+    }
+
+    const settings = this._getSettings();
+    this._persistenceSettings = {
+      durable: true,
+      synchronizeTabs,
+      forceOwningTab: false,
+      cacheSizeBytes:
+        settings.cacheSizeBytes ?? LruParams.DEFAULT_CACHE_SIZE_BYTES
+    };
+    this._componentProvider = persistenceProvider;
+
+    // TODO(firestorexp): Add support for Persistence fallback
+    return this._getFirestoreClient().then(() => {});
+  }
+
   delete(): Promise<void> {
     return terminate(this);
   }
+
+  _clearPersistence(): Promise<void> {
+    if (this._firestoreClientPromise !== undefined && !this._terminated) {
+      throw new FirestoreError(
+        Code.FAILED_PRECONDITION,
+        'Persistence can only be cleared before the Firestore instance is ' +
+          'initialized or after it is terminated.'
+      );
+    }
+
+    const settings = this._getSettings();
+    const deferred = new Deferred<void>();
+    this._queue.enqueueAndForgetEvenAfterShutdown(async () => {
+      try {
+        const databaseInfo = this._makeDatabaseInfo(
+          settings.host,
+          settings.ssl,
+          settings.experimentalForceLongPolling
+        );
+        await this._componentProvider.clearPersistence(databaseInfo);
+        deferred.resolve();
+      } catch (e) {
+        deferred.reject(e);
+      }
+    });
+    return deferred.promise;
+  }
 }
 
 export function initializeFirestore(
@@ -108,11 +174,66 @@ export function getFirestore(app: FirebaseApp): Firestore {
   return _getProvider(app, 'firestore-exp').getImmediate() as Firestore;
 }
 
+export function enableIndexedDbPersistence(
+  firestore: firestore.FirebaseFirestore
+): Promise<void> {
+  const firestoreImpl = cast(firestore, Firestore);
+  return firestoreImpl._enablePersistence(
+    new IndexedDbComponentProvider(),
+    /*synchronizeTabs=*/ false
+  );
+}
+
+export function enableMultiTabIndexedDbPersistence(
+  firestore: firestore.FirebaseFirestore
+): Promise<void> {
+  const firestoreImpl = cast(firestore, Firestore);
+  return firestoreImpl._enablePersistence(
+    new IndexedDbComponentProvider(),
+    /*synchronizeTabs=*/ true
+  );
+}
+
+export function clearIndexedDbPersistence(
+  firestore: firestore.FirebaseFirestore
+): Promise<void> {
+  const firestoreImpl = cast(firestore, Firestore);
+  return firestoreImpl._clearPersistence();
+}
+
+export function waitForPendingWrites(
+  firestore: firestore.FirebaseFirestore
+): Promise<void> {
+  const firestoreImpl = cast(firestore, Firestore);
+  return firestoreImpl
+    ._getFirestoreClient()
+    .then(firestoreClient => firestoreClient.waitForPendingWrites());
+}
+
+export function enableNetwork(
+  firestore: firestore.FirebaseFirestore
+): Promise<void> {
+  const firestoreImpl = cast(firestore, Firestore);
+  return firestoreImpl
+    ._getFirestoreClient()
+    .then(firestoreClient => firestoreClient.enableNetwork());
+}
+
+export function disableNetwork(
+  firestore: firestore.FirebaseFirestore
+): Promise<void> {
+  const firestoreImpl = cast(firestore, Firestore);
+  return firestoreImpl
+    ._getFirestoreClient()
+    .then(firestoreClient => firestoreClient.disableNetwork());
+}
+
 export function terminate(
   firestore: firestore.FirebaseFirestore
 ): Promise<void> {
   _removeServiceInstance(firestore.app, 'firestore/lite');
   const firestoreImpl = cast(firestore, Firestore);
+  firestoreImpl._terminated = true;
   return firestoreImpl
     ._getFirestoreClient()
     .then(firestoreClient => firestoreClient.terminate());