Query get() method for RTDB

packages/database/src/api/Query.ts

@@ -54,6 +54,10 @@ export interface SnapshotCallback {
   (a: DataSnapshot, b?: string | null): unknown;
 }
 
+export interface FailureCallback {
+  (a: Error): void;
+}
+
 /**
  * A Query represents a filter to be applied to a firebase location.  This object purely represents the
  * query expression (and exposes our public API to build the query).  The actual query logic is in ViewBase.js.
@@ -295,6 +299,17 @@ export class Query {
     this.repo.removeEventCallbackForQuery(this, container);
   }
 
+  get(): Promise<DataSnapshot> {
+    const deferred = new Deferred<DataSnapshot>();
+    const callback = (snapshot: DataSnapshot) => {
+      deferred.resolve(snapshot);
+    };
+    this.repo.get(this, callback, err => {
+      deferred.reject(err);
+    });
+    return deferred.promise;
+  }
+
   /**
    * Attaches a listener, waits for the first event, and then removes the listener
    * @param {!string} eventType

packages/database/src/core/PersistentConnection.ts

@@ -75,6 +75,13 @@ interface OutstandingPut {
   onComplete: (a: string, b?: string) => void;
 }
 
+interface OutstandingGet {
+  action: string;
+  request: object;
+  queued?: boolean;
+  onComplete: (a: string, b?: string) => void;
+}
+
 /**
  * Firebase connection.  Abstracts wire protocol and handles reconnecting.
  *
@@ -92,6 +99,8 @@ export class PersistentConnection extends ServerActions {
     /* path */ string,
     Map</* queryId */ string, ListenSpec>
   > = new Map();
+  private outstandingGets_: OutstandingGet[] = [];
+  private outstandingGetCount_ = 0;
   private outstandingPuts_: OutstandingPut[] = [];
   private outstandingPutCount_ = 0;
   private onDisconnectRequestQueue_: OnDisconnectRequest[] = [];
@@ -184,6 +193,29 @@ export class PersistentConnection extends ServerActions {
     }
   }
 
+  get(query: Query, onComplete: (a: string, b: unknown) => void) {
+    const action = 'g';
+
+    const req: { [k: string]: unknown } = {
+      p: query.path.toString(),
+      q: query.queryObject()
+    };
+
+    this.outstandingGets_.push({
+      action,
+      request: req,
+      onComplete
+    });
+
+    this.outstandingGetCount_++;
+
+    if (this.connected_) {
+      this.sendGet_(this.outstandingGets_.length - 1);
+    } else {
+      this.log_('Buffering get: ' + query.path.toString());
+    }
+  }
+
   /**
    * @inheritDoc
    */
@@ -221,6 +253,26 @@ export class PersistentConnection extends ServerActions {
     }
   }
 
+  private sendGet_(index: number) {
+    const action = this.outstandingGets_[index].action;
+    const request = this.outstandingGets_[index].request;
+    const onComplete = this.outstandingGets_[index].onComplete;
+    this.outstandingGets_[index].queued = this.connected_;
+
+    this.sendRequest(action, request, (message: { [k: string]: unknown }) => {
+      delete this.outstandingGets_[index];
+      this.outstandingGetCount_--;
+
+      if (this.outstandingGetCount_ === 0) {
+        this.outstandingGets_ = [];
+      }
+
+      if (onComplete) {
+        onComplete(message['s'] as string, message['d'] as string);
+      }
+    });
+  }
+
   private sendListen_(listenSpec: ListenSpec) {
     const query = listenSpec.query;
     const pathString = query.path.toString();
@@ -935,6 +987,12 @@ export class PersistentConnection extends ServerActions {
       }
     }
 
+    for (let i = 0; i < this.outstandingGets_.length; i++) {
+      if (this.outstandingGets_[i]) {
+        this.sendGet_(i);
+      }
+    }
+
     for (let i = 0; i < this.outstandingPuts_.length; i++) {
       if (this.outstandingPuts_[i]) {
         this.sendPut_(i);

packages/database/src/core/Repo.ts

@@ -38,8 +38,9 @@ import { ReadonlyRestClient } from './ReadonlyRestClient';
 import { FirebaseApp } from '@firebase/app-types';
 import { RepoInfo } from './RepoInfo';
 import { Database } from '../api/Database';
+import { DataSnapshot } from '../api/DataSnapshot';
 import { ServerActions } from './ServerActions';
-import { Query } from '../api/Query';
+import { FailureCallback, SnapshotCallback, Query } from '../api/Query';
 import { EventRegistration } from './view/EventRegistration';
 import { StatsCollection } from './stats/StatsCollection';
 import { Event } from './view/Event';
@@ -296,6 +297,31 @@ export class Repo {
     return this.nextWriteId_++;
   }
 
+  get(query: Query, onComplete: SnapshotCallback, onFailure: FailureCallback) {
+    this.server_.get(query, (status, payload) => {
+      if (status === 'ok') {
+        // TODO(wyszynski): Is this the correct way to update client SDK caches
+        // with the data that we've received from get()?
+        this.onDataUpdate_(
+          query.path.toString(),
+          payload,
+          /*isMerge=*/ false,
+          /*tag=*/ null
+        );
+        const newNode = nodeFromJSON(payload as string);
+        onComplete(
+          new DataSnapshot(
+            newNode,
+            query.getRef(),
+            query.getQueryParams().getIndex()
+          )
+        );
+      } else {
+        onFailure(Error(payload as string));
+      }
+    });
+  }
+
   setWithPriority(
     path: Path,
     newVal: unknown,

packages/database/src/core/ServerActions.ts

@@ -45,6 +45,13 @@ export abstract class ServerActions {
    */
   abstract unlisten(query: Query, tag: number | null): void;
 
+  /**
+   * Get the server value satisfying this query.
+   * @param query
+   * @param onComplete
+   */
+  get(query: Query, onComplete: (a: string, b: unknown) => void): void {}
+
   /**
    * @param {string} pathString
    * @param {*} data

packages/database/test/query.test.ts

@@ -2191,6 +2191,49 @@ describe('Query Tests', () => {
       });
   });
 
+  it('get() at empty root returns null', done => {
+    const node = getRandomNode() as Reference;
+    node.get().then(snapshot => {
+      const val = snapshot.val();
+      expect(val).to.be.null;
+      done();
+    });
+  });
+
+  it('get() at non-empty root returns correct value', done => {
+    const nodes = getRandomNode(2) as Reference;
+    const reader = nodes[0];
+    const writer = nodes[1];
+    writer.set({ foo: 'a', bar: 'b' }, (err, dummy) => {
+      reader.get().then(snapshot => {
+        const val = snapshot.val();
+        expect(val['foo']).to.equal('a');
+        expect(val['bar']).to.equal('b');
+        done();
+      });
+    });
+  });
+
+  it('get() for removed node returns correct value', done => {
+    const nodes = getRandomNode(2) as Reference;
+    const reader = nodes[0];
+    const writer = nodes[1];
+    writer.set({ foo: 'a', bar: 'b' }, (err, dummy) => {
+      reader.get().then(snapshot => {
+        const val = snapshot.val();
+        expect(val['foo']).to.equal('a');
+        expect(val['bar']).to.equal('b');
+        writer.remove().then(err => {
+          reader.get().then(snapshot => {
+            const val = snapshot.val();
+            expect(val).to.be.null;
+            done();
+          });
+        });
+      });
+    });
+  });
+
   it('set() at query root raises correct value event', done => {
     const nodePair = getRandomNode(2);
     const writer = nodePair[0];