Vendor dependencies

notes-service/vendor/schemars/examples/custom_serialization.rs

@@ -0,0 +1,59 @@
+use schemars::{schema_for, JsonSchema, Schema, SchemaGenerator};
+use serde::{Deserialize, Serialize};
+
+// `int_as_string` and `bool_as_string` use the schema for `String`.
+#[derive(Default, Deserialize, Serialize, JsonSchema)]
+pub struct MyStruct {
+    #[serde(default = "eight", with = "as_string")]
+    #[schemars(with = "String")]
+    pub int_as_string: i32,
+
+    #[serde(default = "eight")]
+    pub int_normal: i32,
+
+    #[serde(default, with = "as_string")]
+    #[schemars(schema_with = "make_custom_schema")]
+    pub bool_as_string: bool,
+
+    #[serde(default)]
+    pub bool_normal: bool,
+}
+
+fn make_custom_schema(generator: &mut SchemaGenerator) -> Schema {
+    let mut schema = String::json_schema(generator);
+    schema.insert("format".into(), "boolean".into());
+    schema
+}
+
+fn eight() -> i32 {
+    8
+}
+
+// This module serializes values as strings
+mod as_string {
+    use serde::{de::Error, Deserialize, Deserializer, Serializer};
+
+    pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        T: std::fmt::Display,
+        S: Serializer,
+    {
+        serializer.collect_str(value)
+    }
+
+    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
+    where
+        T: std::str::FromStr,
+        D: Deserializer<'de>,
+    {
+        let string = String::deserialize(deserializer)?;
+        string
+            .parse()
+            .map_err(|_| D::Error::custom("Input was not valid"))
+    }
+}
+
+fn main() {
+    let schema = schema_for!(MyStruct);
+    println!("{}", serde_json::to_string_pretty(&schema).unwrap());
+}

notes-service/vendor/schemars/examples/custom_serialization.schema.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "MyStruct",
+  "type": "object",
+  "properties": {
+    "bool_as_string": {
+      "type": "string",
+      "format": "boolean",
+      "default": "false"
+    },
+    "bool_normal": {
+      "type": "boolean",
+      "default": false
+    },
+    "int_as_string": {
+      "type": "string",
+      "default": "8"
+    },
+    "int_normal": {
+      "type": "integer",
+      "format": "int32",
+      "default": 8
+    }
+  }
+}

notes-service/vendor/schemars/examples/custom_settings.rs

@@ -0,0 +1,24 @@
+use schemars::{generate::SchemaSettings, JsonSchema};
+
+#[derive(JsonSchema)]
+pub struct MyStruct {
+    pub my_int: i32,
+    pub my_bool: bool,
+    pub my_nullable_enum: Option<MyEnum>,
+}
+
+#[derive(JsonSchema)]
+pub enum MyEnum {
+    StringNewType(String),
+    StructVariant { floats: Vec<f32> },
+}
+
+fn main() {
+    let settings = SchemaSettings::draft07().with(|s| {
+        s.meta_schema = None;
+        s.inline_subschemas = true;
+    });
+    let generator = settings.into_generator();
+    let schema = generator.into_root_schema_for::<MyStruct>();
+    println!("{}", serde_json::to_string_pretty(&schema).unwrap());
+}

notes-service/vendor/schemars/examples/custom_settings.schema.json

