feat: add builder patterns to request structs

- Add typed-builder v0.20 dependency to both redis-cloud and redis-enterprise
- Implement builders for high-priority request structs:

  redis-cloud:
  - CreateDatabaseRequest, UpdateDatabaseRequest
  - CreateSubscriptionRequest, UpdateSubscriptionRequest
  - CloudProviderConfig, CloudRegionConfig
  - CreateBackupRequest, CreatePeeringRequest

  redis-enterprise:
  - CreateUserRequest, UpdateUserRequest
  - CreateRoleRequest with BdbRole
  - CreateCrdbRequest with CreateCrdbInstance

- Builder benefits:
  - No more manual Some() wrapping for optional fields
  - No more .to_string() calls with setter(into)
  - strip_option allows natural API (no Option in setter)
  - Default values for optional fields
  - Compile-time validation

- Update example to showcase cleaner builder API
- Add comprehensive examples in doc comments

Resolves #38

Author: joshrotenberg

crates/redis-cloud/Cargo.toml

@@ -24,6 +24,7 @@ anyhow = { workspace = true }
 base64 = { workspace = true }
 chrono = { workspace = true }
 url = { workspace = true }
+typed-builder = "0.20"
 
 [dev-dependencies]
 wiremock = { workspace = true }

crates/redis-cloud/examples/database_management.rs

