Struct apollo_compiler::ApolloCompiler

pub struct ApolloCompiler {
    pub db: RootDatabase,
}

Fields

db: RootDatabase

Implementations

impl ApolloCompiler

Apollo compiler creates a context around your GraphQL. It creates refernces between various GraphQL types in scope.

Example

use apollo_compiler::ApolloCompiler;

let input = r#"
  interface Pet {
    name: String
  }

  type Dog implements Pet {
    name: String
    nickname: String
    barkVolume: Int
  }

  type Cat implements Pet {
    name: String
    nickname: String
    meowVolume: Int
  }

  union CatOrDog = Cat | Dog

  type Human {
    name: String
    pets: [Pet]
  }

  type Query {
    human: Human
  }
"#;

let ctx = ApolloCompiler::new(input);
let diagnostics = ctx.validate();
for diagnostic in &diagnostics {
    // this will pretty-print diagnostics using the miette crate.
    println!("{}", diagnostic);
}
assert!(diagnostics.is_empty());

pub fn new(input: &str) -> Self

Create a new instance of Apollo Compiler.

pub fn with_recursion_limit(input: &str, limit: usize) -> Self

Create a new instance of Apollo Compiler, and configure the parser with the given recursion limit.

pub fn snapshot(&self) -> Snapshot<RootDatabase>

Get a snapshot of the current database.

pub fn validate(&self) -> Vec<ApolloDiagnostic>

Validate your GraphQL input. Returns Diagnostics that you can pretty-print.

Example

use apollo_compiler::ApolloCompiler;
let input = r#"
type Query {
  website: URL,
  amount: Int
}
"#;

let ctx = ApolloCompiler::new(input);
let diagnostics = ctx.validate();
for diagnostic in &diagnostics {
    println!("{}", diagnostic);
}
assert_eq!(diagnostics.len(), 1);