Use serializer constructed from firestore client.

wu-hui · wu-hui · commit 322e27d868cb · 2020-08-14T11:02:28.000-04:00
diff --git a/packages/firestore/exp/src/api/database.ts b/packages/firestore/exp/src/api/database.ts
@@ -46,7 +46,6 @@ import {
   indexedDbStoragePrefix
 } from '../../../src/local/indexeddb_persistence';
 import { LoadBundleTask } from '../../../src/api/bundle';
-import { Query } from '../../../lite';
 import {
   getLocalStore,
   getPersistence,
@@ -332,9 +331,15 @@ export function loadBundle(
   const firestoreImpl = cast(firestore, Firestore);
   const resultTask = new LoadBundleTask();
   // eslint-disable-next-line @typescript-eslint/no-floating-promises
-  getSyncEngine(firestoreImpl).then(syncEngine =>
-    enqueueLoadBundle(firestoreImpl._queue, syncEngine, bundleData, resultTask)
-  );
+  getSyncEngine(firestoreImpl).then(async syncEngine => {
+    enqueueLoadBundle(
+      (await firestoreImpl._getConfiguration()).databaseInfo.databaseId,
+      firestoreImpl._queue,
+      syncEngine,
+      bundleData,
+      resultTask
+    );
+  });
 
   return resultTask;
 }
diff --git a/packages/firestore/src/core/bundle.ts b/packages/firestore/src/core/bundle.ts
@@ -83,7 +83,7 @@ export type BundledDocuments = BundledDocument[];
  * Helper to convert objects from bundles to model objects in the SDK.
  */
 export class BundleConverter {
-  constructor(private serializer: JsonProtoSerializer) {}
+  constructor(private readonly serializer: JsonProtoSerializer) {}
 
   toDocumentKey(name: string): DocumentKey {
     return fromName(this.serializer, name);
@@ -165,7 +165,8 @@ export class BundleLoader {
 
   constructor(
     private metadata: bundleProto.BundleMetadata,
-    private localStore: LocalStore
+    private localStore: LocalStore,
+    private serializer: JsonProtoSerializer
   ) {
     this.progress = bundleInitialProgress(metadata);
   }
@@ -216,9 +217,7 @@ export class BundleLoader {
     documents: BundledDocuments
   ): Map<string, DocumentKeySet> {
     const queryDocumentMap = new Map<string, DocumentKeySet>();
-    const bundleConverter = new BundleConverter(
-      this.localStore.getSerializer()
-    );
+    const bundleConverter = new BundleConverter(this.serializer);
     for (const bundleDoc of documents) {
       if (bundleDoc.metadata.queries) {
         const documentKey = bundleConverter.toDocumentKey(
diff --git a/packages/firestore/src/core/firestore_client.ts b/packages/firestore/src/core/firestore_client.ts
@@ -55,9 +55,10 @@ import { TransactionRunner } from './transaction_runner';
 import { Datastore } from '../remote/datastore';
 import { BundleReader } from '../util/bundle_reader';
 import { LoadBundleTask } from '../api/bundle';
-import { newTextEncoder } from '../platform/serializer';
+import { newSerializer, newTextEncoder } from '../platform/serializer';
 import { toByteStreamReader } from '../platform/byte_stream_reader';
 import { NamedQuery } from './bundle';
+import { JsonProtoSerializer } from '../remote/serializer';
 
 const LOG_TAG = 'FirestoreClient';
 export const MAX_CONCURRENT_LIMBO_RESOLUTIONS = 100;
@@ -537,7 +538,10 @@ export class FirestoreClient {
   ): void {
     this.verifyNotTerminated();
 
-    const reader = createBundleReader(data);
+    const reader = createBundleReader(
+      data,
+      newSerializer(this.databaseInfo.databaseId)
+    );
     this.asyncQueue.enqueueAndForget(async () => {
       loadBundle(this.syncEngine, reader, resultTask);
       return resultTask.catch(e => {
@@ -798,24 +802,26 @@ export function enqueueExecuteQueryViaSnapshotListener(
 }
 
 function createBundleReader(
-  data: ReadableStream<Uint8Array> | ArrayBuffer | string
+  data: ReadableStream<Uint8Array> | ArrayBuffer | string,
+  serializer: JsonProtoSerializer
 ): BundleReader {
   let content: ReadableStream<Uint8Array> | ArrayBuffer;
   if (typeof data === 'string') {
     content = newTextEncoder().encode(data);
   } else {
     content = data;
   }
-  return new BundleReader(toByteStreamReader(content));
+  return new BundleReader(toByteStreamReader(content), serializer);
 }
 
 export function enqueueLoadBundle(
+  databaseId: DatabaseId,
   asyncQueue: AsyncQueue,
   syncEngine: SyncEngine,
   data: ReadableStream<Uint8Array> | ArrayBuffer | string,
   resultTask: LoadBundleTask
 ): void {
-  const reader = createBundleReader(data);
+  const reader = createBundleReader(data, newSerializer(databaseId));
   asyncQueue.enqueueAndForget(async () => {
     loadBundle(syncEngine, reader, resultTask);
     return resultTask.catch(e => {
diff --git a/packages/firestore/src/core/sync_engine.ts b/packages/firestore/src/core/sync_engine.ts
@@ -1358,7 +1358,11 @@ async function loadBundleImpl(
 
     task._updateProgress(bundleInitialProgress(metadata));
 
-    const loader = new BundleLoader(metadata, syncEngine.localStore);
+    const loader = new BundleLoader(
+      metadata,
+      syncEngine.localStore,
+      reader.serializer
+    );
     let element = await reader.nextElement();
     while (element) {
       debugAssert(
diff --git a/packages/firestore/src/local/local_store.ts b/packages/firestore/src/local/local_store.ts
@@ -277,9 +277,6 @@ export interface LocalStore {
   executeQuery(query: Query, usePreviousResults: boolean): Promise<QueryResult>;
 
   collectGarbage(garbageCollector: LruGarbageCollector): Promise<LruResults>;
-
-  /** Returns the serializer associated with the local store. */
-  getSerializer(): JsonProtoSerializer;
 }
 
 /**
@@ -1086,10 +1083,6 @@ class LocalStoreImpl implements LocalStore {
       txn => garbageCollector.collect(txn, this.targetDataByTarget)
     );
   }
-
-  getSerializer(): JsonProtoSerializer {
-    return this.serializer;
-  }
 }
 
 export function newLocalStore(
@@ -1391,42 +1384,46 @@ export async function saveNamedQuery(
   const allocated = await localStore.allocateTarget(
     queryToTarget(fromBundledQuery(query.bundledQuery!))
   );
+
   const localStoreImpl = debugCast(localStore, LocalStoreImpl);
   return localStoreImpl.persistence.runTransaction(
     'Save named query',
     'readwrite',
     transaction => {
-      // Update allocated target's read time, if the bundle's read time is newer.
-      let readTimeUpdated = PersistencePromise.resolve();
       const readTime = fromVersion(query.readTime!);
-      if (allocated.snapshotVersion.compareTo(readTime) < 0) {
-        const newTargetData = allocated.withResumeToken(
-          ByteString.EMPTY_BYTE_STRING,
-          readTime
-        );
-        readTimeUpdated = localStoreImpl.targetCache
-          .updateTargetData(transaction, newTargetData)
-          .next(() =>
-            localStoreImpl.targetCache.removeMatchingKeysForTargetId(
-              transaction,
-              allocated.targetId
-            )
-          )
-          .next(() =>
-            localStoreImpl.targetCache.addMatchingKeys(
-              transaction,
-              documents,
-              allocated.targetId
-            )
-          );
-        localStoreImpl.targetDataByTarget = localStoreImpl.targetDataByTarget.insert(
-          newTargetData.targetId,
-          newTargetData
-        );
+      // Simply save the query itself if it is older than what the SDK already
+      // has.
+      if (allocated.snapshotVersion.compareTo(readTime) >= 0) {
+        return localStoreImpl.bundleCache.saveNamedQuery(transaction, query);
       }
-      return readTimeUpdated.next(() =>
-        localStoreImpl.bundleCache.saveNamedQuery(transaction, query)
+
+      // Update existing target data because the query from the bundle is newer.
+      const newTargetData = allocated.withResumeToken(
+        ByteString.EMPTY_BYTE_STRING,
+        readTime
       );
+      localStoreImpl.targetDataByTarget = localStoreImpl.targetDataByTarget.insert(
+        newTargetData.targetId,
+        newTargetData
+      );
+      return localStoreImpl.targetCache
+        .updateTargetData(transaction, newTargetData)
+        .next(() =>
+          localStoreImpl.targetCache.removeMatchingKeysForTargetId(
+            transaction,
+            allocated.targetId
+          )
+        )
+        .next(() =>
+          localStoreImpl.targetCache.addMatchingKeys(
+            transaction,
+            documents,
+            allocated.targetId
+          )
+        )
+        .next(() =>
+          localStoreImpl.bundleCache.saveNamedQuery(transaction, query)
+        );
     }
   );
 }
diff --git a/packages/firestore/src/util/bundle_reader.ts b/packages/firestore/src/util/bundle_reader.ts
@@ -23,6 +23,7 @@ import { Deferred } from './promise';
 import { debugAssert } from './assert';
 import { toByteStreamReader } from '../platform/byte_stream_reader';
 import { newTextDecoder } from '../platform/serializer';
+import { JsonProtoSerializer } from '../remote/serializer';
 
 /**
  * A complete element in the bundle stream, together with the byte length it
@@ -70,13 +71,20 @@ export class BundleReader {
   /** The decoder used to parse binary data into strings. */
   private textDecoder: TextDecoder;
 
-  static fromBundleSource(source: BundleSource): BundleReader {
-    return new BundleReader(toByteStreamReader(source, BYTES_PER_READ));
+  static fromBundleSource(
+    source: BundleSource,
+    serializer: JsonProtoSerializer
+  ): BundleReader {
+    return new BundleReader(
+      toByteStreamReader(source, BYTES_PER_READ),
+      serializer
+    );
   }
 
   constructor(
     /** The reader to read from underlying binary bundle data source. */
-    private reader: ReadableStreamReader<Uint8Array>
+    private reader: ReadableStreamReader<Uint8Array>,
+    readonly serializer: JsonProtoSerializer
   ) {
     this.textDecoder = newTextDecoder();
     // Read the metadata (which is the first element).
diff --git a/packages/firestore/test/unit/specs/spec_test_runner.ts b/packages/firestore/test/unit/specs/spec_test_runner.ts
@@ -477,7 +477,8 @@ abstract class TestRunner {
 
   private async doLoadBundle(bundle: string): Promise<void> {
     const reader = new BundleReader(
-      toByteStreamReader(newTextEncoder().encode(bundle))
+      toByteStreamReader(newTextEncoder().encode(bundle)),
+      this.serializer
     );
     const task = new LoadBundleTask();
     return this.queue.enqueue(async () => {
diff --git a/packages/firestore/test/unit/util/bundle.test.ts b/packages/firestore/test/unit/util/bundle.test.ts
@@ -40,6 +40,7 @@ import {
   doc2
 } from './bundle_data';
 import { newTextEncoder } from '../../../src/platform/serializer';
+import { JSON_SERIALIZER } from '../local/persistence_test_helpers';
 
 use(chaiAsPromised);
 
@@ -92,7 +93,10 @@ describe('Bundle ', () => {
 
 function genericBundleReadingTests(bytesPerRead: number): void {
   function bundleFromString(s: string): BundleReader {
-    return new BundleReader(byteStreamReaderFromString(s, bytesPerRead));
+    return new BundleReader(
+      byteStreamReaderFromString(s, bytesPerRead),
+      JSON_SERIALIZER
+    );
   }
 
   async function getAllElements(
