feat: add builder patterns to ALL remaining request structs

Complete 100% builder pattern coverage across both libraries!

redis-cloud (already complete):
- All 6 request structs have TypedBuilder

redis-enterprise (now complete):
- All 18 request structs now have TypedBuilder
- Migrated CreateDatabaseRequest from custom builder to TypedBuilder
- Added builders to all HIGH, MEDIUM, and LOW priority structs

Structs updated in this commit:
- CreateDatabaseRequest (migrated from custom builder)
- BootstrapRequest with nested ClusterBootstrapInfo
- CreateMigrationRequest with MigrationEndpoint
- DebugInfoRequest (all optional fields)
- CreateScheduledJobRequest
- CreateLdapMappingRequest
- CreateSuffixRequest
- CreateRedisAclRequest
- CreateCrdbTaskRequest
- DiagnosticRequest
- ServiceConfigRequest
- NodeActionRequest
- LicenseUpdateRequest
- ModuleConfig (helper struct)

Achievement: 100% builder pattern coverage!
- redis-cloud: 6/6 structs ✅
- redis-enterprise: 18/18 structs ✅

Resolves #38
Closes #41

Author: joshrotenberg

crates/redis-enterprise/src/bdb.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;
 
 // Aliases for easier use
 pub type Database = DatabaseInfo;
@@ -243,136 +244,62 @@ pub struct EndpointInfo {
     pub dns_name: Option<String>,
 }
 
-/// Builder for CreateDatabaseRequest
-#[derive(Debug, Default)]
-pub struct CreateDatabaseRequestBuilder {
-    name: Option<String>,
-    memory_size: Option<u64>,
-    port: Option<u16>,
-    replication: Option<bool>,
-    persistence: Option<String>,
-    eviction_policy: Option<String>,
-    shards_count: Option<u32>,
-    module_list: Option<Vec<ModuleConfig>>,
-    authentication_redis_pass: Option<String>,
-}
-
-impl CreateDatabaseRequestBuilder {
-    /// Create a new builder
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Set the database name (required)
-    pub fn name(mut self, name: impl Into<String>) -> Self {
-        self.name = Some(name.into());
-        self
-    }
-
-    /// Set the memory size in bytes (required)
-    pub fn memory_size(mut self, size: u64) -> Self {
-        self.memory_size = Some(size);
-        self
-    }
-
-    /// Set the port number
-    pub fn port(mut self, port: u16) -> Self {
-        self.port = Some(port);
-        self
-    }
-
-    /// Enable or disable replication
-    pub fn replication(mut self, enabled: bool) -> Self {
-        self.replication = Some(enabled);
-        self
-    }
-
-    /// Set persistence type ("aof", "snapshot", "disabled")
-    pub fn persistence(mut self, persistence: impl Into<String>) -> Self {
-        self.persistence = Some(persistence.into());
-        self
-    }
-
-    /// Set eviction policy
-    pub fn eviction_policy(mut self, policy: impl Into<String>) -> Self {
-        self.eviction_policy = Some(policy.into());
-        self
-    }
-
-    /// Set number of shards
-    pub fn shards(mut self, count: u32) -> Self {
-        self.shards_count = Some(count);
-        self
-    }
-
-    /// Add Redis modules
-    pub fn modules(mut self, modules: Vec<ModuleConfig>) -> Self {
-        self.module_list = Some(modules);
-        self
-    }
-
-    /// Set database password
-    pub fn password(mut self, password: impl Into<String>) -> Self {
-        self.authentication_redis_pass = Some(password.into());
-        self
-    }
-
-    /// Build the request
-    pub fn build(self) -> Result<CreateDatabaseRequest> {
-        Ok(CreateDatabaseRequest {
-            name: self.name.ok_or_else(|| {
-                crate::error::RestError::ValidationError("Database name is required".to_string())
-            })?,
-            memory_size: self.memory_size.ok_or_else(|| {
-                crate::error::RestError::ValidationError("Memory size is required".to_string())
-            })?,
-            port: self.port,
-            replication: self.replication,
-            persistence: self.persistence,
-            eviction_policy: self.eviction_policy,
-            shards_count: self.shards_count,
-            module_list: self.module_list,
-            authentication_redis_pass: self.authentication_redis_pass,
-        })
-    }
-}
-
 /// Module configuration for database creation
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, TypedBuilder)]
 pub struct ModuleConfig {
+    #[builder(setter(into))]
     pub module_name: String,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub module_args: Option<String>,
 }
 
 /// Create database request
-#[derive(Debug, Serialize, Deserialize)]
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// use redis_enterprise::{CreateDatabaseRequest, ModuleConfig};
+///
+/// let request = CreateDatabaseRequest::builder()
+///     .name("my-database")
+///     .memory_size(1024 * 1024 * 1024) // 1GB
+///     .port(12000)
+///     .replication(true)
+///     .persistence("aof")
+///     .eviction_policy("volatile-lru")
+///     .shards_count(2)
+///     .authentication_redis_pass("secure-password")
+///     .build();
+/// ```
+#[derive(Debug, Serialize, Deserialize, TypedBuilder)]
 pub struct CreateDatabaseRequest {
+    #[builder(setter(into))]
     pub name: String,
     pub memory_size: u64,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub port: Option<u16>,
     #[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 persistence: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub eviction_policy: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub shards_count: Option<u32>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub module_list: Option<Vec<ModuleConfig>>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub authentication_redis_pass: Option<String>,
 }
 
