Struct CanonicalSchema 

pub struct CanonicalSchema {
    pub name: Option<String>,
    pub schema: Value,
}

A JSON Schema with, when the type has one, a stable component name (the type’s title).

Fields

name: Option<String>

The component name projections use (RepositoryInfo); None for an anonymous schema such as the empty input.

schema: Value

The schema itself, without $schema; nested types live under $defs.

Implementations

impl CanonicalSchema

pub fn of<T: JsonSchema>() -> Self

The schema of a Rust type.

use majordomus_cli::capability::CanonicalSchema;
use schemars::JsonSchema;

/// The thing.
#[derive(JsonSchema)]
struct Thing {
    /// A name.
    name: String,
    count: Option<u32>,
}
let s = CanonicalSchema::of::<Thing>();
assert_eq!(s.name.as_deref(), Some("Thing"));
let (props, required) = s.properties();
assert_eq!(props.iter().map(|(k, _)| k.as_str()).collect::<Vec<_>>(), ["name", "count"]);
assert_eq!(required, ["name"]);

pub fn empty() -> Self

No input: an object with no properties and none allowed.

pub fn resolved(&self) -> Cow<'_, CanonicalSchema>

This schema with a root $ref followed into its own $defs: the object the type describes, rather than the reference that names it.

A #[serde(transparent)] newtype is one shape under two names, and that is how schemars writes it: the wrapper’s title and description at the root, the shape under $defs, and nothing but a $ref between them. Every projection that binds properties — a GET operation’s query parameters, the router’s coercion of the query string, the Cockpit’s form, the generated module reference — reads the root, and a root that is a reference has no properties. Unfollowed, the document says the operation takes nothing while the route still binds every field of the inner struct, and the router coerces each one against an empty schema: every integer and boolean parameter then arrives as a string and the call is refused as invalid.

The $defs travel with the resolved schema, so a nested reference still resolves and for_openapi still hoists every definition.

use majordomus_cli::capability::CanonicalSchema;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

/// What to look for.
#[derive(Serialize, Deserialize, JsonSchema)]
struct SearchInput {
    /// The words.
    query: String,
    /// How many hits at most.
    limit: Option<u32>,
}

/// The input of `fixture.search`.
#[derive(Serialize, Deserialize, JsonSchema)]
#[serde(transparent)]
struct Wrapper(SearchInput);

let schema = CanonicalSchema::of::<Wrapper>();
// the wrapper names the component, and its root is a reference
assert_eq!(schema.name.as_deref(), Some("Wrapper"));
assert_eq!(schema.schema["$ref"], "#/$defs/SearchInput");
// and the properties every projection binds are the inner type's
let (properties, required) = schema.properties();
let names: Vec<&str> = properties.iter().map(|(n, _)| n.as_str()).collect();
assert_eq!(names, ["query", "limit"]);
assert_eq!(required, ["query"]);
// a schema whose root is already the object is its own resolution
let plain = CanonicalSchema::of::<SearchInput>();
assert_eq!(plain.resolved().schema, plain.schema);

pub fn properties(&self) -> (Vec<(String, Value)>, Vec<String>)

Top-level properties with their schemas, and which are required, for a schema that describes an object. Order is the schema’s. A root $ref is followed first, so a transparent newtype yields the properties of the type it wraps.

pub fn for_mcp(&self) -> Value

The schema as an MCP client expects it: self-contained, $defs kept inline.

pub fn for_openapi( &self, components: &mut BTreeMap<String, Value>, ) -> Result<Value, String>

Split into the top-level schema and its named definitions with every $ref rewritten to #/components/schemas/<name>, for OpenAPI. A definition name that is already registered with different content is a conflict, reported by name.

pub fn openapi_ref( &self, components: &mut BTreeMap<String, Value>, ) -> Result<Value, String>

Register this schema under its name and return a $ref to it; an anonymous schema is returned inline.

Trait Implementations

impl Clone for CanonicalSchema

fn clone(&self) -> CanonicalSchema

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CanonicalSchema

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CanonicalSchema

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for CanonicalSchema

impl JsonSchema for CanonicalSchema

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for CanonicalSchema

fn eq(&self, other: &CanonicalSchema) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CanonicalSchema

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CanonicalSchema