Extend syncpoint spec protocol

Author: tohhsinpei

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

@@ -73,10 +73,10 @@ export class QueryParams {
   limitSet_ = false;
   startSet_ = false;
   startNameSet_ = false;
-  startAfterSet_ = false;
+  startAfterSet_ = false; // can only be true if startSet_ is true
   endSet_ = false;
   endNameSet_ = false;
-  endBeforeSet_ = false;
+  endBeforeSet_ = false; // can only be true if endSet_ is true
   limit_ = 0;
   viewFrom_ = '';
   indexStartValue_: unknown | null = null;
@@ -89,14 +89,6 @@ export class QueryParams {
     return this.startSet_;
   }
 
-  hasStartAfter(): boolean {
-    return this.startAfterSet_;
-  }
-
-  hasEndBefore(): boolean {
-    return this.endBeforeSet_;
-  }
-
   /**
    * @returns True if it would return from left.
    */
@@ -278,7 +270,12 @@ export function queryParamsStartAfter(
   indexValue: unknown,
   key?: string | null
 ): QueryParams {
-  const params: QueryParams = queryParamsStartAt(queryParams, indexValue, key);
+  let params: QueryParams;
+  if (queryParams.index_ === KEY_INDEX || !!key) {
+    params = queryParamsStartAt(queryParams, indexValue, key);
+  } else {
+    params = queryParamsStartAt(queryParams, indexValue, MAX_NAME);
+  }
   params.startAfterSet_ = true;
   return params;
 }
@@ -309,7 +306,12 @@ export function queryParamsEndBefore(
   indexValue: unknown,
   key?: string | null
 ): QueryParams {
-  const params: QueryParams = queryParamsEndAt(queryParams, indexValue, key);
+  let params: QueryParams;
+  if (queryParams.index_ === KEY_INDEX || !!key) {
+    params = queryParamsEndAt(queryParams, indexValue, key);
+  } else {
+    params = queryParamsEndAt(queryParams, indexValue, MIN_NAME);
+  }
   params.endBeforeSet_ = true;
   return params;
 }

packages/database/src/core/view/filter/RangedFilter.ts

@@ -39,11 +39,17 @@ export class RangedFilter implements NodeFilter {
 
   private endPost_: NamedNode;
 
+  private startIsInclusive_: boolean;
+
+  private endIsInclusive_: boolean;
+
   constructor(params: QueryParams) {
     this.indexedFilter_ = new IndexedFilter(params.getIndex());
     this.index_ = params.getIndex();
     this.startPost_ = RangedFilter.getStartPost_(params);
     this.endPost_ = RangedFilter.getEndPost_(params);
+    this.startIsInclusive_ = !params.startAfterSet_;
+    this.endIsInclusive_ = !params.endBeforeSet_;
   }
 
   getStartPost(): NamedNode {
@@ -55,10 +61,13 @@ export class RangedFilter implements NodeFilter {
   }
 
   matches(node: NamedNode): boolean {
-    return (
-      this.index_.compare(this.getStartPost(), node) <= 0 &&
-      this.index_.compare(node, this.getEndPost()) <= 0
-    );
+    const isWithinStart = this.startIsInclusive_
+      ? this.index_.compare(this.getStartPost(), node) <= 0
+      : this.index_.compare(this.getStartPost(), node) < 0;
+    const isWithinEnd = this.endIsInclusive_
+      ? this.index_.compare(node, this.getEndPost()) <= 0
+      : this.index_.compare(node, this.getEndPost()) < 0;
+    return isWithinStart && isWithinEnd;
   }
   updateChild(
     snap: Node,

packages/database/test/helpers/syncPointSpec.json

@@ -4179,6 +4179,98 @@
       }
     ]
   },
+  {
+    "name": "Queries with startAfter and endBefore work",
+    "steps":
+    [
+      {
+        "type": "listen",
+        "path": "",
+        "params": {
+          "tag": 1,
+          "orderBy": "index",
+          "startAfter": { "index": 1 },
+          "endBefore": { "index": 10 }
+        },
+        "events": []
+      },
+      {
+        ".comment": "update from server sends all data",
+        "type": "serverUpdate",
+        "path": "",
+        "data": {
+          "a": { "index": 0, "value": "a" },
+          "b": { "index": 2, "value": "b" },
+          "c": { "index": 9, "value": "c" },
+          "d": { "index": 11, "value": "d" }
+        },
+        "events": [
+          {
+            "path": "",
+            "type": "child_added",
+            "name": "b",
+            "prevName": null,
+            "data": { "index": 2, "value": "b" }
+          },
+          {
+            "path": "",
+            "type": "child_added",
+            "name": "c",
+            "prevName": null,
+            "data": { "index": 9, "value": "c" }
+          },
+          {
+            "path": "",
+            "type": "value",
+            "data": {
+              "b": { "index": 2, "value": "b" },
+              "c": { "index": 9, "value": "c" }
+            }
+          }
+        ]
+      },
+      {
+        ".comment": "update from server to move child c out of query",
+        "type": "serverUpdate",
+        "path": "c/index",
+        "data": 10,
+        "events": [
+          {
+            "path": "",
+            "type": "child_removed",
+            "name": "c",
+            "data": { "index": 9, "value": "c" }
+          },
+          {
+            "path": "",
+            "type": "value",
+            "data": {
+              "b": { "index": 2, "value": "b" }
+            }
+          }
+        ]
+      },
+      {
+        ".comment": "update from server to move child b out of window",
+        "type": "serverUpdate",
+        "path": "b/index",
+        "data": 1,
+        "events": [
+          {
+            "path": "",
+            "type": "child_removed",
+            "name": "b",
+            "data": { "index": 2, "value": "b" }
+          },
+          {
+            "path": "",
+            "type": "value",
+            "data": {}
+          }
+        ]
+      }
+    ]
+  },
   {
     "name": "Update to single child that moves out of window",
     "steps":

packages/database/test/helpers/syncpoint-util.ts

@@ -31,9 +31,11 @@ import {
   ref,
   limitToFirst,
   limitToLast,
+  startAfter,
   startAt,
   equalTo,
   endAt,
+  endBefore,
   orderByChild,
   orderByKey,
   orderByPriority
@@ -366,10 +368,14 @@ export class SyncPointTestParser {
           q = query(q, limitToFirst(paramValue));
         } else if (paramName === 'limitToLast') {
           q = query(q, limitToLast(paramValue));
+        } else if (paramName === 'startAfter') {
+          q = query(q, startAfter(paramValue.index, paramValue.name));
         } else if (paramName === 'startAt') {
           q = query(q, startAt(paramValue.index, paramValue.name));
         } else if (paramName === 'endAt') {
           q = query(q, endAt(paramValue.index, paramValue.name));
+        } else if (paramName === 'endBefore') {
+          q = query(q, endBefore(paramValue.index, paramValue.name));
         } else if (paramName === 'equalTo') {
           q = query(q, equalTo(paramValue.index, paramValue.name));
         } else if (paramName === 'orderBy') {