merge: pick up Filter API removal from #545

Author: beekld

libs/server-sdk/include/launchdarkly/server_side/config/builders/data_system/fdv2_builder.hpp

@@ -15,7 +15,6 @@ class FDv2Builder {
     class Streaming {
        public:
         Streaming& InitialReconnectDelay(std::chrono::milliseconds delay);
-        Streaming& Filter(std::string filter_key);
         Streaming& BaseUrl(std::string base_url);
         [[nodiscard]] built::FDv2Config::StreamingConfig Build() const;
 
@@ -28,7 +27,6 @@ class FDv2Builder {
     class Polling {
        public:
         Polling& PollInterval(std::chrono::seconds interval);
-        Polling& Filter(std::string filter_key);
         Polling& BaseUrl(std::string base_url);
         [[nodiscard]] built::FDv2Config::PollingConfig Build() const;
 

libs/server-sdk/include/launchdarkly/server_side/config/built/data_system/fdv2_config.hpp

@@ -14,26 +14,22 @@ namespace launchdarkly::server_side::config::built {
 struct FDv2Config {
     struct StreamingConfig {
         std::chrono::milliseconds initial_reconnect_delay;
-        std::optional<std::string> filter_key;
         std::optional<std::string> base_url_override;
 
         friend bool operator==(StreamingConfig const& lhs,
                                StreamingConfig const& rhs) {
             return lhs.initial_reconnect_delay == rhs.initial_reconnect_delay &&
-                   lhs.filter_key == rhs.filter_key &&
                    lhs.base_url_override == rhs.base_url_override;
         }
     };
 
     struct PollingConfig {
         std::chrono::seconds poll_interval;
-        std::optional<std::string> filter_key;
         std::optional<std::string> base_url_override;
 
         friend bool operator==(PollingConfig const& lhs,
                                PollingConfig const& rhs) {
             return lhs.poll_interval == rhs.poll_interval &&
-                   lhs.filter_key == rhs.filter_key &&
                    lhs.base_url_override == rhs.base_url_override;
         }
     };

libs/server-sdk/src/config/builders/data_system/fdv2_builder.cpp

@@ -10,18 +10,13 @@ FDv2Builder::Streaming& FDv2Builder::Streaming::InitialReconnectDelay(
     return *this;
 }
 
-FDv2Builder::Streaming& FDv2Builder::Streaming::Filter(std::string filter_key) {
-    filter_key_ = std::move(filter_key);
-    return *this;
-}
-
 FDv2Builder::Streaming& FDv2Builder::Streaming::BaseUrl(std::string base_url) {
     base_url_override_ = std::move(base_url);
     return *this;
 }
 
 built::FDv2Config::StreamingConfig FDv2Builder::Streaming::Build() const {
-    return {initial_reconnect_delay_, filter_key_, base_url_override_};
+    return {initial_reconnect_delay_, base_url_override_};
 }
 
 FDv2Builder::Polling& FDv2Builder::Polling::PollInterval(
@@ -30,18 +25,13 @@ FDv2Builder::Polling& FDv2Builder::Polling::PollInterval(
     return *this;
 }
 
-FDv2Builder::Polling& FDv2Builder::Polling::Filter(std::string filter_key) {
-    filter_key_ = std::move(filter_key);
-    return *this;
-}
-
 FDv2Builder::Polling& FDv2Builder::Polling::BaseUrl(std::string base_url) {
     base_url_override_ = std::move(base_url);
     return *this;
 }
 
 built::FDv2Config::PollingConfig FDv2Builder::Polling::Build() const {
-    return {poll_interval_, filter_key_, base_url_override_};
+    return {poll_interval_, base_url_override_};
 }
 
 FDv2Builder::FDv2Builder()

libs/server-sdk/src/data_systems/fdv2/initializer_factories.cpp

@@ -25,7 +25,7 @@ std::unique_ptr<data_interfaces::IFDv2Initializer>
 FDv2PollingInitializerFactory::Build() {
     return std::make_unique<FDv2PollingInitializer>(
         executor_, logger_, polling_base_url_, http_properties_,
-        data_model::Selector{}, polling_.filter_key);
+        data_model::Selector{}, std::nullopt);
 }
 
 }  // namespace launchdarkly::server_side::data_systems

libs/server-sdk/src/data_systems/fdv2/synchronizer_factories.cpp

@@ -28,8 +28,8 @@ FDv2StreamingSynchronizerFactory::FDv2StreamingSynchronizerFactory(
 std::unique_ptr<data_interfaces::IFDv2Synchronizer>
 FDv2StreamingSynchronizerFactory::Build() {
     return std::make_unique<FDv2StreamingSynchronizer>(
-        executor_, logger_, streaming_base_url_, http_properties_,
-        streaming_.filter_key, streaming_.initial_reconnect_delay);
+        executor_, logger_, streaming_base_url_, http_properties_, std::nullopt,
+        streaming_.initial_reconnect_delay);
 }
 
 FDv2PollingSynchronizerFactory::FDv2PollingSynchronizerFactory(
@@ -48,8 +48,8 @@ FDv2PollingSynchronizerFactory::FDv2PollingSynchronizerFactory(
 std::unique_ptr<data_interfaces::IFDv2Synchronizer>
 FDv2PollingSynchronizerFactory::Build() {
     return std::make_unique<FDv2PollingSynchronizer>(
-        executor_, logger_, polling_base_url_, http_properties_,
-        polling_.filter_key, polling_.poll_interval);
+        executor_, logger_, polling_base_url_, http_properties_, std::nullopt,
+        polling_.poll_interval);
 }
 
 FDv1StreamingAdapterFactory::FDv1StreamingAdapterFactory(

libs/server-sdk/tests/config_builder_test.cpp

@@ -181,7 +181,8 @@ TEST_F(ConfigBuilderTest, FDv2_MultipleSynchronizers) {
         builders::DataSystemBuilder::FDv2::Custom()
             .Synchronizer(builders::FDv2Builder::Polling().PollInterval(
                 std::chrono::seconds{45}))
-            .Synchronizer(builders::FDv2Builder::Streaming().Filter("filt")));
+            .Synchronizer(builders::FDv2Builder::Streaming()
+                          /* .Filter("filt") -- public API removed */));
 
     auto cfg = builder.Build();
     auto const fdv2_config =
@@ -192,24 +193,29 @@ TEST_F(ConfigBuilderTest, FDv2_MultipleSynchronizers) {
         fdv2_config.synchronizers[0]));
     ASSERT_TRUE(std::holds_alternative<built::FDv2Config::StreamingConfig>(
         fdv2_config.synchronizers[1]));
+    /* filter_key field removed from public StreamingConfig
     EXPECT_EQ(std::get<built::FDv2Config::StreamingConfig>(
                   fdv2_config.synchronizers[1])
                   .filter_key,
               "filt");
+    */
 }
 
 TEST_F(ConfigBuilderTest, FDv2_AddingInitializerClearsDefaults) {
     ConfigBuilder builder("sdk-123");
     builder.DataSystem().Method(
         builders::DataSystemBuilder::FDv2::Custom().Initializer(
-            builders::FDv2Builder::Polling().Filter("flag-subset")));
+            builders::FDv2Builder::Polling()
+            /* .Filter("flag-subset") -- public API removed */));
 
     auto cfg = builder.Build();
     auto const fdv2_config =
         std::get<built::FDv2Config>(cfg->DataSystemConfig().system_);
 
     ASSERT_EQ(fdv2_config.initializers.size(), 1u);
+    /* filter_key field removed from public PollingConfig
     EXPECT_EQ(fdv2_config.initializers[0].filter_key, "flag-subset");
+    */
 }
 
 TEST_F(ConfigBuilderTest, FDv2_PerSourceBaseUrlOverride) {