feat(firestore): Firestore Filter instance. Use Filter, Filter.or() & Filter.and() in Firestore queries.

docs/firestore/usage/index.md

@@ -239,6 +239,43 @@ firestore()
 To learn more about all of the querying capabilities Cloud Firestore has to offer, view the
 [Firebase documentation](https://firebase.google.com/docs/firestore/query-data/queries).
 
+It is now possible to use the `Filter` instance to make queries. They can be used with the existing query API.
+For example, you could chain like so:
+
+```js
+const snapshot = await firestore()
+  .collection('Users')
+  .where(Filter('user', '==', 'Tim'))
+  .where('email', '==', 'tim@example.com')
+  .get();
+```
+
+You can use the `Filter.and()` static method to make logical AND queries:
+
+```js
+const snapshot = await firestore()
+  .collection('Users')
+  .where(Filter.and(Filter('user', '==', 'Tim'), Filter('email', '==', 'tim@example.com')))
+  .get();
+```
+
+You can use the `Filter.or()` static method to make logical OR queries:
+
+```js
+const snapshot = await firestore()
+  .collection('Users')
+  .where(
+    Filter.or(
+      Filter.and(Filter('user', '==', 'Tim'), Filter('email', '==', 'tim@example.com')),
+      Filter.and(Filter('user', '==', 'Dave'), Filter('email', '==', 'dave@example.com')),
+    ),
+  )
+  .get();
+```
+
+For an understanding of what queries are possible, please consult the query limitation documentation on the official
+[Firebase Firestore documentation](https://firebase.google.com/docs/firestore/query-data/queries#limits_on_or_queries).
+
 #### Limiting
 
 To limit the number of documents returned from a query, use the `limit` method on a collection reference:
@@ -317,7 +354,6 @@ with an ID of `DEF`.
 Cloud Firestore does not support the following types of queries:
 
 - Queries with range filters on different fields, as described in the previous section.
-- Logical OR queries. In this case, you should create a separate query for each OR condition and merge the query results in your app.
 
 ## Writing Data
 

packages/firestore/android/src/reactnative/java/io/invertase/firebase/firestore/ReactNativeFirebaseFirestoreQuery.java

@@ -26,6 +26,7 @@
 import com.google.android.gms.tasks.Task;
 import com.google.android.gms.tasks.Tasks;
 import com.google.firebase.firestore.FieldPath;
+import com.google.firebase.firestore.Filter;
 import com.google.firebase.firestore.Query;
 import com.google.firebase.firestore.QuerySnapshot;
 import com.google.firebase.firestore.Source;
@@ -65,62 +66,139 @@ private void applyFilters(ReadableArray filters) {
     for (int i = 0; i < filters.size(); i++) {
       ReadableMap filter = filters.getMap(i);
 
-      ArrayList fieldPathArray = Objects.requireNonNull(filter).getArray("fieldPath").toArrayList();
-      String[] segmentArray = (String[]) fieldPathArray.toArray(new String[0]);
+      if (filter.hasKey("fieldPath")) {
+        ArrayList<Object> fieldPathArray =
+            Objects.requireNonNull(Objects.requireNonNull(filter).getArray("fieldPath"))
+                .toArrayList();
+        String[] segmentArray = (String[]) fieldPathArray.toArray(new String[0]);
+
+        FieldPath fieldPath = FieldPath.of(Objects.requireNonNull(segmentArray));
+        String operator = filter.getString("operator");
+        ReadableArray arrayValue = filter.getArray("value");
+        Object value = parseTypeMap(query.getFirestore(), Objects.requireNonNull(arrayValue));
+
+        switch (Objects.requireNonNull(operator)) {
+          case "EQUAL":
+            query = query.whereEqualTo(Objects.requireNonNull(fieldPath), value);
+            break;
+          case "NOT_EQUAL":
+            query = query.whereNotEqualTo(Objects.requireNonNull(fieldPath), value);
+            break;
+          case "GREATER_THAN":
+            query =
+                query.whereGreaterThan(
+                    Objects.requireNonNull(fieldPath), Objects.requireNonNull(value));
+            break;
+          case "GREATER_THAN_OR_EQUAL":
+            query =
+                query.whereGreaterThanOrEqualTo(
+                    Objects.requireNonNull(fieldPath), Objects.requireNonNull(value));
+            break;
+          case "LESS_THAN":
+            query =
+                query.whereLessThan(
+                    Objects.requireNonNull(fieldPath), Objects.requireNonNull(value));
+            break;
+          case "LESS_THAN_OR_EQUAL":
+            query =
+                query.whereLessThanOrEqualTo(
+                    Objects.requireNonNull(fieldPath), Objects.requireNonNull(value));
+            break;
+          case "ARRAY_CONTAINS":
+            query =
+                query.whereArrayContains(
+                    Objects.requireNonNull(fieldPath), Objects.requireNonNull(value));
+            break;
+          case "ARRAY_CONTAINS_ANY":
+            query =
+                query.whereArrayContainsAny(
+                    Objects.requireNonNull(fieldPath),
+                    Objects.requireNonNull((List<Object>) value));
+            break;
+          case "IN":
+            query =
+                query.whereIn(
+                    Objects.requireNonNull(fieldPath),
+                    Objects.requireNonNull((List<Object>) value));
+            break;
+          case "NOT_IN":
+            query =
+                query.whereNotIn(
+                    Objects.requireNonNull(fieldPath),
+                    Objects.requireNonNull((List<Object>) value));
+            break;
+        }
+      } else if (filter.hasKey("operator") && filter.hasKey("queries")) {
+        query = query.where(applyFilterQueries(filter));
+      }
+    }
+  }
+
+  private Filter applyFilterQueries(ReadableMap filter) {
+    if (filter.hasKey("fieldPath")) {
+      String operator =
+          (String) Objects.requireNonNull(Objects.requireNonNull(filter).getString("operator"));
+      ReadableMap fieldPathMap = Objects.requireNonNull(filter.getMap("fieldPath"));
+      ReadableArray segments = Objects.requireNonNull(fieldPathMap.getArray("_segments"));
+      int arraySize = segments.size();
+      String[] segmentArray = new String[arraySize];
 
-      FieldPath fieldPath = FieldPath.of(Objects.requireNonNull(segmentArray));
-      String operator = filter.getString("operator");
+      for (int i = 0; i < arraySize; i++) {
+        segmentArray[i] = segments.getString(i);
+      }
+      FieldPath fieldPath = FieldPath.of(segmentArray);
       ReadableArray arrayValue = filter.getArray("value");
+
       Object value = parseTypeMap(query.getFirestore(), Objects.requireNonNull(arrayValue));
 
-      switch (Objects.requireNonNull(operator)) {
+      switch (operator) {
         case "EQUAL":
-          query = query.whereEqualTo(Objects.requireNonNull(fieldPath), value);
-          break;
+          return Filter.equalTo(fieldPath, value);
         case "NOT_EQUAL":
-          query = query.whereNotEqualTo(Objects.requireNonNull(fieldPath), value);
-          break;
-        case "GREATER_THAN":
-          query =
-              query.whereGreaterThan(
-                  Objects.requireNonNull(fieldPath), Objects.requireNonNull(value));
-          break;
-        case "GREATER_THAN_OR_EQUAL":
-          query =
-              query.whereGreaterThanOrEqualTo(
-                  Objects.requireNonNull(fieldPath), Objects.requireNonNull(value));
-          break;
+          return Filter.notEqualTo(fieldPath, value);
         case "LESS_THAN":
-          query =
-              query.whereLessThan(Objects.requireNonNull(fieldPath), Objects.requireNonNull(value));
-          break;
+          return Filter.lessThan(fieldPath, value);
         case "LESS_THAN_OR_EQUAL":
-          query =
-              query.whereLessThanOrEqualTo(
-                  Objects.requireNonNull(fieldPath), Objects.requireNonNull(value));
-          break;
+          return Filter.lessThanOrEqualTo(fieldPath, value);
+        case "GREATER_THAN":
+          return Filter.greaterThan(fieldPath, value);
+        case "GREATER_THAN_OR_EQUAL":
+          return Filter.greaterThanOrEqualTo(fieldPath, value);
         case "ARRAY_CONTAINS":
-          query =
-              query.whereArrayContains(
-                  Objects.requireNonNull(fieldPath), Objects.requireNonNull(value));
-          break;
+          return Filter.arrayContains(fieldPath, value);
         case "ARRAY_CONTAINS_ANY":
-          query =
-              query.whereArrayContainsAny(
-                  Objects.requireNonNull(fieldPath), Objects.requireNonNull((List<Object>) value));
-          break;
+          assert value != null;
+          return Filter.arrayContainsAny(fieldPath, (List<?>) value);
         case "IN":
-          query =
-              query.whereIn(
-                  Objects.requireNonNull(fieldPath), Objects.requireNonNull((List<Object>) value));
-          break;
+          assert value != null;
+          return Filter.inArray(fieldPath, (List<?>) value);
         case "NOT_IN":
-          query =
-              query.whereNotIn(
-                  Objects.requireNonNull(fieldPath), Objects.requireNonNull((List<Object>) value));
-          break;
+          assert value != null;
+          return Filter.notInArray(fieldPath, (List<?>) value);
+        default:
+          throw new Error("Invalid operator");
       }
     }
+
+    String operator = Objects.requireNonNull(filter).getString("operator");
+    ReadableArray queries =
+        Objects.requireNonNull(Objects.requireNonNull(filter).getArray("queries"));
+    ArrayList<Filter> parsedFilters = new ArrayList<>();
+    int arraySize = queries.size();
+    for (int i = 0; i < arraySize; i++) {
+      ReadableMap map = queries.getMap(i);
+      parsedFilters.add(applyFilterQueries(map));
+    }
+
+    if (operator.equals("AND")) {
+      return Filter.and(parsedFilters.toArray(new Filter[0]));
+    }
+
+    if (operator.equals("OR")) {
+      return Filter.or(parsedFilters.toArray(new Filter[0]));
+    }
+
+    throw new Error("Missing 'Filter' instance return");
   }
 
   private void applyOrders(ReadableArray orders) {