Refactor Filters (#1894)

* Rename RelationFilter to FieldFilter

* Remove NullFilter and NanFilter (replaced by just using FieldFilter)

* Rename RelationOp to Operator

* Extract KeyFieldFilter from FieldFilter

This makes it possible to validate arguments once rather than
per-document.

* Extract ArrayContainsFilter from FieldFilter

* Extract InFilter from FieldFilter

* Extract ArrayContainsAnyFilter from FieldFilter

* Factor out ArrayValue.contains

Author: wilhuff

packages/firestore/src/api/database.ts

@@ -30,11 +30,11 @@ import {
 import {
   Bound,
   Direction,
+  FieldFilter,
   Filter,
+  Operator,
   OrderBy,
-  Query as InternalQuery,
-  RelationFilter,
-  RelationOp
+  Query as InternalQuery
 } from '../core/query';
 import { Transaction as InternalTransaction } from '../core/transaction';
 import { ChangeType, ViewSnapshot } from '../core/view_snapshot';
@@ -1430,16 +1430,16 @@ export class Query implements firestore.Query {
 
     let fieldValue;
     const fieldPath = fieldPathFromArgument('Query.where', field);
-    const relationOp = RelationOp.fromString(opStr);
+    const operator = Operator.fromString(opStr);
     if (fieldPath.isKeyField()) {
       if (
-        relationOp === RelationOp.ARRAY_CONTAINS ||
-        relationOp === RelationOp.ARRAY_CONTAINS_ANY ||
-        relationOp === RelationOp.IN
+        operator === Operator.ARRAY_CONTAINS ||
+        operator === Operator.ARRAY_CONTAINS_ANY ||
+        operator === Operator.IN
       ) {
         throw new FirestoreError(
           Code.INVALID_ARGUMENT,
-          `Invalid Query. You can't perform '${relationOp.toString()}' ` +
+          `Invalid Query. You can't perform '${operator.toString()}' ` +
             'queries on FieldPath.documentId().'
         );
       }
@@ -1492,20 +1492,20 @@ export class Query implements firestore.Query {
       }
     } else {
       if (
-        relationOp === RelationOp.IN ||
-        relationOp === RelationOp.ARRAY_CONTAINS_ANY
+        operator === Operator.IN ||
+        operator === Operator.ARRAY_CONTAINS_ANY
       ) {
         if (!Array.isArray(value) || value.length === 0) {
           throw new FirestoreError(
             Code.INVALID_ARGUMENT,
             'Invalid Query. A non-empty array is required for ' +
-              `'${relationOp.toString()}' filters.`
+              `'${operator.toString()}' filters.`
           );
         }
         if (value.length > 10) {
           throw new FirestoreError(
             Code.INVALID_ARGUMENT,
-            `Invalid Query. '${relationOp.toString()}' filters support a ` +
+            `Invalid Query. '${operator.toString()}' filters support a ` +
               'maximum of 10 elements in the value array.'
           );
         }
@@ -1515,7 +1515,7 @@ export class Query implements firestore.Query {
         value
       );
     }
-    const filter = Filter.create(fieldPath, relationOp, fieldValue);
+    const filter = Filter.create(fieldPath, operator, fieldValue);
     this.validateNewFilter(filter);
     return new Query(this._query.addFilter(filter), this.firestore);
   }
@@ -1947,12 +1947,9 @@ export class Query implements firestore.Query {
   }
 
   private validateNewFilter(filter: Filter): void {
-    if (filter instanceof RelationFilter) {
-      const arrayOps = [
-        RelationOp.ARRAY_CONTAINS,
-        RelationOp.ARRAY_CONTAINS_ANY
-      ];
-      const disjunctiveOps = [RelationOp.IN, RelationOp.ARRAY_CONTAINS_ANY];
+    if (filter instanceof FieldFilter) {
+      const arrayOps = [Operator.ARRAY_CONTAINS, Operator.ARRAY_CONTAINS_ANY];
+      const disjunctiveOps = [Operator.IN, Operator.ARRAY_CONTAINS_ANY];
       const isArrayOp = arrayOps.indexOf(filter.op) >= 0;
       const isDisjunctiveOp = disjunctiveOps.indexOf(filter.op) >= 0;
 
@@ -1978,12 +1975,12 @@ export class Query implements firestore.Query {
       } else if (isDisjunctiveOp || isArrayOp) {
         // You can have at most 1 disjunctive filter and 1 array filter. Check if
         // the new filter conflicts with an existing one.
-        let conflictingOp: RelationOp | null = null;
+        let conflictingOp: Operator | null = null;
         if (isDisjunctiveOp) {
-          conflictingOp = this._query.findRelationOpFilter(disjunctiveOps);
+          conflictingOp = this._query.findFilterOperator(disjunctiveOps);
         }
         if (conflictingOp === null && isArrayOp) {
-          conflictingOp = this._query.findRelationOpFilter(arrayOps);
+          conflictingOp = this._query.findFilterOperator(arrayOps);
         }
         if (conflictingOp != null) {
           // We special case when it's a duplicate op to give a slightly clearer error message.