feat: add serde_path_to_error for better deserialization error messages (#349)

* fix(redis-enterprise): correct master_persistence type from String to bool

The Redis Enterprise API returns master_persistence as a boolean value (false),
not a string. This mismatch was causing deserialization errors when fetching
database information.

Fixes #347

* feat: add serde_path_to_error for better deserialization error messages

- Add serde_path_to_error dependency to both redis-cloud and redis-enterprise crates
- Update handle_response methods to use serde_path_to_error::deserialize
- Provides exact field path in error messages (e.g., 'master_persistence')
- Makes debugging type mismatches much easier

Example improvement:
Before: 'invalid type: string "should-be-bool", expected a boolean'
After: 'Failed to deserialize field 'master_persistence': invalid type: string "should-be-bool", expected a boolean'

This will help catch field type issues like #347 more quickly in the future.

Author: joshrotenberg

Cargo.lock

@@ -19,6 +19,7 @@ async-trait = { workspace = true }
 reqwest = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+serde_path_to_error = "0.1"
 thiserror = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }

crates/redis-cloud/Cargo.toml

@@ -309,15 +309,21 @@ impl CloudClient {
         let status = response.status();
 
         if status.is_success() {
-            // Try to get the response text first for debugging
-            let text = response.text().await.map_err(|e| {
+            // Get the response bytes for better error reporting
+            let bytes = response.bytes().await.map_err(|e| {
                 RestError::ConnectionError(format!("Failed to read response: {}", e))
             })?;
 
-            // Try to parse as JSON
-            serde_json::from_str::<T>(&text).map_err(|e| {
-                // If parsing fails, include the actual response for debugging
-                RestError::JsonError(e)
+            // Use serde_path_to_error for better deserialization error messages
+            let deserializer = &mut serde_json::Deserializer::from_slice(&bytes);
+            serde_path_to_error::deserialize(deserializer).map_err(|err| {
+                let path = err.path().to_string();
+                // Use ConnectionError to provide detailed error message with field path
+                RestError::ConnectionError(format!(
+                    "Failed to deserialize field '{}': {}",
+                    path,
+                    err.inner()
+                ))
             })
         } else {
             let text = response.text().await.unwrap_or_default();

crates/redis-cloud/src/client.rs

@@ -19,6 +19,7 @@ async-trait = { workspace = true }
 reqwest = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+serde_path_to_error = "0.1"
 serde_urlencoded = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }

crates/redis-enterprise/Cargo.toml

@@ -512,7 +512,19 @@ impl EnterpriseClient {
     /// Handle HTTP response
     async fn handle_response<T: DeserializeOwned>(&self, response: Response) -> Result<T> {
         if response.status().is_success() {
-            response.json::<T>().await.map_err(Into::into)
+            // Get the response bytes for better error reporting
+            let bytes = response.bytes().await.map_err(Into::<RestError>::into)?;
+
+            // Use serde_path_to_error for better deserialization error messages
+            let deserializer = &mut serde_json::Deserializer::from_slice(&bytes);
+            serde_path_to_error::deserialize(deserializer).map_err(|err| {
+                let path = err.path().to_string();
+                RestError::ParseError(format!(
+                    "Failed to deserialize field '{}': {}",
+                    path,
+                    err.inner()
+                ))
+            })
         } else {
             let status = response.status();
             let text = response.text().await.unwrap_or_default();

crates/redis-enterprise/src/client.rs

@@ -0,0 +1,59 @@
+use redis_enterprise::bdb::DatabaseInfo;
+
+#[test]
+fn test_serde_path_to_error_improvement() {
+    // Create a test JSON with incorrect type for master_persistence
+    // Previously this would give a generic error, now it should show the exact field path
+    let bad_json = r#"{
+        "uid": 1,
+        "name": "test-db",
+        "type": "redis",
+        "memory_size": 1073741824,
+        "port": 12000,
+        "status": "active",
+        "master_persistence": "should-be-bool",
+        "data_persistence": "disabled"
+    }"#;
+
+    // Test with standard serde_json
+    let standard_result: Result<DatabaseInfo, _> = serde_json::from_str(bad_json);
+    assert!(standard_result.is_err());
+    let standard_error = standard_result.unwrap_err();
+    println!("Standard serde_json error: {}", standard_error);
+
+    // Test with serde_path_to_error
+    let deserializer = &mut serde_json::Deserializer::from_str(bad_json);
+    let path_result: Result<DatabaseInfo, _> = serde_path_to_error::deserialize(deserializer);
+    assert!(path_result.is_err());
+
+    let path_error = path_result.unwrap_err();
+    println!("Improved error with path:");
+    println!("  Field path: {}", path_error.path());
+    println!("  Error: {}", path_error.inner());
+
+    // Verify the path includes "master_persistence"
+    assert!(path_error.path().to_string().contains("master_persistence"));
+}
+
+#[test]
+fn test_correct_types_work() {
+    // Test that correctly typed JSON still works
+    let good_json = r#"{
+        "uid": 1,
+        "name": "test-db",
+        "type": "redis",
+        "memory_size": 1073741824,
+        "port": 12000,
+        "status": "active",
+        "master_persistence": false,
+        "data_persistence": "disabled"
+    }"#;
+
+    let result: Result<DatabaseInfo, _> = serde_json::from_str(good_json);
+    assert!(result.is_ok());
+
+    let db = result.unwrap();
+    assert_eq!(db.uid, 1);
+    assert_eq!(db.name, "test-db".to_string());
+    assert_eq!(db.master_persistence, Some(false));
+}