@@ -0,0 +1,64 @@
+{
+  "title": "MyStruct",
+  "type": "object",
+  "properties": {
+    "my_bool": {
+      "type": "boolean"
+    },
+    "my_int": {
+      "type": "integer",
+      "format": "int32"
+    },
+    "my_nullable_enum": {
+      "anyOf": [
+        {
+          "oneOf": [
+            {
+              "type": "object",
+              "properties": {
+                "StringNewType": {
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "required": [
+                "StringNewType"
+              ]
+            },
+            {
+              "type": "object",
+              "properties": {
+                "StructVariant": {
+                  "type": "object",
+                  "properties": {
+                    "floats": {
+                      "type": "array",
+                      "items": {
+                        "type": "number",
+                        "format": "float"
+                      }
+                    }
+                  },
+                  "required": [
+                    "floats"
+                  ]
+                }
+              },
+              "additionalProperties": false,
+              "required": [
+                "StructVariant"
+              ]
+            }
+          ]
+        },
+        {
+          "type": "null"
+        }
+      ]
+    }
+  },
+  "required": [
+    "my_int",
+    "my_bool"
+  ]
+}

notes-service/vendor/schemars/examples/doc_comments.rs

@@ -0,0 +1,33 @@
+use schemars::{schema_for, JsonSchema};
+
+/// # My Amazing Struct
+/// This struct shows off generating a schema with
+/// a custom title and description.
+#[derive(JsonSchema)]
+pub struct MyStruct {
+    /// # My Amazing Integer
+    pub my_int: i32,
+    /// This bool has a description, but no title.
+    pub my_bool: bool,
+    /// # A Nullable Enum
+    /// This enum might be set, or it might not.
+    pub my_nullable_enum: Option<MyEnum>,
+}
+
+/// # My Amazing Enum
+#[derive(JsonSchema)]
+pub enum MyEnum {
+    /// A wrapper around a `String`
+    StringNewType(String),
+    /// A struct-like enum variant which contains
+    /// some floats
+    StructVariant {
+        /// The floats themselves
+        floats: Vec<f32>,
+    },
+}
+
+fn main() {
+    let schema = schema_for!(MyStruct);
+    println!("{}", serde_json::to_string_pretty(&schema).unwrap());
+}

notes-service/vendor/schemars/examples/doc_comments.schema.json

@@ -0,0 +1,79 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "My Amazing Struct",
+  "description": "This struct shows off generating a schema with\na custom title and description.",
+  "type": "object",
+  "properties": {
+    "my_bool": {
+      "description": "This bool has a description, but no title.",
+      "type": "boolean"
+    },
+    "my_int": {
+      "title": "My Amazing Integer",
+      "type": "integer",
+      "format": "int32"
+    },
+    "my_nullable_enum": {
+      "title": "A Nullable Enum",
+      "description": "This enum might be set, or it might not.",
+      "anyOf": [
+        {
+          "$ref": "#/$defs/MyEnum"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    }
+  },
+  "required": [
+    "my_int",
+    "my_bool"
+  ],
+  "$defs": {
+    "MyEnum": {
+      "title": "My Amazing Enum",
+      "oneOf": [
+        {
+          "description": "A wrapper around a `String`",
+          "type": "object",
+          "properties": {
+            "StringNewType": {
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "StringNewType"
+          ]
+        },
+        {
+          "description": "A struct-like enum variant which contains\nsome floats",
+          "type": "object",
+          "properties": {
+            "StructVariant": {
+              "type": "object",
+              "properties": {
+                "floats": {
+                  "description": "The floats themselves",
+                  "type": "array",
+                  "items": {
+                    "type": "number",
+                    "format": "float"
+                  }
+                }
+              },
+              "required": [
+                "floats"
+              ]
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "StructVariant"
+          ]
+        }
+      ]
+    }
+  }
+}

notes-service/vendor/schemars/examples/enum_repr.rs

@@ -0,0 +1,15 @@
+use schemars::{schema_for, JsonSchema_repr};
+
+#[derive(JsonSchema_repr)]
+#[repr(u8)]
+enum SmallPrime {
+    Two = 2,
+    Three = 3,
+    Five = 5,
+    Seven = 7,
+}
+
+fn main() {
+    let schema = schema_for!(SmallPrime);
+    println!("{}", serde_json::to_string_pretty(&schema).unwrap());
+}

notes-service/vendor/schemars/examples/enum_repr.schema.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "SmallPrime",
+  "type": "integer",
+  "enum": [
+    2,
+    3,
+    5,
+    7
+  ]
+}

notes-service/vendor/schemars/examples/from_value.rs

@@ -0,0 +1,24 @@
+use schemars::schema_for_value;
+use serde::Serialize;
+
+#[derive(Serialize)]
+pub struct MyStruct {
+    pub my_int: i32,
+    pub my_bool: bool,
+    pub my_nullable_enum: Option<MyEnum>,
+}
+
+#[derive(Serialize)]
+pub enum MyEnum {
+    StringNewType(String),
+    StructVariant { floats: Vec<f32> },
+}
+
+fn main() {
+    let schema = schema_for_value!(MyStruct {
+        my_int: 123,
+        my_bool: true,
+        my_nullable_enum: Some(MyEnum::StringNewType("foo".to_string()))
+    });
+    println!("{}", serde_json::to_string_pretty(&schema).unwrap());
+}

notes-service/vendor/schemars/examples/from_value.schema.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "MyStruct",
+  "type": "object",
+  "properties": {
+    "my_bool": {
+      "type": "boolean"
+    },
+    "my_int": {
+      "type": "integer"
+    },
+    "my_nullable_enum": true
+  },
+  "examples": [
+    {
+      "my_bool": true,
+      "my_int": 123,
+      "my_nullable_enum": {
+        "StringNewType": "foo"
+      }
+    }
+  ]
+}

notes-service/vendor/schemars/examples/main.rs

@@ -0,0 +1,19 @@
+use schemars::{schema_for, JsonSchema};
+
+#[derive(JsonSchema)]
+pub struct MyStruct {
+    pub my_int: i32,
+    pub my_bool: bool,
+    pub my_nullable_enum: Option<MyEnum>,
+}
+
+#[derive(JsonSchema)]
+pub enum MyEnum {
+    StringNewType(String),
+    StructVariant { floats: Vec<f32> },
+}
+
+fn main() {
+    let schema = schema_for!(MyStruct);
+    println!("{}", serde_json::to_string_pretty(&schema).unwrap());
+}

notes-service/vendor/schemars/examples/main.schema.json

@@ -0,0 +1,70 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "MyStruct",
+  "type": "object",
+  "properties": {
+    "my_bool": {
+      "type": "boolean"
+    },
+    "my_int": {
+      "type": "integer",
+      "format": "int32"
+    },
+    "my_nullable_enum": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/MyEnum"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    }
+  },
+  "required": [
+    "my_int",
+    "my_bool"
+  ],
+  "$defs": {
+    "MyEnum": {
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "StringNewType": {
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "StringNewType"
+          ]
+        },
+        {
+          "type": "object",
+          "properties": {
+            "StructVariant": {
+              "type": "object",
+              "properties": {
+                "floats": {
+                  "type": "array",
+                  "items": {
+                    "type": "number",
+                    "format": "float"
+                  }
+                }
+              },
+              "required": [
+                "floats"
+              ]
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "StructVariant"
+          ]
+        }
+      ]
+    }
+  }
+}

notes-service/vendor/schemars/examples/remote_derive.rs

@@ -0,0 +1,42 @@
+// Pretend that this is somebody else's crate, not a module.
+mod other_crate {
+    // Neither Schemars nor the other crate provides a JsonSchema impl
+    // for this struct.
+    pub struct Duration {
+        pub secs: i64,
+        pub nanos: i32,
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+use other_crate::Duration;
+use schemars::{schema_for, JsonSchema};
+
+// This is just a copy of the remote data structure that Schemars can use to
+// create a suitable JsonSchema impl.
+#[derive(JsonSchema)]
+#[serde(remote = "Duration")]
+pub struct DurationDef {
+    pub secs: i64,
+    pub nanos: i32,
+}
+
+// Now the remote type can be used almost like it had its own JsonSchema impl
+// all along. The `with` attribute gives the path to the definition for the
+// remote type. Note that the real type of the field is the remote type, not
+// the definition type.
+#[derive(JsonSchema)]
+pub struct Process {
+    pub command_line: String,
+    #[serde(with = "DurationDef")]
+    pub wall_time: Duration,
+    // Generic types must be explicitly specified with turbofix `::<>` syntax.
+    #[serde(with = "Vec::<DurationDef>")]
+    pub durations: Vec<Duration>,
+}
+
+fn main() {
+    let schema = schema_for!(Process);
+    println!("{}", serde_json::to_string_pretty(&schema).unwrap());
+}

notes-service/vendor/schemars/examples/remote_derive.schema.json

@@ -0,0 +1,43 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Process",
+  "type": "object",
+  "properties": {
+    "command_line": {
+      "type": "string"
+    },
+    "durations": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/Duration"
+      }
+    },
+    "wall_time": {
+      "$ref": "#/$defs/Duration"
+    }
+  },
+  "required": [
+    "command_line",
+    "wall_time",
+    "durations"
+  ],
+  "$defs": {
+    "Duration": {
+      "type": "object",
+      "properties": {
+        "nanos": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "secs": {
+          "type": "integer",
+          "format": "int64"
+        }
+      },
+      "required": [
+        "secs",
+        "nanos"
+      ]
+    }
+  }
+}

