Add unparsedObject support (#33)

Co-authored-by: Kevin Zou <[email protected]>

Author: skarimo

.generator/src/generator/templates/common_mod.j2

@@ -1,5 +1,6 @@
 use std::error;
 use std::fmt;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[derive(Debug, Clone)]
 pub struct ResponseContent<T> {
@@ -117,3 +118,26 @@ impl serde_json::ser::Formatter for DDFormatter {
 }
 
 pub mod configuration;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct UnparsedObject {
+    pub value: serde_json::Value,
+}
+
+impl<'de> Deserialize<'de> for UnparsedObject {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let val: serde_json::Value = Deserialize::deserialize(deserializer)?;
+        Ok(UnparsedObject {
+            value: val,
+        })
+    }
+}
+
+impl Serialize for UnparsedObject {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.value.serialize(serializer)
+    }
+}

.generator/src/generator/templates/model_enum.j2

@@ -10,6 +10,7 @@ pub enum {{ name }} {
 {%- for index, value in enumerate(model.enum) %}
 	{{ model["x-enum-varnames"][index] or value.upper() }},
 {%- endfor %}
+    UnparsedObject(crate::datadog::UnparsedObject),
 }
 
 {%- if not model["type"] == "integer" %}
@@ -20,6 +21,7 @@ impl ToString for {{ name }} {
 {%- for index, value in enumerate(model.enum) %}
             Self::{{model["x-enum-varnames"][index] or value.upper()}} => String::from("{{value}}"),
 {%- endfor %}
+            Self::UnparsedObject(v) => v.value.to_string(),
         }
     }
 }
@@ -31,6 +33,7 @@ impl Serialize for {{ name }} {
         S: Serializer,
     {
         match self {
+            Self::UnparsedObject(v) => v.serialize(serializer),
         {%- if model["type"] == "string"%}
             _ => serializer.serialize_str(self.to_string().as_str()),
         {%- else %}
@@ -52,12 +55,7 @@ impl<'de> Deserialize<'de> for {{ name }} {
             {%- for index, value in enumerate(model.enum) %}
             {%- if model["type"] == "string" %}"{%- endif %}{{ value }}{%- if model["type"] == "string" %}"{%- endif %} => Self::{{ model["x-enum-varnames"][index] or value.upper() }},
             {%- endfor %}
-            _ => {
-                return Err(serde::de::Error::custom(format!(
-                    "Invalid value for SyntheticsDeviceID: {}",
-                    s
-                )))
-            }
+            _ => Self::UnparsedObject(crate::datadog::UnparsedObject { value: serde_json::Value::{%- if model["type"] == "string" %}String{%- else %}Number{%- endif %}(s.into()) }),
         })
     }
 }

.generator/src/generator/templates/model_oneof.j2

@@ -1,8 +1,8 @@
-use serde::{Deserialize, Serialize};
+use serde::{Deserializer, Deserialize, Serialize};
 
 {{ model.description | block_comment }}
 #[non_exhaustive]
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize)]
 #[serde(untagged)]
 pub enum {{name}} {
     {%- for oneOf in model.oneOf %}
@@ -14,4 +14,34 @@ pub enum {{name}} {
 	{{attributeName}}(Box<{{dataType}}>),
 	{%- endif %}
     {%- endfor%}
+	UnparsedObject(crate::datadog::UnparsedObject),
 }
+
+impl<'de> Deserialize<'de> for {{ name }} {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value: serde_json::Value = Deserialize::deserialize(deserializer)?;
+
+		{%- for oneOf in model.oneOf %}
+		{%- set dataType = get_type(oneOf, render_nullable=false, render_option=false, render_box=false, version=version) %}
+		{%- set attributeName = (get_name(oneOf) or dataType)|upperfirst %}
+
+		{%- if oneOf | is_primitive or oneOf.type == "array" %}
+		if let Ok(_v) = serde_json::from_value::<{{ dataType }}>(value.clone()) {
+            return Ok({{ name }}::{{ attributeName }}(_v))
+        }
+		{%- else %}
+		if let Ok(_v) = serde_json::from_value::<Box<{{ dataType }}>>(value.clone()) {
+			if !_v._unparsed {
+                return Ok({{ name }}::{{ attributeName }}(_v));
+            }
+        }
+		{%- endif %}
+
+		{%- endfor%}
+	
+        return Ok({{ name }}::UnparsedObject(crate::datadog::UnparsedObject { value }));
+    }
+}

