From b38f42c6398a6041f420f80d962d68c8d7f92af4 Mon Sep 17 00:00:00 2001
From: Michael de Lang <kingoipo@gmail.com>
Date: Mon, 29 Apr 2024 10:52:45 +0200
Subject: [PATCH] With latest glaze, do not send optional values to Etcd
 anymore

---
 external/Catch2                        |   2 +-
 external/glaze                         |   2 +-
 include/ichor/services/etcd/IEtcdV3.h  |  68 +++--
 src/services/etcd/EtcdV3Service.cpp    | 347 +++++++++++++++++--------
 test/TestServices/Etcdv3UsingService.h |   6 +-
 5 files changed, 283 insertions(+), 142 deletions(-)

diff --git a/external/Catch2 b/external/Catch2
index 05e10dfc..b5373dad 160000
--- a/external/Catch2
+++ b/external/Catch2
@@ -1 +1 @@
-Subproject commit 05e10dfccc28c7f973727c54f850237d07d5e10f
+Subproject commit b5373dadca40b7edc8570cf9470b9b1cb1934d40
diff --git a/external/glaze b/external/glaze
index 031db00e..957d39c3 160000
--- a/external/glaze
+++ b/external/glaze
@@ -1 +1 @@
-Subproject commit 031db00e852fb36e6a8f3125276860b890395fe1
+Subproject commit 957d39c3c5a0c9fa06128374080faeade0e0d470
diff --git a/include/ichor/services/etcd/IEtcdV3.h b/include/ichor/services/etcd/IEtcdV3.h
index dffef868..15985e88 100644
--- a/include/ichor/services/etcd/IEtcdV3.h
+++ b/include/ichor/services/etcd/IEtcdV3.h
@@ -3,7 +3,6 @@
 #include <ichor/coroutines/Task.h>
 #include <ichor/stl/StringUtils.h>
 #include <string_view>
-#include <optional> // Glaze does not support tl::optional
 #include <tl/optional.h>
 #include <string>
 #include <tl/expected.h>