notes-service/vendor/schemars/examples/schemars_attrs.rs

@@ -0,0 +1,34 @@
+use schemars::{schema_for, JsonSchema, Schema};
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize, Serialize, JsonSchema)]
+#[schemars(rename_all = "camelCase", deny_unknown_fields, extend("x-customProperty" = "example"))]
+pub struct MyStruct {
+    #[serde(rename = "thisIsOverridden")]
+    #[schemars(rename = "myNumber", range(min = 1, max = 10), transform = remove_format)]
+    pub my_int: i32,
+    pub my_bool: bool,
+    #[schemars(default)]
+    pub my_nullable_enum: Option<MyEnum>,
+    #[schemars(inner(regex(pattern = "^x$")))]
+    pub my_vec_str: Vec<String>,
+}
+
+#[derive(Deserialize, Serialize, JsonSchema)]
+#[schemars(untagged)]
+pub enum MyEnum {
+    StringNewType(#[schemars(email)] String),
+    StructVariant {
+        #[schemars(length(min = 1, max = 100))]
+        floats: Vec<f32>,
+    },
+}
+
+fn remove_format(schema: &mut Schema) {
+    schema.remove("format");
+}
+
+fn main() {
+    let schema = schema_for!(MyStruct);
+    println!("{}", serde_json::to_string_pretty(&schema).unwrap());
+}

notes-service/vendor/schemars/examples/schemars_attrs.schema.json

@@ -0,0 +1,67 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "MyStruct",
+  "type": "object",
+  "properties": {
+    "myBool": {
+      "type": "boolean"
+    },
+    "myNullableEnum": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/MyEnum"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null
+    },
+    "myNumber": {
+      "type": "integer",
+      "maximum": 10,
+      "minimum": 1
+    },
+    "myVecStr": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "pattern": "^x$"
+      }
+    }
+  },
+  "additionalProperties": false,
+  "required": [
+    "myNumber",
+    "myBool",
+    "myVecStr"
+  ],
+  "x-customProperty": "example",
+  "$defs": {
+    "MyEnum": {
+      "anyOf": [
+        {
+          "type": "string",
+          "format": "email"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "floats": {
+              "type": "array",
+              "items": {
+                "type": "number",
+                "format": "float"
+              },
+              "maxItems": 100,
+              "minItems": 1
+            }
+          },
+          "required": [
+            "floats"
+          ]
+        }
+      ]
+    }
+  }
+}

