Support #[serde(flatten)]ed structs

schemars/src/make_schema.rs

@@ -273,6 +273,8 @@ map_impl!(<K: Eq + core::hash::Hash, V, H: core::hash::BuildHasher> MakeSchema f
 
 ////////// OPTION //////////
 
+// TODO should a field with a default set also be considered nullable?
+
 impl<T: MakeSchema> MakeSchema for Option<T> {
     no_ref_schema!();
 

schemars/src/schema.rs

@@ -1,5 +1,5 @@
 use crate as schemars;
-use crate::MakeSchema;
+use crate::{MakeSchema, MakeSchemaError, Result};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::BTreeMap as Map;
@@ -30,6 +30,63 @@ impl From<SchemaRef> for Schema {
     }
 }
 
+fn extend<A, E: Extend<A>>(mut a: E, b: impl IntoIterator<Item = A>) -> E {
+    a.extend(b);
+    a
+}
+
+impl Schema {
+    pub fn flatten(self, other: Self) -> Result {
+        let s1 = self.ensure_flattenable()?;
+        let s2 = other.ensure_flattenable()?;
+        Ok(Schema::Object(SchemaObject {
+            schema: s1.schema.or(s2.schema),
+            id: s1.id.or(s2.id),
+            title: s1.title.or(s2.title),
+            description: s1.description.or(s2.description),
+            items: s1.items.or(s2.items),
+            properties: extend(s1.properties, s2.properties),
+            required: extend(s1.required, s2.required),
+            definitions: extend(s1.definitions, s2.definitions),
+            extensions: extend(s1.extensions, s2.extensions),
+            // TODO do the following make sense?
+            instance_type: s1.instance_type.or(s2.instance_type),
+            enum_values: s1.enum_values.or(s2.enum_values),
+            all_of: s1.all_of.or(s2.all_of),
+            any_of: s1.any_of.or(s2.any_of),
+            one_of: s1.one_of.or(s2.one_of),
+            not: s1.not.or(s2.not),
+        }))
+    }
+
+    fn ensure_flattenable(self) -> Result<SchemaObject> {
+        let s = match self {
+            Schema::Object(s) => s,
+            s => {
+                return Err(MakeSchemaError::new(
+                    "Only schemas with type `object` can be flattened.",
+                    s,
+                ))
+            }
+        };
+        match s.instance_type {
+            Some(SingleOrVec::Single(ref t)) if **t != InstanceType::Object => {
+                Err(MakeSchemaError::new(
+                    "Only schemas with type `object` can be flattened.",
+                    s.into(),
+                ))
+            }
+            Some(SingleOrVec::Vec(ref t)) if !t.contains(&InstanceType::Object) => {
+                Err(MakeSchemaError::new(
+                    "Only schemas with type `object` can be flattened.",
+                    s.into(),
+                ))
+            }
+            _ => Ok(s),
+        }
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, MakeSchema)]
 pub struct SchemaRef {
     #[serde(rename = "$ref")]
@@ -55,8 +112,8 @@ pub struct SchemaObject {
     pub items: Option<SingleOrVec<Schema>>,
     #[serde(skip_serializing_if = "Map::is_empty")]
     pub properties: Map<String, Schema>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub required: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub required: Vec<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub all_of: Option<Vec<Schema>>,
     #[serde(skip_serializing_if = "Option::is_none")]

schemars/tests/flatten.rs

@@ -1,5 +1,5 @@
 use pretty_assertions::assert_eq;
-use schemars::{schema_for, MakeSchema};
+use schemars::{schema::*, schema_for, MakeSchema};
 use serde::{Deserialize, Serialize};
 use std::error::Error;
 
@@ -32,8 +32,13 @@ struct Deep3 {
 }
 
 #[test]
-#[ignore = "flattening is not yet implemented"]
 fn flatten_schema() -> Result<(), Box<dyn Error>> {
-    assert_eq!(schema_for!(Flat)?, schema_for!(Deep1)?);
+    let flat = schema_for!(Flat)?;
+    let mut deep = schema_for!(Deep1)?;
+    match deep {
+        Schema::Object(ref mut o) => o.title = Some("Flat".to_owned()),
+        _ => assert!(false, "Schema was not object: {:?}", deep),
+    };
+    assert_eq!(flat, deep);
     Ok(())
 }

schemars/tests/schema-openapi3.json

@@ -38,6 +38,7 @@
       ]
     },
     "SchemaObject": {
+      "type": "object",
       "properties": {
         "$id": {
           "type": "string",
@@ -76,10 +77,6 @@
           "items": {},
           "nullable": true
         },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": true
-        },
         "items": {
           "anyOf": [
             {
@@ -125,8 +122,7 @@
           "type": "array",
           "items": {
             "type": "string"
-          },
-          "nullable": true
+          }
         },
         "title": {
           "type": "string",
@@ -146,9 +142,11 @@
           ],
           "nullable": true
         }
-      }
+      },
+      "additionalProperties": true
     },
     "SchemaRef": {
+      "type": "object",
       "properties": {
         "$ref": {
           "type": "string"

schemars/tests/schema.json

@@ -38,6 +38,7 @@
       ]
     },
     "SchemaObject": {
+      "type": "object",
       "properties": {
         "$id": {
           "anyOf": [
@@ -112,10 +113,6 @@
             }
           ]
         },
-        "extensions": {
-          "type": "object",
-          "additionalProperties": true
-        },
         "items": {
           "anyOf": [
             {
@@ -156,17 +153,10 @@
           }
         },
         "required": {
-          "anyOf": [
-            {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            },
-            {
-              "type": "null"
-            }
-          ]
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
         },
         "title": {
           "anyOf": [
@@ -188,9 +178,11 @@
             }
           ]
         }
-      }
+      },
+      "additionalProperties": true
     },
     "SchemaRef": {
+      "type": "object",
       "properties": {
         "$ref": {
           "type": "string"