Struct apollo_encoder::Schema

pub struct Schema { /* fields omitted */ }

GraphQLSchema represented in Schema Definition Language.

SDL is used as a human-readable format for a given schema to help define and store schema as a string. More information about SDL can be read in this documentation

The Schema struct provides method to encode various types to a schema.

Example

use apollo_encoder::{Schema, Field, UnionDef, EnumValue, Directive, EnumDef, Type_};
use indoc::indoc;

let mut schema = Schema::new();

let mut union_def = UnionDef::new("Cat".to_string());
union_def.description(Some(
    "A union of all cats represented within a household.".to_string(),
));
union_def.member("NORI".to_string());
union_def.member("CHASHU".to_string());
schema.union(union_def);
assert_eq!(
    schema.finish(),
    indoc! { r#"
        "A union of all cats represented within a household."
        union Cat = NORI | CHASHU
    "# }
);

Implementations

impl Schema

pub fn new() -> Self

Creates a new instance of Schema Encoder.

pub fn directive(&mut self, directive: Directive)

Adds a new Directive Definition.

pub fn object(&mut self, object: ObjectDef)

Adds a new Type Definition.

pub fn schema(&mut self, schema: SchemaDef)

Adds a new Schema Definition.

The schema type is only used when the root GraphQL type is different from default GraphQL types.

pub fn input(&mut self, input: InputObjectDef)

Adds a new Input Object Definition.

pub fn enum_(&mut self, enum_: EnumDef)

Adds a new Enum Definition.

pub fn scalar(&mut self, scalar: ScalarDef)

Adds a new Scalar Definition.

pub fn union(&mut self, union_: UnionDef)

Adds a new Union Definition.

pub fn interface(&mut self, interface: InterfaceDef)

Adds a new Interface Definition.

pub fn finish(self) -> String

Return the encoded SDL string after all types have been processed.

Trait Implementations

impl Debug for Schema

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

Formats the value using the given formatter.

impl Default for Schema

fn default() -> Self

Returns the “default value” for a type.