Crate apollo_encoder
source · [−]Expand description
apollo-encoder
A library to generate GraphQL Code, SDL.
Getting started
Add this to your Cargo.toml to start using apollo-encoder:
[dependencies]
apollo-encoder = "0.2.3"Or using cargo-edit:
cargo add apollo-encoderExamples
Create executable definitions
use apollo_encoder::{
Document, Field, FragmentSpread, InlineFragment, OperationDefinition, OperationType,
Selection, SelectionSet, TypeCondition,
};
use indoc::indoc;
let mut document = Document::new();
let mut droid_selection_set = SelectionSet::new();
let primary_function_field = Selection::Field(Field::new(String::from("primaryFunction")));
droid_selection_set.selection(primary_function_field);
let mut droid_inline_fragment = InlineFragment::new(droid_selection_set);
droid_inline_fragment.type_condition(Some(TypeCondition::new(String::from("Droid"))));
let comparison_fields_fragment_spread =
FragmentSpread::new(String::from("comparisonFields"));
let name_field = Field::new(String::from("name"));
let hero_selection_set = vec![
Selection::Field(name_field),
Selection::FragmentSpread(comparison_fields_fragment_spread),
Selection::InlineFragment(droid_inline_fragment),
];
let mut hero_field = Field::new(String::from("hero"));
hero_field.selection_set(Some(SelectionSet::with_selections(hero_selection_set)));
let hero_for_episode_selection_set = vec![Selection::Field(hero_field)];
let mut hero_for_episode_operation = OperationDefinition::new(
OperationType::Query,
SelectionSet::with_selections(hero_for_episode_selection_set),
);
hero_for_episode_operation.name(Some(String::from("HeroForEpisode")));
document.operation(hero_for_episode_operation);
assert_eq!(
document.to_string(),
indoc! { r#"
query HeroForEpisode {
hero {
name
...comparisonFields
... on Droid {
primaryFunction
}
}
}
"#}
);Create type system definitions
use apollo_encoder::{
Argument, Directive, Document, DirectiveDefinition, EnumValue,
EnumDefinition, UnionDefinition, Value
};
use indoc::indoc;
let mut document = Document::new();
// Create a Directive Definition.
let mut directive_def = DirectiveDefinition::new("provideTreat".to_string());
directive_def.description(Some("Ensures cats get treats.".to_string()));
directive_def.location("OBJECT".to_string());
directive_def.location("FIELD_DEFINITION".to_string());
directive_def.location("INPUT_FIELD_DEFINITION".to_string());
document.directive(directive_def);
// Create an Enum Definition
let mut enum_ty_1 = EnumValue::new("CatTree".to_string());
enum_ty_1.description(Some("Top bunk of a cat tree.".to_string()));
let enum_ty_2 = EnumValue::new("Bed".to_string());
let mut enum_ty_3 = EnumValue::new("CardboardBox".to_string());
let mut directive = Directive::new(String::from("deprecated"));
directive.arg(Argument::new(
String::from("reason"),
Value::String("Box was recycled.".to_string()),
));
enum_ty_3.directive(directive);
let mut enum_def = EnumDefinition::new("NapSpots".to_string());
enum_def.description(Some("Favourite cat\nnap spots.".to_string()));
enum_def.value(enum_ty_1);
enum_def.value(enum_ty_2);
enum_def.value(enum_ty_3);
document.enum_(enum_def);
// Union Definition
let mut union_def = UnionDefinition::new("Pet".to_string());
union_def.description(Some(
"A union of all pets represented within a household.".to_string(),
));
union_def.member("Cat".to_string());
union_def.member("Dog".to_string());
document.union(union_def);
assert_eq!(
document.to_string(),
indoc! { r#"
"A union of all pets represented within a household."
union Pet = Cat | Dog
"""
Favourite cat
nap spots.
"""
enum NapSpots {
"Top bunk of a cat tree."
CatTree
Bed
CardboardBox @deprecated(reason: "Box was recycled.")
}
"Ensures cats get treats."
directive @provideTreat on OBJECT | FIELD_DEFINITION | INPUT_FIELD_DEFINITION
"#}
);License
Licensed under either of
- Apache License, Version 2.0 (LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0)
- MIT license (LICENSE-MIT or https://opensource.org/licenses/MIT)
at your option.
Structs
The Argument type represents an argument
The ArgumentsDefinition type represents an arguments definition
The Directive type represents a Directive, it provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.
The DirectiveDefinition type represents a Directive definition.
The Document type represents a GraphQL document. A GraphQL Document
describes a complete file or request string operated on by a GraphQL service
or client. A document contains multiple definitions, either executable or
representative of a GraphQL type system.
Enums are special scalars that can only have a defined set of values.
The EnumValue type represents one of possible values of an enum.
The __Field type represents each field in an Object or Interface type.
The FieldDefinition type represents each field definition in an Object definition or Interface type definition.
The FragmentDefinition type represents a fragment definition
The FragmentSpread type represents a named fragment used in a selection set.
The InlineFragment type represents an inline fragment in a selection set that could be used as a field
Input Field in a given Input Object. A GraphQL Input Object defines a set of input fields; the input fields are either scalars, enums, or other input objects. Input fields are similar to Fields, but can have a default value.
Input objects are composite types used as inputs into queries defined as a list of named input values..
The InputValueDefinition type represents field and directive arguments.
InterfaceDefinition is an abstract type where there are common fields declared.
ObjectDefinition types represent concrete instantiations of sets of fields.
The OperationDefinition type represents an operation definition
Represents scalar types such as Int, String, and Boolean. Scalars cannot have fields.
A GraphQL service’s collective type system capabilities are referred to as that service’s “schema”.
The SelectionSet type represents a selection_set type in a fragment spread, an operation or a field
The TypeCondition type represents where a fragment could be applied
UnionDefinitions are an abstract type where no common fields are declared.
The VariableDefinition type represents a variable definition
Enums
The OperationType type represents the kind of operation
The Selection type represents a selection in a selection set Selection: Field | FragmentSpread | InlineFragment
Convenience enum to create a Description. Can be a Top level, a Field
level or an Input level. The variants are distinguished by the way they
get displayed, e.g. number of leading spaces.
Convenience Type_ implementation used when creating a Field.
Can be a NamedType, a NonNull or a List.
The Value type represents available values you could give as an input.