Struct apollo_encoder::DirectiveDefinition

pub struct DirectiveDefinition { /* private fields */ }

The DirectiveDefinition type represents a Directive definition.

DirectiveDefinition: Description? directive @ Name Arguments Definition? repeatable? on DirectiveLocations

Detailed documentation can be found in GraphQL spec.

Example

use apollo_encoder::DirectiveDefinition;
use indoc::indoc;

let mut directive = DirectiveDefinition::new("infer".to_string());
directive.description("Infer field types\nfrom field values.".to_string());
directive.location("OBJECT".to_string());
directive.location("FIELD_DEFINITION".to_string());
directive.location("INPUT_FIELD_DEFINITION".to_string());

assert_eq!(
    directive.to_string(),
    r#""""
Infer field types
from field values.
"""
directive @infer on OBJECT | FIELD_DEFINITION | INPUT_FIELD_DEFINITION
"#
);

Implementations

impl DirectiveDefinition

pub fn new(name: String) -> Self

Create a new instance of Directive definition.

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

Set the Directive’s description.

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

Add a location where this Directive can be used.

pub fn arg(&mut self, arg: InputValueDefinition)

Add an argument to this Directive.

pub fn repeatable(&mut self)

Set the Directive’s repeatable

Trait Implementations

impl Debug for DirectiveDefinition

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

Formats the value using the given formatter.

impl Display for DirectiveDefinition

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

Formats the value using the given formatter.

impl TryFrom<DirectiveDefinition> for DirectiveDefinition

fn try_from(node: DirectiveDefinition) -> 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.