b/79432277: Limit Queries to only a single array-contains clause.

packages/firestore/src/api/database.ts

@@ -1735,21 +1735,34 @@ export class Query implements firestore.Query {
   }
 
   private validateNewFilter(filter: Filter): void {
-    if (filter instanceof RelationFilter && filter.isInequality()) {
-      const existingField = this._query.getInequalityFilterField();
-      if (existingField !== null && !existingField.isEqual(filter.field)) {
-        throw new FirestoreError(
-          Code.INVALID_ARGUMENT,
-          'Invalid query. All where filters with an inequality' +
-            ' (<, <=, >, or >=) must be on the same field. But you have' +
-            ` inequality filters on '${existingField.toString()}'` +
-            ` and '${filter.field.toString()}'`
-        );
-      }
+    if (filter instanceof RelationFilter) {
+      if (filter.isInequality()) {
+        const existingField = this._query.getInequalityFilterField();
+        if (existingField !== null && !existingField.isEqual(filter.field)) {
+          throw new FirestoreError(
+            Code.INVALID_ARGUMENT,
+            'Invalid query. All where filters with an inequality' +
+              ' (<, <=, >, or >=) must be on the same field. But you have' +
+              ` inequality filters on '${existingField.toString()}'` +
+              ` and '${filter.field.toString()}'`
+          );
+        }
 
-      const firstOrderByField = this._query.getFirstOrderByField();
-      if (firstOrderByField !== null) {
-        this.validateOrderByAndInequalityMatch(filter.field, firstOrderByField);
+        const firstOrderByField = this._query.getFirstOrderByField();
+        if (firstOrderByField !== null) {
+          this.validateOrderByAndInequalityMatch(
+            filter.field,
+            firstOrderByField
+          );
+        }
+      } else if (filter.op === RelationOp.ARRAY_CONTAINS) {
+        if (this._query.hasArrayContainsFilter()) {
+          throw new FirestoreError(
+            Code.INVALID_ARGUMENT,
+            'Invalid query. Queries only support a single array-contains ' +
+              'filter.'
+          );
+        }
       }
     }
   }

packages/firestore/src/core/query.ts

@@ -316,6 +316,16 @@ export class Query {
     return null;
   }
 
+  hasArrayContainsFilter(): boolean {
+    return (
+      this.filters.find(
+        filter =>
+          filter instanceof RelationFilter &&
+          filter.op === RelationOp.ARRAY_CONTAINS
+      ) !== undefined
+    );
+  }
+
   isDocumentQuery(): boolean {
     return DocumentKey.isDocumentKey(this.path) && this.filters.length === 0;
   }

packages/firestore/test/integration/api/validation.test.ts

@@ -790,6 +790,21 @@ apiDescribe('Validation:', persistence => {
       }
     );
 
+    validationIt(
+      persistence,
+      'with multiple array-contains filters fail.',
+      db => {
+        expect(() =>
+          db
+            .collection('test')
+            .where('foo', arrayContainsOp, 1)
+            .where('foo', arrayContainsOp, 2)
+        ).to.throw(
+          'Invalid query. Queries only support a single array-contains filter.'
+        );
+      }
+    );
+
     validationIt(
       persistence,
       'must not specify starting or ending point after orderBy',