enhance(sdk-rs): builder pattern

Author: ardatan

.changeset/busy-cloths-search.md

@@ -0,0 +1,54 @@
+---
+'hive-console-sdk-rs': minor
+---
+
+Breaking Changes to avoid future breaking changes;
+
+Switch to [Builder](https://rust-unofficial.github.io/patterns/patterns/creational/builder.html) pattern for `SupergraphFetcher`, `PersistedDocumentsManager` and `UsageAgent` structs. 
+
+Benefits;
+
+- No need to provide all parameters at once when creating an instance even for default values.
+
+Example;
+```rust
+// Before
+let fetcher = SupergraphFetcher::try_new_async(
+        "SOME_ENDPOINT", // endpoint
+         "SOME_KEY",
+        "MyUserAgent/1.0".to_string(),
+        Duration::from_secs(5), // connect_timeout
+        Duration::from_secs(10), // request_timeout
+        false, // accept_invalid_certs
+        3, // retry_count
+    )?;
+
+// After
+// No need to provide all parameters at once, can use default values
+let fetcher = SupergraphFetcherBuilder::new()
+    .endpoint("SOME_ENDPOINT".to_string())
+    .key("SOME_KEY".to_string())
+    .build_async()?;
+```
+
+- Easier to add new configuration options in the future without breaking existing code.
+
+Example;
+
+```rust
+let fetcher = SupergraphFetcher::try_new_async(
+        "SOME_ENDPOINT", // endpoint
+         "SOME_KEY",
+        "MyUserAgent/1.0".to_string(),
+        Duration::from_secs(5), // connect_timeout
+        Duration::from_secs(10), // request_timeout
+        false, // accept_invalid_certs
+        3, // retry_count
+        circuit_breaker_config, // Breaking Change -> new parameter added
+    )?;
+
+let fetcher = SupergraphFetcherBuilder::new()
+    .endpoint("SOME_ENDPOINT".to_string())
+    .key("SOME_KEY".to_string())
+    .build_async()?; // No breaking change, circuit_breaker_config can be added later if needed
+```

configs/cargo/Cargo.lock

@@ -100,17 +100,38 @@ impl PersistedDocumentsPlugin {
             }
         };
 
+        let mut persisted_documents_manager = PersistedDocumentsManager::builder()
+            .key(key)
+            .endpoint(endpoint)
+            .user_agent(format!("hive-apollo-router/{}", PLUGIN_VERSION));
+
+        if let Some(connect_timeout) = config.connect_timeout {
+            persisted_documents_manager =
+                persisted_documents_manager.connect_timeout(Duration::from_secs(connect_timeout));
+        }
+
+        if let Some(request_timeout) = config.request_timeout {
+            persisted_documents_manager =
+                persisted_documents_manager.request_timeout(Duration::from_secs(request_timeout));
+        }
+
+        if let Some(retry_count) = config.retry_count {
+            persisted_documents_manager = persisted_documents_manager.max_retries(retry_count);
+        }
+
+        if let Some(accept_invalid_certs) = config.accept_invalid_certs {
+            persisted_documents_manager =
+                persisted_documents_manager.accept_invalid_certs(accept_invalid_certs);
+        }
+
+        if let Some(cache_size) = config.cache_size {
+            persisted_documents_manager = persisted_documents_manager.cache_size(cache_size);
+        }
+
+        let persisted_documents_manager = persisted_documents_manager.build()?;
+
         Ok(PersistedDocumentsPlugin {
-            persisted_documents_manager: Some(Arc::new(PersistedDocumentsManager::new(
-                key,
-                endpoint,
-                config.accept_invalid_certs.unwrap_or(false),
-                Duration::from_secs(config.connect_timeout.unwrap_or(5)),
-                Duration::from_secs(config.request_timeout.unwrap_or(15)),
-                config.retry_count.unwrap_or(3),
-                config.cache_size.unwrap_or(1000),
-                format!("hive-apollo-router/{}", PLUGIN_VERSION),
-            ))),
+            persisted_documents_manager: Some(Arc::new(persisted_documents_manager)),
             allow_arbitrary_documents,
         })
     }

packages/libraries/router/src/persisted_documents.rs

