[query] - Rework firebaseWebApi queries to allow chaining of filters. iOS implementation

Author: KkevinLi

src/firebase.android.ts

@@ -11,6 +11,7 @@ import {
   GetAuthTokenOptions,
   GetAuthTokenResult,
   OnDisconnect as OnDisconnectBase, QueryOptions,
+  Query as QueryBase,
   User
 } from "./firebase";
 import {
@@ -21,15 +22,7 @@ import {
   isDocumentReference
 } from "./firebase-common";
 import * as firebaseFunctions from "./functions/functions";
-<<<<<<< HEAD
 import * as firebaseMessaging from "./messaging/messaging";
-=======
-import * as appModule from "tns-core-modules/application";
-import { AndroidActivityResultEventData } from "tns-core-modules/application";
-import { ad as AndroidUtils } from "tns-core-modules/utils/utils";
-import lazy from "tns-core-modules/utils/lazy";
-import { firestore, User, OnDisconnect as OnDisconnectBase, DataSnapshot, Query as QueryBase } from "./firebase";
->>>>>>> [query] - Rework firebaseWebApi queries to allow chaining of filters. Android implementation
 
 declare const com: any;
 const gmsAds = (<any>com.google.android.gms).ads;
@@ -1629,11 +1622,10 @@ firebase.update = (path, val) => {
     }
   });
 };
