apollo-encoder

A library to generate GraphQL Code, SDL.

Crates.io Download docs.rs docs

Getting started

Add this to your Cargo.toml to start using apollo-encoder:

```toml

Just an example, change to the necessary package version.

[dependencies] apollo-encoder = "0.4.0" ```

Or using [cargo-edit]:

bash cargo add apollo-encoder

Rust versions

apollo-encoder is tested on the latest stable version of Rust. Older version may or may not be compatible.

Examples

Create executable definitions

```rust use apollo_encoder::{ Document, Field, FragmentSpread, InlineFragment, OperationDefinition, OperationType, Selection, SelectionSet, TypeCondition, }; use indoc::indoc;

let mut document = Document::new();

let mut droidselectionset = SelectionSet::new(); let primaryfunctionfield = Selection::Field(Field::new(String::from("primaryFunction"))); droidselectionset.selection(primaryfunctionfield);

let mut droidinlinefragment = InlineFragment::new(droidselectionset); droidinlinefragment.type_condition(Some(TypeCondition::new(String::from("Droid"))));

let comparisonfieldsfragment_spread = FragmentSpread::new(String::from("comparisonFields"));

let name_field = Field::new(String::from("name"));

let heroselectionset = vec![ Selection::Field(namefield), Selection::FragmentSpread(comparisonfieldsfragmentspread), Selection::InlineFragment(droidinlinefragment), ];

let mut herofield = Field::new(String::from("hero")); herofield.selectionset(Some(SelectionSet::withselections(heroselectionset)));

let heroforepisodeselectionset = vec![Selection::Field(herofield)]; let mut heroforepisodeoperation = OperationDefinition::new( OperationType::Query, SelectionSet::withselections(heroforepisodeselectionset), ); heroforepisodeoperation.name(Some(String::from("HeroForEpisode")));

document.operation(heroforepisode_operation);

asserteq!( document.tostring(), indoc! { r#" query HeroForEpisode { hero { name ...comparisonFields ... on Droid { primaryFunction } } } "#} ); ```

Create type system definitions

```rust 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 directivedef = DirectiveDefinition::new("provideTreat".tostring()); directivedef.description("Ensures cats get treats.".tostring()); directivedef.location("OBJECT".tostring()); directivedef.location("FIELDDEFINITION".tostring()); directivedef.location("INPUTFIELDDEFINITION".tostring()); document.directive(directivedef);

// Create an Enum Definition let mut enumty1 = EnumValue::new("CatTree".tostring()); enumty1.description("Top bunk of a cat tree.".tostring()); let enumty2 = EnumValue::new("Bed".tostring()); let mut enumty3 = EnumValue::new("CardboardBox".tostring()); let mut directive = Directive::new(String::from("deprecated")); directive.arg(Argument::new( String::from("reason"), Value::String("Box was recycled.".tostring()), )); enumty_3.directive(directive);

let mut enumdef = EnumDefinition::new("NapSpots".tostring()); enumdef.description("Favourite cat\nnap spots.".tostring()); enumdef.value(enumty1); enumdef.value(enumty2); enumdef.value(enumty3); document.enum(enumdef); // Union Definition let mut uniondef = UnionDefinition::new("Pet".tostring()); uniondef.description( "A union of all pets represented within a household.".tostring(), ); uniondef.member("Cat".tostring()); uniondef.member("Dog".tostring()); document.union(uniondef);

asserteq!( document.tostring(), 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 | FIELDDEFINITION | INPUTFIELD_DEFINITION

"#} ); ```

License

Licensed under either of

at your option.