Apply range-filters in get when probing active-listener cache

packages/database/src/core/Repo.ts

@@ -382,8 +382,8 @@ export class Repo {
    */
   getValue(query: Query): Promise<DataSnapshot> {
     // Only active queries are cached. There is no persisted cache.
-    const cached = this.serverSyncTree_.calcCompleteEventCache(query.path);
-    if (!cached.isEmpty()) {
+    const cached = this.serverSyncTree_.getServerValue(query);
+    if (cached != null /*&& !cached.isEmpty()*/) {
       return Promise.resolve(
         new DataSnapshot(
           cached,

packages/database/src/core/SyncPoint.ts

@@ -94,25 +94,15 @@ export class SyncPoint {
     }
   }
 
-  /**
-   * Add an event callback for the specified query.
-   *
-   * @param {!Query} query
-   * @param {!EventRegistration} eventRegistration
-   * @param {!WriteTreeRef} writesCache
-   * @param {?Node} serverCache Complete server cache, if we have it.
-   * @param {boolean} serverCacheComplete
-   * @return {!Array.<!Event>} Events to raise.
-   */
-  addEventRegistration(
+  getView(
     query: Query,
-    eventRegistration: EventRegistration,
     writesCache: WriteTreeRef,
     serverCache: Node | null,
     serverCacheComplete: boolean
-  ): Event[] {
+  ): View {
     const queryId = query.queryIdentifier();
     let view = this.views.get(queryId);
+    console.log('We already have a view? ' + JSON.stringify(view));
     if (!view) {
       // TODO: make writesCache take flag for complete server node
       let eventCache = writesCache.calcCompleteEventCache(
@@ -140,10 +130,37 @@ export class SyncPoint {
           false
         )
       );
-      view = new View(query, viewCache);
-      this.views.set(queryId, view);
+      return new View(query, viewCache);
     }
+    return view;
+  }
 
+  /**
+   * Add an event callback for the specified query.
+   *
+   * @param {!Query} query
+   * @param {!EventRegistration} eventRegistration
+   * @param {!WriteTreeRef} writesCache
+   * @param {?Node} serverCache Complete server cache, if we have it.
+   * @param {boolean} serverCacheComplete
+   * @return {!Array.<!Event>} Events to raise.
+   */
+  addEventRegistration(
+    query: Query,
+    eventRegistration: EventRegistration,
+    writesCache: WriteTreeRef,
+    serverCache: Node | null,
+    serverCacheComplete: boolean
+  ): Event[] {
+    let view = this.getView(
+      query,
+      writesCache,
+      serverCache,
+      serverCacheComplete
+    );
+    if (!this.views.has(query.queryIdentifier())) {
+      this.views.set(query.queryIdentifier(), view);
+    }
     // This is guaranteed to exist now, we just created anything that was missing
     view.addEventRegistration(eventRegistration);
     return view.getInitialEvents(eventRegistration);

packages/database/src/core/SyncTree.ts

@@ -32,6 +32,7 @@ import { Node } from './snap/Node';
 import { Event } from './view/Event';
 import { EventRegistration } from './view/EventRegistration';
 import { View } from './view/View';
+import { CacheNode } from './view/CacheNode';
 
 /**
  * @typedef {{
@@ -505,6 +506,42 @@ export class SyncTree {
     );
   }
 
+  getServerValue(query: Query): Node | null {
+    const path = query.path;
+    let serverCache: Node | null = null;
+    let foundAncestorDefaultView = false;
+    // Any covering writes will necessarily be at the root, so really all we need to find is the server cache.
+    // Consider optimizing this once there's a better understanding of what actual behavior will be.
+    this.syncPointTree_.foreachOnPath(path, (pathToSyncPoint, sp) => {
+      const relativePath = Path.relativePath(pathToSyncPoint, path);
+      serverCache = serverCache || sp.getCompleteServerCache(relativePath);
+      foundAncestorDefaultView =
+        foundAncestorDefaultView || sp.hasCompleteView();
+    });
+    let syncPoint = this.syncPointTree_.get(path);
+    if (!syncPoint) {
+      syncPoint = new SyncPoint();
+      this.syncPointTree_ = this.syncPointTree_.set(path, syncPoint);
+    } else {
+      foundAncestorDefaultView =
+        foundAncestorDefaultView || syncPoint.hasCompleteView();
+      serverCache = serverCache || syncPoint.getCompleteServerCache(Path.Empty);
+    }
+    if (serverCache != null) {
+      let serverCacheNode: CacheNode | null = new CacheNode(
+        serverCache,
+        true,
+        false
+      );
+      let writesCache: WriteTreeRef | null = this.pendingWriteTree_.childWrites(
+        query.path
+      );
+      let view: View = syncPoint.getView(query, writesCache, serverCache, true);
+      return view.getCompleteServerCache(query.path);
+    }
+    return null;
+  }
+
   /**
    * This collapses multiple unfiltered views into a single view, since we only need a single
    * listener for them.

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

@@ -130,6 +130,7 @@ export class View {
         this.query_.getQueryParams().loadsAllData() ||
         (!path.isEmpty() && !cache.getImmediateChild(path.getFront()).isEmpty())
       ) {
+        console.log('Returning ' + cache.getChild(path));
         return cache.getChild(path);
       }
     }

packages/database/test/query.test.ts

@@ -1399,6 +1399,38 @@ describe('Query Tests', () => {
     expect(Object.values(snap.val())).to.deep.equal([snap.val()[childOne.key]]);
   });
 
+  it('Ensure startAfter on key index works with overlapping listener', async () => {
+    const node = getRandomNode() as Reference;
+    const childOne = node.push();
+    const childTwo = node.push();
+    await childOne.set(1);
+    await childTwo.set(2);
+    const ea = EventAccumulatorFactory.waitsForCount(1);
+    node.on('value', snap => {
+      ea.addEvent(snap.val());
+    });
+    await ea.promise;
+    const snap = await node.orderByKey().startAfter(childOne.key).get();
+    expect(Object.keys(snap.val())).to.deep.equal([childTwo.key]);
+    expect(Object.values(snap.val())).to.deep.equal([snap.val()[childTwo.key]]);
+  });
+
+  it('Ensure endBefore on key index works with overlapping listener', async () => {
+    const node = getRandomNode() as Reference;
+    const childOne = node.push();
+    const childTwo = node.push();
+    await childOne.set(1);
+    await childTwo.set(2);
+    const ea = EventAccumulatorFactory.waitsForCount(1);
+    node.on('value', snap => {
+      ea.addEvent(snap.val());
+    });
+    await ea.promise;
+    const snap = await node.orderByKey().endBefore(childTwo.key).get();
+    expect(Object.keys(snap.val())).to.deep.equal([childOne.key]);
+    expect(Object.values(snap.val())).to.deep.equal([snap.val()[childOne.key]]);
+  });
+
   it('Ensure startAt / endAt with priority works.', async () => {
     const node = getRandomNode() as Reference;