Merge c0f627c into 8697166

Author: jmwski

.changeset/many-snails-kneel.md

@@ -0,0 +1,5 @@
+---
+"@firebase/database": minor
+---
+
+Add a `get` method for database queries that returns server result when connected

packages/database/src/api/Query.ts

@@ -295,6 +295,13 @@ export class Query {
     this.repo.removeEventCallbackForQuery(this, container);
   }
 
+  /**
+   * Get the server-value for this query, or return a cached value if not connected.
+   */
+  get(): Promise<DataSnapshot> {
+    return this.repo.getValue(this);
+  }
+
   /**
    * Attaches a listener, waits for the first event, and then removes the listener
    * @param {!string} eventType

packages/database/src/core/PersistentConnection.ts

@@ -26,7 +26,8 @@ import {
   isValidFormat,
   isMobileCordova,
   isReactNative,
-  isNodeSdk
+  isNodeSdk,
+  Deferred
 } from '@firebase/util';
 
 import { error, log, logWrapper, warn, ObjectToUniqueKey } from './util/util';
@@ -44,6 +45,7 @@ import { SDK_VERSION } from './version';
 
 const RECONNECT_MIN_DELAY = 1000;
 const RECONNECT_MAX_DELAY_DEFAULT = 60 * 5 * 1000; // 5 minutes in milliseconds (Case: 1858)
+const GET_CONNECT_TIMEOUT = 3 * 1000;
 const RECONNECT_MAX_DELAY_FOR_ADMINS = 30 * 1000; // 30 seconds for admin clients (likely to be a backend server)
 const RECONNECT_DELAY_MULTIPLIER = 1.3;
 const RECONNECT_DELAY_RESET_TIMEOUT = 30000; // Reset delay back to MIN_DELAY after being connected for 30sec.
@@ -75,6 +77,12 @@ interface OutstandingPut {
   onComplete: (a: string, b?: string) => void;
 }
 
+interface OutstandingGet {
+  action: string;
+  request: object;
+  onComplete: (response: { [k: string]: unknown }) => void;
+}
+
 /**
  * Firebase connection.  Abstracts wire protocol and handles reconnecting.
  *
@@ -93,7 +101,9 @@ export class PersistentConnection extends ServerActions {
     Map</* queryId */ string, ListenSpec>
   > = new Map();
   private outstandingPuts_: OutstandingPut[] = [];
+  private outstandingGets_: OutstandingGet[] = [];
   private outstandingPutCount_ = 0;
+  private outstandingGetCount_ = 0;
   private onDisconnectRequestQueue_: OnDisconnectRequest[] = [];
   private connected_ = false;
   private reconnectDelay_ = RECONNECT_MIN_DELAY;
@@ -184,6 +194,58 @@ export class PersistentConnection extends ServerActions {
     }
   }
 
+  get(query: Query): Promise<string> {
+    const deferred = new Deferred<string>();
+    const request = {
+      p: query.path.toString(),
+      q: query.queryObject()
+    };
+    const outstandingGet = {
+      action: 'g',
+      request,
+      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);
+        }
+      }
+    };
+    this.outstandingGets_.push(outstandingGet);
+    this.outstandingGetCount_++;
+    const index = this.outstandingGets_.length - 1;
+
+    if (!this.connected_) {
+      const self = this;
+      setTimeout(() => {
+        const get = self.outstandingGets_[index];
+        if (get === undefined || outstandingGet !== get) {
+          return;
+        }
+        delete self.outstandingGets_[index];
+        self.outstandingGetCount_--;
+        if (self.outstandingGetCount_ === 0) {
+          self.outstandingGets_ = [];
+        }
+        self.log_('get ' + index + ' timed out on connection');
+        deferred.reject(new Error('Client is offline.'));
+      }, GET_CONNECT_TIMEOUT);
+    }
+
+    if (this.connected_) {
+      this.sendGet_(index);
+    }
+
+    return deferred.promise;
+  }
+
   /**
    * @inheritDoc
    */
@@ -201,7 +263,7 @@ export class PersistentConnection extends ServerActions {
     }
     assert(
       query.getQueryParams().isDefault() ||
-        !query.getQueryParams().loadsAllData(),
+      !query.getQueryParams().loadsAllData(),
       'listen() called for non-default but complete query'
     );
     assert(
@@ -221,6 +283,24 @@ export class PersistentConnection extends ServerActions {
     }
   }
 
