Forbid queries endAt an uncommitted server timestamp.

packages/firestore/src/api/database.ts

@@ -46,7 +46,8 @@ import {
   FieldValue,
   FieldValueOptions,
   ObjectValue,
-  RefValue
+  RefValue,
+  ServerTimestampValue
 } from '../model/field_value';
 import { DeleteMutation, Mutation, Precondition } from '../model/mutation';
 import { FieldPath, ResourcePath } from '../model/path';
@@ -1557,7 +1558,8 @@ export class Query implements firestore.Query {
    * position.
    *
    * Will throw if the document does not contain all fields of the order by
-   * of the query.
+   * of the query or if any of the fields in the order by are an uncommitted
+   * server timestamp.
    */
   private boundFromDocument(
     methodName: string,
@@ -1578,7 +1580,16 @@ export class Query implements firestore.Query {
         components.push(new RefValue(this.firestore._databaseId, doc.key));
       } else {
         const value = doc.field(orderBy.field);
-        if (value !== undefined) {
+        if (value instanceof ServerTimestampValue) {
+          throw new FirestoreError(
+            Code.INVALID_ARGUMENT,
+            'Invalid query. You are trying to start or end a query using a ' +
+              'document for which the field "' +
+              orderBy.field +
+              '" is an uncommitted server timestamp. (Since the value of ' +
+              'this field is unknown, you cannot start/end a query with it.)'
+          );
+        } else if (value !== undefined) {
           components.push(value);
         } else {
           const field = orderBy.field.canonicalString();

packages/firestore/test/integration/api/validation.test.ts

@@ -19,6 +19,7 @@ import * as firestore from '@firebase/firestore-types';
 import { expect } from 'chai';
 
 import { CACHE_SIZE_UNLIMITED } from '../../../src/api/database';
+import { EventsAccumulator } from '../util/events_accumulator';
 import firebase from '../util/firebase_export';
 import {
   ALT_PROJECT_ID,
@@ -795,6 +796,64 @@ apiDescribe('Validation:', persistence => {
       });
     });
 
+    validationIt(
+      persistence,
+      'cannot be sorted by an uncommitted server timestamp',
+      db => {
+        return withTestCollection(
+          persistence,
+          /*docs=*/ {},
+          async (collection: firestore.CollectionReference) => {
+            await db.disableNetwork();
+
+            const offlineAccumulator = new EventsAccumulator<
+              firestore.QuerySnapshot
+            >();
+            const onlineAccumulator = new EventsAccumulator<
+              firestore.QuerySnapshot
+            >();
+
+            const unsubscribe = collection.onSnapshot(snapshot => {
+              // Skip the initial empty snapshot.
+              if (snapshot.empty) return;
+
+              expect(snapshot.docs).to.have.lengthOf(1);
+              const docSnap: firestore.DocumentSnapshot = snapshot.docs[0];
+
+              if (snapshot.metadata.hasPendingWrites) {
+                // Offline snapshot. Since the server timestamp is uncommitted,
+                // we shouldn't be able to query by it.
+                expect(() =>
+                  collection
+                    .orderBy('timestamp')
+                    .endAt(docSnap)
+                    .onSnapshot(() => {})
+                ).to.throw('uncommitted server timestamp');
+                offlineAccumulator.storeEvent(snapshot);
+              } else {
+                // Online snapshot. Since the server timestamp is committed, we
+                // should be able to query by it.
+                collection
+                  .orderBy('timestamp')
+                  .endAt(docSnap)
+                  .onSnapshot(() => {});
+                onlineAccumulator.storeEvent(snapshot);
+              }
+            });
+
+            const doc: firestore.DocumentReference = collection.doc();
+            doc.set({ timestamp: FieldValue.serverTimestamp() });
+            await offlineAccumulator.awaitEvent();
+
+            await db.enableNetwork();
+            await onlineAccumulator.awaitEvent();
+
+            unsubscribe();
+          }
+        );
+      }
+    );
+
     validationIt(
       persistence,
       'must not have more components than order by.',