Initial implementation

Author: wu-hui

packages/firestore/src/api/database.ts

@@ -26,6 +26,7 @@ import { deepEqual, getDefaultEmulatorHostnameAndPort } from '@firebase/util';
 import { User } from '../auth/user';
 import {
   IndexedDbOfflineComponentProvider,
+  LruGcMemoryOfflineComponentProvider,
   MultiTabOfflineComponentProvider,
   OfflineComponentProvider,
   OnlineComponentProvider
@@ -286,28 +287,65 @@ export function configureFirestore(firestore: Firestore): void {
 }
 
 /**
- * Attempts to enable persistent storage, if possible.
+ * Attempts to enable the LRU garbage collector for memory persistence.
  *
  * Must be called before any other functions (other than
  * {@link initializeFirestore}, {@link (getFirestore:1)} or
  * {@link clearIndexedDbPersistence}.
  *
- * If this fails, `enableIndexedDbPersistence()` will reject the promise it
- * returns. Note that even after this failure, the {@link Firestore} instance will
- * remain usable, however offline persistence will be disabled.
+ * By default, any documents that are not part of an active query result or
+ * with no mutation attached to them are removed from memory immediately.
  *
- * There are several reasons why this can fail, which can be identified by
- * the `code` on the error.
- *
- *   * failed-precondition: The app is already open in another browser tab.
- *   * unimplemented: The browser is incompatible with the offline
- *     persistence implementation.
+ * This function changes the default behavior, to enable a least-recent-used
+ * garbage collector. Documents will be collected when their total size exceeds
+ * `Settings.cacheSizeBytes`, with least recently used documents get removed first.
  *
  * @param firestore - The {@link Firestore} instance to enable persistence for.
- * @param persistenceSettings - Optional settings object to configure
- * persistence.
  * @returns A `Promise` that represents successfully enabling persistent storage.
  */
+export function enableMemoryLRUGarbageCollection(
+  firestore: Firestore
+): Promise<void> {
+  firestore = cast(firestore, Firestore);
+  verifyNotInitialized(firestore);
+
+  const client = ensureFirestoreConfigured(firestore);
+  const settings = firestore._freezeSettings();
+
+  const onlineComponentProvider = new OnlineComponentProvider();
+  const offlineComponentProvider = new LruGcMemoryOfflineComponentProvider(
+    settings.cacheSizeBytes
+  );
+  return setPersistenceProviders(
+    client,
+    onlineComponentProvider,
+    offlineComponentProvider
+  );
+}
+
+/**
+ * Attempts to enable persistent storage, if possible. //
+ *				//
+ * Must be called before any other functions (other than //
+ * {@link initializeFirestore}, {@link (getFirestore:1)} or //
+ * {@link clearIndexedDbPersistence}. //
+ *				//
+ * If this fails, `enableIndexedDbPersistence()` will reject the promise it //
+ * returns. Note that even after this failure, the {@link Firestore} instance will //
+ * remain usable, however offline persistence will be disabled. //
+ *				//
+ * There are several reasons why this can fail, which can be identified by //
+ * the `code` on the error.	//
+ *				//
+ *   * failed-precondition: The app is already open in another browser tab. //
+ *   * unimplemented: The browser is incompatible with the offline //
+ *     persistence implementation. //
+ *				//
+ * @param firestore - The {@link Firestore} instance to enable persistence for. //
+ * @param persistenceSettings - Optional settings object to configure //
+ * persistence.			//
+ * @returns A `Promise` that represents successfully enabling persistent storage. //
+ */
 export function enableIndexedDbPersistence(
   firestore: Firestore,
   persistenceSettings?: PersistenceSettings

packages/firestore/src/core/component_provider.ts

@@ -31,6 +31,7 @@ import { LruParams } from '../local/lru_garbage_collector';
 import { LruScheduler } from '../local/lru_garbage_collector_impl';
 import {
   MemoryEagerDelegate,
+  MemoryLruDelegate,
   MemoryPersistence
 } from '../local/memory_persistence';
 import { Scheduler, Persistence } from '../local/persistence';
@@ -72,6 +73,7 @@ import {
   syncEngineSynchronizeWithChangedDocuments
 } from './sync_engine_impl';
 import { OnlineStateSource } from './types';
+import { hardAssert } from '../util/assert';
 
 export interface ComponentConfiguration {
   asyncQueue: AsyncQueue;
@@ -172,6 +174,37 @@ export class MemoryOfflineComponentProvider
   }
 }
 
+export class LruGcMemoryOfflineComponentProvider extends MemoryOfflineComponentProvider {
+  constructor(protected readonly cacheSizeBytes: number | undefined) {
+    super();
+  }
+
+  createGarbageCollectionScheduler(
+    cfg: ComponentConfiguration,
+    localStore: LocalStore
+  ): Scheduler | null {
+    hardAssert(
+      this.persistence.referenceDelegate instanceof MemoryLruDelegate,
+      'referenceDelegate is expected to be an instance of MemoryLruDelegate.'
+    );
+
+    const garbageCollector =
+      this.persistence.referenceDelegate.garbageCollector;
+    return new LruScheduler(garbageCollector, cfg.asyncQueue, localStore);
+  }
+
+  createPersistence(cfg: ComponentConfiguration): Persistence {
+    const lruParams =
+      this.cacheSizeBytes !== undefined
+        ? LruParams.withCacheSize(this.cacheSizeBytes)
+        : LruParams.DEFAULT;
+    return new MemoryPersistence(
+      p => MemoryLruDelegate.factory(p, lruParams),
+      this.serializer
+    );
+  }
+}
+
 /**
  * Provides all components needed for Firestore with IndexedDB persistence.
  */

packages/firestore/src/local/memory_persistence.ts

@@ -353,6 +353,13 @@ export class MemoryLruDelegate implements ReferenceDelegate, LruDelegate {
     this.garbageCollector = newLruGarbageCollector(this, lruParams);
   }
 
+  static factory(
+    persistence: MemoryPersistence,
+    lruParams: LruParams | null
+  ): MemoryLruDelegate {
+    return new MemoryLruDelegate(persistence, lruParams!!);
+  }
+
   // No-ops, present so memory persistence doesn't have to care which delegate
   // it has.
   onTransactionStarted(): void {}