LocalStore-only queries

Author: schmidt-sebastian

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

@@ -28,11 +28,20 @@ import {
   OnlineComponentProvider
 } from '../../../src/core/component_provider';
 import { DEFAULT_HOST, DEFAULT_SSL } from '../../../lite/src/api/components';
+import { LocalStore } from '../../../src/local/local_store';
+import { Deferred } from '../../../src/util/promise';
 
 // The components module manages the lifetime of dependencies of the Firestore
 // client. Dependencies can be lazily constructed and only one exists per
 // Firestore instance.
 
+// TODO: These should be promises too
+const offlineComponentProviders = new Map<
+  Firestore,
+  OfflineComponentProvider
+>();
+const onlineComponentProviders = new Map<Firestore, OnlineComponentProvider>();
+
 /**
  * An instance map that ensures only one FirestoreClient exists per Firestore
  * instance.
@@ -56,18 +65,58 @@ export function getFirestoreClient(
   }
   if (!firestoreClientInstances.has(firestore)) {
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    initializeFirestoreClient(
-      firestore,
-      new MemoryOfflineComponentProvider(),
-      new OnlineComponentProvider(),
-      {
-        durable: false
-      }
-    );
+    initializeFirestoreClient(firestore, {
+      durable: false
+    });
   }
   return firestoreClientInstances.get(firestore)!;
 }
 
+async function getOfflineComponentProvider(
+  firestore: Firestore
+): Promise<OfflineComponentProvider> {
+  let offlineComponentProvider = offlineComponentProviders.get(firestore);
+  if (!offlineComponentProvider) {
+    offlineComponentProvider = new MemoryOfflineComponentProvider();
+    offlineComponentProviders.set(firestore, offlineComponentProvider);
+    const componentConfiguration = {
+      asyncQueue: firestore._queue,
+      databaseInfo: firestore._databaseId,
+      clientId: null as any,
+      credentials: null as any,
+      initialUser: null as any,
+      maxConcurrentLimboResolutions: null as any,
+      persistenceSettings: null as any
+    };
+    await offlineComponentProvider.initialize(componentConfiguration as any);
+  }
+  return offlineComponentProvider;
+}
+
+async function getOnlineComponentProvider(
+  firestore: Firestore
+): Promise<OnlineComponentProvider> {
+  let onlineComponentProvider = onlineComponentProviders.get(firestore);
+  if (!onlineComponentProvider) {
+    onlineComponentProvider = new OnlineComponentProvider();
+    onlineComponentProviders.set(firestore, onlineComponentProvider);
+    const componentConfiguration = {
+      asyncQueue: firestore._queue,
+      databaseInfo: firestore._databaseId,
+      clientId: null as any,
+      credentials: null as any,
+      initialUser: null as any,
+      maxConcurrentLimboResolutions: null as any,
+      persistenceSettings: null as any
+    };
+    await onlineComponentProvider.initialize(
+      await getOfflineComponentProvider(firestore),
+      componentConfiguration as any
+    );
+  }
+  return onlineComponentProvider;
+}
+
 /**
  * Creates a new FirestoreClient for the given Firestore instance. Throws if the
  * instance exists.
@@ -79,8 +128,6 @@ export function getFirestoreClient(
  */
 export function initializeFirestoreClient(
   firestore: Firestore,
-  offlineComponentProvider: OfflineComponentProvider,
-  onlineComponentProvider: OnlineComponentProvider,
   persistenceSettings: PersistenceSettings
 ): Promise<void> {
   if (firestore._initialized) {
@@ -104,17 +151,23 @@ export function initializeFirestoreClient(
     firestore._credentials,
     firestore._queue
   );
-  const initializationPromise = firestoreClient.start(
-    databaseInfo,
-    offlineComponentProvider,
-    onlineComponentProvider,
-    persistenceSettings
-  );
-  firestoreClientInstances.set(
-    firestore,
-    initializationPromise.then(() => firestoreClient)
-  );
-  return initializationPromise;
+  const initializationDeferred = new Deferred<FirestoreClient>();
+  firestoreClientInstances.set(firestore, initializationDeferred.promise);
+
+  Promise.all([
+    getOfflineComponentProvider(firestore),
+    getOnlineComponentProvider(firestore)
+  ]).then(([offlineComponentProvider, onlineComponentProvider]) => {
+    firestoreClient
+      .start(
+        databaseInfo,
+        offlineComponentProvider,
+        onlineComponentProvider,
+        persistenceSettings
+      )
+      .then(() => initializationDeferred.resolve(firestoreClient));
+  });
+  return initializationDeferred.promise.then(() => {});
 }
 
 /**
@@ -130,3 +183,39 @@ export async function removeFirestoreClient(
     return firestoreClient.terminate();
   }
 }
+
+export async function setComponentProviders(
+  firestore: Firestore,
+  offlineComponentProvider: OfflineComponentProvider,
+  onlineComponentProvider: OnlineComponentProvider
+): Promise<void> {
+  // TODO: Move this to Firestore
+  const componentConfiguration = {
+    asyncQueue: firestore._queue,
+    databaseInfo: firestore._databaseId,
+    clientId: null as any,
+    credentials: null as any,
+    initialUser: null as any,
+    maxConcurrentLimboResolutions: null as any,
+    persistenceSettings: null as any
+  };
+  await offlineComponentProvider.initialize(componentConfiguration as any);
+  await onlineComponentProvider.initialize(
+    offlineComponentProvider,
+    componentConfiguration as any
+  );
+  offlineComponentProviders.set(firestore, offlineComponentProvider);
+  onlineComponentProviders.set(firestore, onlineComponentProvider);
+}
+
+export function getLocalStore(firestore: Firestore): Promise<LocalStore> {
+  if (firestore._terminated) {
+    throw new FirestoreError(
+      Code.FAILED_PRECONDITION,
+      'The client has already been terminated.'
+    );
+  }
+  return getOfflineComponentProvider(firestore).then(
+    provider => provider.localStore
+  );
+}

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

@@ -37,7 +37,8 @@ import {
 import {
   getFirestoreClient,
   initializeFirestoreClient,
-  removeFirestoreClient
+  removeFirestoreClient,
+  setComponentProviders
 } from './components';
 import {
   IndexedDbOfflineComponentProvider,
@@ -113,17 +114,18 @@ export function enableIndexedDbPersistence(
 ): Promise<void> {
   const firestoreImpl = cast(firestore, Firestore);
   const settings = firestoreImpl._getSettings();
-  return initializeFirestoreClient(
+  return setComponentProviders(
     firestoreImpl,
     new IndexedDbOfflineComponentProvider(),
-    new OnlineComponentProvider(),
-    {
+    new OnlineComponentProvider()
+  ).then(() =>
+    initializeFirestoreClient(firestoreImpl, {
       durable: true,
       synchronizeTabs: false,
       cacheSizeBytes:
         settings.cacheSizeBytes || LruParams.DEFAULT_CACHE_SIZE_BYTES,
       forceOwningTab: false
-    }
+    })
   );
 }
 
@@ -132,17 +134,18 @@ export function enableMultiTabIndexedDbPersistence(
 ): Promise<void> {
   const firestoreImpl = cast(firestore, Firestore);
   const settings = firestoreImpl._getSettings();
-  return initializeFirestoreClient(
+  return setComponentProviders(
     firestoreImpl,
     new MultiTabOfflineComponentProvider(),
-    new MultiTabOnlineComponentProvider(),
-    {
+    new MultiTabOnlineComponentProvider()
+  ).then(() =>
+    initializeFirestoreClient(firestoreImpl, {
       durable: true,
       synchronizeTabs: true,
       cacheSizeBytes:
         settings.cacheSizeBytes || LruParams.DEFAULT_CACHE_SIZE_BYTES,
       forceOwningTab: false
-    }
+    })
   );
 }
 

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

@@ -59,7 +59,11 @@ import {
   PartialObserver,
   Unsubscribe
 } from '../../../src/api/observer';
-import { getFirestoreClient } from './components';
+import { getFirestoreClient, getLocalStore } from './components';
+import {
+  getDocumentFromLocalCache,
+  getDocumentsFromLocalCache
+} from '../../../src/core/firestore_client';
 
 export function getDoc<T>(
   reference: firestore.DocumentReference<T>
@@ -75,15 +79,17 @@ export function getDoc<T>(
   });
 }
 
-// TODO(firestorexp): Make sure we don't include Datastore/RemoteStore in builds
-// that only include `getDocFromCache`.
 export function getDocFromCache<T>(
   reference: firestore.DocumentReference<T>
 ): Promise<firestore.DocumentSnapshot<T>> {
   const ref = cast<DocumentReference<T>>(reference, DocumentReference);
   const firestore = cast<Firestore>(ref.firestore, Firestore);
-  return getFirestoreClient(firestore).then(async firestoreClient => {
-    const doc = await firestoreClient.getDocumentFromLocalCache(ref._key);
+  return getLocalStore(firestore).then(async localStore => {
+    const doc = await getDocumentFromLocalCache(
+      firestore._queue,
+      localStore,
+      ref._key
+    );
     return new DocumentSnapshot(
       firestore,
       ref._key,
@@ -133,8 +139,10 @@ export function getQueryFromCache<T>(
 ): Promise<QuerySnapshot<T>> {
   const internalQuery = cast<Query<T>>(query, Query);
   const firestore = cast<Firestore>(query.firestore, Firestore);
-  return getFirestoreClient(firestore).then(async firestoreClient => {
-    const snapshot = await firestoreClient.getDocumentsFromLocalCache(
+  return getLocalStore(firestore).then(async localStore => {
+    const snapshot = await getDocumentsFromLocalCache(
+      firestore._queue,
+      localStore,
       internalQuery._query
     );
     return new QuerySnapshot(firestore, internalQuery, snapshot);