Bundle's named query resume.

packages/firestore-types/index.d.ts

@@ -97,6 +97,8 @@ export class FirebaseFirestore {
     bundleData: ArrayBuffer | ReadableStream<ArrayBuffer> | string
   ): LoadBundleTask;
 
+  namedQuery(name: string): Promise<Query | null>;
+
   INTERNAL: { delete: () => Promise<void> };
 }
 

packages/firestore/exp/index.ts

@@ -32,6 +32,7 @@ export {
   waitForPendingWrites,
   disableNetwork,
   enableNetwork,
+  namedQuery,
   loadBundle,
   terminate
 } from './src/api/database';

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

@@ -51,6 +51,7 @@ import {
   indexedDbClearPersistence
 } from '../../../src/local/indexeddb_persistence';
 import { LoadBundleTask } from '../../../src/api/bundle';
+import { Query } from '../../../lite';
 
 /**
  * The root reference to the Firestore database and the entry point for the
@@ -310,3 +311,17 @@ export function loadBundle(
 
   return resultTask;
 }
+
+export async function namedQuery(
+  firestore: firestore.FirebaseFirestore,
+  name: string
+): Promise<firestore.Query | null> {
+  const firestoreImpl = cast(firestore, Firestore);
+  const client = await firestoreImpl._getFirestoreClient();
+  const namedQuery = await client.getNamedQuery(name);
+  if (!namedQuery) {
+    return null;
+  }
+
+  return new Query(firestoreImpl, null, namedQuery.query);
+}

packages/firestore/exp/test/shim.ts

@@ -46,6 +46,7 @@ import {
   increment,
   initializeFirestore,
   loadBundle,
+  namedQuery,
   onSnapshot,
   onSnapshotsInSync,
   parent,
@@ -173,6 +174,12 @@ export class FirebaseFirestore implements legacy.FirebaseFirestore {
     return loadBundle(this._delegate, bundleData)!;
   }
 
+  async namedQuery(name: string): Promise<legacy.Query | null> {
+    return namedQuery(this._delegate, name).then(query => {
+      return query ? new Query(this, query) : null;
+    });
+  }
+
   INTERNAL = {
     delete: () => terminate(this._delegate)
   };

packages/firestore/src/api/database.ts

@@ -504,6 +504,16 @@ export class Firestore implements firestore.FirebaseFirestore, FirebaseService {
     return resultTask;
   }
 
+  async namedQuery(name: string): Promise<firestore.Query | null> {
+    this.ensureClientConfigured();
+    const namedQuery = await this._firestoreClient!.getNamedQuery(name);
+    if (!namedQuery) {
+      return null;
+    }
+
+    return new Query(namedQuery.query, this, null);
+  }
+
   ensureClientConfigured(): FirestoreClient {
     if (!this._firestoreClient) {
       // Kick off starting the client but don't actually wait for it.

packages/firestore/src/core/firestore_client.ts

@@ -17,7 +17,7 @@
 
 import { CredentialsProvider } from '../api/credentials';
 import { User } from '../auth/user';
-import { LocalStore } from '../local/local_store';
+import { getNamedQuery, LocalStore } from '../local/local_store';
 import { GarbageCollectionScheduler, Persistence } from '../local/persistence';
 import { Document, NoDocument } from '../model/document';
 import { DocumentKey } from '../model/document_key';
@@ -50,6 +50,7 @@ import { BundleReader } from '../util/bundle_reader';
 import { LoadBundleTask } from '../api/bundle';
 import { newTextEncoder } from '../platform/serializer';
 import { toByteStreamReader } from '../platform/byte_stream_reader';
+import { NamedQuery } from './bundle';
 
 const LOG_TAG = 'FirestoreClient';
 const MAX_CONCURRENT_LIMBO_RESOLUTIONS = 100;
@@ -533,4 +534,9 @@ export class FirestoreClient {
       });
     });
   }
+
+  getNamedQuery(queryName: string): Promise<NamedQuery | undefined> {
+    this.verifyNotTerminated();
+    return getNamedQuery(this.localStore, queryName);
+  }
 }

packages/firestore/src/local/indexeddb_bundle_cache.ts

@@ -47,7 +47,7 @@ export class IndexedDbBundleCache implements BundleCache {
       .get(bundleId)
       .next(bundle => {
         if (bundle) {
-          return fromDbBundle(this.serializer, bundle);
+          return fromDbBundle(bundle);
         }
         return undefined;
       });
@@ -57,9 +57,7 @@ export class IndexedDbBundleCache implements BundleCache {
     transaction: PersistenceTransaction,
     bundleMetadata: bundleProto.BundleMetadata
   ): PersistencePromise<void> {
-    return bundlesStore(transaction).put(
-      toDbBundle(this.serializer, bundleMetadata)
-    );
+    return bundlesStore(transaction).put(toDbBundle(bundleMetadata));
   }
 
   getNamedQuery(
@@ -70,7 +68,7 @@ export class IndexedDbBundleCache implements BundleCache {
       .get(queryName)
       .next(query => {
         if (query) {
-          return fromDbNamedQuery(this.serializer, query);
+          return fromDbNamedQuery(query);
         }
         return undefined;
       });
@@ -80,9 +78,7 @@ export class IndexedDbBundleCache implements BundleCache {
     transaction: PersistenceTransaction,
     query: bundleProto.NamedQuery
   ): PersistencePromise<void> {
-    return namedQueriesStore(transaction).put(
-      toDbNamedQuery(this.serializer, query)
-    );
+    return namedQueriesStore(transaction).put(toDbNamedQuery(query));
   }
 }
 

packages/firestore/src/local/local_serializer.ts

@@ -280,10 +280,7 @@ function isDocumentQuery(dbQuery: DbQuery): dbQuery is api.DocumentsTarget {
 }
 
 /** Encodes a DbBundle to a Bundle. */