-impl CreateDatabaseRequest {
-    /// Create a new builder for the request
-    pub fn builder() -> CreateDatabaseRequestBuilder {
-        CreateDatabaseRequestBuilder::new()
-    }
-}
-
 /// Database handler for executing database commands
 pub struct DatabaseHandler {
     client: RestClient,
@@ -398,16 +325,6 @@ impl DatabaseHandler {
         self.client.post("/v1/bdbs", &request).await
     }
 
-    /// Create a new database using builder pattern
-    pub async fn create_with_builder<F>(&self, f: F) -> Result<DatabaseInfo>
-    where
-        F: FnOnce(CreateDatabaseRequestBuilder) -> CreateDatabaseRequestBuilder,
-    {
-        let builder = CreateDatabaseRequestBuilder::new();
-        let request = f(builder).build()?;
-        self.create(request).await
-    }
-
     /// Update database configuration (BDB.UPDATE)
     pub async fn update(&self, uid: u32, updates: Value) -> Result<DatabaseInfo> {
         self.client

crates/redis-enterprise/src/cluster.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;
 
 /// Node information
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -119,23 +120,27 @@ pub struct ClusterSettings {
 }
 
 /// Bootstrap request for creating a new cluster
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, TypedBuilder)]
 pub struct BootstrapRequest {
+    #[builder(setter(into))]
     pub action: String,
     pub cluster: ClusterBootstrapInfo,
     pub credentials: BootstrapCredentials,
 }
 
 /// Cluster information for bootstrap
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, TypedBuilder)]
 pub struct ClusterBootstrapInfo {
+    #[builder(setter(into))]
     pub name: String,
 }
 
 /// Credentials for bootstrap
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, TypedBuilder)]
 pub struct BootstrapCredentials {
+    #[builder(setter(into))]
     pub username: String,
+    #[builder(setter(into))]
     pub password: String,
 }
 

crates/redis-enterprise/src/crdb_tasks.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 task information
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -26,11 +27,14 @@ pub struct CrdbTask {
 }
 
 /// CRDB task creation request
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, TypedBuilder)]
 pub struct CreateCrdbTaskRequest {
+    #[builder(setter(into))]
     pub crdb_guid: String,
+    #[builder(setter(into))]
     pub task_type: String,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub params: Option<Value>,
 }
 

crates/redis-enterprise/src/debuginfo.rs

@@ -4,21 +4,28 @@ use crate::client::RestClient;
 use crate::error::Result;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use typed_builder::TypedBuilder;
 
 /// Debug info collection request
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, TypedBuilder)]
 pub struct DebugInfoRequest {
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub node_uids: Option<Vec<u32>>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub bdb_uids: Option<Vec<u32>>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub include_logs: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub include_metrics: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub include_configs: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub time_range: Option<TimeRange>,
 }
 

crates/redis-enterprise/src/diagnostics.rs

@@ -4,15 +4,19 @@ use crate::client::RestClient;
 use crate::error::Result;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use typed_builder::TypedBuilder;
 
 /// Diagnostic check request
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, TypedBuilder)]
 pub struct DiagnosticRequest {
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub checks: Option<Vec<String>>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub node_uids: Option<Vec<u32>>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub bdb_uids: Option<Vec<u32>>,
 }
 

crates/redis-enterprise/src/job_scheduler.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;
 
 /// Scheduled job information
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -26,14 +27,19 @@ pub struct ScheduledJob {
 }
 
 /// Create scheduled job request
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, TypedBuilder)]
 pub struct CreateScheduledJobRequest {
+    #[builder(setter(into))]
     pub name: String,
+    #[builder(setter(into))]
     pub job_type: String,
+    #[builder(setter(into))]
     pub schedule: String,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub enabled: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub params: Option<Value>,
 }
 

crates/redis-enterprise/src/ldap_mappings.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;
 
 /// LDAP mapping information
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -22,14 +23,19 @@ pub struct LdapMapping {
 }
 
 /// Create or update LDAP mapping request
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, TypedBuilder)]
 pub struct CreateLdapMappingRequest {
+    #[builder(setter(into))]
     pub name: String,
+    #[builder(setter(into))]
     pub dn: String,
+    #[builder(setter(into))]
     pub role: String,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(into, strip_option))]
     pub email: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[builder(default, setter(strip_option))]
     pub role_uids: Option<Vec<u32>>,
 }
 

crates/redis-enterprise/src/lib.rs

@@ -24,7 +24,7 @@
 //! ## Working with Databases
 //!
 //! ```no_run
-//! use redis_enterprise::{EnterpriseClient, BdbHandler, CreateDatabaseRequestBuilder};
+//! use redis_enterprise::{EnterpriseClient, BdbHandler, CreateDatabaseRequest};
 //!
 //! # async fn example(client: EnterpriseClient) -> Result<(), Box<dyn std::error::Error>> {
 //! // List all databases
@@ -35,13 +35,13 @@
 //! }
 //!
 //! // Create a new database
-//! let request = CreateDatabaseRequestBuilder::new()
+//! let request = CreateDatabaseRequest::builder()
 //!     .name("my-database")
 //!     .memory_size(1024 * 1024 * 1024) // 1GB
 //!     .port(12000)
 //!     .replication(false)
 //!     .persistence("aof")
-//!     .build()?;
+//!     .build();
 //!
 //! let new_db = handler.create(request).await?;
 //! println!("Created database: {}", new_db.uid);