notes-service/vendor/schemars/examples/serde_attrs.rs

@@ -0,0 +1,24 @@
+use schemars::{schema_for, JsonSchema};
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize, Serialize, JsonSchema)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct MyStruct {
+    #[serde(rename = "myNumber")]
+    pub my_int: i32,
+    pub my_bool: bool,
+    #[serde(default)]
+    pub my_nullable_enum: Option<MyEnum>,
+}
+
+#[derive(Deserialize, Serialize, JsonSchema)]
+#[serde(untagged)]
+pub enum MyEnum {
+    StringNewType(String),
+    StructVariant { floats: Vec<f32> },
+}
+
+fn main() {
+    let schema = schema_for!(MyStruct);
+    println!("{}", serde_json::to_string_pretty(&schema).unwrap());
+}

notes-service/vendor/schemars/examples/serde_attrs.schema.json

@@ -0,0 +1,54 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "MyStruct",
+  "type": "object",
+  "properties": {
+    "myBool": {
+      "type": "boolean"
+    },
+    "myNullableEnum": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/MyEnum"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null
+    },
+    "myNumber": {
+      "type": "integer",
+      "format": "int32"
+    }
+  },
+  "additionalProperties": false,
+  "required": [
+    "myNumber",
+    "myBool"
+  ],
+  "$defs": {
+    "MyEnum": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "floats": {
+              "type": "array",
+              "items": {
+                "type": "number",
+                "format": "float"
+              }
+            }
+          },
+          "required": [
+            "floats"
+          ]
+        }
+      ]
+    }
+  }
+}

