Fix for repoGet request

packages/database/src/core/PersistentConnection.ts

@@ -206,12 +206,6 @@ export class PersistentConnection extends ServerActions {
       onComplete: (message: { [k: string]: unknown }) => {
         const payload = message['d'] as string;
         if (message['s'] === 'ok') {
-          this.onDataUpdate_(
-            request['p'],
-            payload,
-            /*isMerge*/ false,
-            /*tag*/ null
-          );
           deferred.resolve(payload);
         } else {
           deferred.reject(payload);

packages/database/src/core/Repo.ts

@@ -48,10 +48,12 @@ import {
   statsManagerGetOrCreateReporter
 } from './stats/StatsManager';
 import { StatsReporter, statsReporterIncludeStat } from './stats/StatsReporter';
+import { syncPointGetView } from './SyncPoint';
 import {
   SyncTree,
   syncTreeAckUserWrite,
   syncTreeAddEventRegistration,
+  syncTreeAddToPath,
   syncTreeApplyServerMerge,
   syncTreeApplyServerOverwrite,
   syncTreeApplyTaggedQueryMerge,
@@ -60,7 +62,8 @@ import {
   syncTreeApplyUserOverwrite,
   syncTreeCalcCompleteEventCache,
   syncTreeGetServerValue,
-  syncTreeRemoveEventRegistration
+  syncTreeRemoveEventRegistration,
+  syncTreeTagForQuery_
 } from './SyncTree';
 import { Indexable } from './util/misc';
 import {
@@ -466,15 +469,50 @@ export function repoGetValue(repo: Repo, query: QueryContext): Promise<Node> {
   }
   return repo.server_.get(query).then(
     payload => {
-      const node = nodeFromJSON(payload as string).withIndex(
+      const node = nodeFromJSON(payload).withIndex(
         query._queryParams.getIndex()
       );
-      const events = syncTreeApplyServerOverwrite(
-        repo.serverSyncTree_,
-        query._path,
-        node
-      );
-      eventQueueRaiseEventsAtPath(repo.eventQueue_, query._path, events);
+      // if this is not a filtered query, then overwrite at path
+      if (query._queryParams.loadsAllData()) {
+        const events = syncTreeApplyServerOverwrite(
+          repo.serverSyncTree_,
+          query._path,
+          node
+        );
+        eventQueueRaiseEventsAtPath(repo.eventQueue_, query._path, events);
+      } else {
+        // Simulate `syncTreeAddEventRegistration` without events/listener setup.
+        const { syncPoint, serverCache, writesCache, serverCacheComplete } =
+          syncTreeAddToPath(query, repo.serverSyncTree_);
+        const view = syncPointGetView(
+          syncPoint,
+          query,
+          writesCache,
+          serverCache,
+          serverCacheComplete
+        );
+        if (!syncPoint.views.has(query._queryIdentifier)) {
+          syncPoint.views.set(query._queryIdentifier, view);
+        }
+        const tag = syncTreeTagForQuery_(repo.serverSyncTree_, query);
+        const events = syncTreeApplyTaggedQueryOverwrite(
+          repo.serverSyncTree_,
+          query._path,
+          node,
+          tag
+        );
+        eventQueueRaiseEventsAtPath(repo.eventQueue_, query._path, events);
+        // Call `syncTreeRemoveEventRegistration` with a null event registration, since there is none.
+        const cancels = syncTreeRemoveEventRegistration(
+          repo.serverSyncTree_,
+          query,
+          null
+        );
+        assert(
+          cancels.length === 0,
+          'unexpected cancel events in repoGetValue'
+        );
+      }
       return Promise.resolve(node);
     },
     err => {

packages/database/src/core/SyncTree.ts

@@ -482,16 +482,7 @@ export function syncTreeApplyTaggedQueryMerge(
   }
 }
 
-/**
- * Add an event callback for the specified query.
- *
- * @returns Events to raise.
- */
-export function syncTreeAddEventRegistration(
-  syncTree: SyncTree,
-  query: QueryContext,
-  eventRegistration: EventRegistration
-): Event[] {
+export function syncTreeAddToPath(query: QueryContext, syncTree: SyncTree) {
   const path = query._path;
 
   let serverCache: Node | null = null;
@@ -550,6 +541,36 @@ export function syncTreeAddEventRegistration(
     syncTree.tagToQueryMap.set(tag, queryKey);
   }
   const writesCache = writeTreeChildWrites(syncTree.pendingWriteTree_, path);
+  // TODO: break this down so you do the minimal amount
+  return {
+    syncPoint,
+    writesCache,
+    serverCache,
+    serverCacheComplete,
+    foundAncestorDefaultView,
+    viewAlreadyExists
+  };
+}
+
+/**
+ * Add an event callback for the specified query.
+ *
+ * @returns Events to raise.
+ */
+export function syncTreeAddEventRegistration(
+  syncTree: SyncTree,
+  query: QueryContext,
+  eventRegistration: EventRegistration
+): Event[] {
+  const {
+    syncPoint,
+    serverCache,
+    writesCache,
+    serverCacheComplete,
+    viewAlreadyExists,
+    foundAncestorDefaultView
+  } = syncTreeAddToPath(query, syncTree);
+
   let events = syncPointAddEventRegistration(
     syncPoint,
     query,
@@ -803,7 +824,7 @@ function syncTreeCreateListenerForView_(
 /**
  * Return the tag associated with the given query.
  */
-function syncTreeTagForQuery_(
+export function syncTreeTagForQuery_(
   syncTree: SyncTree,
   query: QueryContext
 ): number | null {

packages/database/test/exp/integration.test.ts

@@ -20,7 +20,12 @@ import { initializeApp, deleteApp } from '@firebase/app';
 import { Deferred } from '@firebase/util';
 import { expect } from 'chai';
 
-import { onValue, set } from '../../src/api/Reference_impl';
+import {
+  limitToFirst,
+  onValue,
+  query,
+  set
+} from '../../src/api/Reference_impl';
 import {
   get,
   getDatabase,
@@ -32,7 +37,7 @@ import {
   runTransaction
 } from '../../src/index';
 import { EventAccumulatorFactory } from '../helpers/EventAccumulator';
-import { DATABASE_ADDRESS, DATABASE_URL } from '../helpers/util';
+import { DATABASE_ADDRESS, DATABASE_URL, waitFor } from '../helpers/util';
 
 export function createTestApp() {
   return initializeApp({ databaseURL: DATABASE_URL });
@@ -97,6 +102,21 @@ describe('Database@exp Tests', () => {
     expect(snap2).to.equal('b');
   });
 
+  // Tests to make sure onValue's data does not get mutated after calling get
+  it('calls onValue only once after get request', async () => {
+    const db = getDatabase(defaultApp);
+    const testRef = ref(db, 'foo');
+    const initial = [{ name: 'child1' }, { name: 'child2' }];
+    await set(testRef, initial);
+    let count = 0;
+    onValue(testRef, () => {
+      count++;
+    });
+    await get(query(testRef, limitToFirst(1)));
+    await waitFor(2000);
+    expect(count).to.equal(1);
+  });
+
   it('Can use onlyOnce', async () => {
     const db = getDatabase(defaultApp);
     const fooRef = ref(db, 'foo');

packages/database/test/helpers/util.ts

@@ -70,3 +70,9 @@ export function shuffle(arr, randFn = Math.random) {
     arr[j] = tmp;
   }
 }
+
+// Waits for specific number of milliseconds before resolving
+// Example: await waitFor(4000) will wait until 4 seconds to execute the next line of code.
+export function waitFor(waitTimeInMS: number) {
+  return new Promise(resolve => setTimeout(resolve, waitTimeInMS));
+}