fix: Move from serde private Content struct to serde_value.

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

Author: dsteeley

CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ### Changed
 
 ### 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

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", "serde_json", "serde-value"]
 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", optional = true, features = ["derive"] }
 serde_json = { version = "1.0", optional = true }
 serde_valid = { version = "1.0", optional = true }
+serde-value = { version = "0.7", optional = true }
 
 # UDS (Unix Domain Sockets)
 tokio = { version = "1.0", default-features = false, optional = true }

src/one_any_of.rs

@@ -4,14 +4,16 @@ use frunk_enum_derive::LabelledGenericEnum;
 use serde::{
     de::Error,
     Deserialize, Deserializer, Serialize, Serializer,
-    __private::de::{Content, ContentRefDeserializer},
 };
 #[cfg(feature = "serdevalid")]
 use serde_valid::Validate;
 use std::fmt;
 use std::str::FromStr;
 use std::string::ToString;
 
+#[cfg(feature = "serdejson")]
+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 +69,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 +136,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 +179,222 @@ 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() {
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct Unit;
+        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}");
+    }
+}