Reduce size of 'Cleanup: Remove validator'

dev/src/document.ts

@@ -381,7 +381,7 @@ export class DocumentSnapshot {
    *   console.log(`Retrieved field value: ${field}`);
    * });
    */
-  get(field: string|FieldPath): any {  // tslint:disable-line no-any
+  get(field: string|FieldPath): UserInput
     validateFieldPath('field', field);
 
     const protoField = this.protoField(field);

dev/src/field-value.ts

@@ -391,5 +391,5 @@ function validateArrayElement(arg: string|number, value: unknown): void {
       arg, value, 'array element',
       /*path=*/{allowEmpty: true, allowDeletes: 'none', allowTransforms: false},
       /*path=*/undefined,
-      /*level=*/0, /* inArray=*/true);
+      /*level=*/0, /*inArray=*/true);
 }

dev/src/index.ts

@@ -1319,6 +1319,39 @@ function validateFieldValue(
   return true;
 }
 
+/**
+ * Validates the use of 'options' as ReadOptions and enforces that 'fieldMask'
+ * is an array of strings or field paths.
+ *
+ * @private
+ * @param options.fieldMask - The subset of fields to return from a read
+ * operation.
+ */
+export function validateReadOptions(options: ReadOptions): boolean {
+  if (!is.object(options)) {
+    throw new Error('Input is not an object.');
+  }
+
+  if (options.fieldMask === undefined) {
+    return true;
+  }
+
+  if (!Array.isArray(options.fieldMask)) {
+    throw new Error('"fieldMask" is not an array.');
+  }
+
+  for (let i = 0; i < options.fieldMask.length; ++i) {
+    try {
+      FieldPath.validateFieldPath(options.fieldMask[i]);
+    } catch (err) {
+      throw new Error(
+          `Element at index ${i} is not a valid FieldPath. ${err.message}`);
+    }
+  }
+
+  return true;
+}
+
 /**
  * A logging function that takes a single string.
  *

dev/src/path.ts

@@ -395,7 +395,7 @@ export class ResourcePath extends Path<ResourcePath> {
 }
 
 /**
- * Returns true if the given string can be used as a relative or absolute
+ * Validates that the given string can be used as a relative or absolute
  * resource path.
  *
  * @private

dev/src/reference.ts

@@ -45,7 +45,9 @@ import {Firestore} from './index';
  */
 const directionOperators: {[k: string]: api.StructuredQuery.Direction} = {
   asc: 'ASCENDING',
+  ASC: 'ASCENDING',
   desc: 'DESCENDING',
+  DESC: 'DESCENDING',
 };
 
 /*!
@@ -58,6 +60,7 @@ const comparisonOperators:
     {[k: string]: api.StructuredQuery.FieldFilter.Operator} = {
       '<': 'LESS_THAN',
       '<=': 'LESS_THAN_OR_EQUAL',
+      '=': 'EQUAL',
       '==': 'EQUAL',
       '>': 'GREATER_THAN',
       '>=': 'GREATER_THAN_OR_EQUAL',
@@ -1003,8 +1006,7 @@ export class Query {
    *   });
    * });
    */
-  where(fieldPath: string|FieldPath, opStr: WhereFilterOp, value: unknown):
-      Query {
+  where(fieldPath: string|FieldPath, opStr: string, value: UserInput): Query {
     validateFieldPath('fieldPath', fieldPath);
     validateQueryOperator('opStr', opStr, value);
     validateQueryValue('value', value);
@@ -1094,7 +1096,7 @@ export class Query {
    *   });
    * });
    */
