update schemars to 0.9.0 (#88)

Signed-off-by: Teo Koon Peng <[email protected]>

Author: koonpeng

Cargo.toml

@@ -46,7 +46,7 @@ thiserror = "1.0"
 bevy_core = "0.12"
 bevy_time = "0.12"
 
-schemars = { version = "0.8.21", optional = true }
+schemars = { version = "0.9.0", optional = true }
 serde = { version = "1.0.210", features = ["derive", "rc"], optional = true }
 serde_json = { version = "1.0.128", optional = true }
 cel-interpreter = { version = "0.9.0", features = ["json"], optional = true }

diagram.schema.json

@@ -18,7 +18,7 @@ bevy_ecs = "0.12"
 bevy_time = "0.12"
 bevy_impulse = { version = "0.0.2", path = "../..", features = ["diagram"] }
 futures = "0.3"
-schemars = { version = "0.8.21" }
+schemars = { version = "0.9.0" }
 serde = { version = "1.0.210", features = ["derive", "rc"] }
 serde_json = "1.0.128"
 prost = "0.13.5"

examples/zenoh-examples/Cargo.toml

@@ -64,11 +64,7 @@ use crate::{
     SpawnWorkflowExt, SplitConnectionError, StreamPack,
 };
 
-use schemars::{
-    r#gen::SchemaGenerator,
-    schema::{InstanceType, Metadata, ObjectValidation, Schema, SchemaObject, SingleOrVec},
-    JsonSchema,
-};
+use schemars::{json_schema, JsonSchema, Schema, SchemaGenerator};
 
 use serde::{
     de::{Error, Visitor},
@@ -191,29 +187,21 @@ impl<'de> Deserialize<'de> for NamespacedOperation {
 }
 
 impl JsonSchema for NamespacedOperation {
-    fn json_schema(generator: &mut SchemaGenerator) -> Schema {
-        let mut schema = SchemaObject::default();
-        schema.instance_type = Some(SingleOrVec::Single(Box::new(InstanceType::Object)));
-        schema.object = Some(Box::new(ObjectValidation {
-            max_properties: Some(1),
-            min_properties: Some(1),
-            required: Default::default(),
-            properties: Default::default(),
-            pattern_properties: Default::default(),
-            property_names: Default::default(),
-            additional_properties: Some(Box::new(generator.subschema_for::<String>())),
-        }));
-        schema.metadata = Some(Box::new(Metadata {
-            title: Some("NamespacedOperation".to_string()),
-            description: Some("Refer to an operation inside of a namespace, e.g. { \"<namespace>\": \"<operation>\"".to_string()),
-            ..Default::default()
-        }));
-
-        Schema::Object(schema)
+    fn json_schema(_generator: &mut SchemaGenerator) -> Schema {
+        json_schema!({
+          "title": "NamespacedOperation",
+          "description": "Refer to an operation inside of a namespace, e.g. { \"<namespace>\": \"<operation>\"",
+          "type": "object",
+          "maxProperties": 1,
+          "minProperties": 1,
+          "additionalProperties": {
+            "type": "string"
+          }
+        })
     }
 
-    fn schema_name() -> String {
-        "NamespacedOperation".to_string()
+    fn schema_name() -> Cow<'static, str> {
+        "NamespacedOperation".into()
     }
 }
 
@@ -984,7 +972,7 @@ impl BuildDiagramOperation for DiagramOperation {
 }
 
 /// Returns the schema for [`String`]
-fn schema_with_string(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+fn schema_with_string(gen: &mut SchemaGenerator) -> Schema {
     gen.subschema_for::<String>()
 }
 

src/diagram.rs

@@ -34,11 +34,7 @@ use crate::{
     StreamPack,
 };
 
-use schemars::{
-    gen::{SchemaGenerator, SchemaSettings},
-    schema::Schema,
-    JsonSchema,
-};
+use schemars::{generate::SchemaSettings, JsonSchema, Schema, SchemaGenerator};
 use serde::{
     de::DeserializeOwned,
     ser::{SerializeMap, SerializeStruct},
@@ -732,7 +728,7 @@ impl Serialize for MessageOperation {
 
 pub struct MessageRegistration {
     pub(super) type_name: &'static str,
-    pub(super) schema: Option<schemars::schema::Schema>,
+    pub(super) schema: Option<Schema>,
     pub(super) operations: MessageOperation,
 }
 
@@ -776,7 +772,7 @@ pub struct MessageRegistry {
 impl MessageRegistry {
     fn new() -> Self {
         let mut settings = SchemaSettings::default();
-        settings.definitions_path = "#/schemas/".to_string();
+        settings.definitions_path = "#/schemas/".into();
 
         Self {
             schema_generator: SchemaGenerator::new(settings),

src/diagram/registration.rs

@@ -17,7 +17,7 @@
 
 use std::{collections::HashMap, sync::Arc};
 
-use schemars::{schema::Schema, JsonSchema};
+use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use crate::{
@@ -39,89 +39,10 @@ pub enum SectionProvider {
     Template(OperationName),
 }
 
-/// schemars generates schemas with `additionalProperties: false` for enums.
-/// When the enum is flatten, that `additionalProperties: false` is inherited by the parent
-/// struct, which leads to schemas that can never be valid.
-///
-/// Example:
-///
-/// ```json
-/// {
-///   "description": "Connect the request to a registered section.\n\n``` # bevy_impulse::Diagram::from_json_str(r#\" { \"version\": \"0.1.0\", \"start\": \"section_op\", \"ops\": { \"section_op\": { \"type\": \"section\", \"builder\": \"my_section_builder\", \"connect\": { \"my_section_output\": { \"builtin\": \"terminate\" } } } } } # \"#)?; # Ok::<_, serde_json::Error>(()) ```\n\nCustom sections can also be created via templates ``` # bevy_impulse::Diagram::from_json_str(r#\" { \"version\": \"0.1.0\", \"templates\": { \"my_template\": { \"inputs\": [\"section_input\"], \"outputs\": [\"section_output\"], \"buffers\": [], \"ops\": { \"section_input\": { \"type\": \"node\", \"builder\": \"my_node\", \"next\": \"section_output\" } } } }, \"start\": \"section_op\", \"ops\": { \"section_op\": { \"type\": \"section\", \"template\": \"my_template\", \"connect\": { \"section_output\": { \"builtin\": \"terminate\" } } } } } # \"#)?; # Ok::<_, serde_json::Error>(()) ```",
-///   "type": "object",
-///   "oneOf": [
-///     {
-///       "type": "object",
-///       "required": [
-///         "builder"
-///       ],
-///       "properties": {
-///         "builder": {
-///           "type": "string"
-///         }
-///       },
-///       "additionalProperties": false
-///     },
-///     {
-///       "type": "object",
-///       "required": [
-///         "template"
-///       ],
-///       "properties": {
-///         "template": {
-///           "type": "string"
-///         }
-///       },
-///       "additionalProperties": false
-///     }
-///   ],
-///   "required": [
-///     "type"
-///   ],
-///   "properties": {
-///     "config": {
-///       "default": null
-///     },
-///     "connect": {
-///       "default": {},
-///       "type": "object",
-///       "additionalProperties": {
-///         "$ref": "#/definitions/NextOperation"
-///       }
-///     },
-///     "type": {
-///       "type": "string",
-///       "enum": [
-///         "section"
-///       ]
-///     }
-///   }
-/// },
-/// ```
-///
-/// Here the section schema needs to have a `builder` or `template` with no additional properties.
-/// Which includes other properties like `type`, `config` etc, but `type` is also required which
-/// breaks the schema.
-fn fix_additional_properties(generator: &mut schemars::SchemaGenerator) -> Schema {
-    let mut schema = generator.root_schema_for::<SectionProvider>().schema;
-    schema.metadata.as_mut().unwrap().title = None;
-    let one_ofs = schema.subschemas.as_mut().unwrap().one_of.as_mut().unwrap();
-    for subschema in one_ofs {
-        match subschema {
-            Schema::Object(schema) => schema.object.as_mut().unwrap().additional_properties = None,
-            _ => {
-                panic!("expected object schema")
-            }
-        }
-    }
-    Schema::Object(schema)
-}
-
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct SectionSchema {
     #[serde(flatten)]
-    #[schemars(schema_with = "fix_additional_properties")]
     pub(super) provider: SectionProvider,
     #[serde(default)]
     pub(super) config: serde_json::Value,

src/diagram/section_schema.rs

@@ -16,11 +16,12 @@
 */
 
 use std::{
+    borrow::Cow,
     collections::{hash_map::Entry, HashMap},
     sync::Arc,
 };
 
-use schemars::{gen::SchemaGenerator, JsonSchema};
+use schemars::{JsonSchema, Schema, SchemaGenerator};
 use serde::{de::DeserializeOwned, Serialize};
 
 use super::{
@@ -31,20 +32,20 @@ use crate::{Builder, JsonBuffer};
 
 pub trait DynType {
     /// Returns the type name of the request. Note that the type name must be unique.
-    fn type_name() -> String;
+    fn type_name() -> Cow<'static, str>;
 
-    fn json_schema(gen: &mut SchemaGenerator) -> schemars::schema::Schema;
+    fn json_schema(gen: &mut SchemaGenerator) -> Schema;
 }
 
 impl<T> DynType for T
 where
     T: JsonSchema,
 {
-    fn type_name() -> String {
+    fn type_name() -> Cow<'static, str> {
         <T>::schema_name()
     }
 
-    fn json_schema(gen: &mut SchemaGenerator) -> schemars::schema::Schema {
+    fn json_schema(gen: &mut SchemaGenerator) -> Schema {
         gen.subschema_for::<T>()
     }
 }