feat(redis-enterprise): add missing fields and comprehensive documentation (#270)

- Add missing fields to License struct (activation_date, cluster_name, ram/flash shards limits)
- Add missing fields to Node struct (bigstore_driver, bigstore_size, public_addr, recovery_path)
- Add missing fields to ClusterInfo struct (uid, created, last_changed_time, bigstore_driver, cnm_http_port, cnm_https_port)
- Add comprehensive documentation to all struct fields based on REST API docs
- Add documentation to previously undocumented structs (Action, BdbGroup, etc.)
- Fix License struct to handle varying field names in API responses

All fields now include descriptive documentation explaining their purpose, whether they're read-only, and any constraints or deprecation notices.

Author: joshrotenberg

crates/redis-enterprise/src/actions.rs

@@ -11,6 +11,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
 /// Action information
+/// Represents an action (operation) in the cluster
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Action {
     pub action_uid: String,
@@ -27,6 +28,7 @@ pub struct Action {
 }
 
 /// Action handler for tracking async operations
+/// Handler for action-related operations
 pub struct ActionHandler {
     client: RestClient,
 }

crates/redis-enterprise/src/bdb_groups.rs

@@ -10,6 +10,7 @@ use crate::error::Result;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
+/// Database group information
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BdbGroup {
     pub uid: u32,
@@ -18,6 +19,7 @@ pub struct BdbGroup {
     pub extra: Value,
 }
 
+/// Handler for database group operations
 pub struct BdbGroupsHandler {
     client: RestClient,
 }
@@ -50,11 +52,13 @@ impl BdbGroupsHandler {
     }
 }
 
+/// Request to create a new database group
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CreateBdbGroupRequest {
     pub name: String,
 }
 
+/// Request to update an existing database group
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct UpdateBdbGroupRequest {
     #[serde(skip_serializing_if = "Option::is_none")]

crates/redis-enterprise/src/cluster.rs

@@ -83,18 +83,56 @@ pub struct ClusterNode {
 /// Cluster information from the REST API
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ClusterInfo {
+    /// Cluster unique ID (read-only)
+    pub uid: Option<u32>,
+
+    /// Cluster's fully qualified domain name (read-only)
     pub name: String,
+
+    /// Cluster creation date (read-only)
+    pub created: Option<String>,
+
+    /// Last changed time (read-only)
+    pub last_changed_time: Option<String>,
+
+    /// Software version
     pub version: Option<String>,
+
+    /// License expiration status
     pub license_expired: Option<bool>,
+
+    /// List of node UIDs in the cluster
     pub nodes: Option<Vec<u32>>,
+
+    /// List of database UIDs in the cluster
     pub databases: Option<Vec<u32>>,
+
+    /// Cluster status
     pub status: Option<String>,
+
+    /// Enables/disables node/cluster email alerts
     pub email_alerts: Option<bool>,
+
+    /// Indicates if cluster operates in rack-aware mode
     pub rack_aware: Option<bool>,
 
+    /// Storage engine for Auto Tiering ('speedb' or 'rocksdb')
+    pub bigstore_driver: Option<String>,
+
+    /// API HTTP listening port (range: 1024-65535)
+    pub cnm_http_port: Option<u16>,
+
+    /// API HTTPS listening port (range: 1024-65535)
+    pub cnm_https_port: Option<u16>,
+
     // Stats
+    /// Total memory available in the cluster
     pub total_memory: Option<u64>,
+
+    /// Total memory used in the cluster
     pub used_memory: Option<u64>,
+
+    /// Total number of shards in the cluster
     pub total_shards: Option<u32>,
 
     #[serde(flatten)]

crates/redis-enterprise/src/license.rs

@@ -14,19 +14,66 @@ use typed_builder::TypedBuilder;
 /// License information
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct License {
+    /// License key string
     pub license_key: String,
-    pub type_: String,
+
+    /// Key field (some endpoints may return this instead of license_key)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub key: Option<String>,
+
+    /// License string
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub license: Option<String>,
+
+    /// License type
+    pub type_: Option<String>,
+
+    /// Mark license expired or not
     pub expired: bool,
+
+    /// License activation date
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub activation_date: Option<String>,
+
+    /// License expiration date
     #[serde(skip_serializing_if = "Option::is_none")]
     pub expiration_date: Option<String>,
+
+    /// The cluster name as appears in the license
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cluster_name: Option<String>,
+
+    /// Owner of license
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub owner: Option<String>,
+
+    /// Shards limit
     #[serde(skip_serializing_if = "Option::is_none")]
     pub shards_limit: Option<u32>,
+
+    /// Amount of RAM shards in use
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ram_shards_in_use: Option<u32>,
+
+    /// Amount of RAM shards allowed
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ram_shards_limit: Option<u32>,
+
+    /// Amount of flash shards in use
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub flash_shards_in_use: Option<u32>,
+
+    /// Amount of flash shards allowed
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub flash_shards_limit: Option<u32>,
+
+    /// Node limit (deprecated in favor of shards_limit)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub node_limit: Option<u32>,
+
+    /// List of features supported by license
     #[serde(skip_serializing_if = "Option::is_none")]
     pub features: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub owner: Option<String>,
 
     #[serde(flatten)]
     pub extra: Value,

crates/redis-enterprise/src/nodes.rs

@@ -26,73 +26,103 @@ pub struct NodeActionResponse {
 /// Node information
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Node {
+    /// Cluster unique ID of node (read-only)
     pub uid: u32,
 
-    /// IP address of the node (renamed from 'address' to match API)
+    /// Internal IP address of node
     #[serde(rename = "addr")]
     pub addr: Option<String>,
 
+    /// Node status (read-only)
     pub status: String,
 
-    /// Whether node accepts new shards
+    /// Node accepts new shards if true
     pub accept_servers: Option<bool>,
 
-    /// System architecture (e.g., "aarch64", "x86_64")
+    /// Hardware architecture (read-only)
     pub architecture: Option<String>,
 
-    /// CPU cores (renamed from 'cpu_cores' to match API)
+    /// Total number of CPU cores (read-only)
     #[serde(rename = "cores")]
     pub cores: Option<u32>,
 
-    /// External IP addresses
+    /// External IP addresses of node
     pub external_addr: Option<Vec<String>>,
 
     /// Total memory in bytes
     pub total_memory: Option<u64>,
 
-    /// OS version information
+    /// Installed OS version (read-only)
     pub os_version: Option<String>,
+    /// Operating system name (read-only)
     pub os_name: Option<String>,
+    /// Operating system family (read-only)
     pub os_family: Option<String>,
+    /// Full version number (read-only)
     pub os_semantic_version: Option<String>,
 
-    /// Storage sizes (API returns f64, not u64)
+    /// Ephemeral storage size in bytes (read-only)
     pub ephemeral_storage_size: Option<f64>,
+    /// Persistent storage size in bytes (read-only)
     pub persistent_storage_size: Option<f64>,
 
-    /// Storage paths
+    /// Ephemeral storage path (read-only)
     pub ephemeral_storage_path: Option<String>,
+    /// Persistent storage path (read-only)
     pub persistent_storage_path: Option<String>,
+    /// Flash storage path (read-only)
     pub bigredis_storage_path: Option<String>,
 
-    /// Rack configuration
+    /// Rack ID where node is installed
     pub rack_id: Option<String>,
+    /// Second rack ID where node is installed
     pub second_rack_id: Option<String>,
 
-    /// Shard information
+    /// Number of shards on the node (read-only)
     pub shard_count: Option<u32>,
+    /// Cluster unique IDs of all node shards
     pub shard_list: Option<Vec<u32>>,
+    /// RAM shard count
     pub ram_shard_count: Option<u32>,
+    /// Flash shard count
     pub flash_shard_count: Option<u32>,
 
-    /// Features and capabilities
+    /// Flash storage enabled for Auto Tiering databases
     pub bigstore_enabled: Option<bool>,
+    /// FIPS mode enabled
     pub fips_enabled: Option<bool>,
+    /// Use internal IPv6
     pub use_internal_ipv6: Option<bool>,
 
-    /// Limits and settings
+    /// Maximum number of listeners on the node
     pub max_listeners: Option<u32>,
+    /// Maximum number of shards on the node
     pub max_redis_servers: Option<u32>,
+    /// Maximum background processes forked from shards
     pub max_redis_forks: Option<i32>,
+    /// Maximum simultaneous replica full syncs
     pub max_slave_full_syncs: Option<i32>,
 
-    /// Runtime information
+    /// Node uptime in seconds
     pub uptime: Option<u64>,
+    /// Installed Redis Enterprise cluster software version (read-only)
     pub software_version: Option<String>,
 
-    /// Supported Redis versions
+    /// Supported database versions
     pub supported_database_versions: Option<Vec<Value>>,
 
+    /// Bigstore driver name (deprecated)
+    pub bigstore_driver: Option<String>,
+
+    /// Storage size of bigstore storage (read-only)
+    pub bigstore_size: Option<u64>,
+
+    /// Public IP address (deprecated)
+    pub public_addr: Option<String>,
+
+    /// Recovery files path
+    pub recovery_path: Option<String>,
+
     /// Capture any additional fields not explicitly defined
     #[serde(flatten)]
     pub extra: Value,

crates/redis-enterprise/tests/license_tests.rs

@@ -79,7 +79,7 @@ async fn test_license_get() {
     assert!(result.is_ok());
     let license = result.unwrap();
     assert_eq!(license.license_key, "lic-123-456-789");
-    assert_eq!(license.type_, "production");
+    assert_eq!(license.type_, Some("production".to_string()));
     assert!(!license.expired);
     assert_eq!(
         license.expiration_date,
@@ -122,7 +122,7 @@ async fn test_license_get_expired() {
     assert!(result.is_ok());
     let license = result.unwrap();
     assert_eq!(license.license_key, "lic-expired-123");
-    assert_eq!(license.type_, "trial");
+    assert_eq!(license.type_, Some("trial".to_string()));
     assert!(license.expired);
     assert_eq!(
         license.expiration_date,
@@ -156,7 +156,7 @@ async fn test_license_get_minimal() {
     assert!(result.is_ok());
     let license = result.unwrap();
     assert_eq!(license.license_key, "lic-minimal-789");
-    assert_eq!(license.type_, "dev");
+    assert_eq!(license.type_, Some("dev".to_string()));
     assert!(!license.expired);
     assert!(license.expiration_date.is_none());
     assert!(license.shards_limit.is_none());
@@ -203,7 +203,7 @@ async fn test_license_update() {
     assert!(result.is_ok());
     let license = result.unwrap();
     assert_eq!(license.license_key, "new-license-key-12345");
-    assert_eq!(license.type_, "production");
+    assert_eq!(license.type_, Some("production".to_string()));
     assert!(!license.expired);
     assert_eq!(license.shards_limit, Some(200));
     assert_eq!(license.node_limit, Some(20));
@@ -323,7 +323,7 @@ async fn test_license_validate_valid() {
     assert!(result.is_ok());
     let license = result.unwrap();
     assert_eq!(license.license_key, "valid-license-to-validate");
-    assert_eq!(license.type_, "production");
+    assert_eq!(license.type_, Some("production".to_string()));
     assert!(!license.expired);
     assert_eq!(license.shards_limit, Some(50));
     assert_eq!(license.node_limit, Some(5));
@@ -394,7 +394,7 @@ async fn test_license_cluster_license() {
     assert!(result.is_ok());
     let license = result.unwrap();
     assert_eq!(license.license_key, "cluster-license-789");
-    assert_eq!(license.type_, "enterprise");
+    assert_eq!(license.type_, Some("enterprise".to_string()));
     assert!(!license.expired);
     assert_eq!(license.shards_limit, Some(1000));
     assert_eq!(license.node_limit, Some(100));