WIP Tree-Shakeable Datastore

Author: schmidt-sebastian

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

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Firestore } from './database';
+import { DatabaseInfo } from '../../../src/core/database_info';
+import {
+  FirestoreClient,
+  PersistenceSettings
+} from '../../../src/core/firestore_client';
+import { Code, FirestoreError } from '../../../src/util/error';
+import {
+  ComponentProvider,
+  MemoryComponentProvider
+} from '../../../src/core/component_provider';
+
+const firestoreClientInstances = new Map<Firestore, Promise<FirestoreClient>>();
+
+// settings() defaults:
+export const DEFAULT_HOST = 'firestore.googleapis.com';
+export const DEFAULT_SSL = true;
+
+export function getFirestoreClient(
+  firestore: Firestore
+): Promise<FirestoreClient> {
+  if (firestore._terminated) {
+    throw new FirestoreError(
+      Code.FAILED_PRECONDITION,
+      'The client has already been terminated.'
+    );
+  }
+
+  if (!firestoreClientInstances.has(firestore)) {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    initializeFirestoreClient(firestore, new MemoryComponentProvider(), {
+      durable: false
+    });
+  }
+  return firestoreClientInstances.get(firestore)!;
+}
+
+export function initializeFirestoreClient(
+  firestore: Firestore,
+  componentProvider: ComponentProvider,
+  persistenceSettings: PersistenceSettings
+): Promise<void> {
+  if (firestore._terminated || hasFirestoreClient(firestore)) {
+    throw new FirestoreError(
+      Code.FAILED_PRECONDITION,
+      'Firestore has already been started and persistence can no longer ' +
+        'be enabled. You can only enable persistence before calling ' +
+        'any other methods on a Firestore object.'
+    );
+  }
+
+  const settings = firestore._getSettings();
+  const databaseInfo = new DatabaseInfo(
+    firestore._databaseId,
+    /* persistenceKey= */ firestore._persistenceKey,
+    settings.host ?? DEFAULT_HOST,
+    settings.ssl ?? DEFAULT_SSL,
+    /** forceLongPolling= */ false
+  );
+  const firestoreClient = new FirestoreClient(
+    firestore._credentials,
+    firestore._queue
+  );
+  const initializationPromise = firestoreClient.start(
+    databaseInfo,
+    componentProvider,
+    persistenceSettings
+  );
+  firestoreClientInstances.set(
+    firestore,
+    initializationPromise.then(() => firestoreClient)
+  );
+  return initializationPromise;
+}
+
+export function hasFirestoreClient(firestore: Firestore): boolean {
+  return firestoreClientInstances.has(firestore);
+}
+
+export async function removeFirestoreClient(
+  firestore: Firestore
+): Promise<void> {
+  const firestoreClient = await firestoreClientInstances.get(firestore);
+  if (firestoreClient) {
+    firestoreClientInstances.delete(firestore);
+    return firestoreClient.terminate();
+  }
+}

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

@@ -18,67 +18,53 @@
 import * as firestore from '../../index';
 
 import { _getProvider, _removeServiceInstance } from '@firebase/app-exp';
-import { FirebaseApp, _FirebaseService } from '@firebase/app-types-exp';
+import { _FirebaseService, FirebaseApp } from '@firebase/app-types-exp';
 import { Provider } from '@firebase/component';
 
 import { FirebaseAuthInternalName } from '@firebase/auth-interop-types';
-import {
-  FirestoreClient,
-  PersistenceSettings
-} from '../../../src/core/firestore_client';
 import { AsyncQueue } from '../../../src/util/async_queue';
 import {
-  ComponentProvider,
   IndexedDbComponentProvider,
-  MemoryComponentProvider,
   MultiTabIndexedDbComponentProvider
 } from '../../../src/core/component_provider';
 
