fix: Move from serde private Content struct to serde_value. (#187)

* fix: Move from serde private Content struct to serde_value.

Signed-off-by: David Steele <david.steele@alianza.com>

* Markups

Signed-off-by: David Steele <david.steele@alianza.com>

---------

Signed-off-by: David Steele <david.steele@alianza.com>

Author: dsteeley

CHANGELOG.md

@@ -9,6 +9,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Fixed
 
+## [7.0.0-rc3] - 2025-09-16
+### Fixed
+- Replace usage of `serde` `__private` module with `serde-value` crate to avoid breakage after  `serde` 1.0.220.
+
 ## [7.0.0-rc2] - 2025-06-10
 ### Changed
 - Replace `mime_multipart` with fork for hyper 1.x
@@ -229,7 +233,8 @@ No changes. We now think we've got enough to declare this crate stable.
 ## [0.5.0] - 2017-09-18
 - Start of changelog.
 
-[Unreleased]: https://github.com/Metaswitch/swagger-rs/compare/7.0.0-rc2...HEAD
+[Unreleased]: https://github.com/Metaswitch/swagger-rs/compare/7.0.0-rc3...HEAD
+[7.0.0-rc3]: https://github.com/Metaswitch/swagger-rs/compare/7.0.0-rc2...7.0.0-rc3
 [7.0.0-rc2]: https://github.com/Metaswitch/swagger-rs/compare/7.0.0-rc1...7.0.0-rc2
 [7.0.0-rc1]: https://github.com/Metaswitch/swagger-rs/compare/6.5.0...7.0.0-rc1
 [6.5.0]: https://github.com/Metaswitch/swagger-rs/compare/6.4.1...6.5.0

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "swagger"
-version = "7.0.0-rc2"
+version = "7.0.0-rc3"
 authors = ["Metaswitch Networks Ltd"]
 license = "Apache-2.0"
 description = "A set of common utilities for Rust code generated by OpenAPI Generator"
@@ -14,7 +14,7 @@ edition = "2021"
 default = ["serdejson"]
 multipart_form = ["mime"]
 multipart_related = ["mime_multipart", "mime"]
-serdejson = ["serde", "serde_json"]
+serdejson = ["serde_json"]
 serdevalid = ["serdejson", "serde_valid", "regex", "paste"]
 server = ["hyper/server"]
 http1 = ["hyper/http1"]
@@ -60,9 +60,10 @@ mime_multipart = { version = "0.10", package = "mime-multipart-hyper1", optional
 # serde
 paste = { version = "1", optional = true }
 regex = { version = "1", optional = true }
-serde = { version = "1.0.119", optional = true, features = ["derive"] }
+serde = { version = "1.0.225", features = ["derive"] }
 serde_json = { version = "1.0", optional = true }
 serde_valid = { version = "1.0", optional = true }
+serde-value = { version = "0.7" }
 
 # UDS (Unix Domain Sockets)
 tokio = { version = "1.0", default-features = false, optional = true }

src/one_any_of.rs

@@ -1,17 +1,15 @@
 //! Implementations of OpenAPI `oneOf` and `anyOf` types, assuming rules are just types
 #[cfg(feature = "conversion")]
 use frunk_enum_derive::LabelledGenericEnum;
-use serde::{
-    de::Error,
-    Deserialize, Deserializer, Serialize, Serializer,
-    __private::de::{Content, ContentRefDeserializer},
-};
+use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
 #[cfg(feature = "serdevalid")]
 use serde_valid::Validate;
 use std::fmt;
 use std::str::FromStr;
 use std::string::ToString;
 
+use serde_value::Value as SerdeValue;
+
 // Define a macro to define the common parts between `OneOf` and `AnyOf` enums for a specific
 // number of inner types.
 macro_rules! common_one_any_of {
@@ -67,10 +65,11 @@ macro_rules! one_of {
             $($i: PartialEq + for<'a> Deserialize<'a>,)*
         {
             fn deserialize<De: Deserializer<'b>>(deserializer: De) -> Result<Self, De::Error> {
-                let content = Content::deserialize(deserializer)?;
+                // Capture once into a generic value (serde_value supports all JSON-like data)
+                let captured: SerdeValue = SerdeValue::deserialize(deserializer)?;
                 let mut result = Err(De::Error::custom("data did not match any within oneOf"));
                 $(
-                    if let Ok(inner) = $i::deserialize(ContentRefDeserializer::<De::Error>::new(&content)) {
+                    if let Ok(inner) = <$i as Deserialize>::deserialize(captured.clone()) {
                         if result.is_err() {
                             result = Ok(Self::$i(inner));
                         } else {
@@ -133,9 +132,9 @@ macro_rules! any_of {
             $($i: PartialEq + for<'a> Deserialize<'a>,)*
         {
             fn deserialize<De: Deserializer<'b>>(deserializer: De) -> Result<Self, De::Error> {
-                let content = Content::deserialize(deserializer)?;
+                let captured: SerdeValue = SerdeValue::deserialize(deserializer)?;
                 $(
-                    if let Ok(inner) = $i::deserialize(ContentRefDeserializer::<De::Error>::new(&content)) {
+                    if let Ok(inner) = <$i as Deserialize>::deserialize(captured.clone()) {
                         return Ok(Self::$i(inner));
                     }
                 )*
@@ -176,3 +175,274 @@ any_of!(AnyOf13, A, B, C, D, E, F, G, H, I, J, K, L, M);
 any_of!(AnyOf14, A, B, C, D, E, F, G, H, I, J, K, L, M, N);
 any_of!(AnyOf15, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
 any_of!(AnyOf16, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn anyof_prefers_first_matching_deserialize_number() {
+        let json = "123";
+        let v: AnyOf2<u32, String> = serde_json::from_str(json).unwrap();
+        match v {
+            AnyOf2::A(n) => assert_eq!(n, 123),
+            AnyOf2::B(_) => panic!("expected A variant"),
+        }
+    }
+
+    #[test]
+    fn anyof_prefers_first_matching_fromstr_number() {
+        let v = AnyOf2::<u8, String>::from_str("123").unwrap();
+        match v {
+            AnyOf2::A(n) => assert_eq!(n, 123),
+            AnyOf2::B(_) => panic!("expected A variant"),
+        }
+    }
+
+    #[test]
+    fn anyof_deserialize_string_to_second_variant() {
+        let json = "\"hello\"";
+        let v: AnyOf2<u32, String> = serde_json::from_str(json).unwrap();
+        match v {
+            AnyOf2::B(s) => assert_eq!(s, "hello"),
+            AnyOf2::A(_) => panic!("expected B variant"),
+        }
+    }
+
+    #[test]
+    fn oneof_deserialize_single_match() {
+        let json = "\"hi\"";
+        let v: OneOf2<u32, String> = serde_json::from_str(json).unwrap();
+        match v {
+            OneOf2::B(s) => assert_eq!(s, "hi"),
+            OneOf2::A(_) => panic!("expected B variant"),
+        }
+    }
+
+    #[test]
+    fn oneof_deserialize_error_on_multiple_matches() {
+        // both u32 and u64 will deserialize from "123" -> ambiguity -> error
+        let json = "123";
+        let res: Result<OneOf2<u32, u64>, _> = serde_json::from_str(json);
+        assert!(res.is_err(), "expected error when multiple variants match");
+    }
+
+    #[test]
+    fn oneof_fromstr_error_on_multiple_matches() {
+        // String::from_str always succeeds and u8::from_str also succeeds here -> multiple matches
+        let res = OneOf2::<u8, String>::from_str("123");
+        assert!(res.is_err(), "expected error when multiple FromStr matches");
+    }
+
+    #[test]
+    fn display_and_serialize_roundtrip() {
+        let a: OneOf2<u32, String> = OneOf2::A(7u32);
+        assert_eq!(a.to_string(), "7");
+        let ser = serde_json::to_string(&a).unwrap();
+        assert_eq!(ser, "7");
+
+        let b: OneOf2<u32, String> = OneOf2::B(String::from("abc"));
+        assert_eq!(b.to_string(), "abc");
+        let ser_b = serde_json::to_string(&b).unwrap();
+        assert_eq!(ser_b, "\"abc\"");
+    }
+
+    #[test]
+    fn map_ambiguity_oneof() {
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct S1 {
+            x: u32,
+        }
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct S2 {
+            x: u64,
+        }
+        let json = "{\"x\":123}";
+        let res: Result<OneOf2<S1, S2>, _> = serde_json::from_str(json);
+        assert!(
+            res.is_err(),
+            "expected ambiguity error for map matching two structs"
+        );
+    }
+
+    #[test]
+    fn map_first_match_anyof() {
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct S1 {
+            x: u32,
+        }
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct S2 {
+            x: u64,
+        }
+        let json = "{\"x\":123}";
+        let v: AnyOf2<S1, S2> = serde_json::from_str(json).unwrap();
+        match v {
+            AnyOf2::A(s) => assert_eq!(s.x, 123),
+            AnyOf2::B(_) => panic!("expected first struct"),
+        }
+    }
+
+    #[test]
+    fn null_ambiguity_oneof() {
+        let json = "null";
+        // Option<Unit> deserializes to None from null; Unit also deserializes from null? (No, unit struct expects object usually) -> To create ambiguity, use Option<String> and Option<u32> both None
+        let res: Result<OneOf2<Option<u32>, Option<String>>, _> = serde_json::from_str(json);
+        assert!(
+            res.is_err(),
+            "expected ambiguity with null across two Option types"
+        );
+    }
+
+    #[test]
+    fn null_preference_anyof() {
+        let json = "null";
+        let v: AnyOf2<Option<u32>, Option<String>> = serde_json::from_str(json).unwrap();
+        match v {
+            AnyOf2::A(opt) => assert!(opt.is_none()),
+            AnyOf2::B(_) => panic!("expected first Option variant"),
+        }
+    }
+
+    #[test]
+    fn sequence_ambiguity_oneof() {
+        let json = "[1,2]";
+        let res: Result<OneOf2<Vec<u8>, Vec<u16>>, _> = serde_json::from_str(json);
+        assert!(
+            res.is_err(),
+            "expected ambiguity for two vector numeric element types fitting both"
+        );
+    }
+
+    #[test]
+    fn sequence_first_match_anyof() {
+        let json = "[1,2]";
+        let v: AnyOf2<Vec<u8>, Vec<u16>> = serde_json::from_str(json).unwrap();
+        match v {
+            AnyOf2::A(v1) => assert_eq!(v1, vec![1, 2]),
+            AnyOf2::B(_) => panic!("expected first vector variant"),
+        }
+    }
+
+    #[test]
+    fn large_number_anyof_prefers_second() {
+        let json = "5000000000"; // > u32::MAX
+        let v: AnyOf2<u32, u64> = serde_json::from_str(json).unwrap();
+        match v {
+            AnyOf2::B(n) => assert_eq!(n, 5_000_000_000u64),
+            AnyOf2::A(_) => panic!("expected second variant since first fails"),
+        }
+    }
+
+    #[test]
+    fn oneof_deserialize_no_match_error() {
+        // bool doesn't match u32 or String (needs quotes for string)
+        let json = "true";
+        let res: Result<OneOf2<u32, String>, _> = serde_json::from_str(json);
+        assert!(res.is_err());
+        let msg = format!("{}", res.unwrap_err());
+        assert!(
+            msg.contains("did not match any within oneOf"),
+            "unexpected error message: {msg}"
+        );
+    }
+
+    #[test]
+    fn anyof_deserialize_no_match_error() {
+        let json = "false"; // neither u32 nor String
+        let res: Result<AnyOf2<u32, String>, _> = serde_json::from_str(json);
+        assert!(res.is_err());
+        let msg = format!("{}", res.unwrap_err());
+        assert!(
+            msg.contains("did not match any within anyOf"),
+            "unexpected error message: {msg}"
+        );
+    }
+
+    #[test]
+    fn oneof_fromstr_single_match() {
+        let v = OneOf2::<bool, u8>::from_str("true").expect("bool should parse");
+        match v {
+            OneOf2::A(b) => assert!(b),
+            _ => panic!("expected bool variant"),
+        }
+    }
+
+    #[test]
+    fn oneof_fromstr_no_match() {
+        let res = OneOf2::<u32, u16>::from_str("abc");
+        assert!(res.is_err());
+    }
+
+    #[test]
+    fn anyof_fromstr_later_match() {
+        let v = AnyOf2::<u32, bool>::from_str("true").expect("bool should parse");
+        match v {
+            AnyOf2::B(b) => assert!(b),
+            _ => panic!("expected second bool variant"),
+        }
+    }
+
+    #[test]
+    fn anyof_fromstr_no_match() {
+        let res = AnyOf2::<u32, u16>::from_str("abc");
+        assert!(res.is_err());
+    }
+
+    #[test]
+    fn oneof_higher_arity_ambiguity() {
+        // "5" (number) matches u8, u16, u32 -> ambiguity error
+        let json = "5";
+        let res: Result<OneOf3<u8, u16, u32>, _> = serde_json::from_str(json);
+        assert!(res.is_err(), "expected ambiguity for three numeric matches");
+    }
+
+    #[test]
+    fn anyof_higher_arity_middle_match() {
+        // true fails u32, matches bool (middle), should select variant B
+        let json = "true";
+        let v: AnyOf3<u32, bool, String> = serde_json::from_str(json).unwrap();
+        match v {
+            AnyOf3::B(b) => assert!(b),
+            _ => panic!("expected middle bool variant"),
+        }
+    }
+
+    #[test]
+    fn oneof_display_serialize_variant_c() {
+        let c: OneOf3<String, u32, bool> = OneOf3::C(true);
+        assert_eq!(c.to_string(), "true");
+        let ser = serde_json::to_string(&c).unwrap();
+        assert_eq!(ser, "true");
+    }
+
+    #[test]
+    fn anyof_nested_structure_second_variant() {
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct A {
+            x: u32,
+        }
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct B {
+            y: u32,
+        }
+        let json = "{\"y\":5}";
+        let v: AnyOf3<A, B, String> = serde_json::from_str(json).unwrap();
+        match v {
+            AnyOf3::B(b) => assert_eq!(b.y, 5),
+            _ => panic!("expected struct B variant"),
+        }
+    }
+
+    #[test]
+    fn oneof_ambiguity_error_message() {
+        let json = "123"; // matches multiple integer widths
+        let res: Result<OneOf2<u32, u64>, _> = serde_json::from_str(json);
+        let err = res.unwrap_err();
+        let msg = format!("{}", err);
+        assert!(
+            msg.contains("data matched multiple within oneOf"),
+            "missing ambiguity message: {msg}"
+        );
+    }
+}