refactor: implement fdv2 polling initializer / synchronizer

libs/internal/include/launchdarkly/fdv2_protocol_handler.hpp

@@ -0,0 +1,114 @@
+#pragma once
+
+#include <launchdarkly/data_model/fdv2_change.hpp>
+#include <launchdarkly/serialization/json_fdv2_events.hpp>
+
+#include <boost/json/value.hpp>
+
+#include <string_view>
+#include <variant>
+#include <vector>
+
+namespace launchdarkly {
+
+/**
+ * Protocol state machine for the FDv2 wire format.
+ *
+ * Accumulates put-object and delete-object events between a server-intent
+ * and payload-transferred event, then emits a complete FDv2ChangeSet.
+ *
+ * Shared between the polling and streaming synchronizers.
+ */
+class FDv2ProtocolHandler {
+   public:
+    /**
+     * Typed error returned by HandleEvent. Carries the original underlying
+     * error context rather than converting to a plain string.
+     */
+    struct Error {
+        enum class Kind {
+            kJsonError,      // Failed to deserialise an event's data field.
+            kProtocolError,  // Out-of-order or unexpected event.
+            kServerError,    // Server sent a valid 'error' event.
+        };
+
+        Kind kind;
+        std::string message;
+
+        /**
+         * Set for kJsonError when the tl::expected parse returned an error.
+         * Nullopt when parse succeeded but the data value was null.
+         */
+        std::optional<JsonError> json_error;
+
+        /**
+         * Set for kServerError: the full wire error including id and reason.
+         */
+        std::optional<FDv2Error> server_error;
+
+        /** JSON deserialisation failed — carries the original JsonError. */
+        static Error JsonParseError(JsonError err, std::string msg) {
+            return {Kind::kJsonError, std::move(msg), err, std::nullopt};
+        }
+        /** Parse succeeded but data was null — no underlying JsonError. */
+        static Error JsonParseError(std::string msg) {
+            return {Kind::kJsonError, std::move(msg), std::nullopt,
+                    std::nullopt};
+        }
+        /** Out-of-order or unexpected protocol event. */
+        static Error ProtocolError(std::string msg) {
+            return {Kind::kProtocolError, std::move(msg), std::nullopt,
+                    std::nullopt};
+        }
+        /** Server sent a well-formed 'error' event. */
+        static Error ServerError(FDv2Error err) {
+            return {Kind::kServerError, err.reason, std::nullopt,
+                    std::move(err)};
+        }
+    };
+
+    /**
+     * Result of handling a single FDv2 event:
+     * - monostate: no output yet (accumulating, heartbeat, or unknown event)
+     * - FDv2ChangeSet: complete changeset ready to apply
+     * - Error: protocol error (JSON parse failure, protocol violation, or
+     *          server-sent error event)
+     * - Goodbye: server is closing; caller should rotate sources
+     */
+    using Result =
+        std::variant<std::monostate, data_model::FDv2ChangeSet, Error, Goodbye>;
+
+    /**
+     * Process one FDv2 event.
+     *
+     * @param event_type The event type string (e.g. "server-intent",
+     *                   "put-object", "payload-transferred").
+     * @param data       The parsed JSON value for the event's data field.
+     * @return           A Result indicating what (if anything) the caller
+     *                   should act on.
+     */
+    Result HandleEvent(std::string_view event_type,
+                       boost::json::value const& data);
+
+    /**
+     * Reset accumulated state. Call on reconnect before processing new events.
+     */
+    void Reset();
+
+    FDv2ProtocolHandler() = default;
+
+   private:
+    enum class State { kInactive, kFull, kPartial };
+
+    Result HandleServerIntent(boost::json::value const& data);
+    Result HandlePutObject(boost::json::value const& data);
+    Result HandleDeleteObject(boost::json::value const& data);
+    Result HandlePayloadTransferred(boost::json::value const& data);
+    Result HandleError(boost::json::value const& data);
+    Result HandleGoodbye(boost::json::value const& data);
+
+    State state_ = State::kInactive;
+    std::vector<data_model::FDv2Change> changes_;
+};
+
+}  // namespace launchdarkly

libs/internal/include/launchdarkly/network/asio_requester.hpp

@@ -283,22 +283,16 @@ class AsioRequester {
 
     template <typename CompletionToken>
     auto Request(HttpRequest request, CompletionToken&& token) {
-        // TODO: Clang-tidy wants to pass the request by reference, but I am not
-        // confident that lifetime would make sense.
-
-        namespace asio = boost::asio;
-        namespace system = boost::system;
-
-        using Sig = void(HttpResult result);
-        using Result = asio::async_result<std::decay_t<CompletionToken>, Sig>;
-        using Handler = typename Result::completion_handler_type;
-
-        Handler handler(std::forward<decltype(token)>(token));
-        Result result(handler);
-
-        InnerRequest(net::make_strand(ctx_), request, std::move(handler), 0);
-
-        return result.get();
+        return boost::asio::async_initiate<CompletionToken, void(HttpResult)>(
+            [this](auto handler, HttpRequest req) {
+                InnerRequest(
+                    net::make_strand(ctx_), std::move(req),
+                    [h = std::move(handler)](HttpResult result) mutable {
+                        std::move(h)(std::move(result));
+                    },
+                    0);
+            },
+            token, std::move(request));
     }
 
    private:
@@ -336,7 +330,7 @@ class AsioRequester {
                                  redirect_count]() mutable {
             auto beast_request = MakeBeastRequest(*request);
 
-            const auto& properties = request->Properties();
+            auto const& properties = request->Properties();
 
             std::string service =
                 request->Port().value_or(request->Https() ? "https" : "http");

libs/internal/src/CMakeLists.txt

@@ -35,6 +35,7 @@ set(INTERNAL_SOURCES
         serialization/value_mapping.cpp
         serialization/json_evaluation_result.cpp
         serialization/json_fdv2_events.cpp
+        fdv2_protocol_handler.cpp
         serialization/json_sdk_data_set.cpp
         serialization/json_segment.cpp
         serialization/json_primitives.cpp