fix: avoid adding duplicate orderBys in startAfter()

dev/src/reference.ts

@@ -1521,6 +1521,9 @@ export class Query<T = firestore.DocumentData> implements firestore.Query<T> {
       // If no explicit ordering is specified, use the first inequality to
       // define an implicit order.
       for (const fieldFilter of this._queryOptions.fieldFilters) {
+        if (FieldPath.documentId().isEqual(fieldFilter.field)) {
+          hasDocumentId = true;
+        }
         if (fieldFilter.isInequalityFilter()) {
           fieldOrders.push(new FieldOrder(fieldFilter.field));
           break;

dev/test/query.ts

@@ -49,6 +49,7 @@ import {
 } from './util/helpers';
 
 import api = google.firestore.v1;
+import protobuf = google.protobuf;
 
 const PROJECT_ID = 'test-project';
 const DATABASE_ROOT = `projects/${PROJECT_ID}/databases/(default)`;
@@ -285,9 +286,24 @@ function endAt(
   return {endAt: cursor};
 }
 
-export function queryEqualsWithParent(
+/**
+ * Returns the timestamp value for the provided readTimes, or the default
+ * readTime value used in tests if no values are provided.
+ */
+export function readTime(
+  seconds?: number,
+  nanos?: number
+): protobuf.ITimestamp {
+  if (seconds === undefined && nanos === undefined) {
+    return {seconds: '5', nanos: 6};
+  }
+  return {seconds: String(seconds), nanos: nanos};
+}
+
+export function queryEqualsWithParentAndReadTime(
   actual: api.IRunQueryRequest | undefined,
   parent: string,
+  readTime?: protobuf.ITimestamp,
   ...protoComponents: api.IStructuredQuery[]
 ): void {
   expect(actual).to.not.be.undefined;
@@ -315,6 +331,10 @@ export function queryEqualsWithParent(
     ];
   }
 
+  if (readTime) {
+    query.readTime = readTime;
+  }
+
   // 'extend' removes undefined fields in the request object. The backend
   // ignores these fields, but we need to manually strip them before we compare
   // the expected and the actual request.
@@ -326,7 +346,12 @@ export function queryEquals(
   actual: api.IRunQueryRequest | undefined,
   ...protoComponents: api.IStructuredQuery[]
 ): void {
-  queryEqualsWithParent(actual, '', ...protoComponents);
+  queryEqualsWithParentAndReadTime(
+    actual,
+    '',
+    /* readTime= */ undefined,
+    ...protoComponents
+  );
 }
 
 function bundledQueryEquals(

dev/test/recursive-delete.ts

@@ -32,10 +32,13 @@ import {
 import {
   allDescendants,
   fieldFilters,
+  orderBy,
   queryEquals,
-  queryEqualsWithParent,
+  queryEqualsWithParentAndReadTime,
+  readTime,
   result,
   select,
+  startAt as queryStartAt,
 } from './query';
 import {
   createRequest,
@@ -147,9 +150,10 @@ describe('recursiveDelete() method:', () => {
     it('for nested collections', async () => {
       const overrides: ApiOverride = {
         runQuery: req => {
-          queryEqualsWithParent(
+          queryEqualsWithParentAndReadTime(
             req,
             'root/doc',
+            /* readTime= */ undefined,
             select('__name__'),
             allDescendants(/* kindless= */ true),
             fieldFilters(
@@ -173,9 +177,10 @@ describe('recursiveDelete() method:', () => {
     it('documents', async () => {
       const overrides: ApiOverride = {
         runQuery: req => {
-          queryEqualsWithParent(
+          queryEqualsWithParentAndReadTime(
             req,
             'root/doc',
+            /* readTime= */ undefined,
             select('__name__'),
             allDescendants(/* kindless= */ true)
           );
@@ -187,6 +192,45 @@ describe('recursiveDelete() method:', () => {
       firestore = await createInstance(overrides);
       return firestore.recursiveDelete(firestore.doc('root/doc'));
     });
+
+    it('creates retry query after stream exception with last received doc', async () => {
+      let callCount = 0;
+      const overrides: ApiOverride = {
+        runQuery: request => {
+          callCount++;
+          if (callCount === 1) {
+            return stream(result('doc1'), new Error('failed in test'));
+          } else {
+            queryEqualsWithParentAndReadTime(
+              request,
+              /* parent= */ '',
+              readTime(),
+              select('__name__'),
+              allDescendants(/* kindless= */ true),
+              orderBy('__name__', 'ASCENDING'),
+              queryStartAt(false, {
+                referenceValue:
+                  `projects/${PROJECT_ID}/databases/(default)/` +
+                  'documents/collectionId/doc1',
+              }),
+              fieldFilters(
+                '__name__',
+                'GREATER_THAN_OR_EQUAL',
+                startAt('root'),
+                '__name__',
+                'LESS_THAN',
+                endAt('root')
+              )
+            );
+            return stream();
+          }
+        },
+        batchWrite: () => response(successResponse(1)),
+      };
+
+      const firestore = await createInstance(overrides);
+      await firestore.recursiveDelete(firestore.collection('root'));
+    });
   });
 
   describe('deletes', () => {