@@ -2,13 +2,13 @@ use crate::consts::PLUGIN_VERSION;
 use crate::registry_logger::Logger;
 use anyhow::{anyhow, Result};
 use hive_console_sdk::supergraph_fetcher::SupergraphFetcher;
+use hive_console_sdk::supergraph_fetcher::SupergraphFetcherBuilder;
 use hive_console_sdk::supergraph_fetcher::SupergraphFetcherSyncState;
 use sha2::Digest;
 use sha2::Sha256;
 use std::env;
 use std::io::Write;
 use std::thread;
-use std::time::Duration;
 
 #[derive(Debug)]
 pub struct HiveRegistry {
@@ -120,19 +120,18 @@ impl HiveRegistry {
                 .to_string_lossy()
                 .to_string(),
         );
-        env::set_var("APOLLO_ROUTER_SUPERGRAPH_PATH", file_name.clone());
-        env::set_var("APOLLO_ROUTER_HOT_RELOAD", "true");
-
-        let fetcher = SupergraphFetcher::try_new_sync(
-            endpoint,
-            &key,
-            format!("hive-apollo-router/{}", PLUGIN_VERSION),
-            Duration::from_secs(5),
-            Duration::from_secs(60),
-            accept_invalid_certs,
-            3,
-        )
-        .map_err(|e| anyhow!("Failed to create SupergraphFetcher: {}", e))?;
+        unsafe {
+            env::set_var("APOLLO_ROUTER_SUPERGRAPH_PATH", file_name.clone());
+            env::set_var("APOLLO_ROUTER_HOT_RELOAD", "true");
+        }
+
+        let fetcher = SupergraphFetcherBuilder::new()
+            .endpoint(endpoint)
+            .key(key)
+            .user_agent(format!("hive-apollo-router/{}", PLUGIN_VERSION))
+            .accept_invalid_certs(accept_invalid_certs)
+            .build_sync()
+            .map_err(|e| anyhow!("Failed to create SupergraphFetcher: {}", e))?;
 
         let registry = HiveRegistry {
             fetcher,

packages/libraries/router/src/registry.rs

@@ -8,8 +8,7 @@ use core::ops::Drop;
 use futures::StreamExt;
 use graphql_parser::parse_schema;
 use graphql_parser::schema::Document;
-use hive_console_sdk::agent::UsageAgentExt;
-use hive_console_sdk::agent::{ExecutionReport, UsageAgent};
+use hive_console_sdk::agent::usage_agent::{ExecutionReport, UsageAgent, UsageAgentExt};
 use http::HeaderValue;
 use rand::Rng;
 use schemars::JsonSchema;
@@ -244,20 +243,27 @@ impl Plugin for UsagePlugin {
             .expect("Failed to parse schema")
             .into_static();
 
+        let token = token.expect("token is set");
+
         let agent = if enabled {
             let flush_interval = Duration::from_secs(flush_interval);
-            let agent = UsageAgent::try_new(
-                &token.expect("token is set"),
-                endpoint,
-                target_id,
-                buffer_size,
-                Duration::from_secs(connect_timeout),
-                Duration::from_secs(request_timeout),
-                accept_invalid_certs,
-                flush_interval,
-                format!("hive-apollo-router/{}", PLUGIN_VERSION),
-            )
-            .map_err(Box::new)?;
+
+            let mut agent = UsageAgent::builder()
+                .token(token)
+                .endpoint(endpoint)
+                .buffer_size(buffer_size)
+                .connect_timeout(Duration::from_secs(connect_timeout))
+                .request_timeout(Duration::from_secs(request_timeout))
+                .accept_invalid_certs(accept_invalid_certs)
+                .user_agent(format!("hive-apollo-router/{}", PLUGIN_VERSION))
+                .flush_interval(flush_interval);
+
+            if let Some(target_id) = target_id {
+                agent = agent.target_id(target_id);
+            }
+
+            let agent = agent.build().map_err(Box::new)?;
+
             start_flush_interval(agent.clone());
             Some(agent)
         } else {

packages/libraries/router/src/usage.rs

@@ -32,6 +32,7 @@ serde_json = "1"
 moka = { version = "0.12.10", features = ["future", "sync"] }
 sha2 = { version = "0.10.8", features = ["std"] }
 tokio-util = "0.7.16"
+regex-automata = "0.4.10"
 
 [dev-dependencies]
 mockito = "1.7.0"