Remove invalidClassError

Author: schmidt-sebastian

packages/firestore/exp/src/api/reference.ts

@@ -24,7 +24,7 @@ import {
   parseUpdateVarargs
 } from '../../../src/api/user_data_reader';
 import { debugAssert } from '../../../src/util/assert';
-import { cast } from '../../../lite/src/api/util';
+import { cast } from '../../../src/util/input_validation';
 import { DocumentSnapshot, QuerySnapshot } from './snapshot';
 import {
   applyFirestoreDataConverter,

packages/firestore/lite/src/api/util.ts

@@ -17,7 +17,6 @@
 
 import { isBase64Available } from '../platform/base64';
 import { Code, FirestoreError } from '../util/error';
-import { invalidClassError } from '../util/input_validation';
 import { ByteString } from '../util/byte_string';
 import { Bytes } from '../../lite/src/api/bytes';
 
@@ -66,9 +65,6 @@ export class Blob extends Bytes {
 
   static fromUint8Array(array: Uint8Array): Blob {
     assertUint8ArrayAvailable();
-    if (!(array instanceof Uint8Array)) {
-      throw invalidClassError('Blob.fromUint8Array', 'Uint8Array', 1, array);
-    }
     return new Blob(ByteString.fromUint8Array(array));
   }
 

packages/firestore/src/api/blob.ts

@@ -62,6 +62,7 @@ import {
   findFilterOperator,
   getFirstOrderByField,
   getInequalityFilterField,
+  hasLimitToLast,
   isCollectionGroupQuery,
   LimitType,
   newQueryComparator,
@@ -76,8 +77,7 @@ import {
   queryWithAddedOrderBy,
   queryWithEndAt,
   queryWithLimit,
-  queryWithStartAt,
-  hasLimitToLast
+  queryWithStartAt
 } from '../core/query';
 import { Transaction as InternalTransaction } from '../core/transaction';
 import { ChangeType, ViewSnapshot } from '../core/view_snapshot';
@@ -92,11 +92,11 @@ import { debugAssert, fail } from '../util/assert';
 import { AsyncQueue } from '../util/async_queue';
 import { Code, FirestoreError } from '../util/error';
 import {
-  invalidClassError,
-  validatePositiveNumber,
-  valueDescription,
+  cast,
   validateIsNotUsedTogether,
-  validateNonEmptyString
+  validateNonEmptyString,
+  validatePositiveNumber,
+  valueDescription
 } from '../util/input_validation';
 import { getLogLevel, logError, LogLevel, setLogLevel } from '../util/log';
 import { AutoId } from '../util/misc';
@@ -1022,7 +1022,7 @@ export class DocumentReference<T = DocumentData>
 
   isEqual(other: PublicDocumentReference<T>): boolean {
     if (!(other instanceof DocumentReference)) {
-      throw invalidClassError('isEqual', 'DocumentReference', 1, other);
+      return false;
     }
     return (
       this.firestore === other.firestore &&
@@ -1346,7 +1346,7 @@ export class DocumentSnapshot<T = DocumentData>
 
   isEqual(other: PublicDocumentSnapshot<T>): boolean {
     if (!(other instanceof DocumentSnapshot)) {
-      throw invalidClassError('isEqual', 'DocumentSnapshot', 1, other);
+      return false;
     }
     return (
       this._firestore === other._firestore &&
@@ -1924,7 +1924,7 @@ export class Query<T = DocumentData> implements PublicQuery<T> {
 
   isEqual(other: PublicQuery<T>): boolean {
     if (!(other instanceof Query)) {
-      throw invalidClassError('isEqual', 'Query', 1, other);
+      return false;
     }
     return (
       this.firestore === other.firestore &&
@@ -2126,7 +2126,7 @@ export class QuerySnapshot<T = DocumentData> implements PublicQuerySnapshot<T> {
   /** Check the equality. The call can be very expensive. */
   isEqual(other: PublicQuerySnapshot<T>): boolean {
     if (!(other instanceof QuerySnapshot)) {
-      throw invalidClassError('isEqual', 'QuerySnapshot', 1, other);
+      return false;
     }
 
     return (
@@ -2199,6 +2199,7 @@ export class CollectionReference<T = DocumentData>
     if (arguments.length === 0) {
       pathString = AutoId.newId();
     }
+    validateNonEmptyString('CollectionReference.doc', 'path', pathString);
     const path = ResourcePath.fromString(pathString!);
     return DocumentReference.forPath<T>(
       this._query.path.child(path),
@@ -2264,15 +2265,14 @@ function validateReference<T>(
   documentRef: PublicDocumentReference<T>,
   firestore: Firestore
 ): _DocumentKeyReference<T> {
-  if (!(documentRef instanceof _DocumentKeyReference)) {
-    throw invalidClassError(methodName, 'DocumentReference', 1, documentRef);
-  } else if (documentRef.firestore !== firestore) {
+  const reference = cast<DocumentReference<T>>(documentRef, DocumentReference);
+  if (reference.firestore !== firestore) {
     throw new FirestoreError(
       Code.INVALID_ARGUMENT,
       'Provided document reference is from a different Firestore instance.'
     );
   } else {
-    return documentRef;
+    return reference;
   }
 }
 

packages/firestore/src/api/database.ts

@@ -19,7 +19,6 @@ import { FieldPath as PublicFieldPath } from '@firebase/firestore-types';
 
 import { FieldPath as InternalFieldPath } from '../model/path';
 import { Code, FirestoreError } from '../util/error';
-import { invalidClassError } from '../util/input_validation';
 
 // The objects that are a part of this API are exposed to third-parties as
 // compiled javascript so we want to flag our private members with a leading
@@ -78,7 +77,7 @@ export class FieldPath extends _BaseFieldPath implements PublicFieldPath {
 
   isEqual(other: PublicFieldPath): boolean {
     if (!(other instanceof FieldPath)) {
-      throw invalidClassError('isEqual', 'FieldPath', 1, other);
+      return false;
     }
     return this._internalPath.isEqual(other._internalPath);
   }

packages/firestore/src/api/field_path.ts

@@ -16,7 +16,6 @@
  */
 import { fail } from './assert';
 import { Code, FirestoreError } from './error';
-import { Dict, forEach } from './obj';
 import { DocumentKey } from '../model/document_key';
 import { ResourcePath } from '../model/path';
 
@@ -143,21 +142,32 @@ export function tryGetCustomObjectType(input: object): string | null {
 }
 
 /**
- * Helper method to throw an error that the provided argument did not pass
- * an instanceof check.
+ * Casts `obj` to `T`. Throws if  `obj` is not an instance of `T`.
+ *
+ * This cast is used in the Lite and Full SDK to verify instance types for
+ * arguments passed to the public API.
  */
-export function invalidClassError(
-  functionName: string,
-  type: string,
-  position: number,
-  argument: unknown
-): Error {
-  const description = valueDescription(argument);
-  return new FirestoreError(
-    Code.INVALID_ARGUMENT,
-    `Function ${functionName}() requires its ${ordinal(position)} ` +
-      `argument to be a ${type}, but it was: ${description}`
-  );
+export function cast<T>(
+  obj: object,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor: { new (...args: any[]): T }
+): T | never {
+  if (!(obj instanceof constructor)) {
+    if (constructor.name === obj.constructor.name) {
+      throw new FirestoreError(
+        Code.INVALID_ARGUMENT,
+        'Type does not match the expected instance. Did you pass a ' +
+          `reference from a different Firestore SDK?`
+      );
+    } else {
+      const description = valueDescription(obj);
+      throw new FirestoreError(
+        Code.INVALID_ARGUMENT,
+        `Expected type '${constructor.name}', but it was: ${description}`
+      );
+    }
+  }
+  return obj as T;
 }
 
 export function validatePositiveNumber(

packages/firestore/src/util/input_validation.ts

@@ -1367,28 +1367,24 @@ apiDescribe('Validation:', (persistence: boolean) => {
       }
     );
 
-    validationIt.only(
-      persistence,
-      'cannot pass undefined as a field value',
-      db => {
-        const collection = db.collection('test');
-        if (usesFunctionalApi()) {
-          expect(() => collection.where('foo', '==', undefined)).to.throw(
-            'Function where() called with invalid data. Unsupported field value: undefined'
-          );
-          expect(() => collection.orderBy('foo').startAt(undefined)).to.throw(
-            'Function startAt() called with invalid data. Unsupported field value: undefined'
-          );
-        } else {
-          expect(() => collection.where('foo', '==', undefined)).to.throw(
-            'Function Query.where() called with invalid data. Unsupported field value: undefined'
-          );
-          expect(() => collection.orderBy('foo').startAt(undefined)).to.throw(
-            'Function Query.startAt() called with invalid data. Unsupported field value: undefined'
-          );
-        }
+    validationIt(persistence, 'cannot pass undefined as a field value', db => {
+      const collection = db.collection('test');
+      if (usesFunctionalApi()) {
+        expect(() => collection.where('foo', '==', undefined)).to.throw(
+          'Function where() called with invalid data. Unsupported field value: undefined'
+        );
+        expect(() => collection.orderBy('foo').startAt(undefined)).to.throw(
+          'Function startAt() called with invalid data. Unsupported field value: undefined'
+        );
+      } else {
+        expect(() => collection.where('foo', '==', undefined)).to.throw(
+          'Function Query.where() called with invalid data. Unsupported field value: undefined'
+        );
+        expect(() => collection.orderBy('foo').startAt(undefined)).to.throw(
+          'Function Query.startAt() called with invalid data. Unsupported field value: undefined'
+        );
       }
-    );
+    });
   });
 });