feat: serialize prerequisites in EvaluationResult

Author: cwaldren-ld

libs/client-sdk/src/data_sources/data_source_event_handler.cpp

@@ -1,9 +1,9 @@
 #include "data_source_event_handler.hpp"
 
+#include <launchdarkly/detail/serialization/json_primitives.hpp>
 #include <launchdarkly/encoding/base_64.hpp>
 #include <launchdarkly/serialization/json_evaluation_result.hpp>
 #include <launchdarkly/serialization/json_item_descriptor.hpp>
-#include <launchdarkly/detail/serialization/json_primitives.hpp>
 #include <launchdarkly/serialization/value_mapping.hpp>
 
 #include <boost/core/ignore_unused.hpp>
@@ -12,7 +12,7 @@
 
 #include <utility>
 
-#include "tl/expected.hpp"
+#include <tl/expected.hpp>
 
 namespace launchdarkly::client_side::data_sources {
 
@@ -76,10 +76,10 @@ DataSourceEventHandler::DataSourceEventHandler(
     IDataSourceUpdateSink& handler,
     Logger const& logger,
     DataSourceStatusManager& status_manager)
-    : context_(context),
-      handler_(handler),
+    : handler_(handler),
       logger_(logger),
-      status_manager_(status_manager) {}
+      status_manager_(status_manager),
+      context_(context) {}
 
 DataSourceEventHandler::MessageStatus DataSourceEventHandler::HandleMessage(
     std::string const& type,

libs/common/include/launchdarkly/data/evaluation_result.hpp

@@ -48,7 +48,8 @@ class EvaluationResult {
      */
     [[nodiscard]] EvaluationDetailInternal const& Detail() const;
 
-    [[nodiscard]] std::vector<std::string> const& Prerequisites() const;
+    [[nodiscard]] std::optional<std::vector<std::string>> const& Prerequisites()
+        const;
 
     EvaluationResult(
         uint64_t version,
@@ -59,6 +60,16 @@ class EvaluationResult {
             debug_events_until_date,
         EvaluationDetailInternal detail);
 
+    EvaluationResult(
+        uint64_t version,
+        std::optional<uint64_t> flag_version,
+        bool track_events,
+        bool track_reason,
+        std::optional<std::chrono::time_point<std::chrono::system_clock>>
+            debug_events_until_date,
+        EvaluationDetailInternal detail,
+        std::optional<std::vector<std::string>> prerequisites);
+
    private:
     uint64_t version_;
     std::optional<uint64_t> flag_version_;
@@ -67,7 +78,7 @@ class EvaluationResult {
     std::optional<std::chrono::time_point<std::chrono::system_clock>>
         debug_events_until_date_;
     EvaluationDetailInternal detail_;
-    std::vector<std::string> prerequisites_;
+    std::optional<std::vector<std::string>> prerequisites_;
 };
 
 std::ostream& operator<<(std::ostream& out, EvaluationResult const& result);

libs/common/src/data/evaluation_result.cpp

@@ -31,7 +31,8 @@ EvaluationDetailInternal const& EvaluationResult::Detail() const {
     return detail_;
 }
 
-std::vector<std::string> const& EvaluationResult::Prerequisites() const {
+std::optional<std::vector<std::string>> const& EvaluationResult::Prerequisites()
+    const {
     return prerequisites_;
 }
 
@@ -43,12 +44,30 @@ EvaluationResult::EvaluationResult(
     std::optional<std::chrono::time_point<std::chrono::system_clock>>
         debug_events_until_date,
     EvaluationDetailInternal detail)
+    : EvaluationResult(version,
+                       flag_version,
+                       track_events,
+                       track_reason,
+                       debug_events_until_date,
+                       std::move(detail),
+                       {}) {}
+
+EvaluationResult::EvaluationResult(
+    uint64_t version,
+    std::optional<uint64_t> flag_version,
+    bool track_events,
+    bool track_reason,
+    std::optional<std::chrono::time_point<std::chrono::system_clock>>
+        debug_events_until_date,
+    EvaluationDetailInternal detail,
+    std::optional<std::vector<std::string>> prerequisites)
     : version_(version),
       flag_version_(flag_version),
       track_events_(track_events),
       track_reason_(track_reason),
       debug_events_until_date_(debug_events_until_date),
-      detail_(std::move(detail)) {}
+      detail_(std::move(detail)),
+      prerequisites_(std::move(prerequisites)) {}
 
 std::ostream& operator<<(std::ostream& out, EvaluationResult const& result) {
     out << "{";
@@ -63,11 +82,11 @@ std::ostream& operator<<(std::ostream& out, EvaluationResult const& result) {
             << std::put_time(std::gmtime(&as_time_t), "%Y-%m-%d %H:%M:%S");
     }
     out << " detail: " << result.Detail();
-    if (result.Prerequisites().size() > 0) {
+    if (auto const prerequisites = result.Prerequisites()) {
         out << " prerequisites: [";
-        for (std::size_t i = 0; i < result.Prerequisites().size(); i++) {
-            out << result.Prerequisites()[i]
-                << (i == result.Prerequisites().size() - 1 ? "" : ", ");
+        for (std::size_t i = 0; i < prerequisites->size(); i++) {
+            out << prerequisites->at(i)
+                << (i == prerequisites->size() - 1 ? "" : ", ");
         }
         out << "]";
     }

libs/internal/include/launchdarkly/serialization/value_mapping.hpp

@@ -136,6 +136,11 @@ template <>
 std::optional<uint64_t> ValueAsOpt(boost::json::object::const_iterator iterator,
                                    boost::json::object::const_iterator end);
 
+template <>
+std::optional<std::vector<std::string>> ValueAsOpt(
+    boost::json::object::const_iterator iterator,
+    boost::json::object::const_iterator end);
+
 template <>
 std::optional<std::string> ValueAsOpt(
     boost::json::object::const_iterator iterator,

libs/internal/src/serialization/json_evaluation_result.cpp

@@ -1,7 +1,7 @@
 #include <launchdarkly/detail/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_value.hpp>
 #include <launchdarkly/serialization/json_evaluation_reason.hpp>
 #include <launchdarkly/serialization/json_evaluation_result.hpp>
-#include <launchdarkly/detail/serialization/json_value.hpp>
 #include <launchdarkly/serialization/value_mapping.hpp>
 
 #include <boost/core/ignore_unused.hpp>
@@ -50,6 +50,10 @@ tl::expected<std::optional<EvaluationResult>, JsonError> tag_invoke(
                     std::chrono::milliseconds{value}};
             });
 
+    auto* prerequisites_iter = json_obj.find("prerequisites");
+    auto prerequisites = ValueAsOpt<std::vector<std::string>>(
+        prerequisites_iter, json_obj.end());
+
     // Evaluation detail is directly de-serialized inline here.
     // This is because the shape of the evaluation detail is different
     // when deserializing FlagMeta. Primarily `variation` not
@@ -105,7 +109,8 @@ tl::expected<std::optional<EvaluationResult>, JsonError> tag_invoke(
         track_events,
         track_reason,
         debug_events_until_date,
-        EvaluationDetailInternal(std::move(value), variation, std::nullopt)};
+        EvaluationDetailInternal(std::move(value), variation, std::nullopt),
+        prerequisites};
 }
 
 void tag_invoke(boost::json::value_from_tag const& unused,
@@ -133,7 +138,14 @@ void tag_invoke(boost::json::value_from_tag const& unused,
             "debugEventsUntilDate",
             std::chrono::duration_cast<std::chrono::milliseconds>(
                 evaluation_result.DebugEventsUntilDate()->time_since_epoch())
-            .count());
+                .count());
+    }
+
+    if (auto const prerequisites = evaluation_result.Prerequisites()) {
+        if (!prerequisites->empty()) {
+            obj.emplace("prerequisites",
+                        boost::json::value_from(prerequisites.value()));
+        }
     }
 
     auto& detail = evaluation_result.Detail();
@@ -149,4 +161,4 @@ void tag_invoke(boost::json::value_from_tag const& unused,
         obj.emplace("reason", reason_json);
     }
 }
-} // namespace launchdarkly
+}  // namespace launchdarkly