Struct Schema

pub struct Schema {
    pub sources: SourceMap,
    pub schema_definition: Node<SchemaDefinition>,
    pub directive_definitions: IndexMap<Name, Node<DirectiveDefinition>>,
    pub types: IndexMap<NamedType, ExtendedType>,
}

High-level representation of a GraphQL type system document a.k.a. schema.

Fields

sources: SourceMap

Source files, if any, that were parsed to contribute to this schema.

The schema (including parsed definitions) may have been modified since parsing.

schema_definition: Node<SchemaDefinition>

The schema definition and its extensions, defining root operations

directive_definitions: IndexMap<Name, Node<DirectiveDefinition>>

Built-in and explicit directive definitions

types: IndexMap<NamedType, ExtendedType>

Definitions and extensions of all types relevant to a schema:

• Explict types in parsed input files or added programatically.

• Schema-introspection types such as __Schema, __Field, etc.

• When a Schema is initially created or parsed, all Built-in scalars. After validation, the Rust types map in a Valid<Schema> only contains built-in scalar definitions for scalars that are used in the schema. We reflect in this Rust API the behavior of __Schema.types in GraphQL introspection.

Implementations

impl Schema

pub fn new() -> Self

Returns an (almost) empty schema.

It starts with built-in directives, built-in scalars, and introspection types. It can then be filled programatically.

pub fn parse( source_text: impl Into<String>, path: impl AsRef<Path>, ) -> Result<Self, WithErrors<Self>>

Parse a single source file into a schema, with the default parser configuration.

Create a Parser to use different parser configuration. Use builder() to build a schema from multiple parsed files.

pub fn parse_and_validate( source_text: impl Into<String>, path: impl AsRef<Path>, ) -> Result<Valid<Self>, WithErrors<Self>>

parse then validate, to get a Valid<Schema> when mutating it isn’t needed.

pub fn builder() -> SchemaBuilder

Returns a new builder for creating a Schema from AST documents, initialized with built-in directives, built-in scalars, and introspection types

use apollo_compiler::Schema;

let empty_schema = Schema::builder().build();

pub fn validate(self) -> Result<Valid<Self>, WithErrors<Self>>

pub fn get_scalar(&self, name: &str) -> Option<&Node<ScalarType>>

Returns the type with the given name, if it is a scalar type

pub fn get_object(&self, name: &str) -> Option<&Node<ObjectType>>

Returns the type with the given name, if it is a object type

pub fn get_interface(&self, name: &str) -> Option<&Node<InterfaceType>>

Returns the type with the given name, if it is a interface type

pub fn get_union(&self, name: &str) -> Option<&Node<UnionType>>

Returns the type with the given name, if it is a union type

pub fn get_enum(&self, name: &str) -> Option<&Node<EnumType>>

Returns the type with the given name, if it is a enum type

pub fn get_input_object(&self, name: &str) -> Option<&Node<InputObjectType>>

Returns the type with the given name, if it is a input object type

pub fn root_operation( &self, operation_type: OperationType, ) -> Option<&NamedType>

Returns the name of the object type for the root operation with the given operation kind

pub fn type_field( &self, type_name: &str, field_name: &str, ) -> Result<&Component<FieldDefinition>, FieldLookupError<'_>>

Returns the definition of a type’s explicit field or meta-field.

pub fn implementers_map(&self) -> HashMap<Name, Implementers>

Returns a map of interface names to names of types that implement that interface

Schema only stores the inverse relationship (in ObjectType::implements_interfaces and InterfaceType::implements_interfaces), so iterating the implementers of an interface requires a linear scan of all types in the schema. If that is repeated for multiple interfaces, gathering them all at once amorticizes that cost.

pub fn is_subtype(&self, abstract_type: &str, maybe_subtype: &str) -> bool

Returns whether maybe_subtype is a subtype of abstract_type, which means either:

• maybe_subtype implements the interface abstract_type
• maybe_subtype is a member of the union type abstract_type

pub fn is_input_type(&self, ty: &Type) -> bool

Returns whether the type ty is defined as is an input type

https://spec.graphql.org/October2021/#sec-Input-and-Output-Types

pub fn is_output_type(&self, ty: &Type) -> bool

Returns whether the type ty is defined as is an output type

https://spec.graphql.org/October2021/#sec-Input-and-Output-Types

pub fn serialize(&self) -> Serialize<'_, Self>

Returns a builder that has chaining methods for setting serialization configuration, and implements the Display and ToString traits by writing GraphQL syntax.

Trait Implementations

impl Clone for Schema

fn clone(&self) -> Schema

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Schema

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

Formats the value using the given formatter.

impl Display for Schema

Serialize to GraphQL syntax with the default configuration

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

Formats the value using the given formatter.

impl PartialEq for Schema

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Schema