FieldPath Compat class

Author: schmidt-sebastian

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

@@ -15,8 +15,11 @@
  * limitations under the License.
  */
 
-import { _BaseFieldPath } from '../../../src/api/field_path';
-import { DOCUMENT_KEY_NAME } from '../../../src/model/path';
+import {
+  DOCUMENT_KEY_NAME,
+  FieldPath as InternalFieldPath
+} from '../../../src/model/path';
+import { Code, FirestoreError } from '../../../src/util/error';
 
 /**
  * A `FieldPath` refers to a field in a document. The path may consist of a
@@ -26,12 +29,9 @@ import { DOCUMENT_KEY_NAME } from '../../../src/model/path';
  * Create a `FieldPath` by providing field names. If more than one field
  * name is provided, the path will point to a nested field in a document.
  */
-export class FieldPath extends _BaseFieldPath {
-  // Note: This class is stripped down a copy of the FieldPath class in the
-  // legacy SDK. The changes are:
-  // - The `documentId()` static method has been removed
-  // - Input validation is limited to errors that cannot be caught by the
-  //   TypeScript transpiler.
+export class FieldPath {
+  /** Internal representation of a Firestore field path. */
+  readonly _internalPath: InternalFieldPath;
 
   /**
    * Creates a FieldPath from the provided field names. If more than one field
@@ -40,7 +40,17 @@ export class FieldPath extends _BaseFieldPath {
    * @param fieldNames A list of field names.
    */
   constructor(...fieldNames: string[]) {
-    super(fieldNames);
+    for (let i = 0; i < fieldNames.length; ++i) {
+      if (fieldNames[i].length === 0) {
+        throw new FirestoreError(
+          Code.INVALID_ARGUMENT,
+          `Invalid field name at argument $(i + 1). ` +
+            'Field names must not be empty.'
+        );
+      }
+    }
+
+    this._internalPath = new InternalFieldPath(fieldNames);
   }
 
   /**

packages/firestore/src/api/database.ts

@@ -77,7 +77,7 @@ import {
 } from '../util/input_validation';
 import { logWarn, setLogLevel as setClientLogLevel } from '../util/log';
 import { AutoId } from '../util/misc';
-import { _BaseFieldPath, FieldPath as ExternalFieldPath } from './field_path';
+import { FieldPath as ExpFieldPath } from '../../lite/src/api/field_path';
 import {
   CompleteFn,
   ErrorFn,
@@ -119,6 +119,7 @@ import {
   DocumentData as PublicDocumentData,
   DocumentReference as PublicDocumentReference,
   DocumentSnapshot as PublicDocumentSnapshot,
+  FieldPath as PublicFieldPath,
   FirebaseFirestore as PublicFirestore,
   FirestoreDataConverter as PublicFirestoreDataConverter,
   GetOptions as PublicGetOptions,
@@ -518,22 +519,28 @@ export class Transaction implements PublicTransaction {
   ): Transaction;
   update(
     documentRef: PublicDocumentReference<unknown>,
-    field: string | ExternalFieldPath,
+    field: string | PublicFieldPath,
     value: unknown,
     ...moreFieldsAndValues: unknown[]
   ): Transaction;
   update(
     documentRef: PublicDocumentReference<unknown>,
-    fieldOrUpdateData: string | ExternalFieldPath | PublicUpdateData,
+    fieldOrUpdateData: string | PublicFieldPath | PublicUpdateData,
     value?: unknown,
     ...moreFieldsAndValues: unknown[]
   ): Transaction {
     let ref;
     let parsed;
 
+    // For Compat types, we have to "extract" the underlying types before
+    // performing validation.
+    if (fieldOrUpdateData instanceof Compat) {
+      fieldOrUpdateData = (fieldOrUpdateData as Compat<ExpFieldPath>)._delegate;
+    }
+
     if (
       typeof fieldOrUpdateData === 'string' ||
-      fieldOrUpdateData instanceof ExternalFieldPath
+      fieldOrUpdateData instanceof ExpFieldPath
     ) {
       ref = validateReference(
         'Transaction.update',
@@ -629,24 +636,30 @@ export class WriteBatch implements PublicWriteBatch {
   ): WriteBatch;
   update(
     documentRef: PublicDocumentReference<unknown>,
-    field: string | ExternalFieldPath,
+    field: string | PublicFieldPath,
     value: unknown,
     ...moreFieldsAndValues: unknown[]
   ): WriteBatch;
   update(
     documentRef: PublicDocumentReference<unknown>,
-    fieldOrUpdateData: string | ExternalFieldPath | PublicUpdateData,
+    fieldOrUpdateData: string | PublicFieldPath | PublicUpdateData,
     value?: unknown,
     ...moreFieldsAndValues: unknown[]
   ): WriteBatch {
     this.verifyNotCommitted();
 
+    // For Compat types, we have to "extract" the underlying types before
+    // performing validation.
+    if (fieldOrUpdateData instanceof Compat) {
+      fieldOrUpdateData = (fieldOrUpdateData as Compat<ExpFieldPath>)._delegate;
+    }
+
     let ref;
     let parsed;
 
     if (
       typeof fieldOrUpdateData === 'string' ||
-      fieldOrUpdateData instanceof ExternalFieldPath
+      fieldOrUpdateData instanceof ExpFieldPath
     ) {
       ref = validateReference(
         'WriteBatch.update',
@@ -825,26 +838,25 @@ export class DocumentReference<T = PublicDocumentData>
 
   update(value: PublicUpdateData): Promise<void>;
   update(
-    field: string | ExternalFieldPath,
+    field: string | PublicFieldPath,
     value: unknown,
     ...moreFieldsAndValues: unknown[]
   ): Promise<void>;
   update(
-    fieldOrUpdateData: string | ExternalFieldPath | PublicUpdateData,
+    fieldOrUpdateData: string | PublicFieldPath | PublicUpdateData,
     value?: unknown,
     ...moreFieldsAndValues: unknown[]
   ): Promise<void> {
     // For Compat types, we have to "extract" the underlying types before
     // performing validation.
     if (fieldOrUpdateData instanceof Compat) {
-      fieldOrUpdateData = (fieldOrUpdateData as Compat<_BaseFieldPath>)
-        ._delegate;
+      fieldOrUpdateData = (fieldOrUpdateData as Compat<ExpFieldPath>)._delegate;
     }
 
     let parsed;
     if (
       typeof fieldOrUpdateData === 'string' ||
-      fieldOrUpdateData instanceof _BaseFieldPath
+      fieldOrUpdateData instanceof ExpFieldPath
     ) {
       parsed = parseUpdateVarargs(
         this._dataReader,
@@ -1080,7 +1092,7 @@ export class DocumentSnapshot<T = PublicDocumentData>
   }
 
   get(
-    fieldPath: string | ExternalFieldPath,
+    fieldPath: string | PublicFieldPath,
     options: PublicSnapshotOptions = {}
   ): unknown {
     if (this._document) {
@@ -1556,7 +1568,7 @@ export class Query<T = PublicDocumentData> implements PublicQuery<T> {
   }
 
   where(
-    field: string | ExternalFieldPath,
+    field: string | PublicFieldPath,
     opStr: PublicWhereFilterOp,
     value: unknown
   ): PublicQuery<T> {
@@ -1578,7 +1590,7 @@ export class Query<T = PublicDocumentData> implements PublicQuery<T> {
   }
 
   orderBy(
-    field: string | ExternalFieldPath,
+    field: string | PublicFieldPath,
     directionStr?: PublicOrderByDirection
   ): PublicQuery<T> {
     let direction: Direction;

packages/firestore/src/api/field_path.ts

@@ -17,52 +17,28 @@
 
 import { FieldPath as PublicFieldPath } from '@firebase/firestore-types';
 
+import { FieldPath as ExpFieldPath } from '../../lite/src/api/field_path';
 import { FieldPath as InternalFieldPath } from '../model/path';
-import { Code, FirestoreError } from '../util/error';
+import { Compat } from '../compat/compat';
 
 // 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
 // underscore to discourage their use.
 
-/**
- * A field class base class that is shared by the lite, full and legacy SDK,
- * which supports shared code that deals with FieldPaths.
- */
-// Use underscore prefix to hide this class from our Public API.
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export abstract class _BaseFieldPath {
-  /** Internal representation of a Firestore field path. */
-  readonly _internalPath: InternalFieldPath;
-
-  constructor(fieldNames: string[]) {
-    for (let i = 0; i < fieldNames.length; ++i) {
-      if (fieldNames[i].length === 0) {
-        throw new FirestoreError(
-          Code.INVALID_ARGUMENT,
-          `Invalid field name at argument $(i + 1). ` +
-            'Field names must not be empty.'
-        );
-      }
-    }
-
-    this._internalPath = new InternalFieldPath(fieldNames);
-  }
-}
-
 /**
  * A `FieldPath` refers to a field in a document. The path may consist of a
  * single field name (referring to a top-level field in the document), or a list
  * of field names (referring to a nested field in the document).
  */
-export class FieldPath extends _BaseFieldPath implements PublicFieldPath {
+export class FieldPath extends Compat<ExpFieldPath> implements PublicFieldPath {
   /**
    * Creates a FieldPath from the provided field names. If more than one field
    * name is provided, the path will point to a nested field in a document.
    *
    * @param fieldNames A list of field names.
    */
   constructor(...fieldNames: string[]) {
-    super(fieldNames);
+    super(new ExpFieldPath(...fieldNames));
   }
 
   static documentId(): FieldPath {
@@ -76,37 +52,12 @@ export class FieldPath extends _BaseFieldPath implements PublicFieldPath {
   }
 
   isEqual(other: PublicFieldPath): boolean {
-    if (!(other instanceof FieldPath)) {
+    if (other instanceof Compat) {
+      other = other._delegate;
+    }
+    if (!(other instanceof ExpFieldPath)) {
       return false;
     }
-    return this._internalPath.isEqual(other._internalPath);
-  }
-}
-
-/**
- * Matches any characters in a field path string that are reserved.
- */
-const RESERVED = new RegExp('[~\\*/\\[\\]]');
-
-/**
- * Parses a field path string into a FieldPath, treating dots as separators.
- */
-export function fromDotSeparatedString(path: string): FieldPath {
-  const found = path.search(RESERVED);
-  if (found >= 0) {
-    throw new FirestoreError(
-      Code.INVALID_ARGUMENT,
-      `Invalid field path (${path}). Paths must not contain ` +
-        `'~', '*', '/', '[', or ']'`
-    );
-  }
-  try {
-    return new FieldPath(...path.split('.'));
-  } catch (e) {
-    throw new FirestoreError(
-      Code.INVALID_ARGUMENT,
-      `Invalid field path (${path}). Paths must not be empty, ` +
-        `begin with '.', end with '.', or contain '..'`
-    );
+    return this._delegate._internalPath.isEqual(other._internalPath);
   }
 }