+  private sendGet_(index: number) {
+    const get = this.outstandingGets_[index];
+    this.sendRequest(
+      get.action,
+      get.request,
+      (message: { [k: string]: unknown }) => {
+        delete this.outstandingGets_[index];
+        this.outstandingGetCount_--;
+        if (this.outstandingGetCount_ === 0) {
+          this.outstandingGets_ = [];
+        }
+        if (get.onComplete) {
+          get.onComplete(message);
+        }
+      }
+    );
+  }
+
   private sendListen_(listenSpec: ListenSpec) {
     const query = listenSpec.query;
     const pathString = query.path.toString();
@@ -273,8 +353,8 @@ export class PersistentConnection extends ServerActions {
         const indexPath = query.path.toString();
         warn(
           `Using an unspecified index. Your data will be downloaded and ` +
-            `filtered on the client. Consider adding ${indexSpec} at ` +
-            `${indexPath} to your security rules for better performance.`
+          `filtered on the client. Consider adding ${indexSpec} at ` +
+          `${indexPath} to your security rules for better performance.`
         );
       }
     }
@@ -292,7 +372,7 @@ export class PersistentConnection extends ServerActions {
       //If we're connected we want to let the server know to unauthenticate us. If we're not connected, simply delete
       //the credential so we dont become authenticated next time we connect.
       if (this.connected_) {
-        this.sendRequest('unauth', {}, () => {});
+        this.sendRequest('unauth', {}, () => { });
       }
     }
 
@@ -356,7 +436,7 @@ export class PersistentConnection extends ServerActions {
 
     assert(
       query.getQueryParams().isDefault() ||
-        !query.getQueryParams().loadsAllData(),
+      !query.getQueryParams().loadsAllData(),
       'unlisten() called for non-default but complete query'
     );
     const listen = this.removeListen_(pathString, queryId);
@@ -614,8 +694,8 @@ export class PersistentConnection extends ServerActions {
     } else {
       error(
         'Unrecognized action received from server: ' +
-          stringify(action) +
-          '\nAre you using the latest client?'
+        stringify(action) +
+        '\nAre you using the latest client?'
       );
     }
   }
@@ -950,6 +1030,12 @@ export class PersistentConnection extends ServerActions {
         request.onComplete
       );
     }
+
+    for (let i = 0; i < this.outstandingGets_.length; i++) {
+      if (this.outstandingGets_[i]) {
+        this.sendGet_(i);
+      }
+    }
   }
 
   /**

packages/database/src/core/ReadonlyRestClient.ts

@@ -15,7 +15,13 @@
  * limitations under the License.
  */
 
-import { assert, jsonEval, safeGet, querystring } from '@firebase/util';
+import {
+  assert,
+  jsonEval,
+  safeGet,
+  querystring,
+  Deferred
+} from '@firebase/util';
 import { logWrapper, warn } from './util/util';
 
 import { ServerActions } from './ServerActions';
@@ -139,6 +145,42 @@ export class ReadonlyRestClient extends ServerActions {
     delete this.listens_[listenId];
   }
 
+  get(query: Query): Promise<string> {
+    const queryStringParameters = query
+      .getQueryParams()
+      .toRestQueryStringParameters();
+
+    const pathString = query.path.toString();
+
+    const deferred = new Deferred<string>();
+
+    this.restRequest_(
+      pathString + '.json',
+      queryStringParameters,
+      (error, result) => {
+        let data = result;
+
+        if (error === 404) {
+          data = null;
+          error = null;
+        }
+
+        if (error === null) {
+          this.onDataUpdate_(
+            pathString,
+            data,
+            /*isMerge=*/ false,
+            /*tag=*/ null
+          );
+          deferred.resolve(data as string);
+        } else {
+          deferred.reject(new Error(data as string));
+        }
+      }
+    );
+    return deferred.promise;
+  }
+
   /** @inheritDoc */
   refreshAuthToken(token: string) {
     // no-op since we just always call getToken.

packages/database/src/core/Repo.ts

@@ -38,6 +38,7 @@ 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 { EventRegistration } from './view/EventRegistration';
@@ -304,6 +305,45 @@ export class Repo {
     return this.nextWriteId_++;
   }
 
+  getValue(query: Query): Promise<DataSnapshot> {
+    return this.server_.get(query).then(
+      payload => {
+        const node = nodeFromJSON(payload as string);
+        const events = this.serverSyncTree_.applyServerOverwrite(
+          query.path,
+          node
+        );
+        this.eventQueue_.raiseEventsAtPath(query.path, events);
+        return Promise.resolve(
+          new DataSnapshot(
+            node,
+            query.getRef(),
+            query.getQueryParams().getIndex()
+          )
+        );
+      },
+      err => {
+        this.log_(
+          'get for query ' +
+            stringify(query) +
+            ' falling back to cache after error: ' +
+            err
+        );
+        const cached = this.serverSyncTree_.calcCompleteEventCache(query.path);
+        if (!cached.isEmpty()) {
+          return Promise.resolve(
+            new DataSnapshot(
+              cached,
+              query.getRef(),
+              query.getQueryParams().getIndex()
+            )
+          );
+        }
+        return Promise.reject(new Error(err as string));
+      }
+    );
+  }
+
   setWithPriority(
     path: Path,
     newVal: unknown,

packages/database/src/core/ServerActions.ts

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