Add serializer support for transform mutations (#3642)

* Rename Encode/DecodeDocumentMask to *FieldMask to name after the model type

* Add Serializer::{Encode,Decode}FieldPath

* Avoid passing Serializer* everywhere in serializer_test.

* Add support for serializing TransformMutations

Author: wilhuff

Firestore/core/src/firebase/firestore/remote/serializer.cc

@@ -547,29 +547,28 @@ google_firestore_v1_Write Serializer::EncodeMutation(
       result.which_operation = google_firestore_v1_Write_update_tag;
       auto patch_mutation = static_cast<const PatchMutation&>(mutation);
       result.update = EncodeDocument(mutation.key(), patch_mutation.value());
-      result.update_mask = EncodeDocumentMask(patch_mutation.mask());
+      result.update_mask = EncodeFieldMask(patch_mutation.mask());
       return result;
     }
 
     case Mutation::Type::Transform: {
-      // TODO(rsgowman): Implement transform mutations. Probably like this:
-      abort();
-      /*
-        result.which_operation = google_firestore_v1_Write_transform_tag;
-        auto transform = static_cast<const TransformMutation&>(mutation);
-        result.transform.document = EncodeKey(transform.key());
-
-        size_t count = transform.field_transforms.size();
-        result.transform.field_transforms_count = count;
-        result.transform.field_transforms =
-      MakeArray<google_firestore_v1_DocumentTransform_FieldTransform>(count);
-        int i = 0;
-        for (const FieldTransform& field_transform :
-      transform.field_transforms()) { result.transform.field_transforms[i] =
-      EncodeFieldTransform(field_transform); i++;
-        }
-        return result;
-      */
+      result.which_operation = google_firestore_v1_Write_transform_tag;
+      auto transform = static_cast<const TransformMutation&>(mutation);
+      result.transform.document = EncodeString(EncodeKey(transform.key()));
+
+      pb_size_t count = CheckedSize(transform.field_transforms().size());
+      result.transform.field_transforms_count = count;
+      result.transform.field_transforms =
+          MakeArray<google_firestore_v1_DocumentTransform_FieldTransform>(
+              count);
+      int i = 0;
+      for (const FieldTransform& field_transform :
+           transform.field_transforms()) {
+        result.transform.field_transforms[i] =
+            EncodeFieldTransform(field_transform);
+        i++;
+      }
+      return result;
     }
 
     case Mutation::Type::Delete: {
@@ -592,7 +591,7 @@ Mutation Serializer::DecodeMutation(
       DocumentKey key = DecodeKey(reader, DecodeString(mutation.update.name));
       ObjectValue value = ObjectValue::FromMap(DecodeFields(
           reader, mutation.update.fields_count, mutation.update.fields));
-      FieldMask mask = DecodeDocumentMask(mutation.update_mask);
+      FieldMask mask = DecodeFieldMask(mutation.update_mask);
       if (mask.size() > 0) {
         return PatchMutation(std::move(key), std::move(value), std::move(mask),
                              std::move(precondition));
@@ -606,22 +605,21 @@ Mutation Serializer::DecodeMutation(
       return DeleteMutation(DecodeKey(reader, DecodeString(mutation.delete_)),
                             std::move(precondition));
 
-      // TODO(rsgowman): Implement transform. Probably like this:
-      /*
-      case google_firestore_v1_Write_transform_tag:
-        std::vector<FieldTransform> field_transforms;
-        for (size_t i = 0; i<mutation.transform.field_transforms_count; i++) {
-          field_transforms.push_back(DecodeFieldTransform(mutation.transform.field_transforms[i]));
-        }
+    case google_firestore_v1_Write_transform_tag: {
+      std::vector<FieldTransform> field_transforms;
+      for (size_t i = 0; i < mutation.transform.field_transforms_count; i++) {
+        field_transforms.push_back(DecodeFieldTransform(
+            reader, mutation.transform.field_transforms[i]));
+      }
 
-        HARD_ASSERT(precondition.type() == Precondition::Type::Exists &&
-      precondition.exists(), "Transforms only support precondition \"exists ==
-      true\"");
+      HARD_ASSERT(precondition.type() == Precondition::Type::Exists &&
+                      precondition.exists(),
+                  "Transforms only support precondition \"exists == true\"");
 
-        return absl::make_unique<TransformMutation>(
-              DecodeKey(reader, mutation.transform.document),
-              field_transforms);
-      */
+      return TransformMutation(
+          DecodeKey(reader, MakeStringView(mutation.transform.document)),
+          field_transforms);
+    }
 
     default:
       reader->Fail(StringFormat("Unknown mutation operation: %s",
@@ -687,7 +685,7 @@ Precondition Serializer::DecodePrecondition(
 }
 
 /* static */
-google_firestore_v1_DocumentMask Serializer::EncodeDocumentMask(
+google_firestore_v1_DocumentMask Serializer::EncodeFieldMask(
     const FieldMask& mask) {
   google_firestore_v1_DocumentMask result{};
 
@@ -697,22 +695,114 @@ google_firestore_v1_DocumentMask Serializer::EncodeDocumentMask(
 
   int i = 0;
   for (const FieldPath& path : mask) {
-    result.field_paths[i] = EncodeString(path.CanonicalString());
+    result.field_paths[i] = EncodeFieldPath(path);
     i++;
   }
 
   return result;
 }
 
 /* static */
-model::FieldMask Serializer::DecodeDocumentMask(
+FieldMask Serializer::DecodeFieldMask(
     const google_firestore_v1_DocumentMask& mask) {
   std::set<FieldPath> fields;
   for (size_t i = 0; i < mask.field_paths_count; i++) {
-    auto path = DecodeString(mask.field_paths[i]);
-    fields.insert(FieldPath::FromServerFormat(path));
+    fields.insert(DecodeFieldPath(mask.field_paths[i]));
+  }
+  return FieldMask(std::move(fields));
+}
+
+/* static */
+google_firestore_v1_DocumentTransform_FieldTransform
+Serializer::EncodeFieldTransform(const FieldTransform& field_transform) {
+  using Type = TransformOperation::Type;
+
+  google_firestore_v1_DocumentTransform_FieldTransform proto{};
+  proto.field_path = EncodeFieldPath(field_transform.path());
+
+  switch (field_transform.transformation().type()) {
+    case Type::ServerTimestamp:
+      proto.which_transform_type =
+          google_firestore_v1_DocumentTransform_FieldTransform_set_to_server_value_tag;  // NOLINT
+      proto.set_to_server_value =
+          google_firestore_v1_DocumentTransform_FieldTransform_ServerValue_REQUEST_TIME;  // NOLINT
+      return proto;
+
+    case Type::ArrayUnion:
+      proto.which_transform_type =
+          google_firestore_v1_DocumentTransform_FieldTransform_append_missing_elements_tag;  // NOLINT
+      proto.append_missing_elements = EncodeArray(
+          ArrayTransform(field_transform.transformation()).elements());
+      return proto;
+
+    case Type::ArrayRemove:
+      proto.which_transform_type =
+          google_firestore_v1_DocumentTransform_FieldTransform_remove_all_from_array_tag;  // NOLINT
+      proto.remove_all_from_array = EncodeArray(
+          ArrayTransform(field_transform.transformation()).elements());
+      return proto;
+
+    case Type::Increment: {
+      const auto& increment = static_cast<const NumericIncrementTransform&>(
+          field_transform.transformation());
+      proto.increment = EncodeFieldValue(increment.operand());
+      return proto;
+    }
   }
-  return model::FieldMask(std::move(fields));
+
+  UNREACHABLE();
+}
+
+/* static */ FieldTransform Serializer::DecodeFieldTransform(
+    nanopb::Reader* reader,
+    const google_firestore_v1_DocumentTransform_FieldTransform& proto) {
+  switch (proto.which_transform_type) {
+    case google_firestore_v1_DocumentTransform_FieldTransform_set_to_server_value_tag: {  // NOLINT
+      HARD_ASSERT(
+          proto.set_to_server_value ==
+              google_firestore_v1_DocumentTransform_FieldTransform_ServerValue_REQUEST_TIME,  // NOLINT
+          "Unknown transform setToServerValue: %s", proto.set_to_server_value);
+
+      return FieldTransform(DecodeFieldPath(proto.field_path),
+                            ServerTimestampTransform());
+    }
+
+    case google_firestore_v1_DocumentTransform_FieldTransform_append_missing_elements_tag: {  // NOLINT
+      std::vector<FieldValue> elements =
+          DecodeArray(reader, proto.append_missing_elements);
+      return FieldTransform(DecodeFieldPath(proto.field_path),
+                            ArrayTransform(TransformOperation::Type::ArrayUnion,
+                                           std::move(elements)));
+    }
+
+    case google_firestore_v1_DocumentTransform_FieldTransform_remove_all_from_array_tag: {  // NOLINT
+      std::vector<FieldValue> elements =
+          DecodeArray(reader, proto.remove_all_from_array);
+      return FieldTransform(
+          DecodeFieldPath(proto.field_path),
+          ArrayTransform(TransformOperation::Type::ArrayRemove,
+                         std::move(elements)));
+    }
+
+    case google_firestore_v1_DocumentTransform_FieldTransform_increment_tag: {
+      FieldValue operand = DecodeFieldValue(reader, proto.increment);
+      return FieldTransform(DecodeFieldPath(proto.field_path),
+                            NumericIncrementTransform(std::move(operand)));
+    }
+  }
+
+  UNREACHABLE();
+}
+
+/* static */
+pb_bytes_array_t* Serializer::EncodeFieldPath(const FieldPath& field_path) {
+  return EncodeString(field_path.CanonicalString());
+}
+
+/* static */
+FieldPath Serializer::DecodeFieldPath(const pb_bytes_array_t* field_path) {
+  absl::string_view str = MakeStringView(field_path);
+  return FieldPath::FromServerFormat(str);
 }
 
 google_firestore_v1_Target_QueryTarget Serializer::EncodeQueryTarget(

Firestore/core/src/firebase/firestore/remote/serializer.h

@@ -175,11 +175,20 @@ class Serializer {
       nanopb::Reader* reader,
       const google_firestore_v1_Precondition& precondition);
 
-  static google_firestore_v1_DocumentMask EncodeDocumentMask(
+  static google_firestore_v1_DocumentMask EncodeFieldMask(
       const model::FieldMask& mask);
-  static model::FieldMask DecodeDocumentMask(
+  static model::FieldMask DecodeFieldMask(
       const google_firestore_v1_DocumentMask& mask);
 
+  static google_firestore_v1_DocumentTransform_FieldTransform
+  EncodeFieldTransform(const model::FieldTransform& field_transform);
+  static model::FieldTransform DecodeFieldTransform(
+      nanopb::Reader* reader,
+      const google_firestore_v1_DocumentTransform_FieldTransform& proto);
+
+  static pb_bytes_array_t* EncodeFieldPath(const model::FieldPath& field_path);
+  static model::FieldPath DecodeFieldPath(const pb_bytes_array_t* field_path);
+
   /**
    * @brief Converts the Query into bytes, representing a
    * firestore::v1::Target::QueryTarget.