Fix startAfter/endBefore for orderByKeys queries

Author: jmwski

packages/database/src/api/Query.ts

@@ -101,21 +101,15 @@ export class Query {
         'or equalTo() must be a string.';
       if (params.hasStart()) {
         const startName = params.getIndexStartName();
-        if (
-          startName !== MIN_NAME &&
-          !(params.hasStartAfter() && startName === MAX_NAME)
-        ) {
+        if (startName !== MIN_NAME) {
           throw new Error(tooManyArgsError);
         } else if (typeof startNode !== 'string') {
           throw new Error(wrongArgTypeError);
         }
       }
       if (params.hasEnd()) {
         const endName = params.getIndexEndName();
-        if (
-          endName !== MAX_NAME &&
-          !(params.hasEndBefore() && endName === MIN_NAME)
-        ) {
+        if (endName !== MAX_NAME) {
           throw new Error(tooManyArgsError);
         } else if (typeof endNode !== 'string') {
           throw new Error(wrongArgTypeError);

packages/database/src/core/view/QueryParams.ts

@@ -289,13 +289,21 @@ export class QueryParams {
   }
 
   startAfter(indexValue: unknown, key?: string | null): QueryParams {
-    let childKey: string;
-    if (key == null) {
-      childKey = MAX_NAME;
+    let params: QueryParams;
+    if (this.index_ === KEY_INDEX) {
+      if (typeof indexValue === 'string') {
+        indexValue = successor(indexValue as string);
+      }
+      params = this.startAt(indexValue, key);
     } else {
-      childKey = successor(key);
+      let childKey: string;
+      if (key == null) {
+        childKey = MAX_NAME;
+      } else {
+        childKey = successor(key);
+      }
+      params = this.startAt(indexValue, childKey);
     }
-    const params: QueryParams = this.startAt(indexValue, childKey);
     params.startAfterSet_ = true;
     return params;
   }
@@ -324,12 +332,20 @@ export class QueryParams {
 
   endBefore(indexValue: unknown, key?: string | null): QueryParams {
     let childKey: string;
-    if (key == null) {
-      childKey = MIN_NAME;
+    let params: QueryParams;
+    if (this.index_ === KEY_INDEX) {
+      if (typeof indexValue === 'string') {
+        indexValue = predecessor(indexValue as string);
+      }
+      params = this.endAt(indexValue, key);
     } else {
-      childKey = predecessor(key);
+      if (key == null) {
+        childKey = MIN_NAME;
+      } else {
+        childKey = predecessor(key);
+      }
+      params = this.endAt(indexValue, childKey);
     }
-    const params: QueryParams = this.endAt(indexValue, childKey);
     params.endBeforeSet_ = true;
     return params;
   }

packages/database/test/query.test.ts

@@ -1377,6 +1377,38 @@ describe('Query Tests', () => {
     expect(removed).to.equal('b ');
   });
 
+  it('Ensure startAfter on key index works', async () => {
+    const node = getRandomNode() as Reference;
+    const keys = [];
+    const values = [];
+    for (var i = 0; i < 10; i++) {
+      const ref = node.push();
+      keys.push(ref.key);
+      const value = { index: i };
+      values.push(value);
+      await ref.set(value);
+    }
+    const snap = await node.orderByKey().startAfter(keys[0]).get();
+    expect(Object.keys(snap.val())).to.deep.equal(keys.slice(1));
+    expect(Object.values(snap.val())).to.deep.equal(values.slice(1));
+  });
+
+  it('Ensure endBefore on key index works', async () => {
+    const node = getRandomNode() as Reference;
+    const keys = [];
+    const values = [];
+    for (var i = 0; i < 10; i++) {
+      const ref = node.push();
+      keys.push(ref.key);
+      const value = { index: i };
+      values.push(value);
+      await ref.set(value);
+    }
+    const snap = await node.orderByKey().endBefore(keys[9]).get();
+    expect(Object.keys(snap.val())).to.deep.equal(keys.slice(0, 9));
+    expect(Object.values(snap.val())).to.deep.equal(values.slice(0, 9));
+  });
+
   it('Ensure startAt / endAt with priority works.', async () => {
     const node = getRandomNode() as Reference;