feat: omit empty items from data model JSON serialization (#309)

The server-side SDK is able to treat missing JSON fields as empty ones
in-memory.

For example, in a segment if `included` was missing then the SDK infers
it's an empty array.

This change makes the SDK write out data using that same logic. If an
in-memory field is conceptually empty, then omit it from the written
data.

This is an optimization, so the only places updated in this commit are top-level flag segment models which are frequently used in unit tests where we'd like to omit missing fields.

Author: cwaldren-ld

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

@@ -166,6 +166,25 @@ void WriteMinimal(boost::json::object& obj,
     }
 }
 
+template <typename T>
+void WriteMinimal(boost::json::object& obj,
+                  std::string const& key,
+                  std::vector<T> const& val) {
+    if (!val.empty()) {
+        obj.emplace(key, boost::json::value_from(val));
+    }
+}
+
+template <typename T>
+void WriteMinimal(boost::json::object& obj,
+                  std::string const& key,
+                  T const& val,
+                  std::function<bool()> const& predicate) {
+    if (predicate()) {
+        obj.emplace(key, boost::json::value_from(val));
+    }
+}
+
 void WriteMinimal(boost::json::object& obj,
                   std::string const& key,  // No copy when not used.
                   bool val);

libs/internal/src/serialization/json_flag.cpp

@@ -349,19 +349,35 @@ void tag_invoke(boost::json::value_from_tag const& unused,
     WriteMinimal(obj, "offVariation", flag.offVariation);
     obj.emplace("key", flag.key);
     obj.emplace("version", flag.version);
-    obj.emplace("variations", boost::json::value_from(flag.variations));
-    obj.emplace("rules", boost::json::value_from(flag.rules));
-    obj.emplace("prerequisites", boost::json::value_from(flag.prerequisites));
-    obj.emplace("fallthrough", boost::json::value_from(flag.fallthrough));
-    obj.emplace("clientSideAvailability",
-                boost::json::value_from(flag.clientSideAvailability));
-    obj.emplace("contextTargets", boost::json::value_from(flag.contextTargets));
+    WriteMinimal(obj, "variations", flag.variations);
+    WriteMinimal(obj, "rules", flag.rules);
+    WriteMinimal(obj, "prerequisites", flag.prerequisites);
+    WriteMinimal(obj, "fallthrough", flag.fallthrough, [&]() {
+        return std::visit(
+            [&](auto&& arg) {
+                using T = std::decay_t<decltype(arg)>;
+                if constexpr (std::is_same_v<T,
+                                             std::optional<Flag::Variation>>) {
+                    return arg.has_value();
+                } else if constexpr (std::is_same_v<T, Flag::Rollout>) {
+                    return true;
+                }
+            },
+            flag.fallthrough);
+    });
+    WriteMinimal(obj, "clientSideAvailability", flag.clientSideAvailability,
+                 [&]() {
+                     return flag.clientSideAvailability.usingEnvironmentId ||
+                            flag.clientSideAvailability.usingMobileKey;
+                 });
+    WriteMinimal(obj, "contextTargets", flag.contextTargets);
 
     std::vector<UserTarget> user_targets;
     for (auto const& target : flag.targets) {
         user_targets.emplace_back(target);
     }
-    obj.emplace("targets", boost::json::value_from(user_targets));
+
+    WriteMinimal(obj, "targets", user_targets);
 }
 
 }  // namespace data_model

libs/internal/src/serialization/json_segment.cpp

@@ -114,13 +114,11 @@ void tag_invoke(boost::json::value_from_tag const& unused,
     WriteMinimal(obj, "unboundedContextKind", segment.unboundedContextKind);
     WriteMinimal(obj, "unbounded", segment.unbounded);
 
-    obj.emplace("rules", boost::json::value_from(segment.rules));
-    obj.emplace("excluded", boost::json::value_from(segment.excluded));
-    obj.emplace("excludedContexts",
-                boost::json::value_from(segment.excludedContexts));
-    obj.emplace("included", boost::json::value_from(segment.included));
-    obj.emplace("includedContexts",
-                boost::json::value_from(segment.includedContexts));
+    WriteMinimal(obj, "rules", segment.rules);
+    WriteMinimal(obj, "excluded", segment.excluded);
+    WriteMinimal(obj, "excludedContexts", segment.excludedContexts);
+    WriteMinimal(obj, "included", segment.included);
+    WriteMinimal(obj, "includedContexts", segment.includedContexts);
 }
 
 void tag_invoke(boost::json::value_from_tag const& unused,

libs/internal/tests/data_model_serialization_test.cpp

@@ -600,9 +600,13 @@ TEST(FlagTests, SerializeAll) {
           },
           24,
           ContextKind("bob")}},  // contextTargets
-        {},                      // rules
-        84,                      // offVariation
-        true,                    // clientSide
+        {data_model::Flag::Rule{{data_model::Clause{data_model::Clause::Op::kIn,
+                                                    {"bob"},
+                                                    false,
+                                                    ContextKind{"user"},
+                                                    "name"}}}},  // rules
+        84,                                                      // offVariation
+        true,                                                    // clientSide
         data_model::Flag::ClientSideAvailability{true, true},
         "4242",  // salt
         true,    // trackEvents
@@ -623,7 +627,7 @@ TEST(FlagTests, SerializeAll) {
             "key":"the-key",
             "version":21,
             "variations":["a","b"],
-            "rules":[],
+            "rules":[{"clauses":[{"op":"in","values":["bob"],"contextKind":"user","attribute":"name"}]}],
             "prerequisites":[{"key":"prereqA","variation":2},
                 {"key":"prereqB","variation":3}],
             "fallthrough":{"variation":42},
@@ -739,12 +743,7 @@ TEST(SegmentTests, SerializeUnbounded) {
         R"({
             "key": "my-segment",
             "version": 87,
-            "included": [],
-            "excluded": [],
-            "includedContexts": [],
-            "excludedContexts": [],
             "salt": "salty",
-            "rules":[],
             "unbounded": true,
             "unboundedContextKind": "company",
             "generation": 12