Struct apollo_encoder::OperationDefinition

pub struct OperationDefinition { /* private fields */ }

The OperationDefinition type represents an operation definition

OperationDefinition: OperationType Name? VariableDefinitions? Directives? SelectionSet

Detailed documentation can be found in GraphQL spec.

Example

use apollo_encoder::{Argument, Field, InlineFragment, Directive, OperationDefinition, OperationType, Selection, SelectionSet, TypeCondition, Type_, Value, VariableDefinition};
use indoc::indoc;

let selection_set = {
    let sels = vec![
        Selection::Field(Field::new(String::from("first"))),
        Selection::Field(Field::new(String::from("second"))),
    ];
    let mut sel_set = SelectionSet::new();
    sels.into_iter().for_each(|sel| sel_set.selection(sel));

    sel_set
};
let var_def = VariableDefinition::new(
    String::from("variable_def"),
    Type_::List {
        ty: Box::new(Type_::NamedType {
            name: String::from("Int"),
        }),
    },
);
let mut new_op = OperationDefinition::new(OperationType::Query, selection_set);
let mut directive = Directive::new(String::from("testDirective"));
directive.arg(Argument::new(
    String::from("first"),
    Value::String("one".to_string()),
));
new_op.variable_definition(var_def);
new_op.directive(directive);

assert_eq!(
    new_op.to_string(),
    indoc! { r#"
        query($variable_def: [Int]) @testDirective(first: "one") {
          first
          second
        }
    "#}
);

Implementations

impl OperationDefinition

pub fn new(operation_type: OperationType, selection_set: SelectionSet) -> Self

Create a new instance of OperationDef

pub fn name(&mut self, name: Option<String>)

Set the operation def’s name.

pub fn variable_definition(&mut self, variable_definition: VariableDefinition)

Add a variable definitions.

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

Add a directive.

pub fn shorthand(&mut self)

Set this operation as a query shorthand If a document contains only one operation and that operation is a query which defines no variables and contains no directives then that operation may be represented in a short-hand form which omits the query keyword and operation name. Be careful, it will automatically drop variable definitions and directives

Trait Implementations

impl Debug for OperationDefinition

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

Formats the value using the given formatter.

impl Display for OperationDefinition

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

Formats the value using the given formatter.

impl TryFrom<OperationDefinition> for OperationDefinition

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