Protobuf-backed Mutations

Firestore/Source/API/FIRQuery.mm

@@ -50,8 +50,8 @@
 #include "Firestore/core/src/model/resource_path.h"
 #include "Firestore/core/src/model/server_timestamp_util.h"
 #include "Firestore/core/src/model/value_util.h"
-#include "Firestore/core/src/nanopb/nanopb_util.h"
 #include "Firestore/core/src/nanopb/message.h"
+#include "Firestore/core/src/nanopb/nanopb_util.h"
 #include "Firestore/core/src/util/error_apple.h"
 #include "Firestore/core/src/util/exception.h"
 #include "Firestore/core/src/util/hard_assert.h"
@@ -632,7 +632,6 @@ - (Bound)boundFromFieldValues:(NSArray<id> *)fieldValues isBefore:(BOOL)isBefore
       fieldValue.release();
       components.values[idx] = *fieldValue;
     }
-
   }
 
   return Bound(components, isBefore);

Firestore/core/src/core/user_data.cc

@@ -72,6 +72,7 @@ void ParseAccumulator::AddToFieldMask(FieldPath field_path) {
 
 void ParseAccumulator::AddToFieldTransforms(
     FieldPath field_path, TransformOperation transform_operation) {
+  // TODO(mrschmidt): Validate that the paths are unique
   field_transforms_.emplace_back(std::move(field_path),
                                  std::move(transform_operation));
 }

Firestore/core/src/model/delete_mutation.cc

@@ -19,10 +19,8 @@
 #include <cstdlib>
 #include <utility>
 
-#include "Firestore/core/src/model/document.h"
 #include "Firestore/core/src/model/field_path.h"
-#include "Firestore/core/src/model/field_value.h"
-#include "Firestore/core/src/model/no_document.h"
+#include "Firestore/core/src/model/mutable_document.h"
 #include "Firestore/core/src/util/hard_assert.h"
 
 namespace firebase {
@@ -41,12 +39,11 @@ DeleteMutation::DeleteMutation(const Mutation& mutation) : Mutation(mutation) {
   HARD_ASSERT(type() == Type::Delete);
 }
 
-MaybeDocument DeleteMutation::Rep::ApplyToRemoteDocument(
-    const absl::optional<MaybeDocument>& maybe_doc,
-    const MutationResult& mutation_result) const {
-  VerifyKeyMatches(maybe_doc);
+void DeleteMutation::Rep::ApplyToRemoteDocument(
+    MutableDocument& document, const MutationResult& mutation_result) const {
+  VerifyKeyMatches(document);
 
-  HARD_ASSERT(mutation_result.transform_results() == absl::nullopt,
+  HARD_ASSERT(mutation_result.transform_results().values_count == 0,
               "Transform results received by DeleteMutation.");
 
   // Unlike ApplyToLocalView, if we're applying a mutation to a remote document
@@ -55,20 +52,17 @@ MaybeDocument DeleteMutation::Rep::ApplyToRemoteDocument(
   // We store the deleted document at the commit version of the delete. Any
   // document version that the server sends us before the delete was applied is
   // discarded.
-  return NoDocument(key(), mutation_result.version(),
-                    /* has_committed_mutations= */ true);
+  document.ConvertToNoDocument(mutation_result.version())
+      .SetHasCommittedMutations();
 }
 
-absl::optional<MaybeDocument> DeleteMutation::Rep::ApplyToLocalView(
-    const absl::optional<MaybeDocument>& maybe_doc, const Timestamp&) const {
-  VerifyKeyMatches(maybe_doc);
+void DeleteMutation::Rep::ApplyToLocalView(MutableDocument& document,
+                                           const Timestamp&) const {
+  VerifyKeyMatches(document);
 
-  if (!precondition().IsValidFor(maybe_doc)) {
-    return maybe_doc;
+  if (precondition().IsValidFor(document)) {
+    document.ConvertToNoDocument(SnapshotVersion::None());
   }
-
-  return NoDocument(key(), SnapshotVersion::None(),
-                    /* has_committed_mutations= */ false);
 }
 
 std::string DeleteMutation::Rep::ToString() const {

Firestore/core/src/model/delete_mutation.h

@@ -52,13 +52,12 @@ class DeleteMutation : public Mutation {
       return Type::Delete;
     }
 
-    MaybeDocument ApplyToRemoteDocument(
-        const absl::optional<MaybeDocument>& maybe_doc,
+    void ApplyToRemoteDocument(
+        MutableDocument& document,
         const MutationResult& mutation_result) const override;
 
-    absl::optional<MaybeDocument> ApplyToLocalView(
-        const absl::optional<MaybeDocument>& maybe_doc,
-        const Timestamp&) const override;
+    void ApplyToLocalView(MutableDocument& document,
+                          const Timestamp&) const override;
 
     // Does not override Equals or Hash; Mutation's versions are sufficient.
 

Firestore/core/src/model/mutation.cc

@@ -23,8 +23,8 @@
 
 #include "Firestore/core/src/model/document.h"
 #include "Firestore/core/src/model/field_path.h"
-#include "Firestore/core/src/model/field_value.h"
-#include "Firestore/core/src/model/no_document.h"
+#include "Firestore/core/src/model/mutable_document.h"
+#include "Firestore/core/src/model/object_value.h"
 #include "Firestore/core/src/util/hard_assert.h"
 #include "Firestore/core/src/util/to_string.h"
 #include "absl/strings/str_cat.h"
@@ -48,39 +48,29 @@ bool operator==(const MutationResult& lhs, const MutationResult& rhs) {
          lhs.transform_results() == rhs.transform_results();
 }
 
-MaybeDocument Mutation::ApplyToRemoteDocument(
-    const absl::optional<MaybeDocument>& maybe_doc,
-    const MutationResult& mutation_result) const {
-  return rep().ApplyToRemoteDocument(maybe_doc, mutation_result);
+void Mutation::ApplyToRemoteDocument(
+    MutableDocument& document, const MutationResult& mutation_result) const {
+  return rep().ApplyToRemoteDocument(document, mutation_result);
 }
 
-absl::optional<MaybeDocument> Mutation::ApplyToLocalView(
-    const absl::optional<MaybeDocument>& maybe_doc,
-    const Timestamp& local_write_time) const {
-  return rep().ApplyToLocalView(maybe_doc, local_write_time);
+void Mutation::ApplyToLocalView(MutableDocument& document,
+                                const Timestamp& local_write_time) const {
+  return rep().ApplyToLocalView(document, local_write_time);
 }
 
 absl::optional<ObjectValue> Mutation::Rep::ExtractTransformBaseValue(
-    const absl::optional<MaybeDocument>& maybe_doc) const {
+    const Document& document) const {
   absl::optional<ObjectValue> base_object;
-  absl::optional<Document> document;
-  if (maybe_doc && maybe_doc->is_document()) {
-    document = Document(*maybe_doc);
-  }
 
   for (const FieldTransform& transform : field_transforms_) {
-    absl::optional<FieldValue> existing_value;
-    if (document) {
-      existing_value = document->field(transform.path());
-    }
-
-    absl::optional<FieldValue> coerced_value =
+    auto existing_value = document->field(transform.path());
+    auto coerced_value =
         transform.transformation().ComputeBaseValue(existing_value);
     if (coerced_value) {
       if (!base_object) {
-        base_object = ObjectValue::Empty();
+        base_object = ObjectValue{};
       }
-      base_object = base_object->Set(transform.path(), *coerced_value);
+      base_object->Set(transform.path(), *coerced_value);
     }
   }
 
@@ -107,79 +97,54 @@ bool Mutation::Rep::Equals(const Mutation::Rep& other) const {
          field_transforms_ == other.field_transforms_;
 }
 
-void Mutation::Rep::VerifyKeyMatches(
-    const absl::optional<MaybeDocument>& maybe_doc) const {
-  if (maybe_doc) {
-    HARD_ASSERT(maybe_doc->key() == key(),
-                "Can only apply a mutation to a document with the same key");
-  }
+void Mutation::Rep::VerifyKeyMatches(const MutableDocument& document) const {
+  HARD_ASSERT(document.key() == key(),
+              "Can only apply a mutation to a document with the same key");
 }
 
 SnapshotVersion Mutation::Rep::GetPostMutationVersion(
-    const absl::optional<MaybeDocument>& maybe_doc) {
-  if (maybe_doc && maybe_doc->type() == MaybeDocument::Type::Document) {
-    return maybe_doc->version();
+    const MutableDocument& document) {
+  if (document.is_found_document()) {
+    return document.version();
   } else {
     return SnapshotVersion::None();
   }
 }
 
-std::vector<FieldValue> Mutation::Rep::ServerTransformResults(
-    const absl::optional<MaybeDocument>& maybe_doc,
-    const std::vector<FieldValue>& server_transform_results) const {
-  HARD_ASSERT(field_transforms_.size() == server_transform_results.size(),
+TransformMap Mutation::Rep::ServerTransformResults(
+    const ObjectValue& previous_data,
+    const google_firestore_v1_ArrayValue& server_transform_results) const {
+  TransformMap transform_results;
+  HARD_ASSERT(field_transforms_.size() == server_transform_results.values_count,
               "server transform result size (%s) should match field transforms "
               "size (%s)",
-              server_transform_results.size(), field_transforms_.size());
+              server_transform_results.values_count, field_transforms_.size());
 
-  std::vector<FieldValue> transform_results;
-  for (size_t i = 0; i < server_transform_results.size(); i++) {
+  for (size_t i = 0; i < server_transform_results.values_count; ++i) {
     const FieldTransform& field_transform = field_transforms_[i];
     const TransformOperation& transform = field_transform.transformation();
-
-    absl::optional<model::FieldValue> previous_value;
-    if (maybe_doc && maybe_doc->is_document()) {
-      previous_value = Document(*maybe_doc).field(field_transform.path());
-    }
-
-    transform_results.push_back(transform.ApplyToRemoteDocument(
-        previous_value, server_transform_results[i]));
+    const auto& previous_value = previous_data.Get(field_transform.path());
+    google_firestore_v1_Value transformed_value =
+        transform.ApplyToRemoteDocument(previous_value,
+                                        server_transform_results.values[i]);
+    transform_results[field_transform.path()] = transformed_value;
   }
   return transform_results;
 }
 
-std::vector<FieldValue> Mutation::Rep::LocalTransformResults(
-    const absl::optional<MaybeDocument>& maybe_doc,
-    const Timestamp& local_write_time) const {
-  std::vector<FieldValue> transform_results;
+TransformMap Mutation::Rep::LocalTransformResults(
+    const ObjectValue& previous_data, const Timestamp& local_write_time) const {
+  TransformMap transform_results;
   for (const FieldTransform& field_transform : field_transforms_) {
     const TransformOperation& transform = field_transform.transformation();
-
-    absl::optional<FieldValue> previous_value;
-    if (maybe_doc && maybe_doc->is_document()) {
-      previous_value = Document(*maybe_doc).field(field_transform.path());
-    }
-
-    transform_results.push_back(
-        transform.ApplyToLocalView(previous_value, local_write_time));
+    const auto& previous_value = previous_data.Get(field_transform.path());
+    google_firestore_v1_Value transformed_value =
+        transform.ApplyToLocalView(*previous_value, local_write_time);
+    transform_results[field_transform.path()] = transformed_value;
   }
   return transform_results;
 }
 
-ObjectValue Mutation::Rep::TransformObject(
-    ObjectValue object_value,
-    const std::vector<FieldValue>& transform_results) const {
-  HARD_ASSERT(transform_results.size() == field_transforms_.size(),
-              "Transform results size mismatch.");
-
-  for (size_t i = 0; i < field_transforms_.size(); i++) {
-    const FieldTransform& field_transform = field_transforms_[i];
-    const FieldPath& field_path = field_transform.path();
-    object_value = object_value.Set(field_path, transform_results[i]);
-  }
-  return object_value;
-}
-
 bool operator==(const Mutation& lhs, const Mutation& rhs) {
   return lhs.rep_ == nullptr
              ? rhs.rep_ == nullptr