@@ -71,16 +71,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Uncomment and modify as needed
     /*
     println!("\nCreating a new database...");
-    let new_database = CreateDatabaseRequest {
-        name: "example-db".to_string(),
-        memory_limit_in_gb: 0.1, // 100 MB
-        data_persistence: "none".to_string(),
-        replication: false,
-        data_eviction: Some("volatile-lru".to_string()),
-        password: None,
-        support_oss_cluster_api: Some(false),
-        use_external_endpoint_for_oss_cluster_api: None,
-    };
+    // Using the new builder pattern for cleaner API
+    let new_database = CreateDatabaseRequest::builder()
+        .name("example-db")
+        .memory_limit_in_gb(0.1) // 100 MB
+        .data_persistence("none")
+        .replication(false)
+        .data_eviction("volatile-lru")
+        .support_oss_cluster_api(false)
+        .build();
 
     let created_db = db_handler
         .create(subscription_id, new_database)

crates/redis-cloud/src/models/backup.rs

@@ -2,6 +2,7 @@
 
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use typed_builder::TypedBuilder;
 
 /// Backup information
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -17,9 +18,10 @@ pub struct CloudBackup {
 }
 
 /// Create backup request
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, TypedBuilder)]
 pub struct CreateBackupRequest {
     pub database_id: u32,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub description: Option<String>,
 }

crates/redis-cloud/src/models/database.rs

@@ -5,6 +5,7 @@
 
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use typed_builder::TypedBuilder;
 
 /// Represents a Redis Cloud database instance
 ///
@@ -92,46 +93,71 @@ pub struct ThroughputMeasurement {
 ///
 /// ```rust,no_run
 /// use redis_cloud::CreateDatabaseRequest;
-/// use serde_json::json;
 ///
-/// let request = json!({
-///     "name": "production-cache",
-///     "memory_limit_in_gb": 5.0,
-///     "data_persistence": "aof-every-1-sec",
-///     "replication": true,
-///     "password": "secure-password-123",
-///     "support_oss_cluster_api": false
-/// });
+/// let request = CreateDatabaseRequest::builder()
+///     .name("production-cache")
+///     .memory_limit_in_gb(5.0)
+///     .data_persistence("aof-every-1-sec")
+///     .replication(true)
+///     .password("secure-password-123")
+///     .support_oss_cluster_api(false)
+///     .build();
 /// ```
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, TypedBuilder)]
 pub struct CreateDatabaseRequest {
+    #[builder(setter(into))]
     pub name: String,
     pub memory_limit_in_gb: f64,
+    #[builder(setter(into))]
     pub data_persistence: String,
+    #[builder(default)]
     pub replication: bool,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub data_eviction: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub password: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub support_oss_cluster_api: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub use_external_endpoint_for_oss_cluster_api: Option<bool>,
 }
 
 /// Update database request
-#[derive(Debug, Serialize)]
+///
+/// All fields are optional - only provide the fields you want to update.
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// use redis_cloud::UpdateDatabaseRequest;
+///
+/// let request = UpdateDatabaseRequest::builder()
+///     .memory_limit_in_gb(10.0)
+///     .replication(true)
+///     .build();
+/// ```
+#[derive(Debug, Serialize, TypedBuilder)]
 pub struct UpdateDatabaseRequest {
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub name: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub memory_limit_in_gb: Option<f64>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub data_persistence: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub replication: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub data_eviction: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub password: Option<String>,
 }

crates/redis-cloud/src/models/peering.rs

@@ -2,6 +2,7 @@
 
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use typed_builder::TypedBuilder;
 
 /// VPC Peering
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -18,12 +19,32 @@ pub struct CloudPeering {
 }
 
 /// Create peering request
-#[derive(Debug, Serialize)]
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// use redis_cloud::CreatePeeringRequest;
+///
+/// let request = CreatePeeringRequest::builder()
+///     .subscription_id(123)
+///     .provider("AWS")
+///     .aws_account_id("123456789012")
+///     .vpc_id("vpc-12345678")
+///     .vpc_cidr("10.0.0.0/16")
+///     .region("us-east-1")
+///     .build();
+/// ```
+#[derive(Debug, Serialize, TypedBuilder)]
 pub struct CreatePeeringRequest {
     pub subscription_id: u32,
+    #[builder(setter(into))]
     pub provider: String,
+    #[builder(default, setter(into, strip_option))]
     pub aws_account_id: Option<String>,
+    #[builder(setter(into))]
     pub vpc_id: String,
+    #[builder(setter(into))]
     pub vpc_cidr: String,
+    #[builder(setter(into))]
     pub region: String,
 }

crates/redis-cloud/src/models/subscription.rs

@@ -2,6 +2,7 @@
 
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use typed_builder::TypedBuilder;
 
 /// Cloud subscription
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -35,42 +36,88 @@ pub struct CloudRegion {
 }
 
 /// Create subscription request
-#[derive(Debug, Serialize)]
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// use redis_cloud::{CreateSubscriptionRequest, CloudProviderConfig, CloudRegionConfig};
+///
+/// let request = CreateSubscriptionRequest::builder()
+///     .name("production")
+///     .payment_method_id(12345)
+///     .memory_storage("ram")
+///     .cloud_provider(
+///         CloudProviderConfig::builder()
+///             .provider("AWS")
+///             .regions(vec![
+///                 CloudRegionConfig::builder()
+///                     .region("us-east-1")
+///                     .multiple_availability_zones(true)
+///                     .build()
+///             ])
+///             .build()
+///     )
+///     .build();
+/// ```
+#[derive(Debug, Serialize, TypedBuilder)]
 pub struct CreateSubscriptionRequest {
+    #[builder(setter(into))]
     pub name: String,
     pub payment_method_id: u32,
+    #[builder(setter(into))]
     pub memory_storage: String,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub persistent_storage_encryption: Option<bool>,
     pub cloud_provider: CloudProviderConfig,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, TypedBuilder)]
 pub struct CloudProviderConfig {
+    #[builder(setter(into))]
     pub provider: String,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub cloud_account_id: Option<u32>,
     pub regions: Vec<CloudRegionConfig>,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, TypedBuilder)]
 pub struct CloudRegionConfig {
+    #[builder(setter(into))]
     pub region: String,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub networking_deployment_cidr: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub preferred_availability_zones: Option<Vec<String>>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub multiple_availability_zones: Option<bool>,
 }
 
 /// Update subscription request
-#[derive(Debug, Serialize)]
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// use redis_cloud::UpdateSubscriptionRequest;
+///
+/// let request = UpdateSubscriptionRequest::builder()
+///     .name("production-updated")
+///     .payment_method_id(54321)
+///     .build();
+/// ```
+#[derive(Debug, Serialize, TypedBuilder)]
 pub struct UpdateSubscriptionRequest {
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub name: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub payment_method_id: Option<u32>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub memory_storage: Option<String>,
 }

crates/redis-enterprise/Cargo.toml

@@ -25,6 +25,7 @@ anyhow = { workspace = true }
 base64 = { workspace = true }
 chrono = { workspace = true }
 url = { workspace = true }
+typed-builder = "0.20"
 
 [dev-dependencies]
 wiremock = { workspace = true }

crates/redis-enterprise/src/crdb.rs

@@ -4,6 +4,7 @@ use crate::client::RestClient;
 use crate::error::Result;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use typed_builder::TypedBuilder;
 
 /// CRDB (Active-Active Database) information
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -36,28 +37,63 @@ pub struct CrdbInstance {
 }
 
 /// Create CRDB request
-#[derive(Debug, Serialize)]
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// use redis_enterprise::{CreateCrdbRequest, CreateCrdbInstance};
+///
+/// let request = CreateCrdbRequest::builder()
+///     .name("global-cache")
+///     .memory_size(1024 * 1024 * 1024) // 1GB
+///     .instances(vec![
+///         CreateCrdbInstance::builder()
+///             .cluster("cluster1.example.com")
+///             .cluster_url("https://cluster1.example.com:9443")
+///             .username("admin")
+///             .password("password")
+///             .build(),
+///         CreateCrdbInstance::builder()
+///             .cluster("cluster2.example.com")
+///             .cluster_url("https://cluster2.example.com:9443")
+///             .username("admin")
+///             .password("password")
+///             .build()
+///     ])
+///     .encryption(true)
+///     .data_persistence("aof")
+///     .build();
+/// ```
+#[derive(Debug, Serialize, TypedBuilder)]
 pub struct CreateCrdbRequest {
+    #[builder(setter(into))]
     pub name: String,
     pub memory_size: u64,
     pub instances: Vec<CreateCrdbInstance>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub encryption: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub data_persistence: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub eviction_policy: Option<String>,
 }
 
 /// Create CRDB instance
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, TypedBuilder)]
 pub struct CreateCrdbInstance {
+    #[builder(setter(into))]
     pub cluster: String,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub cluster_url: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub username: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub password: Option<String>,
 }