.generator/src/generator/templates/model_simple.j2

@@ -1,10 +1,12 @@
-use serde::{Serialize, Deserialize};
+use std::fmt::{self, Formatter};
+use serde::{Deserializer, Deserialize, Serialize};
+use serde::de::{Error, MapAccess, Visitor};
 use serde_with::skip_serializing_none;
 
 {{ model.description | block_comment }}
 #[non_exhaustive]
 #[skip_serializing_none]
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize)]
 pub struct {{ name }} {
 {%- for attr, schema in model.get("properties", {}).items() %}
 {%- set propertyName = attr|variable_name %}
@@ -28,6 +30,9 @@ pub struct {{ name }} {
     #[serde(flatten)]
     pub additional_properties: std::collections::BTreeMap<String, {{ dataType }}>,
 {%- endif %}
+    #[serde(skip)]
+    #[serde(default)]
+    pub(crate) _unparsed: bool
 }
 
 impl {{ name }} {
@@ -49,6 +54,7 @@ impl {{ name }} {
             {%- if model.additionalProperties is defined and model.additionalProperties != false %}
             additional_properties: std::collections::BTreeMap::new(),
             {%- endif %}
+            _unparsed: false,
         }
     }
     {% for attr, schema in model.get("properties", {}).items() if attr not in model.required %}
@@ -78,3 +84,98 @@ impl Default for {{ name }} {
     }
 }
 {%- endif %}
+
+impl<'de> Deserialize<'de> for {{ name }} {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct {{ name }}Visitor;
+        impl<'a> Visitor<'a> for {{ name }}Visitor {
+            type Value = {{ name }};
+
+            fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
+                f.write_str("a mapping")
+            }
+
+            fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
+            where
+                M: MapAccess<'a>,
+            {
+                {%- for attr, schema in model.get("properties", {}).items() %}
+                {%- set required = attr in model.required %}
+                {%- set propertyName = attr|variable_name %}
+                {%- set nullable = schema.get("nullable", false)%}
+                {%- set dataType = get_type(schema, alternative_name=name + attr|variable_name, render_nullable=nullable, render_option=not required, render_box=false, version=version) %}
+                let mut {{ propertyName }}: {% if required %}Option<{% endif %}{{ dataType }}{% if required %}>{% endif %} = None;
+                {%- endfor %}
+
+                {%- if model.additionalProperties is defined and model.additionalProperties != false %}
+                {%- set dataType = get_type(model.additionalProperties, alternative_name=None, render_nullable=false, render_option=false, render_box=false, version=version) %}
+                    let mut additional_properties: std::collections::BTreeMap<String, {{ dataType }}> = std::collections::BTreeMap::new();
+                {%- endif %}
+                let mut _unparsed = false;
+
+                while let Some((k, v)) = map.next_entry::<String, serde_json::Value>()? {
+                    match k.as_str() {
+                        {%- for attr, schema in model.get("properties", {}).items() %}
+                        {%- set required = attr in model.required %}
+                        {%- set propertyName = attr|variable_name %}
+                        {%- set nullable = schema.get("nullable", false)%}
+                        {%- set dataType = get_type(schema, alternative_name=name + propertyName, render_option=false, version=version) %}
+                        "{{ attr }}" => {
+                            {%- if not nullable and not required %}
+                            if v.is_null() {
+                                continue;
+                            }
+                            {%- endif %}
+                            {{ propertyName }} = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                            {%- if schema.enum or schema.oneOf %}
+                            if let Some(ref _{{ propertyName }}) = {{ propertyName }} {
+                                match _{{ propertyName }} {
+                                    {% if nullable%}Some({% endif %}{{ dataType }}::UnparsedObject(_{{ propertyName }}){% if nullable%}){% endif %} => {
+                                        _unparsed = true;
+                                    },
+                                    _ => {}
+                                }
+                            }
+                            {%- endif %}
+                        },
+                        {%- endfor %}
+                        &_ => {
+                            {%- if model.additionalProperties is defined and model.additionalProperties != false %}
+                            if let Ok(value) = serde_json::from_value(v.clone()) {
+                                additional_properties.insert(k, value);
+                            }
+                            {%- endif %}
+                        },
+                    }
+                }
+
+                {%- for attr, schema in model.get("properties", {}).items() %}
+                {%- set required = attr in model.required %}
+                {%- set propertyName = attr|variable_name %}
+                {%- set nullable = schema.get("nullable", false)%}
+                {%- if required %}
+                let {{ propertyName }} = {{ propertyName }}.ok_or_else(|| M::Error::missing_field("{{ propertyName }}"))?;
+                {%- endif %}
+                {%- endfor %}
+
+                let content = {{ name }} {
+                    {%- for attr, schema in model.get("properties", {}).items() %}
+                    {%- set propertyName = attr|variable_name %}
+                    {{ propertyName }},
+                    {%- endfor %}
+                    {%- if model.additionalProperties is defined and model.additionalProperties != false %}
+                    additional_properties,
+                    {%- endif %}
+                    _unparsed,
+                };
+
+                Ok(content)
+            }
+        }
+
+        deserializer.deserialize_any({{ name }}Visitor)
+    }
+}

