Fix serialization of SchemaObject with boolean json_schema

Author: jplatte

crates/aide/src/openapi/schema.rs

@@ -1,15 +1,15 @@
 #![allow(clippy::large_enum_variant)]
 use crate::openapi::*;
 use schemars::Schema;
-use serde::{Deserialize, Serialize};
+use serde::{ser::SerializeMap, Deserialize, Serialize};
+use serde_json::json;
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, schemars::JsonSchema)]
+#[derive(Debug, Clone, Deserialize, PartialEq, schemars::JsonSchema)]
 pub struct SchemaObject {
     #[serde(flatten)]
     pub json_schema: Schema,
     /// Additional external documentation for this schema.
     #[serde(rename = "externalDocs")]
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub external_docs: Option<ExternalDocumentation>,
     /// A free-form property to include an example of an instance for this
     /// schema. To represent examples that cannot be naturally represented in
@@ -18,16 +18,52 @@ pub struct SchemaObject {
     /// been deprecated in favor of the JSON Schema `examples` keyword. Use
     /// of `example` is discouraged, and later versions of this
     /// specification may remove it.
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub example: Option<serde_json::Value>,
 }
 
+impl Serialize for SchemaObject {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        if self.external_docs.is_none() && self.example.is_none() {
+            return self.json_schema.serialize(serializer);
+        }
+
+        let mut map = serializer.serialize_map(None)?;
+        match self.json_schema.as_bool() {
+            Some(true) => {}
+            Some(false) => {
+                map.serialize_entry("not", &json!({}))?;
+            }
+            _ => {
+                let object = self
+                    .json_schema
+                    .as_object()
+                    .expect("JSON schema must be either a bool or an object");
+                for (k, v) in object {
+                    map.serialize_entry(k, v)?;
+                }
+            }
+        }
+
+        if let Some(value) = &self.external_docs {
+            map.serialize_entry("externalDocs", value)?;
+        }
+        if let Some(value) = &self.example {
+            map.serialize_entry("example", value)?;
+        }
+
+        map.end()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::openapi::ExternalDocumentation;
 
     use super::SchemaObject;
-    use schemars::Schema;
+    use schemars::{json_schema, Schema};
     use serde_json::json;
 
     #[test]
@@ -63,4 +99,58 @@ mod tests {
             })
         );
     }
+
+    #[test]
+    fn test_serialize_true_schema() {
+        let serialized = serde_json::to_value(SchemaObject {
+            json_schema: json_schema!(true),
+            external_docs: None,
+            example: None,
+        })
+        .unwrap();
+
+        assert_eq!(serialized, json!(true));
+    }
+
+    #[test]
+    fn test_serialize_true_schema_with_external_docs() {
+        let serialized = serde_json::to_value(SchemaObject {
+            json_schema: json_schema!(true),
+            external_docs: Some(ExternalDocumentation {
+                description: None,
+                url: "http://example.org".to_owned(),
+                extensions: Default::default(),
+            }),
+            example: None,
+        })
+        .unwrap();
+
+        assert_eq!(
+            serialized,
+            json!({
+                "externalDocs": { "url": "http://example.org" },
+            })
+        );
+    }
+
+    #[test]
+    fn test_serialize_false_schema_with_example() {
+        let example = json!({
+            "what a useless schema": "even this example is wrong",
+        });
+        let serialized = serde_json::to_value(SchemaObject {
+            json_schema: json_schema!(false),
+            external_docs: None,
+            example: Some(example.clone()),
+        })
+        .unwrap();
+
+        assert_eq!(
+            serialized,
+            json!({
+                "not": {},
+                "example": example,
+            })
+        );
+    }
 }