incorporating first round of changes

Author: Brian Chen

packages/firestore/src/api/database.ts

@@ -59,7 +59,6 @@ import { AsyncQueue } from '../util/async_queue';
 import { Code, FirestoreError } from '../util/error';
 import {
   invalidClassError,
-  validateArgEnum,
   validateArgType,
   validateAtLeastNumberOfArgs,
   validateBetweenNumberOfArgs,
@@ -71,6 +70,7 @@ import {
   validateOptionalArgType,
   validateOptionalArrayElements,
   validateOptionNames,
+  validateStringEnum,
   valueDescription
 } from '../util/input_validation';
 import * as log from '../util/log';
@@ -1353,17 +1353,10 @@ export class Query implements firestore.Query {
     value: unknown
   ): firestore.Query {
     validateExactNumberOfArgs('Query.where', arguments, 3);
-    validateArgType('Query.where', 'non-empty string', 2, opStr);
     validateDefined('Query.where', 3, value);
     // Enumerated from the WhereFilterOp type in index.d.ts.
     const whereFilterOpEnums = ['<', '<=', '==', '>=', '>', 'array-contains'];
-    validateArgEnum(
-      'Query.where',
-      whereFilterOpEnums,
-      'WhereFilterOp',
-      2,
-      opStr
-    );
+    validateStringEnum('Query.where', whereFilterOpEnums, 2, opStr);
     let fieldValue;
     const fieldPath = fieldPathFromArgument('Query.where', field);
     const relationOp = RelationOp.fromString(opStr);

packages/firestore/src/util/input_validation.ts

@@ -151,7 +151,6 @@ export function validateArgType(
   position: number,
   argument: unknown
 ): void {
-  // console.log('validating: ', argument, 'as', type);
   validateType(functionName, type, `${ordinal(position)} argument`, argument);
 }
 
@@ -293,26 +292,24 @@ export function validateNamedOptionalPropertyEquals<T>(
 }
 
 /**
- * Validates that the provided argument is part of the
+ * Validates that the provided argument is a valid enum.
  *
  * @param functionName Function making the validation call.
  * @param enums Array containing all possible values for the enum.
- * @param enumName Custom type name.
  * @param position Position of the argument in `functionName`.
  * @param argument Arugment to validate.
  */
-export function validateArgEnum<T>(
+export function validateStringEnum<T>(
   functionName: string,
   enums: string[],
-  enumName: string,
   position: number,
-  argument: string
+  argument: unknown
 ): void {
   if (!enums.some(element => element === argument)) {
     throw new FirestoreError(
       Code.INVALID_ARGUMENT,
-      `Function ${functionName}() requires its ${ordinal(position)} ` +
-        `argument to be of type ${enumName}, but it was: ${argument}`
+      `Invalid value ${argument} provided to function ${functionName}() for its` +
+        ` ${ordinal(position)} argument. Acceptable values: ${enums.join(', ')}`
     );
   }
 }

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

@@ -803,8 +803,8 @@ apiDescribe('Validation:', persistence => {
     validationIt(persistence, 'enum', db => {
       const collection = db.collection('test') as any;
       expect(() => collection.where('a', 'foo', 'b')).to.throw(
-        'Function Query.where() requires its second argument to be of type WhereFilterOp,' +
-          ' but it was: foo'
+        'Invalid value foo provided to function Query.where() for its second argument. ' +
+          'Acceptable values: <, <=, ==, >=, >, array-contains'
       );
     });