src/datadog/mod.rs

@@ -1,3 +1,4 @@
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::error;
 use std::fmt;
 
@@ -121,3 +122,24 @@ impl serde_json::ser::Formatter for DDFormatter {
 }
 
 pub mod configuration;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct UnparsedObject {
+    pub value: serde_json::Value,
+}
+
+impl<'de> Deserialize<'de> for UnparsedObject {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let val: serde_json::Value = Deserialize::deserialize(deserializer)?;
+        Ok(UnparsedObject { value: val })
+    }
+}
+
+impl Serialize for UnparsedObject {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.value.serialize(serializer)
+    }
+}

src/datadogV1/model/model_access_role.rs

@@ -11,6 +11,7 @@ pub enum AccessRole {
     ADMIN,
     READ_ONLY,
     ERROR,
+    UnparsedObject(crate::datadog::UnparsedObject),
 }
 
 impl ToString for AccessRole {
@@ -20,6 +21,7 @@ impl ToString for AccessRole {
             Self::ADMIN => String::from("adm"),
             Self::READ_ONLY => String::from("ro"),
             Self::ERROR => String::from("ERROR"),
+            Self::UnparsedObject(v) => v.value.to_string(),
         }
     }
 }
@@ -30,6 +32,7 @@ impl Serialize for AccessRole {
         S: Serializer,
     {
         match self {
+            Self::UnparsedObject(v) => v.serialize(serializer),
             _ => serializer.serialize_str(self.to_string().as_str()),
         }
     }
@@ -46,12 +49,9 @@ impl<'de> Deserialize<'de> for AccessRole {
             "adm" => Self::ADMIN,
             "ro" => Self::READ_ONLY,
             "ERROR" => Self::ERROR,
-            _ => {
-                return Err(serde::de::Error::custom(format!(
-                    "Invalid value for SyntheticsDeviceID: {}",
-                    s
-                )))
-            }
+            _ => Self::UnparsedObject(crate::datadog::UnparsedObject {
+                value: serde_json::Value::String(s.into()),
+            }),
         })
     }
 }