Struct RootNode

pub struct RootNode<'a, QueryT: GraphQLType<S>, MutationT: GraphQLType<S>, SubscriptionT: GraphQLType<S>, S = DefaultScalarValue>
where
    S: ScalarValue,
{ /* private fields */ }

Root query node of a schema

This brings the mutation, subscription and query types together, and provides the predefined metadata fields.

Implementations

impl<'a, QueryT, MutationT, SubscriptionT> RootNode<'a, QueryT, MutationT, SubscriptionT, DefaultScalarValue>

where QueryT: GraphQLType<DefaultScalarValue, TypeInfo = ()>, MutationT: GraphQLType<DefaultScalarValue, TypeInfo = ()>, SubscriptionT: GraphQLType<DefaultScalarValue, TypeInfo = ()>,

pub fn new( query: QueryT, mutation: MutationT, subscription: SubscriptionT, ) -> Self

Constructs a new RootNode from query, mutation and subscription nodes, parametrizing it with a DefaultScalarValue.

impl<'a, QueryT, MutationT, SubscriptionT, S> RootNode<'a, QueryT, MutationT, SubscriptionT, S>

where S: ScalarValue + 'a, QueryT: GraphQLType<S, TypeInfo = ()>, MutationT: GraphQLType<S, TypeInfo = ()>, SubscriptionT: GraphQLType<S, TypeInfo = ()>,

pub fn new_with_scalar_value( query: QueryT, mutation: MutationT, subscription: SubscriptionT, ) -> Self

Constructs a new RootNode from query, mutation and subscription nodes, parametrizing it with the provided ScalarValue.

impl<'a, S, QueryT, MutationT, SubscriptionT> RootNode<'a, QueryT, MutationT, SubscriptionT, S>

where QueryT: GraphQLType<S>, MutationT: GraphQLType<S>, SubscriptionT: GraphQLType<S>, S: ScalarValue + 'a,

pub fn new_with_info( query_obj: QueryT, mutation_obj: MutationT, subscription_obj: SubscriptionT, query_info: QueryT::TypeInfo, mutation_info: MutationT::TypeInfo, subscription_info: SubscriptionT::TypeInfo, ) -> Self

Construct a new root node from query and mutation nodes, while also providing type info objects for the query and mutation types.

pub fn disable_introspection(self) -> Self

Disables introspection for this RootNode, making it to return a [FieldError] whenever its __schema or __type field is resolved.

By default, all introspection queries are allowed.

Example

pub struct Query;

#[graphql_object]
impl Query {
    fn some() -> bool {
        true
    }
}

type Schema = RootNode<'static, Query, EmptyMutation, EmptySubscription>;

let schema = Schema::new(Query, EmptyMutation::new(), EmptySubscription::new())
    .disable_introspection();

let query = "query { __schema { queryType { name } } }";

match juniper::execute_sync(query, None, &schema, &graphql_vars! {}, &()) {
    Err(GraphQLError::ValidationError(errs)) => {
        assert_eq!(
            errs.first().unwrap().message(),
            "GraphQL introspection is not allowed, but the operation contained `__schema`",
        );
    }
    res => panic!("expected `ValidationError`, returned: {res:#?}"),
}

pub fn enable_introspection(self) -> Self

Enables introspection for this RootNode, if it was previously disabled.

By default, all introspection queries are allowed.

pub fn as_sdl(&self) -> String

Returns this RootNode as a String containing the schema in [SDL (schema definition language)].

Sorted

The order of the generated definitions is stable and is sorted in the “type-then-name” manner.

If another sorting order is required, then the as_document() method should be used, which allows to sort the returned Document in the desired manner and then to convert it to_string().