@@ -85,46 +84,45 @@ namespace Ichor::Etcd::v3 {
 
     struct EtcdRangeRequest final {
         std::string key;
-        std::optional<std::string> range_end;
-        int64_t limit{};
-        int64_t revision{};
-        EtcdSortOrder sort_order{};
-        EtcdSortTarget sort_target{};
-        bool serializable{};
-        bool keys_only{};
-        bool count_only{};
-        std::optional<int64_t> min_mod_revision;
-        std::optional<int64_t> max_mod_revision;
-        std::optional<int64_t> min_create_revision;
-        std::optional<int64_t> max_create_revision;
+        tl::optional<std::string> range_end;
+        tl::optional<int64_t> limit{};
+        tl::optional<int64_t> revision{};
+        tl::optional<EtcdSortOrder> sort_order{};
+        tl::optional<EtcdSortTarget> sort_target{};
+        tl::optional<bool> serializable{};
+        tl::optional<bool> keys_only{};
+        tl::optional<bool> count_only{};
+        tl::optional<int64_t> min_mod_revision;
+        tl::optional<int64_t> max_mod_revision;
+        tl::optional<int64_t> min_create_revision;
+        tl::optional<int64_t> max_create_revision;
     };
 
     struct EtcdRangeResponse final {
         EtcdResponseHeader header;
         std::vector<EtcdKeyValue> kvs;
         int64_t count{};
-        bool more{};
+        tl::optional<bool> more{};
     };
 
     struct EtcdPutRequest final {
         std::string key;
         std::string value;
         int64_t lease{};
-        std::optional<bool> prev_kv;
-        std::optional<bool> ignore_value;
-        std::optional<bool> ignore_lease;
+        tl::optional<bool> prev_kv;
+        tl::optional<bool> ignore_value;
+        tl::optional<bool> ignore_lease;
     };
 
     struct EtcdPutResponse final {
         EtcdResponseHeader header;
-        std::optional<EtcdKeyValue> prev_kv;
-
+        tl::optional<EtcdKeyValue> prev_kv;
     };
 
     struct EtcdDeleteRangeRequest final {
         std::string key;
-        std::optional<std::string> range_end;
-        std::optional<bool> prev_kv;
+        tl::optional<std::string> range_end;
+        tl::optional<bool> prev_kv;
 
     };
 
@@ -139,14 +137,14 @@ namespace Ichor::Etcd::v3 {
         EtcdCompareResult result{};
         EtcdCompareTarget target{};
         std::string key;
-        std::optional<std::string> range_end;
+        tl::optional<std::string> range_end;
         // one of:
         // {
-        std::optional<int64_t> version;
-        std::optional<int64_t> create_revision;
-        std::optional<int64_t> mod_revision;
-        std::optional<std::string> value;
-        std::optional<int64_t> lease;
+        tl::optional<int64_t> version;
+        tl::optional<int64_t> create_revision;
+        tl::optional<int64_t> mod_revision;
+        tl::optional<std::string> value;
+        tl::optional<int64_t> lease;
         // }
     };
 
@@ -168,20 +166,20 @@ namespace Ichor::Etcd::v3 {
     struct EtcdRequestOp final {
         // one of:
         // {
-        std::optional<EtcdRangeRequest> request_range;
-        std::optional<EtcdPutRequest> request_put;
-        std::optional<EtcdDeleteRangeRequest> request_delete;
-        std::optional<EtcdTxnRequest> request_txn;
+        tl::optional<EtcdRangeRequest> request_range;
+        tl::optional<EtcdPutRequest> request_put;
+        tl::optional<EtcdDeleteRangeRequest> request_delete;
+        tl::optional<EtcdTxnRequest> request_txn;
         // }
     };
 
     struct EtcdResponseOp final {
         // one of:
         // {
-        std::optional<EtcdRangeResponse> response_range;
-        std::optional<EtcdPutResponse> response_put;
-        std::optional<EtcdDeleteRangeResponse> response_delete_range;
-        std::optional<EtcdTxnResponse> response_txn;
+        tl::optional<EtcdRangeResponse> response_range;
+        tl::optional<EtcdPutResponse> response_put;
+        tl::optional<EtcdDeleteRangeResponse> response_delete_range;
+        tl::optional<EtcdTxnResponse> response_txn;
         // }
     };
 
diff --git a/src/services/etcd/EtcdV3Service.cpp b/src/services/etcd/EtcdV3Service.cpp
index ff277d58..2b915477 100644
--- a/src/services/etcd/EtcdV3Service.cpp
+++ b/src/services/etcd/EtcdV3Service.cpp
@@ -33,8 +33,138 @@ namespace {
     struct EtcdEnableAuthReply final {
         bool enabled;
     };
+
+    // treat a value as base64
+    template <class T>
+    struct Base64StringType final {
+        static constexpr bool glaze_wrapper = true;
+        using value_type = T;
+        T& val;
+    };
+
+    // treat a value as an optional base64
+    template <class T>
+    struct OptionalBase64StringType final {
+        static constexpr bool glaze_wrapper = true;
+        using value_type = T;
+        T& val;
+    };
+}
+
+namespace glz::detail {
+    template <>
+    struct from_json<tl::optional<bool>> {
+        template <auto Opts>
+        static void op(tl::optional<bool>& value, auto&&... args) {
+            bool val;
+            read<json>::op<Opts>(val, args...);
+            value = val;
+        }
+    };
+
+    template <>
+    struct to_json<tl::optional<bool>> {
+        template <auto Opts>
+        static void op(tl::optional<bool> const & value, auto&&... args) noexcept {
+            if(value) {
+                write<json>::op<Opts>(*value, args...);
+            }
+        }
+    };
+
+    template <>
+    struct from_json<tl::optional<int64_t>> {
+        template <auto Opts>
+        static void op(tl::optional<int64_t>& value, auto&&... args) {
+            int64_t val;
+            read<json>::op<Opts>(val, args...);
+            value = val;
+        }
+    };
+
+    template <>
+    struct to_json<tl::optional<int64_t>> {
+        template <auto Opts>
+        static void op(tl::optional<int64_t> const & value, auto&&... args) noexcept {
+            if(value) {
+                write<json>::op<Opts>(*value, args...);
+            }
+        }
+    };
+
+    template <>
+    struct from_json<tl::optional<std::string>> {
+        template <auto Opts>
+        static void op(tl::optional<std::string>& value, auto&&... args) {
+            std::string val;
+            read<json>::op<Opts>(val, args...);
+            value = val;
+        }
+    };
+
+    template <>
+    struct to_json<tl::optional<std::string>> {
+        template <auto Opts>
+        static void op(tl::optional<std::string> const & value, auto&&... args) noexcept {
+            if(value) {
+                write<json>::op<Opts>(*value, args...);
+            }
+        }
+    };
+
+    template <class T>
+    struct from_json<Base64StringType<T>> {
+        template <auto Opts>
+        static void op(auto&& value, auto&&... args) {
+            read<json>::op<Opts>(value.val, args...);
+            value.val = base64_decode(value.val);
+        }
+    };
+
+    template <class T>
+    struct to_json<Base64StringType<T>> {
+        template <auto Opts>
+        static void op(Base64StringType<T> const & value, auto&&... args) noexcept {
+            write<json>::op<Opts>(base64_encode(reinterpret_cast<unsigned char const *>(value.val.c_str()), value.val.size()), args...);
+        }
+    };
+
+    template <class T>
+    struct from_json<OptionalBase64StringType<T>> {
+        template <auto Opts>
+        static void op(OptionalBase64StringType<T>& value, auto&&... args) {
+            read<json>::op<Opts>(*value.val, args...);
+            value.val = base64_decode(*value.val);
+        }
+    };
+
+    template <class T>
+    struct to_json<OptionalBase64StringType<T>> {
+        template <auto Opts>
+        static void op(OptionalBase64StringType<T> const & value, auto&&... args) noexcept {
+            if(value.val) {
+                write<json>::op<Opts>(base64_encode(reinterpret_cast<unsigned char const *>(value.val->c_str()), value.val->size()), args...);
+            }
+        }
+    };
+
+    template <auto MemPtr>
+    inline constexpr decltype(auto) Base64StringImpl() noexcept {
+        return [](auto&& val) { return Base64StringType<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
+    }
+
+    template <auto MemPtr>
+    inline constexpr decltype(auto) OptionalBase64StringImpl() noexcept {
+        return [](auto&& val) { return OptionalBase64StringType<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
+    }
 }
 
+template <auto MemPtr>
+constexpr auto Base64String = glz::detail::Base64StringImpl<MemPtr>();
+
+template <auto MemPtr>
+constexpr auto OptionalBase64String = glz::detail::OptionalBase64StringImpl<MemPtr>();
+
 template <>
 struct glz::meta<EtcdResponseHeader> {
     using T = EtcdResponseHeader;
@@ -48,23 +178,10 @@ struct glz::meta<EtcdResponseHeader> {
 
 template <>
 struct glz::meta<EtcdPutRequest> {
-    static constexpr auto read_key = [](EtcdPutRequest &req, std::string const &s) {
-        req.key = base64_decode(s);
-    };
-    static constexpr auto write_key = [](EtcdPutRequest const &req) -> std::string {
-        return base64_encode(reinterpret_cast<unsigned char const *>(req.key.c_str()), req.key.size());
-    };
-    static constexpr auto read_value = [](EtcdPutRequest &req, std::string const &s) {
-        req.value = base64_decode(s);
-    };
-    static constexpr auto write_value = [](EtcdPutRequest const &req) -> std::string {
-        return base64_encode(reinterpret_cast<unsigned char const *>(req.value.c_str()), req.value.size());
-    };
-
     using T = EtcdPutRequest;
     static constexpr auto value = object(
-        "key", custom<read_key, write_key>,
-        "value", custom<read_value, write_value>,
+        "key", Base64String<&T::key>,
+        "value", Base64String<&T::value>,
         "lease", quoted_num<&T::lease>,
         "prev_kv", &T::prev_kv,
         "ignore_value", &T::ignore_value,
@@ -83,28 +200,10 @@ struct glz::meta<EtcdPutResponse> {
 
 template <>
 struct glz::meta<EtcdRangeRequest> {
-    static constexpr auto read_key = [](EtcdRangeRequest &req, std::string const &s) {
-        req.key = base64_decode(s);
-    };
-    static constexpr auto write_key = [](EtcdRangeRequest const &req) -> std::string {
-        return base64_encode(reinterpret_cast<unsigned char const *>(req.key.c_str()), req.key.size());
-    };
-    static constexpr auto read_range_end = [](EtcdRangeRequest &req, std::optional<std::string> const &s) {
-        if(s) {
-            req.range_end = base64_decode(*s);
-        }
-    };
-    static constexpr auto write_range_end = [](EtcdRangeRequest const &req) -> std::optional<std::string> {
-        if(!req.range_end) {
-            return std::nullopt;
-        }
-        return base64_encode(reinterpret_cast<unsigned char const *>(req.range_end->c_str()), req.range_end->size());
-    };
-
     using T = EtcdRangeRequest;
     static constexpr auto value = object(
-        "key", custom<read_key, write_key>,
-        "range_end", custom<read_range_end, write_range_end>,
+        "key", Base64String<&T::key>,
+        "range_end", OptionalBase64String<&T::range_end>,
         "limit", quoted_num<&T::limit>,
         "revision", quoted_num<&T::revision>,
         "sort_order", &T::sort_order,
@@ -132,28 +231,10 @@ struct glz::meta<EtcdRangeResponse> {
 
 template <>
 struct glz::meta<EtcdDeleteRangeRequest> {
-    static constexpr auto read_key = [](EtcdDeleteRangeRequest &req, std::string const &s) {
-        req.key = base64_decode(s);
-    };
-    static constexpr auto write_key = [](EtcdDeleteRangeRequest const &req) -> std::string {
-        return base64_encode(reinterpret_cast<unsigned char const *>(req.key.c_str()), req.key.size());
-    };
-    static constexpr auto read_range_end = [](EtcdDeleteRangeRequest &req, std::optional<std::string> const &s) {
-        if(s) {
-            req.range_end = base64_decode(*s);
-        }
-    };
-    static constexpr auto write_range_end = [](EtcdDeleteRangeRequest const &req) -> std::optional<std::string> {
-        if(!req.range_end) {
-            return std::nullopt;
-        }
-        return base64_encode(reinterpret_cast<unsigned char const *>(req.range_end->c_str()), req.range_end->size());
-    };
-
     using T = EtcdDeleteRangeRequest;
     static constexpr auto value = object(
-        "key", custom<read_key, write_key>,
-        "range_end", custom<read_range_end, write_range_end>,
+        "key", Base64String<&T::key>,
+        "range_end", OptionalBase64String<&T::range_end>,
         "prev_kv", &T::prev_kv
     );
 };
@@ -177,23 +258,10 @@ struct glz::meta<EtcdDeleteRangeResponse> {
 
 template <>
 struct glz::meta<EtcdKeyValue> {
-    static constexpr auto read_key = [](EtcdKeyValue &req, std::string const &s) {
-        req.key = base64_decode(s);
-    };
-    static constexpr auto write_key = [](EtcdKeyValue const &req) -> std::string {
-        return base64_encode(reinterpret_cast<unsigned char const *>(req.key.c_str()), req.key.size());
-    };
-    static constexpr auto read_value = [](EtcdKeyValue &req, std::string const &s) {
-        req.value = base64_decode(s);
-    };
-    static constexpr auto write_value = [](EtcdKeyValue const &req) -> std::string {
-        return base64_encode(reinterpret_cast<unsigned char const *>(req.value.c_str()), req.value.size());
-    };
-
     using T = EtcdKeyValue;
     static constexpr auto value = object(
-        "key", custom<read_key, write_key>,
-        "value", custom<read_value, write_value>,
+        "key", Base64String<&T::key>,
+        "value", Base64String<&T::value>,
         "create_revision", quoted_num<&T::create_revision>,
         "mod_revision", quoted_num<&T::mod_revision>,
         "version", quoted_num<&T::version>,
@@ -203,45 +271,16 @@ struct glz::meta<EtcdKeyValue> {
 
 template <>
 struct glz::meta<EtcdCompare> {
-    static constexpr auto read_key = [](EtcdCompare &req, std::string const &s) {
-        req.key = base64_decode(s);
-    };
-    static constexpr auto write_key = [](EtcdCompare const &req) -> std::string {
-        return base64_encode(reinterpret_cast<unsigned char const *>(req.key.c_str()), req.key.size());
-    };
-    static constexpr auto read_range_end = [](EtcdCompare &req, std::optional<std::string> const &s) {
-        if(s) {
-            req.range_end = base64_decode(*s);
-        }
-    };
-    static constexpr auto write_range_end = [](EtcdCompare const &req) -> std::optional<std::string> {
-        if(!req.range_end) {
-            return std::nullopt;
-        }
-        return base64_encode(reinterpret_cast<unsigned char const *>(req.range_end->c_str()), req.range_end->size());
-    };
-    static constexpr auto read_value = [](EtcdCompare &req, std::optional<std::string> const &s) {
-        if(s) {
-            req.value = base64_decode(*s);
-        }
-    };
-    static constexpr auto write_value = [](EtcdCompare const &req) -> std::optional<std::string> {
-        if(!req.value) {
-            return std::nullopt;
-        }
-        return base64_encode(reinterpret_cast<unsigned char const *>(req.value->c_str()), req.value->size());
-    };
-
     using T = EtcdCompare;
     static constexpr auto value = object(
         "result", &T::result,
         "target", &T::target,
-        "key", custom<read_key, write_key>,
-        "range_end", custom<read_range_end, write_range_end>,
+        "key", Base64String<&T::key>,
+        "range_end", OptionalBase64String<&T::range_end>,
         "version", quoted_num<&T::version>,
         "create_revision", quoted_num<&T::create_revision>,
         "mod_revision", quoted_num<&T::mod_revision>,
-        "value", custom<read_value, write_value>,
+        "value", OptionalBase64String<&T::value>,
         "lease", quoted_num<&T::lease>
     );
 };
@@ -315,6 +354,110 @@ struct glz::meta<EtcdInternalVersionReply> {
     );
 };
 
+namespace glz::detail {
+    template <>
+    struct from_json<tl::optional<EtcdKeyValue>> {
+        template <auto Opts>
+        static void op(tl::optional<EtcdKeyValue>& value, auto&&... args) {
+            EtcdKeyValue val;
+            read<json>::op<Opts>(val, args...);
+            value = val;
+        }
+    };
+
+    template <>
+    struct to_json<tl::optional<EtcdKeyValue>> {
+        template <auto Opts>
+        static void op(tl::optional<EtcdKeyValue> const & value, auto&&... args) noexcept {
+            if(value) {
+                write<json>::op<Opts>(*value, args...);
+            }
+        }
+    };
+
+    template <>
+    struct from_json<tl::optional<EtcdRangeResponse>> {
+        template <auto Opts>
+        static void op(tl::optional<EtcdRangeResponse>& value, auto&&... args) {
+            fmt::print("EtcdRangeResponse read\n");
+            EtcdRangeResponse val;
+            read<json>::op<Opts>(val, args...);
+            value = val;
+        }
+    };
+
+    template <>
+    struct to_json<tl::optional<EtcdRangeResponse>> {
+        template <auto Opts>
+        static void op(tl::optional<EtcdRangeResponse> const & value, auto&&... args) noexcept {
+            fmt::print("EtcdRangeResponse write\n");
+            if(value) {
+                write<json>::op<Opts>(*value, args...);
+            }
+        }
+    };
+
+    template <>
+    struct from_json<tl::optional<EtcdPutResponse>> {
+        template <auto Opts>
+        static void op(tl::optional<EtcdPutResponse>& value, auto&&... args) {
+            EtcdPutResponse val;
+            read<json>::op<Opts>(val, args...);
+            value = val;
+        }
+    };
+
+    template <>
+    struct to_json<tl::optional<EtcdPutResponse>> {
+        template <auto Opts>
+        static void op(tl::optional<EtcdPutResponse> const & value, auto&&... args) noexcept {
+            if(value) {
+                write<json>::op<Opts>(*value, args...);
+            }
+        }
+    };
+
+    template <>
+    struct from_json<tl::optional<EtcdDeleteRangeResponse>> {
+        template <auto Opts>
+        static void op(tl::optional<EtcdDeleteRangeResponse>& value, auto&&... args) {
+            EtcdDeleteRangeResponse val;
+            read<json>::op<Opts>(val, args...);
+            value = val;
+        }
+    };
+
+    template <>
+    struct to_json<tl::optional<EtcdDeleteRangeResponse>> {
+        template <auto Opts>
+        static void op(tl::optional<EtcdDeleteRangeResponse> const & value, auto&&... args) noexcept {
+            if(value) {
+                write<json>::op<Opts>(*value, args...);
+            }
+        }
+    };
+
+    template <>
+    struct from_json<tl::optional<EtcdTxnResponse>> {
+        template <auto Opts>
+        static void op(tl::optional<EtcdTxnResponse>& value, auto&&... args) {
+            EtcdTxnResponse val;
+            read<json>::op<Opts>(val, args...);
+            value = val;
+        }
+    };
+
+    template <>
+    struct to_json<tl::optional<EtcdTxnResponse>> {
+        template <auto Opts>
+        static void op(tl::optional<EtcdTxnResponse> const & value, auto&&... args) noexcept {
+            if(value) {
+                write<json>::op<Opts>(*value, args...);
+            }
+        }
+    };
+}
+
 EtcdService::EtcdService(DependencyRegister &reg, Properties props) : AdvancedService<EtcdService>(std::move(props)) {
     reg.registerDependency<ILogger>(this, DependencyFlags::NONE, getProperties());
     reg.registerDependency<IHttpConnectionService>(this, DependencyFlags::REQUIRED | DependencyFlags::ALLOW_MULTIPLE, getProperties());
diff --git a/test/TestServices/Etcdv3UsingService.h b/test/TestServices/Etcdv3UsingService.h
index cb3d028c..bda46d6a 100644
--- a/test/TestServices/Etcdv3UsingService.h
+++ b/test/TestServices/Etcdv3UsingService.h
@@ -39,7 +39,7 @@ namespace Ichor {
         Task<void> put_get_delete_test() const {
             ICHOR_LOG_INFO(_logger, "running test");
             int64_t revision{};
-            Etcd::v3::EtcdPutRequest putReq{"v3_test_key", "test_value", 0, std::nullopt, std::nullopt, std::nullopt};
+            Etcd::v3::EtcdPutRequest putReq{"v3_test_key", "test_value", 0, tl::nullopt, tl::nullopt, tl::nullopt};
 
             auto putReply = co_await _etcd->put(putReq);
             if (!putReply) {
@@ -84,7 +84,7 @@ namespace Ichor {
         Task<void> txn_test() const {
             ICHOR_LOG_INFO(_logger, "running test");
             int64_t revision{};
-            Etcd::v3::EtcdPutRequest putReq{"v3_txn_key", "txn_value", 0, std::nullopt, std::nullopt, std::nullopt};
+            Etcd::v3::EtcdPutRequest putReq{"v3_txn_key", "txn_value", 0, tl::nullopt, tl::nullopt, tl::nullopt};
 
             auto putReply = co_await _etcd->put(putReq);
             if (!putReply) {
@@ -105,7 +105,7 @@ namespace Ichor {
             Etcd::v3::EtcdTxnRequest txnReq{};
             txnReq.compare.emplace_back(Etcd::v3::EtcdCompare{.target = Etcd::v3::EtcdCompareTarget::CREATE,.key = "v3_txn_key", .create_revision = revision});
             txnReq.success.emplace_back(Etcd::v3::EtcdRequestOp{.request_range = Etcd::v3::EtcdRangeRequest{.key = "v3_txn_key"}});
-            txnReq.failure.emplace_back(Etcd::v3::EtcdRequestOp{.request_range = Etcd::v3::EtcdRangeRequest{.key = "v3_txn_key"}});
+            //txnReq.failure.emplace_back(Etcd::v3::EtcdRequestOp{.request_range = Etcd::v3::EtcdRangeRequest{.key = "v3_txn_key"}});
             auto txnReply = co_await _etcd->txn(txnReq);
             if (!txnReply) {
                 throw std::runtime_error("txn");