Struct apollo_encoder::InterfaceDefinition

pub struct InterfaceDefinition { /* private fields */ }

InterfaceDefinition is an abstract type where there are common fields declared.

Any type that implements an interface must define all the fields with names and types exactly matching. The implementations of this interface are explicitly listed out in possibleTypes.

InterfaceDefTypeDefinition: Description? interface Name ImplementsInterfaceDefs? Directives?

Detailed documentation can be found in GraphQL spec.

Example

use apollo_encoder::{Type_, FieldDefinition, InterfaceDefinition};
use indoc::indoc;

let ty_1 = Type_::NamedType {
    name: "String".to_string(),
};

let ty_2 = Type_::NamedType {
    name: "String".to_string(),
};

let ty_3 = Type_::NonNull { ty: Box::new(ty_2) };
let ty_4 = Type_::List { ty: Box::new(ty_3) };
let ty_5 = Type_::NonNull { ty: Box::new(ty_4) };

let ty_6 = Type_::NamedType {
    name: "Boolean".to_string(),
};

let mut field_1 = FieldDefinition::new("main".to_string(), ty_1);
field_1.description("Cat's main dish of a meal.".to_string());

let mut field_2 = FieldDefinition::new("snack".to_string(), ty_5);
field_2.description("Cat's post meal snack.".to_string());

let mut field_3 = FieldDefinition::new("pats".to_string(), ty_6);
field_3.description("Does cat get a pat after meal?".to_string());

// a schema definition
let mut interface = InterfaceDefinition::new("Meal".to_string());
interface.description(
    "Meal interface for various\nmeals during the day.".to_string(),
);
interface.field(field_1);
interface.field(field_2);
interface.field(field_3);

assert_eq!(
    interface.to_string(),
    indoc! { r#"
    """
    Meal interface for various
    meals during the day.
    """
    interface Meal {
      "Cat's main dish of a meal."
      main: String
      "Cat's post meal snack."
      snack: [String!]!
      "Does cat get a pat after meal?"
      pats: Boolean
    }
    "# }
);

Implementations

impl InterfaceDefinition

pub fn new(name: String) -> Self

Create a new instance of InterfaceDef.

pub fn description(&mut self, description: String)

Set the schema def’s description.

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

Set the interfaces ObjectDef implements.

pub fn extend(&mut self)

Set the interface as an extension

pub fn field(&mut self, field: FieldDefinition)

Push a Field to schema def’s fields vector.

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

Add a directive.

Trait Implementations

impl Clone for InterfaceDefinition

fn clone(&self) -> InterfaceDefinition

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InterfaceDefinition

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

Formats the value using the given formatter.

impl Display for InterfaceDefinition

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

Formats the value using the given formatter.

impl TryFrom<InterfaceTypeDefinition> for InterfaceDefinition

fn try_from(node: InterfaceTypeDefinition) -> Result<Self, Self::Error>

Create an apollo-encoder node from an apollo-parser one.

Errors

This returns an error if the apollo-parser tree is not valid. The error doesn’t have much context due to TryFrom API constraints: validate the parse tree before using TryFrom if granular errors are important to you.

type Error = FromError

The type returned in the event of a conversion error.

impl TryFrom<InterfaceTypeExtension> for InterfaceDefinition

fn try_from(node: InterfaceTypeExtension) -> Result<Self, Self::Error>

Create an apollo-encoder node from an apollo-parser one.

Errors

This returns an error if the apollo-parser tree is not valid. The error doesn’t have much context due to TryFrom API constraints: validate the parse tree before using TryFrom if granular errors are important to you.

type Error = FromError

The type returned in the event of a conversion error.