Implement bundle features in local store.

packages/firestore/src/core/bundle.ts

@@ -17,6 +17,12 @@
 
 import { Query } from './query';
 import { SnapshotVersion } from './snapshot_version';
+import { JsonProtoSerializer } from '../remote/serializer';
+import * as bundleProto from '../protos/firestore_bundle_proto';
+import * as api from '../protos/firestore_proto_api';
+import { DocumentKey } from '../model/document_key';
+import { MaybeDocument, NoDocument } from '../model/document';
+import { debugAssert } from '../util/assert';
 
 /**
  * Represents a Firestore bundle saved by the SDK in its local storage.
@@ -40,3 +46,53 @@ export interface NamedQuery {
   /** The time at which the results for this query were read. */
   readonly readTime: SnapshotVersion;
 }
+
+/**
+ * Represents a bundled document, including the metadata and the document
+ * itself, if exists.
+ */
+interface BundledDocument {
+  metadata: bundleProto.BundledDocumentMetadata;
+  document: api.Document | undefined;
+}
+
+/**
+ * An array of `BundledDocument`.
+ */
+export type BundledDocuments = Array<{
+  metadata: bundleProto.BundledDocumentMetadata;
+  document: api.Document | undefined;
+}>;
+
+/**
+ * Helper to convert objects from bundles to model objects in the SDK.
+ */
+export class BundleConverter {
+  constructor(private serializer: JsonProtoSerializer) {}
+
+  toDocumentKey(name: string): DocumentKey {
+    return this.serializer.fromName(name);
+  }
+
+  /**
+   * Converts a [metadata, document] pair to a MaybeDocument.
+   */
+  toMaybeDocument(bundledDoc: BundledDocument): MaybeDocument {
+    if (bundledDoc.metadata.exists) {
+      debugAssert(
+        !!bundledDoc.document,
+        'Document is undefined when metadata.exist is true.'
+      );
+      return this.serializer.fromDocument(bundledDoc.document!, false);
+    } else {
+      return new NoDocument(
+        this.toDocumentKey(bundledDoc.metadata.name!),
+        this.toSnapshotVersion(bundledDoc.metadata.readTime!)
+      );
+    }
+  }
+
+  toSnapshotVersion(time: api.Timestamp): SnapshotVersion {
+    return this.serializer.fromVersion(time);
+  }
+}

packages/firestore/src/core/component_provider.ts

@@ -42,6 +42,7 @@ import {
   MemoryEagerDelegate,
   MemoryPersistence
 } from '../local/memory_persistence';
+import { JsonProtoSerializer } from '../remote/serializer';
 
 const MEMORY_ONLY_PERSISTENCE_ERROR_MESSAGE =
   'You are using the memory-only build of Firestore. Persistence support is ' +
@@ -90,7 +91,10 @@ export class MemoryComponentProvider implements ComponentProvider {
   remoteStore!: RemoteStore;
   eventManager!: EventManager;
 
+  serializer!: JsonProtoSerializer;
+
   async initialize(cfg: ComponentConfiguration): Promise<void> {
+    this.serializer = cfg.platform.newSerializer(cfg.databaseInfo.databaseId);
     this.sharedClientState = this.createSharedClientState(cfg);
     this.persistence = this.createPersistence(cfg);
     await this.persistence.start();
@@ -128,7 +132,8 @@ export class MemoryComponentProvider implements ComponentProvider {
     return new LocalStore(
       this.persistence,
       new IndexFreeQueryEngine(),
-      cfg.initialUser
+      cfg.initialUser,
+      this.serializer
     );
   }
 
@@ -137,8 +142,7 @@ export class MemoryComponentProvider implements ComponentProvider {
       !cfg.persistenceSettings.durable,
       'Can only start memory persistence'
     );
-    const serializer = cfg.platform.newSerializer(cfg.databaseInfo.databaseId);
-    return new MemoryPersistence(MemoryEagerDelegate.factory, serializer);
+    return new MemoryPersistence(MemoryEagerDelegate.factory, this.serializer);
   }
 
   createRemoteStore(cfg: ComponentConfiguration): RemoteStore {
@@ -212,7 +216,8 @@ export class IndexedDbComponentProvider extends MemoryComponentProvider {
     return new MultiTabLocalStore(
       this.persistence,
       new IndexFreeQueryEngine(),
-      cfg.initialUser
+      cfg.initialUser,
+      this.serializer
     );
   }
 
@@ -247,15 +252,14 @@ export class IndexedDbComponentProvider extends MemoryComponentProvider {
     const persistenceKey = IndexedDbPersistence.buildStoragePrefix(
       cfg.databaseInfo
     );
-    const serializer = cfg.platform.newSerializer(cfg.databaseInfo.databaseId);
     return new IndexedDbPersistence(
       cfg.persistenceSettings.synchronizeTabs,
       persistenceKey,
       cfg.clientId,
       cfg.platform,
       LruParams.withCacheSize(cfg.persistenceSettings.cacheSizeBytes),
       cfg.asyncQueue,
-      serializer,
+      this.serializer,
       this.sharedClientState
     );
   }

packages/firestore/src/local/bundle_cache.ts

@@ -28,7 +28,7 @@ export interface BundleCache {
    * Gets a saved `Bundle` for a given `bundleId`, returns undefined if
    * no bundles are found under the given id.
    */
-  getBundle(
+  getBundleMetadata(
     transaction: PersistenceTransaction,
     bundleId: string
   ): PersistencePromise<Bundle | undefined>;

packages/firestore/src/local/indexeddb_bundle_cache.ts

@@ -39,7 +39,7 @@ import { Bundle, NamedQuery } from '../core/bundle';
 export class IndexedDbBundleCache implements BundleCache {
   constructor(private serializer: LocalSerializer) {}
 
-  getBundle(
+  getBundleMetadata(
     transaction: PersistenceTransaction,
     bundleId: string
   ): PersistencePromise<Bundle | undefined> {

packages/firestore/src/local/indexeddb_remote_document_cache.ts

@@ -445,20 +445,20 @@ export class IndexedDbRemoteDocumentCache implements RemoteDocumentCache {
         primitiveComparator(l.canonicalString(), r.canonicalString())
       );
 
-      this.changes.forEach((key, maybeDocument) => {
+      this.changes.forEach((key, documentChange) => {
         const previousSize = this.documentSizes.get(key);
         debugAssert(
           previousSize !== undefined,
           `Cannot modify a document that wasn't read (for ${key})`
         );
-        if (maybeDocument) {
+        if (documentChange.maybeDocument) {
           debugAssert(
-            !this.readTime.isEqual(SnapshotVersion.min()),
+            !this.getReadTime(key).isEqual(SnapshotVersion.min()),
             'Cannot add a document with a read time of zero'
           );
           const doc = this.documentCache.serializer.toDbRemoteDocument(
-            maybeDocument,
-            this.readTime
+            documentChange.maybeDocument,
+            this.getReadTime(key)
           );
           collectionParents = collectionParents.add(key.path.popLast());
 
@@ -474,7 +474,7 @@ export class IndexedDbRemoteDocumentCache implements RemoteDocumentCache {
             // preserved in `getNewDocumentChanges()`.
             const deletedDoc = this.documentCache.serializer.toDbRemoteDocument(
               new NoDocument(key, SnapshotVersion.min()),
-              this.readTime
+              this.getReadTime(key)
             );
             promises.push(
               this.documentCache.addEntry(transaction, key, deletedDoc)