+firebase.query = (updateCallback, path, options) => {
+  return new Promise((resolve, reject) => {
+
 
-<<<<<<< HEAD
-firebase.query = (updateCallback: (data: FBDataSingleEvent | FBErrorData) => void, path: string, options: QueryOptions): Promise<any> => {
-  return new Promise<any>((resolve, reject) => {
-=======
 firebase.webQuery = (path: string): QueryBase => {
   if (!firebase.initialized) {
     console.error("Please run firebase.init() before firebase.query()");
@@ -1841,7 +1833,6 @@ class Query implements QueryBase {
 
 firebase.query = (updateCallback, path, options) => {
   return new Promise((resolve, reject) => {
->>>>>>> [query] - Rework firebaseWebApi queries to allow chaining of filters. Android implementation
     try {
       if (firebase.instance === null) {
         reject("Run init() first!");

src/firebase.ios.ts

@@ -7,6 +7,7 @@ import {
   GetAuthTokenOptions,
   GetAuthTokenResult,
   OnDisconnect as OnDisconnectBase, QueryOptions,
+  Query as QueryBase,
   User
 } from "./firebase";
 import {
@@ -1384,6 +1385,191 @@ firebase.update = (path, val) => {
     }
   });
 };
+firebase.webQuery = (path: string): QueryBase => {
+  if (!firebase.initialized) {
+    console.error("Please run firebase.init() before firebase.query()");
+    throw new Error("FirebaseApp is not initialized. Make sure you run firebase.init() first");
+  }
+  const dbRef: FIRDatabaseReference =  FIRDatabase.database().reference().child(path);
+  return new Query(dbRef, path);
+};
+
+class Query implements QueryBase {
+  private query: FIRDatabaseQuery; // Keep track of internal query state allowing us to chain filter/range/limit
+  private static eventListenerMap: Map<string, Array<any>> = new Map(); // A map to keep track all all the listeners attached for the specified eventType
+
+  constructor(private dbRef: FIRDatabaseReference, private path: string) { }
+
+  on(eventType: string, callback: (a: any, b?: string) => any): Promise<any> {
+    const onValueEvent = result => {
+      if (result.error) {
+        callback(result); // CAREFUL before we were calling result.error!
+      } else {
+        callback({
+          key: result.key,
+          val: () => result.value,
+          exists: () => !!result.value
+        });
+      }
+    };
+    return new Promise((resolve, reject) => {
+      try {
+        if (eventType === "value" || eventType === "child_added" || eventType === "child_changed"
+          || eventType === "child_removed" || eventType === "child_moved") {
+            // This.query may not exist if we call on without any sorts
+          const firDatabaseHandle = this.query ? this.attachEventObserver(this.query, eventType, onValueEvent) :
+            this.attachEventObserver(this.dbRef, eventType, onValueEvent);
+          if (!Query.eventListenerMap.has(eventType)) {
+            Query.eventListenerMap.set(eventType, []);
+          }
+          Query.eventListenerMap.get(eventType).push(firDatabaseHandle); // We need to keep track of the listeners to fully remove them when calling off
+        } else {
+          reject("Invalid eventType.  Use one of the following: 'value', 'child_added', 'child_changed', 'child_removed', or 'child_moved'");
+          return;
+        }
+        resolve();
+      } catch (ex) {
+        console.log("Error in firebase.addValueEventListener: " + ex);
+        reject(ex);
+      }
+    });
+  }
+
+  once(eventType: string): Promise<any> {
+    return new Promise((resolve, reject) => {
+      firebase.getValue(this.path).then(result => {
+        resolve({
+          key: result.key,
+          val: () => result.value,
+          exists: () => !!result.value
+        });
+      });
+    });
+  }
+
+  off(eventType?: string): void {
+    // Remove all events if none specified
+    if (!eventType) {
+      Query.eventListenerMap.forEach((value: any[], key: string) => {
+        firebase.removeEventListeners(value, this.path);
+      });
+    } else { // Remove only the event specified by the user
+      if (Query.eventListenerMap.get(eventType)) {
+        firebase.removeEventListeners(Query.eventListenerMap.get(eventType), this.path);
+      }
+    }
+  }
+
+  orderByChild(value: string): Query {
+    if (this.query) {
+      throw new Error("You can't combine multiple orderBy calls!");
+    }
+    this.query = this.dbRef.queryOrderedByChild(value);
+    return this;
+  }
+
+  orderByKey(): Query {
+    if (this.query) {
+      throw new Error("You can't combine multiple orderBy calls!");
+    }
+    this.query = this.dbRef.queryOrderedByKey();
+    return this;
+  }
+
+  orderByPriority(): Query {
+    if (this.query) {
+      throw new Error("You can't combine multiple orderBy calls!");
+    }
+    this.query = this.dbRef.queryOrderedByPriority();
+    return this;
+  }
+
+  orderByValue(): Query {
+    if (this.query) {
+      throw new Error("You can't combine multiple orderBy calls!");
+    }
+    this.query = this.dbRef.queryOrderedByValue();
+    return this;
+  }
+
+  // Unlike the order-by methods, you can combine multiple limit or range functions.
+  // For example, you can combine the startAt() and endAt() methods to limit the results to a specified range of values.
+
+  equalTo(value: any, key?: string): Query {
+    if (key) {
+      this.query = this.query.queryEqualToValueChildKey(value, key);
+    } else {
+      this.query = this.query.queryEqualToValue(value);
+    }
+    return this;
+  }
+
+  startAt(value: any, key?: string): Query {
+    if (key) {
+      this.query = this.query.queryStartingAtValueChildKey(value, key);
+    } else {
+      this.query = this.query.queryStartingAtValue(value);
+    }
+    return this;
+  }
+
+  endAt(value: any, key?: string): Query {
+    if (key) {
+      this.query = this.query.queryEndingAtValueChildKey(value, key);
+    } else {
+      this.query = this.query.queryEndingAtValue(value);
+    }
+    return this;
+  }
+
+  limitToFirst(value: number): Query {
+    this.query = this.query.queryLimitedToFirst(value);
+    return this;
+  }
+
+  limitToLast(value: number): Query {
+    this.query = this.query.queryLimitedToLast(value);
+    return this;
+  }
+
+  /**
+  * Depending on the eventType, attach listeners at the specified Database location. Follow the WebApi which listens
+  * to specific events (Android is more generic value / child - which includes all events add, change, remove etc).
+  * Similar to firebase._addObserver but I do not want to listen for every event
+  */
+  private attachEventObserver(dbRef: FIRDatabaseQuery | FIRDatabaseReference, eventType: string, callback): number {
+    let firEventType: FIRDataEventType;
+    switch (eventType) {
+      case "value":
+        firEventType = FIRDataEventType.Value;
+        break;
+      case "child_added":
+        firEventType = FIRDataEventType.ChildAdded;
+        break;
+      case "child_changed":
+        firEventType = FIRDataEventType.ChildChanged;
+        break;
+      case "child_removed":
+        firEventType = FIRDataEventType.ChildRemoved;
+        break;
+      case "child_moved":
+        firEventType = FIRDataEventType.ChildMoved;
+        break;
+    }
+
+    const listener = dbRef.observeEventTypeWithBlockWithCancelBlock(
+      firEventType,
+      snapshot => {
+        callback(firebase.getCallbackData(eventType, snapshot));
+      },
+      firebaseError => {
+        callback({
+          error: firebaseError.localizedDescription
+        });
+      });
+    return listener;
+  }
+}
 
 firebase.query = (updateCallback: (data: FBDataSingleEvent) => void, path: string, options: QueryOptions): Promise<any> => {
   return new Promise<any>((resolve, reject) => {