Struct async_graphql::dynamic::Object

pub struct Object { /* private fields */ }

Available on crate feature dynamic-schema only.

A GraphQL object type

Examples

use async_graphql::{dynamic::*, value, Value};

let query = Object::new("Query").field(Field::new("value", TypeRef::named_nn(TypeRef::STRING), |ctx| {
    FieldFuture::new(async move { Ok(Some(Value::from("abc"))) })
}));


let schema = Schema::build(query.type_name(), None, None)
    .register(query)
    .finish()?;

assert_eq!(
   schema
       .execute("{ value }")
       .await
       .into_result()
       .unwrap()
       .data,
   value!({ "value": "abc" })
);

Implementations

impl Object

pub fn new(name: impl Into<String>) -> Self

Create a GraphQL object type

pub fn description(self, description: impl Into<String>) -> Self

Set the description

pub fn extends(self) -> Self

Indicates that an object or interface definition is an extension of another definition of that same type.

pub fn shareable(self) -> Self

Indicate that an object type’s field is allowed to be resolved by multiple subgraphs

pub fn inaccessible(self) -> Self

Indicate that an enum is not accessible from a supergraph when using Apollo Federation

Reference: https://www.apollographql.com/docs/federation/federated-types/federated-directives/#inaccessible

pub fn interface_object(self) -> Self

During composition, the fields of every @interfaceObject are added both to their corresponding interface definition and to all entity types that implement that interface.

Reference: https://www.apollographql.com/docs/federation/federated-types/federated-directives/#interfaceobject

pub fn tags<I: IntoIterator<Item = T>, T: Into<String>>(self, tags: I) -> Self

Arbitrary string metadata that will be propagated to the supergraph when using Apollo Federation. This attribute is repeatable

Reference: https://www.apollographql.com/docs/federation/federated-types/federated-directives/#applying-metadata

pub fn field(self, field: Field) -> Self

Add an field to the object

pub fn implement(self, interface: impl Into<String>) -> Self

Add an implement to the object

pub fn key(self, fields: impl Into<String>) -> Self

Add an entity key

Examples

use async_graphql::{dynamic::*, Value};

let obj = Object::new("MyObj")
    .field(Field::new("a", TypeRef::named(TypeRef::INT), |_| {
        FieldFuture::new(async move { Ok(Some(Value::from(10))) })
    }))
    .field(Field::new("b", TypeRef::named(TypeRef::INT), |_| {
        FieldFuture::new(async move { Ok(Some(Value::from(20))) })
    }))
    .field(Field::new("c", TypeRef::named(TypeRef::INT), |_| {
        FieldFuture::new(async move { Ok(Some(Value::from(30))) })
    }))
    .key("a b")
    .key("c");

pub fn unresolvable(self, fields: impl Into<String>) -> Self

Make the entity unresolvable by the current subgraph

Most commonly used to reference an entity without contributing fields.

Examples

use async_graphql::{dynamic::*, Value};

let obj = Object::new("MyObj")
    .field(Field::new("a", TypeRef::named(TypeRef::INT), |_| {
        FieldFuture::new(async move { Ok(Some(Value::from(10))) })
    }))
    .unresolvable("a");

This references the MyObj entity with the key a that cannot be resolved by the current subgraph.

pub fn type_name(&self) -> &str

Returns the type name

Trait Implementations

impl Debug for Object

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

Formats the value using the given formatter.

impl From<Object> for Type

fn from(obj: Object) -> Self

Converts to this type from the input type.