-import {
-  DEFAULT_FORCE_LONG_POLLING,
-  DEFAULT_HOST,
-  DEFAULT_SSL,
-  Firestore as LiteFirestore
-} from '../../../lite/src/api/database';
+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';
 import { CACHE_SIZE_UNLIMITED } from '../../../src/api/database';
-import { DatabaseId, DatabaseInfo } from '../../../src/core/database_info';
+import { DatabaseId } from '../../../src/core/database_info';
 import {
-  indexedDbStoragePrefix,
-  indexedDbClearPersistence
+  indexedDbClearPersistence,
+  indexedDbStoragePrefix
 } from '../../../src/local/indexeddb_persistence';
+import {
+  getFirestoreClient,
+  hasFirestoreClient,
+  initializeFirestoreClient,
+  removeFirestoreClient
+} from './components';
 
 /**
  * The root reference to the Firestore database and the entry point for the
  * tree-shakeable SDK.
  */
 export class Firestore extends LiteFirestore
   implements firestore.FirebaseFirestore, _FirebaseService {
-  private readonly _queue = new AsyncQueue();
-  private readonly _firestoreClient: FirestoreClient;
-  private readonly _persistenceKey: string;
-  private _componentProvider: ComponentProvider = new MemoryComponentProvider();
+  readonly _queue = new AsyncQueue();
+  readonly _persistenceKey: string;
 
-  // Assigned via _getFirestoreClient()
-  private _deferredInitialization?: Promise<void>;
-
-  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;
 
-  private _terminated: boolean = false;
-
   constructor(
     app: FirebaseApp,
     authProvider: Provider<FirebaseAuthInternalName>
   ) {
     super(app, authProvider);
     this._persistenceKey = app.name;
-    this._firestoreClient = new FirestoreClient(this._credentials, this._queue);
   }
 
   _getSettings(): firestore.Settings {
@@ -88,65 +74,6 @@ export class Firestore extends LiteFirestore
     return this._settings;
   }
 
-  _getFirestoreClient(): Promise<FirestoreClient> {
-    if (this._terminated) {
-      throw new FirestoreError(
-        Code.FAILED_PRECONDITION,
-        'The client has already been terminated.'
-      );
-    }
-
-    if (!this._deferredInitialization) {
-      const settings = this._getSettings();
-      const databaseInfo = this._makeDatabaseInfo(
-        settings.host,
-        settings.ssl,
-        settings.experimentalForceLongPolling
-      );
-
-      this._deferredInitialization = this._firestoreClient.start(
-        databaseInfo,
-        this._componentProvider,
-        this._persistenceSettings
-      );
-    }
-
-    return this._deferredInitialization.then(() => this._firestoreClient);
-  }
-
-  // TODO(firestorexp): Factor out MultiTabComponentProvider and remove
-  // `synchronizeTabs` argument
-  _enablePersistence(
-    persistenceProvider: ComponentProvider,
-    synchronizeTabs: boolean
-  ): Promise<void> {
-    if (this._deferredInitialization) {
-      throw new FirestoreError(
-        Code.FAILED_PRECONDITION,
-        'Firestore has already been started and persistence can no longer ' +
-          'be enabled. You can only 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);
-  }
-
   /**
    * Verifies that the client is not running and clears persistence by invoking
    * `delegate` on the async queue.
@@ -157,7 +84,7 @@ export class Firestore extends LiteFirestore
   _clearPersistence(
     delegate: (databaseId: DatabaseId, persistenceKey: string) => Promise<void>
   ): Promise<void> {
-    if (this._deferredInitialization !== undefined && !this._terminated) {
+    if (hasFirestoreClient(this)) {
       throw new FirestoreError(
         Code.FAILED_PRECONDITION,
         'Persistence can only be cleared before a Firestore instance is ' +
@@ -177,28 +104,9 @@ export class Firestore extends LiteFirestore
     return deferred.promise;
   }
 
-  protected _makeDatabaseInfo(
-    host?: string,
-    ssl?: boolean,
-    forceLongPolling?: boolean
-  ): DatabaseInfo {
-    return new DatabaseInfo(
-      this._databaseId,
-      this._persistenceKey,
-      host ?? DEFAULT_HOST,
-      ssl ?? DEFAULT_SSL,
-      forceLongPolling ?? DEFAULT_FORCE_LONG_POLLING
-    );
-  }
-
-  _terminate(): Promise<void> {
-    this._terminated = true;
-    if (this._deferredInitialization) {
-      return this._deferredInitialization.then(() =>
-        this._firestoreClient.terminate()
-      );
-    }
-    return Promise.resolve();
+  async _terminate(): Promise<void> {
+    await super._terminate();
+    await removeFirestoreClient(this);
   }
 }
 
@@ -234,20 +142,33 @@ export function enableIndexedDbPersistence(
   firestore: firestore.FirebaseFirestore
 ): Promise<void> {
   const firestoreImpl = cast(firestore, Firestore);
-  return firestoreImpl._enablePersistence(
+  const settings = firestoreImpl._getSettings();
+  return initializeFirestoreClient(
+    firestoreImpl,
     new IndexedDbComponentProvider(),
-    /*synchronizeTabs=*/ false
+    {
+      durable: true,
+      cacheSizeBytes:
+        settings.cacheSizeBytes || LruParams.DEFAULT_CACHE_SIZE_BYTES
+    }
   );
 }
 
 export function enableMultiTabIndexedDbPersistence(
   firestore: firestore.FirebaseFirestore
 ): Promise<void> {
   const firestoreImpl = cast(firestore, Firestore);
-  return firestoreImpl._enablePersistence(
+  const settings = firestoreImpl._getSettings();
+  return initializeFirestoreClient(
+    firestoreImpl,
     new MultiTabIndexedDbComponentProvider(),
-    /*synchronizeTabs=*/ false
-  );
+    {
+      durable: true,
+      synchronizeTabs: true,
+      cacheSizeBytes:
+        settings.cacheSizeBytes || LruParams.DEFAULT_CACHE_SIZE_BYTES
+    }
+  ).then(() => {});
 }
 
 export function clearIndexedDbPersistence(
@@ -265,33 +186,33 @@ export function waitForPendingWrites(
   firestore: firestore.FirebaseFirestore
 ): Promise<void> {
   const firestoreImpl = cast(firestore, Firestore);
-  return firestoreImpl
-    ._getFirestoreClient()
-    .then(firestoreClient => firestoreClient.waitForPendingWrites());
+  return getFirestoreClient(firestoreImpl).then(firestoreClient =>
+    firestoreClient.waitForPendingWrites()
+  );
 }
 
 export function enableNetwork(
   firestore: firestore.FirebaseFirestore
 ): Promise<void> {
   const firestoreImpl = cast(firestore, Firestore);
-  return firestoreImpl
-    ._getFirestoreClient()
-    .then(firestoreClient => firestoreClient.enableNetwork());
+  return getFirestoreClient(firestoreImpl).then(firestoreClient =>
+    firestoreClient.enableNetwork()
+  );
 }
 
 export function disableNetwork(
   firestore: firestore.FirebaseFirestore
 ): Promise<void> {
   const firestoreImpl = cast(firestore, Firestore);
-  return firestoreImpl
-    ._getFirestoreClient()
-    .then(firestoreClient => firestoreClient.disableNetwork());
+  return getFirestoreClient(firestoreImpl).then(firestoreClient =>
+    firestoreClient.disableNetwork()
+  );
 }
 
 export function terminate(
   firestore: firestore.FirebaseFirestore
 ): Promise<void> {
   _removeServiceInstance(firestore.app, 'firestore/lite');
   const firestoreImpl = cast(firestore, Firestore);
-  return firestoreImpl._terminate();
+  return firestoreImpl.delete();
 }