Trait PartialSchema

pub trait PartialSchema {
    // Required method
    fn schema() -> RefOr<Schema>;
}

Trait used to implement only Schema part of the OpenAPI doc.

This trait is by default implemented for Rust primitive types and some well known types like Vec, Option, std::collections::HashMap and BTreeMap. The default implementation adds schema() method to the implementing type allowing simple conversion of the type to the OpenAPI Schema object. Moreover this allows handy way of constructing schema objects manually if ever so wished.

The trait can be implemented manually easily on any type. This trait comes especially handy with schema macro that can be used to generate schema for arbitrary types.

struct MyType;

impl PartialSchema for MyType {
    fn schema() -> RefOr<Schema> {
        // ... impl schema generation here
        RefOr::T(Schema::Object(ObjectBuilder::new().build()))
    }
}

Examples

Create number schema from u64.

let number: RefOr<Schema> = i64::schema().into();

let number2 = RefOr::T(
    Schema::Object(
        ObjectBuilder::new()
            .schema_type(Type::Integer)
            .format(Some(SchemaFormat::KnownFormat(KnownFormat::Int64)))
            .build()
        )
    );

Construct a Pet object schema manually.

struct Pet {
    id: i32,
    name: String,
}

let pet_schema = ObjectBuilder::new()
    .property("id", i32::schema())
    .property("name", String::schema())
    .required("id").required("name")
    .build();

Required Methods

fn schema() -> RefOr<Schema>

Return ref or schema of implementing type that can then be used to construct combined schemas.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl PartialSchema for Value

fn schema() -> RefOr<Schema>

Implementors

impl PartialSchema for TupleUnit

impl<T: ComposeSchema + ?Sized> PartialSchema for T