Add FieldValue methods to the Lite SDK

Author: schmidt-sebastian

packages/firestore/lite/index.node.ts

@@ -26,6 +26,15 @@ export {
   getFirestore
 } from './src/api/database';
 
+export {
+  FieldValue,
+  deleteField,
+  increment,
+  arrayRemove,
+  arrayUnion,
+  serverTimestamp
+} from './src/api/field_value';
+
 export function registerFirestore(): void {
   _registerComponent(
     new Component(

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

@@ -0,0 +1,97 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as firestore from '../../';
+
+import { validateAtLeastNumberOfArgs } from '../../../src/util/input_validation';
+import {
+  ArrayRemoveFieldValueImpl,
+  ArrayUnionFieldValueImpl,
+  DeleteFieldValueImpl,
+  NumericIncrementFieldValueImpl,
+  SerializableFieldValue,
+  ServerTimestampFieldValueImpl
+} from '../../../src/api/field_value';
+import { ParseContext } from '../../../src/api/user_data_reader';
+import { FieldTransform } from '../../../src/model/mutation';
+
+/** The public FieldValue class of the lite API. */
+export abstract class FieldValue extends SerializableFieldValue
+  implements firestore.FieldValue {}
+
+/**
+ * A delegate class that allows the FieldValue implementations returned by
+ * deleteField(), serverTimestamp(), arrayUnion(), arrayRemove() and
+ * increment() to be an instance of the lite FieldValue class declared above.
+ *
+ * We don't directly subclass `FieldValue` in the various field value
+ * implementations as the base FieldValue class differs between the lite, full
+ * and legacy SDK.
+ */
+class FieldValueDelegate extends FieldValue implements firestore.FieldValue {
+  readonly _methodName: string;
+
+  constructor(readonly _delegate: SerializableFieldValue) {
+    super();
+    this._methodName = _delegate._methodName;
+  }
+
+  _toFieldTransform(context: ParseContext): FieldTransform | null {
+    return this._delegate._toFieldTransform(context);
+  }
+
+  isEqual(other: firestore.FieldValue): boolean {
+    if (!(other instanceof FieldValueDelegate)) {
+      return false;
+    }
+    return this._delegate.isEqual(other._delegate);
+  }
+}
+
+export function deleteField(): firestore.FieldValue {
+  return new FieldValueDelegate(new DeleteFieldValueImpl('delete'));
+}
+
+export function serverTimestamp(): firestore.FieldValue {
+  return new FieldValueDelegate(
+    new ServerTimestampFieldValueImpl('serverTimestamp')
+  );
+}
+
+export function arrayUnion(...elements: unknown[]): firestore.FieldValue {
+  validateAtLeastNumberOfArgs('arrayUnion()', arguments, 1);
+  // NOTE: We don't actually parse the data until it's used in set() or
+  // update() since we need access to the Firestore instance.
+  return new FieldValueDelegate(
+    new ArrayUnionFieldValueImpl('arrayUnion', elements)
+  );
+}
+
+export function arrayRemove(...elements: unknown[]): firestore.FieldValue {
+  validateAtLeastNumberOfArgs('arrayRemove()', arguments, 1);
+  // NOTE: We don't actually parse the data until it's used in set() or
+  // update() since we need access to the Firestore instance.
+  return new FieldValueDelegate(
+    new ArrayRemoveFieldValueImpl('arrayRemove', elements)
+  );
+}
+
+export function increment(n: number): firestore.FieldValue {
+  return new FieldValueDelegate(
+    new NumericIncrementFieldValueImpl('increment', n)
+  );
+}

packages/firestore/src/api/field_value.ts

@@ -33,23 +33,29 @@ import { ParseContext, parseData, UserDataSource } from './user_data_reader';
 import { debugAssert } from '../util/assert';
 
 /**
- * An opaque base class for FieldValue sentinel objects in our public API,
- * with public static methods for creating said sentinel objects.
+ * An opaque base class for FieldValue sentinel objects in our public API that
+ * is shared between the full, lite and legacy SDK.
  */
-export abstract class FieldValueImpl {
-  protected constructor(readonly _methodName: string) {}
+export abstract class SerializableFieldValue {
+  /** A pointer to the implementing class. */
+  abstract readonly _delegate: SerializableFieldValue;
 
-  abstract toFieldTransform(context: ParseContext): FieldTransform | null;
+  /** The public API endpoint that returns this class. */
+  abstract readonly _methodName: string;
 
-  abstract isEqual(other: FieldValue): boolean;
+  abstract _toFieldTransform(context: ParseContext): FieldTransform | null;
+
+  abstract isEqual(other: SerializableFieldValue): boolean;
 }
 
-export class DeleteFieldValueImpl extends FieldValueImpl {
-  constructor() {
-    super('FieldValue.delete');
+export class DeleteFieldValueImpl extends SerializableFieldValue {
+  _delegate = this;
+
+  constructor(readonly _methodName: string) {
+    super();
   }
 
-  toFieldTransform(context: ParseContext): null {
+  _toFieldTransform(context: ParseContext): null {
     if (context.dataSource === UserDataSource.MergeSet) {
       // No transform to add for a delete, but we need to add it to our
       // fieldMask so it gets deleted.
@@ -79,12 +85,14 @@ export class DeleteFieldValueImpl extends FieldValueImpl {
   }
 }
 
-export class ServerTimestampFieldValueImpl extends FieldValueImpl {
-  constructor() {
-    super('FieldValue.serverTimestamp');
+export class ServerTimestampFieldValueImpl extends SerializableFieldValue {
+  _delegate = this;
+
+  constructor(readonly _methodName: string) {
+    super();
   }
 
-  toFieldTransform(context: ParseContext): FieldTransform {
+  _toFieldTransform(context: ParseContext): FieldTransform {
     return new FieldTransform(context.path!, ServerTimestampTransform.instance);
   }
 
@@ -93,12 +101,17 @@ export class ServerTimestampFieldValueImpl extends FieldValueImpl {
   }
 }
 
-export class ArrayUnionFieldValueImpl extends FieldValueImpl {
-  constructor(private readonly _elements: unknown[]) {
-    super('FieldValue.arrayUnion');
+export class ArrayUnionFieldValueImpl extends SerializableFieldValue {
+  _delegate = this;
+
+  constructor(
+    readonly _methodName: string,
+    private readonly _elements: unknown[]
+  ) {
+    super();
   }
 
-  toFieldTransform(context: ParseContext): FieldTransform {
+  _toFieldTransform(context: ParseContext): FieldTransform {
     // Although array transforms are used with writes, the actual elements
     // being uniomed or removed are not considered writes since they cannot
     // contain any FieldValue sentinels, etc.
@@ -125,12 +138,14 @@ export class ArrayUnionFieldValueImpl extends FieldValueImpl {
   }
 }
 
-export class ArrayRemoveFieldValueImpl extends FieldValueImpl {
-  constructor(readonly _elements: unknown[]) {
-    super('FieldValue.arrayRemove');
+export class ArrayRemoveFieldValueImpl extends SerializableFieldValue {
+  _delegate = this;
+
+  constructor(readonly _methodName: string, readonly _elements: unknown[]) {
+    super();
   }
 
-  toFieldTransform(context: ParseContext): FieldTransform {
+  _toFieldTransform(context: ParseContext): FieldTransform {
     // Although array transforms are used with writes, the actual elements
     // being unioned or removed are not considered writes since they cannot
     // contain any FieldValue sentinels, etc.
@@ -157,12 +172,14 @@ export class ArrayRemoveFieldValueImpl extends FieldValueImpl {
   }
 }
 
-export class NumericIncrementFieldValueImpl extends FieldValueImpl {
-  constructor(private readonly _operand: number) {
-    super('FieldValue.increment');
+export class NumericIncrementFieldValueImpl extends SerializableFieldValue {
+  _delegate = this;
+
+  constructor(readonly _methodName: string, private readonly _operand: number) {
+    super();
   }
 
-  toFieldTransform(context: ParseContext): FieldTransform {
+  _toFieldTransform(context: ParseContext): FieldTransform {
     const parseContext = new ParseContext(
       {
         dataSource: UserDataSource.Argument,
@@ -186,38 +203,75 @@ export class NumericIncrementFieldValueImpl extends FieldValueImpl {
   }
 }
 
-export class FieldValue implements firestore.FieldValue {
-  static delete(): FieldValueImpl {
+/** The public FieldValue class of the lite API. */
+export abstract class FieldValue extends SerializableFieldValue
+  implements firestore.FieldValue {
+  static delete(): firestore.FieldValue {
     validateNoArgs('FieldValue.delete', arguments);
-    return new DeleteFieldValueImpl();
+    return new FieldValueDelegate(
+      new DeleteFieldValueImpl('FieldValue.delete')
+    );
   }
 
-  static serverTimestamp(): FieldValueImpl {
+  static serverTimestamp(): firestore.FieldValue {
     validateNoArgs('FieldValue.serverTimestamp', arguments);
-    return new ServerTimestampFieldValueImpl();
+    return new FieldValueDelegate(
+      new ServerTimestampFieldValueImpl('FieldValue.serverTimestamp')
+    );
   }
 
-  static arrayUnion(...elements: unknown[]): FieldValueImpl {
+  static arrayUnion(...elements: unknown[]): firestore.FieldValue {
     validateAtLeastNumberOfArgs('FieldValue.arrayUnion', arguments, 1);
     // NOTE: We don't actually parse the data until it's used in set() or
     // update() since we need access to the Firestore instance.
-    return new ArrayUnionFieldValueImpl(elements);
+    return new FieldValueDelegate(
+      new ArrayUnionFieldValueImpl('FieldValue.arrayUnion', elements)
+    );
   }
 
-  static arrayRemove(...elements: unknown[]): FieldValueImpl {
+  static arrayRemove(...elements: unknown[]): firestore.FieldValue {
     validateAtLeastNumberOfArgs('FieldValue.arrayRemove', arguments, 1);
     // NOTE: We don't actually parse the data until it's used in set() or
     // update() since we need access to the Firestore instance.
-    return new ArrayRemoveFieldValueImpl(elements);
+    return new FieldValueDelegate(
+      new ArrayRemoveFieldValueImpl('FieldValue.arrayRemove', elements)
+    );
   }
 
-  static increment(n: number): FieldValueImpl {
+  static increment(n: number): firestore.FieldValue {
     validateArgType('FieldValue.increment', 'number', 1, n);
     validateExactNumberOfArgs('FieldValue.increment', arguments, 1);
-    return new NumericIncrementFieldValueImpl(n);
+    return new FieldValueDelegate(
+      new NumericIncrementFieldValueImpl('FieldValue.increment', n)
+    );
   }
+}
 
-  isEqual(other: FieldValue): boolean {
-    return this === other;
+/**
+ * A delegate class that allows the FieldValue implementations returned by
+ * deleteField(), serverTimestamp(), arrayUnion(), arrayRemove() and
+ * increment() to be an instance of the legacy FieldValue class declared above.
+ *
+ * We don't directly subclass `FieldValue` in the various field value
+ * implementations as the base FieldValue class differs between the lite, full
+ * and legacy SDK.
+ */
+class FieldValueDelegate extends FieldValue implements firestore.FieldValue {
+  readonly _methodName: string;
+
+  constructor(readonly _delegate: SerializableFieldValue) {
+    super();
+    this._methodName = _delegate._methodName;
+  }
+
+  _toFieldTransform(context: ParseContext): FieldTransform | null {
+    return this._delegate._toFieldTransform(context);
+  }
+
+  isEqual(other: firestore.FieldValue): boolean {
+    if (!(other instanceof FieldValueDelegate)) {
+      return false;
+    }
+    return this._delegate.isEqual(other._delegate);
   }
 }

packages/firestore/src/api/user_data_reader.ts

@@ -43,7 +43,7 @@ import {
   FieldPath as ExternalFieldPath,
   fromDotSeparatedString
 } from './field_path';
-import { DeleteFieldValueImpl, FieldValueImpl } from './field_value';
+import { DeleteFieldValueImpl, SerializableFieldValue } from './field_value';
 import { GeoPoint } from './geo_point';
 import { PlatformSupport } from '../platform/platform';
 
@@ -383,7 +383,10 @@ export class UserDataReader {
       const path = fieldPathFromDotSeparatedString(methodName, key);
 
       const childContext = context.childContextForFieldPath(path);
-      if (value instanceof DeleteFieldValueImpl) {
+      if (
+        value instanceof SerializableFieldValue &&
+        value._delegate instanceof DeleteFieldValueImpl
+      ) {
         // Add it to the field mask, but don't add anything to updateData.
         fieldMaskPaths.push(path);
       } else {
@@ -442,7 +445,10 @@ export class UserDataReader {
         const path = keys[i];
         const value = values[i];
         const childContext = context.childContextForFieldPath(path);
-        if (value instanceof DeleteFieldValueImpl) {
+        if (
+          value instanceof SerializableFieldValue &&
+          value._delegate instanceof DeleteFieldValueImpl
+        ) {
           // Add it to the field mask, but don't add anything to updateData.
           fieldMaskPaths.push(path);
         } else {
@@ -523,7 +529,7 @@ export function parseData(
   if (looksLikeJsonObject(input)) {
     validatePlainObject('Unsupported field value:', context, input);
     return parseObject(input, context);
-  } else if (input instanceof FieldValueImpl) {
+  } else if (input instanceof SerializableFieldValue) {
     // FieldValues usually parse into transforms (except FieldValue.delete())
     // in which case we do not want to include this field in our parsed data
     // (as doing so will overwrite the field directly prior to the transform
@@ -606,7 +612,7 @@ function parseArray(array: unknown[], context: ParseContext): api.Value {
  * context.fieldTransforms.
  */
 function parseSentinelFieldValue(
-  value: FieldValueImpl,
+  value: SerializableFieldValue,
   context: ParseContext
 ): void {
   // Sentinels are only supported with writes, and not within arrays.
@@ -621,7 +627,7 @@ function parseSentinelFieldValue(
     );
   }
 
-  const fieldTransform = value.toFieldTransform(context);
+  const fieldTransform = value._toFieldTransform(context);
   if (fieldTransform) {
     context.fieldTransforms.push(fieldTransform);
   }
@@ -707,7 +713,7 @@ function looksLikeJsonObject(input: unknown): boolean {
     !(input instanceof GeoPoint) &&
     !(input instanceof Blob) &&
     !(input instanceof DocumentKeyReference) &&
-    !(input instanceof FieldValueImpl)
+    !(input instanceof SerializableFieldValue)
   );
 }
 

packages/firestore/test/util/helpers.ts

@@ -241,7 +241,7 @@ export function patchMutation(
   // Replace '<DELETE>' from JSON with FieldValue
   forEach(json, (k, v) => {
     if (v === '<DELETE>') {
-      json[k] = new DeleteFieldValueImpl();
+      json[k] = new DeleteFieldValueImpl('FieldValue.delete');
     }
   });
   const parsed = testUserDataReader().parseUpdateData('patchMutation', json);