Struct async_graphql::dynamic::TypeRef

pub struct TypeRef(_);

Available on crate feature dynamic-schema only.

A type reference

Implementations

impl TypeRef

pub const INT: &'static str = "Int"

A int scalar type

pub const FLOAT: &'static str = "Float"

A float scalar type

pub const STRING: &'static str = "String"

A string scalar type

pub const BOOLEAN: &'static str = "Boolean"

A boolean scalar type

pub const ID: &'static str = "ID"

A ID scalar type

pub fn named(type_name: impl Into<String>) -> TypeRef

Returns the nullable type reference

GraphQL Type: T

pub fn named_nn(type_name: impl Into<String>) -> TypeRef

Returns the non-null type reference

GraphQL Type: T!

pub fn named_list(type_name: impl Into<String>) -> TypeRef

Returns a nullable list of nullable members type reference

GraphQL Type: [T]

pub fn named_nn_list(type_name: impl Into<String>) -> TypeRef

Returns a nullable list of non-null members type reference

GraphQL Type: [T!]

pub fn named_list_nn(type_name: impl Into<String>) -> TypeRef

Returns a non-null list of nullable members type reference

GraphQL Type: [T]!

Examples found in repository

src/dynamic/resolve.rs (line 175)

fn collect_fields<'a>(
    fields: &mut Vec<BoxFieldFuture<'a>>,
    schema: &'a Schema,
    object: &'a Object,
    ctx: &ContextSelectionSet<'a>,
    parent_value: &'a FieldValue,
) -> ServerResult<()> {
    for selection in &ctx.item.node.items {
        match &selection.node {
            Selection::Field(field) => {
                if field.node.name.node == "__typename" {
                    if matches!(
                        ctx.schema_env.registry.introspection_mode,
                        IntrospectionMode::Enabled | IntrospectionMode::IntrospectionOnly
                    ) && matches!(
                        ctx.query_env.introspection_mode,
                        IntrospectionMode::Enabled | IntrospectionMode::IntrospectionOnly,
                    ) {
                        fields.push(
                            async move {
                                Ok((
                                    field.node.response_key().node.clone(),
                                    Value::from(object.name.as_str()),
                                ))
                            }
                            .boxed(),
                        )
                    } else {
                        fields.push(
                            async move { Ok((field.node.response_key().node.clone(), Value::Null)) }.boxed(),
                        )
                    }
                    continue;
                }

                if object.name == schema.0.env.registry.query_type
                    && matches!(
                        ctx.schema_env.registry.introspection_mode,
                        IntrospectionMode::Enabled | IntrospectionMode::IntrospectionOnly
                    )
                    && matches!(
                        ctx.query_env.introspection_mode,
                        IntrospectionMode::Enabled | IntrospectionMode::IntrospectionOnly,
                    )
                {
                    // is query root
                    if field.node.name.node == "__schema" {
                        let ctx = ctx.clone();
                        fields.push(
                            async move {
                                let ctx_field = ctx.with_field(field);
                                let mut ctx_obj =
                                    ctx.with_selection_set(&ctx_field.item.node.selection_set);
                                ctx_obj.is_for_introspection = true;
                                let visible_types =
                                    ctx.schema_env.registry.find_visible_types(&ctx_field);
                                let value = crate::OutputType::resolve(
                                    &crate::model::__Schema::new(
                                        &ctx.schema_env.registry,
                                        &visible_types,
                                    ),
                                    &ctx_obj,
                                    ctx_field.item,
                                )
                                .await?;
                                Ok((field.node.response_key().node.clone(), value))
                            }
                            .boxed(),
                        );
                        continue;
                    } else if field.node.name.node == "__type" {
                        let ctx = ctx.clone();
                        fields.push(
                            async move {
                                let ctx_field = ctx.with_field(field);
                                let (_, type_name) =
                                    ctx_field.param_value::<String>("name", None)?;
                                let mut ctx_obj =
                                    ctx.with_selection_set(&ctx_field.item.node.selection_set);
                                ctx_obj.is_for_introspection = true;
                                let visible_types =
                                    ctx.schema_env.registry.find_visible_types(&ctx_field);
                                let value = crate::OutputType::resolve(
                                    &ctx.schema_env
                                        .registry
                                        .types
                                        .get(&type_name)
                                        .filter(|_| visible_types.contains(type_name.as_str()))
                                        .map(|ty| {
                                            crate::model::__Type::new_simple(
                                                &ctx.schema_env.registry,
                                                &visible_types,
                                                ty,
                                            )
                                        }),
                                    &ctx_obj,
                                    ctx_field.item,
                                )
                                .await?;
                                Ok((field.node.response_key().node.clone(), value))
                            }
                            .boxed(),
                        );
                        continue;
                    } else if ctx.schema_env.registry.enable_federation
                        && field.node.name.node == "_service"
                    {
                        let sdl = ctx
                            .schema_env
                            .registry
                            .export_sdl(SDLExportOptions::new().federation());
                        fields.push(
                            async move {
                                Ok((field.node.response_key().node.clone(), Value::from(sdl)))
                            }
                            .boxed(),
                        );
                        continue;
                    } else if ctx.schema_env.registry.enable_federation
                        && field.node.name.node == "_entities"
                    {
                        let ctx = ctx.clone();
                        fields.push(
                            async move {
                                let ctx_field = ctx.with_field(field);
                                let entity_resolver =
                                    schema.0.entity_resolver.as_ref().ok_or_else(|| {
                                        ctx_field.set_error_path(
                                            Error::new("internal: missing entity resolver")
                                                .into_server_error(ctx_field.item.pos),
                                        )
                                    })?;
                                let entity_type = TypeRef::named_list_nn("_Entity");

                                let arguments = ObjectAccessor(Cow::Owned(
                                    field
                                        .node
                                        .arguments
                                        .iter()
                                        .map(|(name, value)| {
                                            ctx_field
                                                .resolve_input_value(value.clone())
                                                .map(|value| (name.node.clone(), value))
                                        })
                                        .collect::<ServerResult<IndexMap<Name, Value>>>()?,
                                ));

                                let field_value = (entity_resolver)(ResolverContext {
                                    ctx: &ctx_field,
                                    args: arguments,
                                    parent_value,
                                })
                                .0
                                .await
                                .map_err(|err| err.into_server_error(field.pos))?;
                                let value = resolve(
                                    schema,
                                    &ctx_field,
                                    &entity_type.0,
                                    field_value.as_ref(),
                                )
                                .await?
                                .unwrap_or_default();
                                Ok((field.node.response_key().node.clone(), value))
                            }
                            .boxed(),
                        );
                        continue;
                    }
                }

                if ctx.schema_env.registry.introspection_mode
                    == IntrospectionMode::IntrospectionOnly
                    || ctx.query_env.introspection_mode == IntrospectionMode::IntrospectionOnly
                {
                    fields.push(
                        async move { Ok((field.node.response_key().node.clone(), Value::Null)) }
                            .boxed(),
                    );
                    continue;
                }

                if let Some(field_def) = object.fields.get(field.node.name.node.as_str()) {
                    let ctx = ctx.clone();
                    fields.push(
                        async move {
                            let ctx_field = ctx.with_field(field);
                            let arguments = ObjectAccessor(Cow::Owned(
                                field
                                    .node
                                    .arguments
                                    .iter()
                                    .map(|(name, value)| {
                                        ctx_field
                                            .resolve_input_value(value.clone())
                                            .map(|value| (name.node.clone(), value))
                                    })
                                    .collect::<ServerResult<IndexMap<Name, Value>>>()?,
                            ));

                            let resolve_info = ResolveInfo {
                                path_node: ctx_field.path_node.as_ref().unwrap(),
                                parent_type: &object.name,
                                return_type: &field_def.ty.to_string(),
                                name: &field.node.name.node,
                                alias: field.node.alias.as_ref().map(|alias| &*alias.node),
                                is_for_introspection: ctx_field.is_for_introspection,
                            };

                            let resolve_fut = async {
                                let field_value = (field_def.resolver_fn)(ResolverContext {
                                    ctx: &ctx_field,
                                    args: arguments,
                                    parent_value,
                                })
                                .0
                                .await
                                .map_err(|err| err.into_server_error(field.pos))?;
                                let value = resolve(
                                    schema,
                                    &ctx_field,
                                    &field_def.ty.0,
                                    field_value.as_ref(),
                                )
                                .await?;
                                Ok(value)
                            };
                            futures_util::pin_mut!(resolve_fut);

                            let res_value = ctx_field
                                .query_env
                                .extensions
                                .resolve(resolve_info, &mut resolve_fut)
                                .await?
                                .unwrap_or_default();
                            Ok((field.node.response_key().node.clone(), res_value))
                        }
                        .boxed(),
                    );
                }
            }
            selection => {
                let (type_condition, selection_set) = match selection {
                    Selection::Field(_) => unreachable!(),
                    Selection::FragmentSpread(spread) => {
                        let fragment = ctx.query_env.fragments.get(&spread.node.fragment_name.node);
                        let fragment = match fragment {
                            Some(fragment) => fragment,
                            None => {
                                return Err(ServerError::new(
                                    format!(
                                        "Unknown fragment \"{}\".",
                                        spread.node.fragment_name.node
                                    ),
                                    Some(spread.pos),
                                ));
                            }
                        };
                        (
                            Some(&fragment.node.type_condition),
                            &fragment.node.selection_set,
                        )
                    }
                    Selection::InlineFragment(fragment) => (
                        fragment.node.type_condition.as_ref(),
                        &fragment.node.selection_set,
                    ),
                };

                let type_condition =
                    type_condition.map(|condition| condition.node.on.node.as_str());
                let introspection_type_name = &object.name;

                if type_condition.is_none() || type_condition == Some(introspection_type_name) {
                    collect_fields(
                        fields,
                        schema,
                        object,
                        &ctx.with_selection_set(selection_set),
                        parent_value,
                    )?;
                }
            }
        }
    }

    Ok(())
}

pub fn named_nn_list_nn(type_name: impl Into<String>) -> TypeRef

Returns a non-null list of non-null members type reference

GraphQL Type: [T!]!

Trait Implementations

impl Clone for TypeRef

fn clone(&self) -> TypeRef

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TypeRef

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

Formats the value using the given formatter.

impl Display for TypeRef

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

Formats the value using the given formatter.

impl Hash for TypeRef

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<TypeRef> for TypeRef

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for TypeRef

impl StructuralEq for TypeRef

impl StructuralPartialEq for TypeRef