-export function fromDbBundle(
-  serializer: LocalSerializer,
-  dbBundle: DbBundle
-): Bundle {
+export function fromDbBundle(dbBundle: DbBundle): Bundle {
   return {
     id: dbBundle.bundleId,
     createTime: fromDbTimestamp(dbBundle.createTime),
@@ -292,10 +289,7 @@ export function fromDbBundle(
 }
 
 /** Encodes a BundleMetadata to a DbBundle. */
-export function toDbBundle(
-  serializer: LocalSerializer,
-  metadata: bundleProto.BundleMetadata
-): DbBundle {
+export function toDbBundle(metadata: bundleProto.BundleMetadata): DbBundle {
   return {
     bundleId: metadata.id!,
     createTime: toDbTimestamp(fromVersion(metadata.createTime!)),
@@ -304,22 +298,16 @@ export function toDbBundle(
 }
 
 /** Encodes a DbNamedQuery to a NamedQuery. */
-export function fromDbNamedQuery(
-  serializer: LocalSerializer,
-  dbNamedQuery: DbNamedQuery
-): NamedQuery {
+export function fromDbNamedQuery(dbNamedQuery: DbNamedQuery): NamedQuery {
   return {
     name: dbNamedQuery.name,
-    query: fromBundledQuery(serializer, dbNamedQuery.bundledQuery),
+    query: fromBundledQuery(dbNamedQuery.bundledQuery),
     readTime: fromDbTimestamp(dbNamedQuery.readTime)
   };
 }
 
 /** Encodes a NamedQuery from a bundle proto to a DbNamedQuery. */
-export function toDbNamedQuery(
-  serializer: LocalSerializer,
-  query: bundleProto.NamedQuery
-): DbNamedQuery {
+export function toDbNamedQuery(query: bundleProto.NamedQuery): DbNamedQuery {
   return {
     name: query.name!,
     readTime: toDbTimestamp(fromVersion(query.readTime!)),
@@ -334,7 +322,6 @@ export function toDbNamedQuery(
  * including features exists only in SDKs (for example: limit-to-last).
  */
 export function fromBundledQuery(
-  serializer: LocalSerializer,
   bundledQuery: bundleProto.BundledQuery
 ): Query {
   const query = convertQueryTargetToQuery({
@@ -353,19 +340,17 @@ export function fromBundledQuery(
 
 /** Encodes a NamedQuery proto object to a NamedQuery model object. */
 export function fromProtoNamedQuery(
-  serializer: LocalSerializer,
   namedQuery: bundleProto.NamedQuery
 ): NamedQuery {
   return {
     name: namedQuery.name!,
-    query: fromBundledQuery(serializer, namedQuery.bundledQuery!),
+    query: fromBundledQuery(namedQuery.bundledQuery!),
     readTime: fromVersion(namedQuery.readTime!)
   };
 }
 
 /** Encodes a BundleMetadata proto object to a Bundle model object. */
 export function fromBundleMetadata(
-  serializer: LocalSerializer,
   metadata: bundleProto.BundleMetadata
 ): Bundle {
   return {

packages/firestore/src/local/local_store.ts

@@ -76,7 +76,8 @@ import { isIndexedDbTransactionError } from './simple_db';
 import * as bundleProto from '../protos/firestore_bundle_proto';
 import { BundleConverter, BundledDocuments, NamedQuery } from '../core/bundle';
 import { BundleCache } from './bundle_cache';
-import { JsonProtoSerializer } from '../remote/serializer';
+import { fromVersion, JsonProtoSerializer } from '../remote/serializer';
+import { fromBundledQuery } from './local_serializer';
 
 const LOG_TAG = 'LocalStore';
 
@@ -898,8 +899,6 @@ class LocalStoreImpl implements LocalStore {
           .getTargetData(txn, target)
           .next((cached: TargetData | null) => {
             if (cached) {
-              // This target has been listened to previously, so reuse the
-              // previous targetID.
               // TODO(mcg): freshen last accessed date?
               targetData = cached;
               return PersistencePromise.resolve(targetData);
@@ -1371,14 +1370,34 @@ export function getNamedQuery(
 /**
  * Saves the given `NamedQuery` to local persistence.
  */
-export function saveNamedQuery(
+export async function saveNamedQuery(
   localStore: LocalStore,
   query: bundleProto.NamedQuery
 ): Promise<void> {
+  // Allocate a target for the named query such that it can be resumed
+  // from associated read time if users use it to listen. It will be
+  // removed through GC as an ordinary query.
+  const allocated = await localStore.allocateTarget(
+    queryToTarget(fromBundledQuery(query.bundledQuery!))
+  );
   const localStoreImpl = debugCast(localStore, LocalStoreImpl);
   return localStoreImpl.persistence.runTransaction(
     'Save named query',
     'readwrite',
-    transaction => localStoreImpl.bundleCache.saveNamedQuery(transaction, query)
+    transaction => {
+      // Update allocated target's read time, if the bundle's read time is newer.
+      let updateReadTime = PersistencePromise.resolve();
+      const readTime = fromVersion(query.readTime!);
+      if (allocated.snapshotVersion.compareTo(readTime) < 0) {
+        const newTargetData = allocated.withReadTime(readTime);
+        updateReadTime = localStoreImpl.targetCache.updateTargetData(
+          transaction,
+          newTargetData
+        );
+      }
+      return updateReadTime.next(() =>
+        localStoreImpl.bundleCache.saveNamedQuery(transaction, query)
+      );
+    }
   );
 }

packages/firestore/src/local/memory_bundle_cache.ts

@@ -43,10 +43,7 @@ export class MemoryBundleCache implements BundleCache {
     transaction: PersistenceTransaction,
     bundleMetadata: bundleProto.BundleMetadata
   ): PersistencePromise<void> {
-    this.bundles.set(
-      bundleMetadata.id!,
-      fromBundleMetadata(this.serializer, bundleMetadata)
-    );
+    this.bundles.set(bundleMetadata.id!, fromBundleMetadata(bundleMetadata));
     return PersistencePromise.resolve();
   }
 
@@ -61,10 +58,7 @@ export class MemoryBundleCache implements BundleCache {
     transaction: PersistenceTransaction,
     query: bundleProto.NamedQuery
   ): PersistencePromise<void> {
-    this.namedQueries.set(
-      query.name!,
-      fromProtoNamedQuery(this.serializer, query)
-    );
+    this.namedQueries.set(query.name!, fromProtoNamedQuery(query));
     return PersistencePromise.resolve();
   }
 }

packages/firestore/src/local/target_data.ts

@@ -69,6 +69,19 @@ export class TargetData {
     readonly resumeToken: ByteString = ByteString.EMPTY_BYTE_STRING
   ) {}
 
+  /** Creates a new target data instance with an updated read time. */
+  withReadTime(version: SnapshotVersion): TargetData {
+    return new TargetData(
+      this.target,
+      this.targetId,
+      this.purpose,
+      this.sequenceNumber,
+      version,
+      this.lastLimboFreeSnapshotVersion,
+      this.resumeToken
+    );
+  }
+
   /** Creates a new target data instance with an updated sequence number. */
   withSequenceNumber(sequenceNumber: number): TargetData {
     return new TargetData(

packages/firestore/src/protos/firestore_bundle_proto.ts

@@ -30,7 +30,7 @@ export interface BundledQuery {
 }
 
 /** LimitType enum. */
-type LimitType = 'FIRST' | 'LAST';
+export type LimitType = 'FIRST' | 'LAST';
 
 /** Properties of a NamedQuery. */
 export interface NamedQuery {

packages/firestore/src/protos/firestore_proto_api.d.ts

@@ -345,7 +345,7 @@ export declare namespace firestoreV1ApiClientInterfaces {
     query?: QueryTarget;
     documents?: DocumentsTarget;
     resumeToken?: string | Uint8Array;
-    readTime?: string;
+    readTime?: Timestamp;
     targetId?: number;
     once?: boolean;
   }

packages/firestore/src/remote/serializer.ts

@@ -973,8 +973,15 @@ export function toTarget(
 
   result.targetId = targetData.targetId;
 
+  // TODO(wuandy): We should consider remove resume token since we can always
+  // use readtime.
   if (targetData.resumeToken.approximateByteSize() > 0) {
     result.resumeToken = toBytes(serializer, targetData.resumeToken);
+  } else if (targetData.snapshotVersion.compareTo(SnapshotVersion.min()) > 0) {
+    result.readTime = toTimestamp(
+      serializer,
+      targetData.snapshotVersion.toTimestamp()
+    );
   }
 
   return result;