-  orderBy(fieldPath: string|FieldPath, directionStr?: OrderByDirection): Query {
+  orderBy(fieldPath: string|FieldPath, directionStr?: string): Query {
     validateFieldPath('fieldPath', fieldPath);
     validateQueryOrder('directionStr', directionStr);
 
@@ -1703,9 +1705,8 @@ export class Query {
       (s1: QueryDocumentSnapshot, s2: QueryDocumentSnapshot) => number {
     return (doc1, doc2) => {
       // Add implicit sorting by name, using the last specified direction.
-      const lastDirection: api.StructuredQuery.Direction =
-          this._fieldOrders.length === 0 ?
-          'ASCENDING' :
+      const lastDirection = this._fieldOrders.length === 0 ?
+          directionOperators.ASC :
           this._fieldOrders[this._fieldOrders.length - 1].direction;
       const orderBys = this._fieldOrders.concat(
           new FieldOrder(FieldPath.documentId(), lastDirection));
@@ -1727,7 +1728,8 @@ export class Query {
         }
 
         if (comp !== 0) {
-          const direction = orderBy.direction === 'ASCENDING' ? 1 : -1;
+          const direction =
+              orderBy.direction === directionOperators.ASC ? 1 : -1;
           return direction * comp;
         }
       }
@@ -1943,7 +1945,9 @@ function createCollectionReference(firestore, path): CollectionReference {
  * @throws when the direction is invalid
  */
 export function validateQueryOrder(arg: string|number, op: unknown): void {
-  validateEnumValue(arg, op, Object.keys(directionOperators), {optional: true});
+  if (!is.string(str) || !is.defined(directionOperators[str])) {
+    throw new Error('Order must be one of "asc" or "desc".');
+  }
 }
 
 /**
@@ -1957,16 +1961,18 @@ export function validateQueryOrder(arg: string|number, op: unknown): void {
  */
 export function validateQueryOperator(
     arg: string|number, op: unknown, fieldValue: unknown): void {
-  validateEnumValue(arg, op, Object.keys(comparisonOperators));
+  if (is.string(str) && comparisonOperators[str]) {
+    const op = comparisonOperators[str];
 
-  if (typeof fieldValue === 'number' && isNaN(fieldValue) && op !== '==') {
-    throw new Error(
-        'Invalid query. You can only perform equals comparisons on NaN.');
-  }
+    if (typeof val === 'number' && isNaN(val) && op !== 'EQUAL') {
+      throw new Error(
+          'Invalid query. You can only perform equals comparisons on NaN.');
+    }
 
-  if (fieldValue === null && op !== '==') {
-    throw new Error(
-        'Invalid query. You can only perform equals comparisons on Null.');
+    if (val === null && op !== 'EQUAL') {
+      throw new Error(
+          'Invalid query. You can only perform equals comparisons on Null.');
+    }
   }
 }
 
@@ -1994,7 +2000,7 @@ export function validateDocumentReference(
 function validateQueryValue(arg: string|number, value: unknown): void {
   validateUserInput(
       arg, value, 'query constraint',
-      {allowEmpty: true, allowDeletes: 'none', allowTransforms: false});
+      {allowDeletes: 'none', allowTransforms: false});
 }
 
 /**

dev/src/types.ts

@@ -107,18 +107,6 @@ export type UpdateData = {
   [fieldPath: string]: UserInput
 };
 
-/**
- * The direction of a `Query.orderBy()` clause is specified as 'desc' or 'asc'
- * (descending or ascending).
- */
-export type OrderByDirection = 'desc'|'asc';
-
-/**
- * Filter conditions in a `Query.where()` clause are specified using the
- * strings '<', '<=', '==', '>=', '>', and 'array-contains'.
- */
-export type WhereFilterOp = '<'|'<='|'=='|'>='|'>'|'array-contains';
-
 /**
  * An options object that configures conditional behavior of `update()` and
  * `delete()` calls in `DocumentReference`, `WriteBatch`, and `Transaction`.
@@ -183,9 +171,6 @@ export interface ValidationOptions {
 
   /** Whether server transforms are supported. */
   allowTransforms: boolean;
-
-  /** Whether empty documents are supported. */
-  allowEmpty: boolean;
 }
 
 /**

dev/src/write-batch.ts

@@ -725,14 +725,10 @@ export function validateDocumentData(
     throw new Error(customObjectMessage(arg, obj));
   }
 
-  let isEmpty = true;
-
   for (const prop in obj) {
     if (obj.hasOwnProperty(prop)) {
-      isEmpty = false;
       validateUserInput(
           arg, obj[prop], 'Firestore document', {
-            allowEmpty: true,
             allowDeletes: allowDeletes ? 'all' : 'none',
             allowTransforms: true,
           },
@@ -786,7 +782,6 @@ function validateUpdateMap(arg: string|number, obj: unknown): void {
       isEmpty = false;
       validateUserInput(
           arg, obj[prop], 'Firestore document', {
-            allowEmpty: true,
             allowDeletes: 'root',
             allowTransforms: true,
           },
@@ -797,4 +792,4 @@ function validateUpdateMap(arg: string|number, obj: unknown): void {
   if (isEmpty) {
     throw new Error('At least one field must be updated.');
   }
-}
+}