fix(firestore): Correct the cursors when LimitToLast is used

[bhshkh]

Context:
Consider the Firestore collection has documents with following ids {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

1. Before field

While sending a Firestore run query request 2 cursors can be specified(StartAt and EndAt). Cursors have a field called Before which specifies whether the result should include the field at the cursor.

When the user runs below query:

query.OrderBy("id", Asc).StartAt(1).EndAt(5)

The query sent to Firestore service should have:

StructuredQuery{
  StartAt: &Cursor{
       Values: {1},
       Before: true // Why true? described below
  },
  EndAt: &Cursor {
       Values: {5},
       Before: false // Why false? Described below
  },
  OrderBy: []{
       Field: "id",
       Direction: ASC
  }
}

Firestore service behavior:
When Before field of StartAt is true, the response includes the key in StartAt cursor
When Before field of EndAt is true, the response does not include the key in EndAt cursor
So, the above query would return: {1, 2, 3, 4, 5}

2. LimitToLast
   While sending a Firestore run query request, a limit can be specified which limits the number of results retuned. Taking the previous example:

query.OrderBy("id", Asc).StartAt(1).EndAt(5).Limit(3)

The request sent will; be

StructuredQuery{
  StartAt: &Cursor{
       Values: {1},
       Before: true
  },
  EndAt: &Cursor {
       Values: {5},
       Before: false
  },
  Limit: 3,
  OrderBy: []{
       Field: "id",
       Direction: ASC
  }
}

would return {1, 2, 3}

If user wants only the last 3 results i.e. {3, 4, 5}, the query they would have to use would be:

query.OrderBy("id", Asc).StartAt(1).EndAt(5).LimitToLast(3)

Since the Firestore service does not provide any LimitToLast field out of the box, Go library queries the documents in reverse order and then reverses the result. So, in the above example, the request sent should be:

StructuredQuery{
  StartAt: &Cursor{
       Values: {5}, <= Notice this
       Before: true
  },
  EndAt: &Cursor {
       Values: {1}, <= Notice this
       Before: false
  },
  Limit: 3,
  OrderBy: []{
       Field: "id",
       Direction: DESC <= Notice this
  }
}

This query would return results: {5, 4, 3} which then the library will reverse and return to the user.

Issue:
Below queries return incorrect results

1. StartAfter(5).EndBefore(1).LimitToLast(5).OrderBy("id", Desc)
   Expected behavior {4, 3, 2}
   Actual behavior {5, 4, 3, 2}

2. StartAt(5).EndAt(1).LimitToLast(5).OrderBy("id", Desc)
   Expected behavior {5, 4, 3, 2, 1}
   Actual behavior {4, 3, 2}

Cause:

1. For case 1, request sent should be :

StructuredQuery{
  StartAt: &Cursor{
       Values: {1}, 
       Before: false
  },
  EndAt: &Cursor {
       Values: {5}, 
       Before: true  <====== This is incorrectly being sent as false
  },
  Limit: 5,
  OrderBy: []{
       Field: "id",
       Direction: ASC 
  }
}

But the current request sent has Before: false in EndAt cursor. So, the result contains the value in the EndAt cursor i.e. 5 is available in the results.

2. For case 2, request should be:

StructuredQuery{
  StartAt: &Cursor{
       Values: {1}, 
       Before: true   <======= This is incorrectly being sent as false
  },
  EndAt: &Cursor {
       Values: {5}, 
       Before: false  <======= This is incorrectly being sent as true
  },
  Limit: 5,
  OrderBy: []{
       Field: "id",
       Direction: ASC 
  }
}

But the current request sent has Before: false in StartAt cursor and Before: true in EndAt cursor. So, the result does not contain the values in the StartAt and EndAt cursors i.e. 1 and 5 are not available in the results.

Fix:
Set the startBefore and endBefore fields correctly