feat: add LDValue_SerializeJSON C binding

contract-tests/client-contract-tests/src/client_entity.cpp

@@ -1,4 +1,4 @@
 #include "client_entity.hpp"
 
 #include <boost/core/ignore_unused.hpp>
 #include <boost/json.hpp>
@@ -6,8 +6,8 @@
 #include <launchdarkly/context_builder.hpp>
 #include <launchdarkly/serialization/json_context.hpp>
 #include <launchdarkly/serialization/json_evaluation_reason.hpp>
-#include <launchdarkly/serialization/json_primitives.hpp>
-#include <launchdarkly/serialization/json_value.hpp>
+#include <launchdarkly/detail/serialization/json_primitives.hpp>
+#include <launchdarkly/detail/serialization/json_value.hpp>
 #include <launchdarkly/value.hpp>
 
 #include <chrono>
@@ -78,7 +78,7 @@
 
 tl::expected<nlohmann::json, std::string> ContextBuild(
     ContextBuildParams const& params) {
     ContextResponse resp{};
 
     auto builder = launchdarkly::ContextBuilder();
 
@@ -102,7 +102,7 @@
 
 tl::expected<nlohmann::json, std::string> ContextConvert(
     ContextConvertParams const& params) {
     ContextResponse resp{};
 
     boost::system::error_code ec;
     auto json_value = boost::json::parse(params.input, ec);

contract-tests/server-contract-tests/src/client_entity.cpp

@@ -1,4 +1,4 @@
 #include "client_entity.hpp"
 
 #include <boost/core/ignore_unused.hpp>
 #include <boost/json.hpp>
@@ -6,8 +6,8 @@
 #include <launchdarkly/context_builder.hpp>
 #include <launchdarkly/serialization/json_context.hpp>
 #include <launchdarkly/serialization/json_evaluation_reason.hpp>
-#include <launchdarkly/serialization/json_primitives.hpp>
-#include <launchdarkly/serialization/json_value.hpp>
+#include <launchdarkly/detail/serialization/json_primitives.hpp>
+#include <launchdarkly/detail/serialization/json_value.hpp>
 #include <launchdarkly/server_side/serialization/json_all_flags_state.hpp>
 #include <launchdarkly/value.hpp>
 
@@ -16,7 +16,7 @@
 
 using namespace launchdarkly::server_side;
 
 tl::expected<launchdarkly::Context, std::string> ParseContext(
     nlohmann::json value) {
     boost::system::error_code ec;
     auto boost_json_val = boost::json::parse(value.dump(), ec);

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

@@ -1,9 +1,9 @@
 #include "data_source_event_handler.hpp"
 
 #include <launchdarkly/encoding/base_64.hpp>
 #include <launchdarkly/serialization/json_evaluation_result.hpp>
 #include <launchdarkly/serialization/json_item_descriptor.hpp>
-#include <launchdarkly/serialization/json_primitives.hpp>
+#include <launchdarkly/detail/serialization/json_primitives.hpp>
 #include <launchdarkly/serialization/value_mapping.hpp>
 
 #include <boost/core/ignore_unused.hpp>
@@ -43,7 +43,7 @@
         if (result.has_value() && result.value().has_value() &&
             key.has_value()) {
             return DataSourceEventHandler::PatchData{key.value(),
                                                      result.value().value()};
         }
     }
     return tl::unexpected(JsonError::kSchemaFailure);
@@ -72,7 +72,7 @@
 }
 
 DataSourceEventHandler::DataSourceEventHandler(
     Context const& context,
     IDataSourceUpdateSink& handler,
     Logger const& logger,
     DataSourceStatusManager& status_manager)
@@ -82,7 +82,7 @@
       status_manager_(status_manager) {}
 
 DataSourceEventHandler::MessageStatus DataSourceEventHandler::HandleMessage(
     std::string const& type,
     std::string const& data) {
     if (type == "put") {
         boost::system::error_code error_code;

libs/client-sdk/src/flag_manager/flag_persistence.cpp

@@ -1,11 +1,11 @@
 #include "flag_persistence.hpp"
 
 #include <launchdarkly/encoding/base_64.hpp>
 #include <launchdarkly/encoding/sha_256.hpp>
 
 #include <launchdarkly/serialization/json_evaluation_result.hpp>
 #include <launchdarkly/serialization/json_item_descriptor.hpp>
-#include <launchdarkly/serialization/json_primitives.hpp>
+#include <launchdarkly/detail/serialization/json_primitives.hpp>
 
 #include <utility>
 
@@ -14,7 +14,7 @@
 std::string PersistenceEncodeKey(std::string const& input) {
     std::array<unsigned char, SHA256_DIGEST_LENGTH> bytes =
         encoding::Sha256String(input);
     std::string byte_str(reinterpret_cast<char*>(bytes.data()), bytes.size());
     return encoding::Base64UrlEncode(byte_str);
 }
 
@@ -29,13 +29,13 @@
                                  std::shared_ptr<IPersistence> persistence,
                                  Logger& logger,
                                  std::size_t max_cached_contexts,
                                  FlagPersistence::TimeStampsource time_stamper)
     : logger_(logger),
       sink_(sink),
       flag_store_(flag_store),
       persistence_(std::move(persistence)),
       environment_namespace_(MakeEnvironment(global_namespace_, sdk_key)),
       time_stamper_(time_stamper),
       max_cached_contexts_(max_cached_contexts) {}
 
 void FlagPersistence::Init(
@@ -106,7 +106,7 @@
     persistence_->Set(environment_namespace_, index_key_,
                       boost::json::serialize(boost::json::value_from(index)));
 
     boost::json::value v = boost::json::value_from(flag_store_.GetAll());
 
     persistence_->Set(environment_namespace_, context_id,
                       boost::json::serialize(v));

libs/common/include/launchdarkly/bindings/c/value.h

@@ -191,6 +191,21 @@ LDValue_GetString(LDValue val);
 LD_EXPORT(unsigned int)
 LDValue_Count(LDValue val);
 
+/**
+ * Serializes the LDValue to a JSON value. The returning string should be
+ * freed with @ref LDMemory_FreeString.
+ *
+ * Please note that numbers are serialized using scientific notation;
+ * for example the number 17 would be serialized as '1.7E1'.
+ *
+ * @param val Target LDValue. Must not be NULL.
+ * @return A string containing the JSON representation of the LDValue. The
+ * string should be freed with @ref LDMemory_FreeString.
+ *
+ */
+LD_EXPORT(char*)
+LDValue_SerializeJSON(LDValue val);
+
 /**
  * Obtain iterator over an array-type @ref LDValue, otherwise NULL.
  *

libs/internal/include/launchdarkly/serialization/json_primitives.hpp → libs/common/include/launchdarkly/detail/serialization/json_primitives.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <launchdarkly/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
 #include <tl/expected.hpp>
 
 #include <boost/core/ignore_unused.hpp>

libs/internal/include/launchdarkly/serialization/json_value.hpp → libs/common/include/launchdarkly/detail/serialization/json_value.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <launchdarkly/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
 #include <launchdarkly/value.hpp>
 
 #include <boost/json/fwd.hpp>

libs/common/src/CMakeLists.txt

@@ -14,6 +14,7 @@ file(GLOB HEADER_LIST CONFIGURE_DEPENDS
         "${LaunchDarklyCommonSdk_SOURCE_DIR}/include/launchdarkly/data/*.hpp"
         "${LaunchDarklyCommonSdk_SOURCE_DIR}/include/launchdarkly/logging/*.hpp"
         "${LaunchDarklyCommonSdk_SOURCE_DIR}/include/launchdarkly/data_sources/*.hpp"
+        "${LaunchDarklyCommonSdk_SOURCE_DIR}/include/launchdarkly/data_sources/persistence/*.hpp"
 )
 
 # Automatic library: static or dynamic based on user config.
@@ -53,6 +54,8 @@ add_library(${LIBNAME} OBJECT
         bindings/c/memory_routines.cpp
         bindings/c/data_source/error_info.cpp
         bindings/c/logging/log_level.cpp
+        serialization/json_errors.cpp
+        serialization/json_value.cpp
         log_level.cpp
         config/persistence_builder.cpp
         config/logging_builder.cpp

libs/common/src/bindings/c/value.cpp

@@ -7,6 +7,10 @@
 #include <launchdarkly/detail/unreachable.hpp>
 #include <launchdarkly/value.hpp>
 
+#include <launchdarkly/detail/serialization/json_value.hpp>
+
+#include <boost/json.hpp>
+
 using launchdarkly::Value;
 
 #define AS_VALUE(x) reinterpret_cast<Value*>(x)
@@ -95,6 +99,18 @@ LD_EXPORT(unsigned int) LDValue_Count(LDValue val) {
     }
 }
 
+LD_EXPORT(char*) LDValue_SerializeJSON(LDValue val) {
+    LD_ASSERT_NOT_NULL(val);
+
+    auto const value = AS_VALUE(val);
+
+    auto boost_value = boost::json::value_from(*value);
+
+    std::string json = boost::json::serialize(boost_value);
+
+    return strdup(json.c_str());
+}
+
 LD_EXPORT(LDValue_ArrayIter) LDValue_ArrayIter_New(LDValue val) {
     LD_ASSERT_NOT_NULL(val);
 

libs/internal/src/serialization/json_errors.cpp → libs/common/src/serialization/json_errors.cpp

@@ -1,4 +1,4 @@
-#include <launchdarkly/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
 
 namespace launchdarkly {
 

libs/internal/src/serialization/json_value.cpp → libs/common/src/serialization/json_value.cpp

@@ -1,7 +1,8 @@
-#include <boost/json.hpp>
 #include <launchdarkly/detail/unreachable.hpp>
-#include <launchdarkly/serialization/json_value.hpp>
-#include <launchdarkly/serialization/value_mapping.hpp>
+#include <launchdarkly/detail/serialization/json_primitives.hpp>
+#include <launchdarkly/detail/serialization/json_value.hpp>
+
+#include <boost/json.hpp>
 
 namespace launchdarkly {
 // NOLINTBEGIN modernize-return-braced-init-list

libs/common/tests/bindings/value_test.cpp

@@ -4,6 +4,8 @@
 #include "launchdarkly/bindings/c/object_builder.h"
 #include "launchdarkly/bindings/c/value.h"
 
+#include "launchdarkly/bindings/c/memory_routines.h"
+
 TEST(ValueCBindingTests, CanCreateNull) {
     auto* ptr = LDValue_NewNull();
 
@@ -168,3 +170,56 @@ TEST(ValueCBindingTests, CanCreateObject) {
 
     LDValue_Free(val_ptr);
 }
+
+// Helper to serialize an LDValue, automatically converts to
+// std::string and frees the result using LDMemory_FreeString.
+std::string serialize(LDValue const val) {
+    char* serialized = LDValue_SerializeJSON(val);
+    std::string result(serialized);
+    LDMemory_FreeString(serialized);
+    return result;
+}
+
+TEST(ValueCBindingTests, CanSerializeToJSON) {
+    auto* null_val = LDValue_NewNull();
+    auto* bool_val_true = LDValue_NewBool(true);
+    auto* bool_val_false = LDValue_NewBool(false);
+
+    auto* num_val = LDValue_NewNumber(17);
+    auto* float_val = LDValue_NewNumber(3.141);
+    auto* str_val = LDValue_NewString("Potato");
+
+    EXPECT_EQ("null", serialize(null_val));
+    EXPECT_EQ("true", serialize(bool_val_true));
+    EXPECT_EQ("false", serialize(bool_val_false));
+    EXPECT_EQ("1.7E1", serialize(num_val));
+    EXPECT_EQ("3.141E0", serialize(float_val));
+    EXPECT_EQ("\"Potato\"", serialize(str_val));
+
+    // Object builder is going to take care of freeing all the primitives
+    // (except for bool_val_false.)
+    auto* object_builder = LDObjectBuilder_New();
+    LDObjectBuilder_Add(object_builder, "null", null_val);
+    LDObjectBuilder_Add(object_builder, "bool", bool_val_true);
+    LDObjectBuilder_Add(object_builder, "num", num_val);
+    LDObjectBuilder_Add(object_builder, "float", float_val);
+    LDObjectBuilder_Add(object_builder, "str", str_val);
+
+    auto* obj_ptr = LDObjectBuilder_Build(object_builder);
+
+    EXPECT_EQ(
+        "{\"bool\":true,\"float\":3.141E0,\"null\":null,\"num\":1.7E1,\"str\":"
+        "\"Potato\"}",
+        serialize(obj_ptr));
+
+    LDValue_Free(obj_ptr);
+
+    // Array builder is going to take care of freeing bool_val_false.
+    auto* array_builder = LDArrayBuilder_New();
+    LDArrayBuilder_Add(array_builder, bool_val_false);
+    auto* array_ptr = LDArrayBuilder_Build(array_builder);
+
+    EXPECT_EQ("[false]", serialize(array_ptr));
+
+    LDValue_Free(array_ptr);
+}

libs/common/tests/value_test.cpp

@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 
-#include <launchdarkly/serialization/json_value.hpp>
+#include <launchdarkly/detail/serialization/json_value.hpp>
 
 #include <boost/json.hpp>
 

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

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <launchdarkly/context.hpp>
-#include <launchdarkly/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
 
 #include <boost/json/fwd.hpp>
 #include <tl/expected.hpp>

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

@@ -1,9 +1,9 @@
 #pragma once
 
 #include <launchdarkly/attribute_reference.hpp>
 #include <launchdarkly/data_model/context_aware_reference.hpp>
 #include <launchdarkly/serialization/json_context_kind.hpp>
-#include <launchdarkly/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
 #include <launchdarkly/serialization/value_mapping.hpp>
 
 #include <boost/json.hpp>

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

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <launchdarkly/data_model/context_kind.hpp>
-#include <launchdarkly/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
 
 #include <boost/json.hpp>
 #include <tl/expected.hpp>

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

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <launchdarkly/data/evaluation_reason.hpp>
-#include <launchdarkly/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
 
 #include <boost/json/fwd.hpp>
 #include <tl/expected.hpp>

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

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <launchdarkly/data/evaluation_result.hpp>
-#include <launchdarkly/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
 
 #include <boost/json/fwd.hpp>
 #include <tl/expected.hpp>

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

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <launchdarkly/data_model/flag.hpp>
-#include <launchdarkly/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
 
 #include <boost/json/fwd.hpp>
 

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

@@ -1,8 +1,8 @@
 #pragma once
 
 #include <launchdarkly/data_model/item_descriptor.hpp>
-#include <launchdarkly/serialization/json_errors.hpp>
-#include <launchdarkly/serialization/json_primitives.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_primitives.hpp>
 #include <launchdarkly/serialization/value_mapping.hpp>
 
 #include <boost/json.hpp>

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

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <launchdarkly/data_model/rule_clause.hpp>
-#include <launchdarkly/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
 
 #include <boost/json/fwd.hpp>
 #include <tl/expected.hpp>

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

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <launchdarkly/data_model/sdk_data_set.hpp>
-#include <launchdarkly/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
 
 #include <boost/json/fwd.hpp>
 

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

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <launchdarkly/data_model/segment.hpp>
-#include <launchdarkly/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
 
 #include <boost/json/fwd.hpp>
 

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

@@ -1,7 +1,6 @@
 #pragma once
 
-#include <launchdarkly/serialization/json_errors.hpp>
-#include <launchdarkly/serialization/json_primitives.hpp>
+#include <launchdarkly/detail/serialization/json_primitives.hpp>
 
 #include <boost/core/ignore_unused.hpp>
 #include <boost/json.hpp>

libs/internal/src/CMakeLists.txt

@@ -30,9 +30,7 @@ add_library(${LIBNAME} OBJECT
         serialization/events/json_events.cpp
         serialization/json_attributes.cpp
         serialization/json_context.cpp
-        serialization/json_errors.cpp
         serialization/json_evaluation_reason.cpp
-        serialization/json_value.cpp
         serialization/value_mapping.cpp
         serialization/json_evaluation_result.cpp
         serialization/json_sdk_data_set.cpp

libs/internal/src/serialization/events/json_events.cpp

@@ -1,6 +1,6 @@
 #include <launchdarkly/serialization/events/json_events.hpp>
 #include <launchdarkly/serialization/json_evaluation_reason.hpp>
-#include <launchdarkly/serialization/json_value.hpp>
+#include <launchdarkly/detail/serialization/json_value.hpp>
 
 namespace launchdarkly::events {
 void tag_invoke(boost::json::value_from_tag const& tag,

libs/internal/src/serialization/json_attributes.cpp

@@ -1,5 +1,5 @@
 #include <launchdarkly/serialization/json_attributes.hpp>
-#include <launchdarkly/serialization/json_value.hpp>
+#include <launchdarkly/detail/serialization/json_value.hpp>
 
 #include <boost/core/ignore_unused.hpp>
 #include <boost/json.hpp>

libs/internal/src/serialization/json_context.cpp

@@ -1,8 +1,8 @@
 #include <launchdarkly/context_builder.hpp>
+#include <launchdarkly/detail/serialization/json_primitives.hpp>
+#include <launchdarkly/detail/serialization/json_value.hpp>
 #include <launchdarkly/serialization/json_attributes.hpp>
 #include <launchdarkly/serialization/json_context.hpp>
-#include <launchdarkly/serialization/json_primitives.hpp>
-#include <launchdarkly/serialization/json_value.hpp>
 
 #include <boost/core/ignore_unused.hpp>
 #include <boost/json.hpp>

libs/internal/src/serialization/json_evaluation_reason.cpp

@@ -1,4 +1,4 @@
-#include <launchdarkly/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
 #include <launchdarkly/serialization/json_evaluation_reason.hpp>
 #include <launchdarkly/serialization/value_mapping.hpp>
 

libs/internal/src/serialization/json_evaluation_result.cpp

@@ -1,7 +1,7 @@
-#include <launchdarkly/serialization/json_errors.hpp>
+#include <launchdarkly/detail/serialization/json_errors.hpp>
 #include <launchdarkly/serialization/json_evaluation_reason.hpp>
 #include <launchdarkly/serialization/json_evaluation_result.hpp>
-#include <launchdarkly/serialization/json_value.hpp>
+#include <launchdarkly/detail/serialization/json_value.hpp>
 #include <launchdarkly/serialization/value_mapping.hpp>
 
 #include <boost/core/ignore_unused.hpp>

libs/internal/src/serialization/json_flag.cpp

@@ -1,8 +1,8 @@
 #include <boost/json.hpp>
 #include <launchdarkly/serialization/json_context_aware_reference.hpp>
 #include <launchdarkly/serialization/json_flag.hpp>
 #include <launchdarkly/serialization/json_rule_clause.hpp>
-#include <launchdarkly/serialization/json_value.hpp>
+#include <launchdarkly/detail/serialization/json_value.hpp>
 #include <launchdarkly/serialization/value_mapping.hpp>
 
 namespace launchdarkly {

libs/internal/src/serialization/json_primitives.cpp

@@ -1,4 +1,4 @@
-#include <launchdarkly/serialization/json_primitives.hpp>
+#include <launchdarkly/detail/serialization/json_primitives.hpp>
 
 namespace launchdarkly {
 tl::expected<std::optional<bool>, JsonError> tag_invoke(

libs/internal/src/serialization/json_rule_clause.cpp

@@ -2,7 +2,7 @@
 #include <boost/json.hpp>
 #include <launchdarkly/serialization/json_context_aware_reference.hpp>
 #include <launchdarkly/serialization/json_rule_clause.hpp>
-#include <launchdarkly/serialization/json_value.hpp>
+#include <launchdarkly/detail/serialization/json_value.hpp>
 #include <launchdarkly/serialization/value_mapping.hpp>
 
 namespace launchdarkly {