pub fn as_document(&'a self) -> Document<'a, &'a str>

Returns this RootNode as a graphql_parser’s Document.

Unsorted

The order of the generated definitions in the returned Document is NOT stable and may change without any real schema changes.

Trait Implementations

impl<'a, QueryT: Debug + GraphQLType<S>, MutationT: Debug + GraphQLType<S>, SubscriptionT: Debug + GraphQLType<S>, S> Debug for RootNode<'a, QueryT, MutationT, SubscriptionT, S>

where S: ScalarValue + Debug, QueryT::TypeInfo: Debug, MutationT::TypeInfo: Debug, SubscriptionT::TypeInfo: Debug,

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

Formats the value using the given formatter.

impl<'a, S, QueryT, MutationT, SubscriptionT> GraphQLType<S> for RootNode<'a, QueryT, MutationT, SubscriptionT, S>

where S: ScalarValue, QueryT: GraphQLType<S>, MutationT: GraphQLType<S, Context = QueryT::Context>, SubscriptionT: GraphQLType<S, Context = QueryT::Context>,

fn name(info: &Self::TypeInfo) -> Option<&str>

Returns name of this GraphQLType to expose.

fn meta<'r>( info: &Self::TypeInfo, registry: &mut Registry<'r, S>, ) -> MetaType<'r, S>

where S: 'r,

Returns MetaType representing this GraphQLType.

impl<'a, S, QueryT, MutationT, SubscriptionT> GraphQLValue<S> for RootNode<'a, QueryT, MutationT, SubscriptionT, S>

where S: ScalarValue, QueryT: GraphQLType<S>, MutationT: GraphQLType<S, Context = QueryT::Context>, SubscriptionT: GraphQLType<S, Context = QueryT::Context>,

type Context = <QueryT as GraphQLValue<S>>::Context

Context type for this GraphQLValue.

type TypeInfo = <QueryT as GraphQLValue<S>>::TypeInfo

Type that may carry additional schema information for this GraphQLValue.

fn type_name<'i>(&self, info: &'i Self::TypeInfo) -> Option<&'i str>

Returns name of the GraphQLType exposed by this GraphQLValue.

fn concrete_type_name( &self, context: &Self::Context, info: &Self::TypeInfo, ) -> String

Returns the concrete GraphQLType name for this GraphQLValue being an interface, an union or an object.

fn resolve_field( &self, info: &Self::TypeInfo, field: &str, args: &Arguments<'_, S>, executor: &Executor<'_, '_, Self::Context, S>, ) -> ExecutionResult<S>

Resolves the value of a single field on this GraphQLValue.

fn resolve( &self, info: &Self::TypeInfo, selection_set: Option<&[Selection<'_, S>]>, executor: &Executor<'_, '_, Self::Context, S>, ) -> ExecutionResult<S>

Resolves the provided selection_set against this GraphQLValue.

fn resolve_into_type( &self, info: &Self::TypeInfo, type_name: &str, selection_set: Option<&[Selection<'_, S>]>, executor: &Executor<'_, '_, Self::Context, S>, ) -> ExecutionResult<S>

Resolves this GraphQLValue (being an interface or an union) into a concrete downstream object type.

impl<'a, S, QueryT, MutationT, SubscriptionT> GraphQLValueAsync<S> for RootNode<'a, QueryT, MutationT, SubscriptionT, S>

where QueryT: GraphQLTypeAsync<S>, QueryT::TypeInfo: Sync, QueryT::Context: Sync + 'a, MutationT: GraphQLTypeAsync<S, Context = QueryT::Context>, MutationT::TypeInfo: Sync, SubscriptionT: GraphQLType<S, Context = QueryT::Context> + Sync, SubscriptionT::TypeInfo: Sync, S: ScalarValue + Send + Sync,

fn resolve_field_async<'b>( &'b self, info: &'b Self::TypeInfo, field_name: &'b str, arguments: &'b Arguments<'_, S>, executor: &'b Executor<'_, '_, Self::Context, S>, ) -> BoxFuture<'b, ExecutionResult<S>>

Resolves the value of a single field on this GraphQLValueAsync.

fn resolve_into_type_async<'a>( &'a self, info: &'a Self::TypeInfo, type_name: &str, selection_set: Option<&'a [Selection<'a, S>]>, executor: &'a Executor<'a, 'a, Self::Context, S>, ) -> BoxFuture<'a, ExecutionResult<S>>

Resolves this GraphQLValueAsync (being an interface or an union) into a concrete downstream object type.

fn resolve_async<'a>( &'a self, info: &'a Self::TypeInfo, selection_set: Option<&'a [Selection<'_, S>]>, executor: &'a Executor<'_, '_, Self::Context, S>, ) -> BoxFuture<'a, ExecutionResult<S>>

Resolves the provided selection_set against this GraphQLValueAsync.