notes-service/vendor/schemars/examples/serialize_contract.rs

@@ -0,0 +1,29 @@
+use schemars::{generate::SchemaSettings, JsonSchema};
+use serde::{Deserialize, Serialize};
+
+#[derive(JsonSchema, Deserialize, Serialize)]
+// The schema effectively ignores this `rename_all`, since it doesn't apply to serialization
+#[serde(rename_all(deserialize = "PascalCase"))]
+pub struct MyStruct {
+    pub my_int: i32,
+    #[serde(skip_deserializing)]
+    pub my_read_only_bool: bool,
+    // This property is excluded from the schema
+    #[serde(skip_serializing)]
+    pub my_write_only_bool: bool,
+    // This property is excluded from the "required" properties of the schema, because it may be
+    // be skipped during serialization
+    #[serde(skip_serializing_if = "str::is_empty")]
+    pub maybe_string: String,
+    pub definitely_string: String,
+}
+
+fn main() {
+    // By default, generated schemas describe how types are deserialized.
+    // So we modify the settings here to instead generate schemas describing how it's serialized:
+    let settings = SchemaSettings::default().for_serialize();
+
+    let generator = settings.into_generator();
+    let schema = generator.into_root_schema_for::<MyStruct>();
+    println!("{}", serde_json::to_string_pretty(&schema).unwrap());
+}

notes-service/vendor/schemars/examples/serialize_contract.schema.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "MyStruct",
+  "type": "object",
+  "properties": {
+    "definitely_string": {
+      "type": "string"
+    },
+    "maybe_string": {
+      "type": "string"
+    },
+    "my_int": {
+      "type": "integer",
+      "format": "int32"
+    },
+    "my_read_only_bool": {
+      "type": "boolean",
+      "default": false,
+      "readOnly": true
+    }
+  },
+  "required": [
+    "my_int",
+    "my_read_only_bool",
+    "definitely_string"
+  ]
+}

notes-service/vendor/schemars/examples/validate.rs

@@ -0,0 +1,24 @@
+use schemars::{schema_for, JsonSchema};
+
+#[derive(JsonSchema)]
+pub struct MyStruct {
+    #[validate(range(min = 1, max = 10))]
+    pub my_int: i32,
+    pub my_bool: bool,
+    #[validate(required)]
+    pub my_nullable_enum: Option<MyEnum>,
+}
+
+#[derive(JsonSchema)]
+pub enum MyEnum {
+    StringNewType(#[validate(email)] String),
+    StructVariant {
+        #[validate(length(min = 1, max = 100))]
+        floats: Vec<f32>,
+    },
+}
+
+fn main() {
+    let schema = schema_for!(MyStruct);
+    println!("{}", serde_json::to_string_pretty(&schema).unwrap());
+}

notes-service/vendor/schemars/examples/validate.schema.json

@@ -0,0 +1,64 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "MyStruct",
+  "type": "object",
+  "properties": {
+    "my_bool": {
+      "type": "boolean"
+    },
+    "my_int": {
+      "type": "integer",
+      "format": "int32",
+      "maximum": 10,
+      "minimum": 1
+    },
+    "my_nullable_enum": {
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "StringNewType": {
+              "type": "string",
+              "format": "email"
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "StringNewType"
+          ]
+        },
+        {
+          "type": "object",
+          "properties": {
+            "StructVariant": {
+              "type": "object",
+              "properties": {
+                "floats": {
+                  "type": "array",
+                  "items": {
+                    "type": "number",
+                    "format": "float"
+                  },
+                  "maxItems": 100,
+                  "minItems": 1
+                }
+              },
+              "required": [
+                "floats"
+              ]
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "StructVariant"
+          ]
+        }
+      ]
+    }
+  },
+  "required": [
+    "my_int",
+    "my_bool",
+    "my_nullable_enum"
+  ]
+}