I sometimes have the desire to set RUST_LOG=trace and see what's going on under the hood. Do you think we should add some tracing to this library as well? I have setup the actix_web middleware for logging but that does not help all too much wenn using graphql because almost all lines look like this: 127.0.0.1:43558 "POST / HTTP/1.1" 200 603432 "http://localhost:5001/" 0.221888.

Why are GraphQL interfaces represented by rust enums and not traits ?

This doesn't seems very idiomatic:

use ::uuid::Uuid;

#[Interface(
    field(name = "id", type = "&Uuid")
    )]
pub enum Node {
    User(User)
}

pub struct User {
    pub id: Uuid,
}

#[::async_graphql::Object]
impl User {
    pub async fn id(&self) -> &Uuid {
        &self.id
    }
}

Something like this would be easier to understand:

use ::uuid::Uuid;

#[::async_graphql::Interface]
#[::async_trait::async_trait]
pub trait Node {
    async fn id(&self) -> &Uuid;
}

pub struct User {
    pub id: Uuid,
}

#[::async_graphql::Object]
#[::async_trait::async_trait]
impl Node for User {
    async fn id(&self) -> &Uuid {
        &self.id
    }
}

Note that the async_trait crate is needed as async trait functions are not currently supported.

I've been working with ctx.data() and sometimes data doesn't exist (e.g. there might not be a User), but if I don't explicitly make it an Option<User>, the data() function panics.

I think we should always return an Option from the method so it doesn't panic. This would make it the same as Tide's ext() method: https://docs.rs/tide/0.11.0/tide/struct.Request.html#method.ext

If the consumer knows the data will exist, they can use .unwrap() on the Option.

Description of the feature

I'd like to be able to merge mutations (and merge objects with mutations), this would allow me to perform nested mutations.

Code example

struct With(Uuid);
struct User(Uuid, String);

#[Object]
impl User {
  fn id(&self) -> ID {
    self.0.into()
  }

  fn name(&self) -> &str {
    &self.1
  }
}

#[Mutation]
impl With {
  fn update(&self) -> Mutation {
    let updated_user = update_user();
    Mutation(self.clone(), updated_user)
  }
}

#[MergedMutation]
struct Mutation(With, User);

I need to build a query endpoint that would support something like this:

pub struct Criteria {
    pub value: HashMap<String, Vec<Criterion>>,
}
impl QueryRoot {
async fn records(&self, criteria: Criteria, start: i64, skip: i64, order: SortCriteria) 
}

I'm trying to figure out a way to do this without manually implementing InputValueType. I'm sure it's possible, but I couldn't find a relevant example.

Trying to use defer with relay and get the following error:

Invariant Violation: RelayModernQueryExecutor: invalid incremental payload, expected `path` and `label` to either both be null/undefined, or `path` to be an `Array<string | number>` and `label` to be a `string`

Found here: https://github.com/facebook/relay/blob/2859aa8df4df7d4d6d9eef4c9dc1134286773710/packages/relay-runtime/store/RelayModernQueryExecutor.js#L1267

This is what my chunk look like:

---
Content-Type: application/json
Content-Length: 1113

{"data":{"room":{"title":"28 Elizabeth Street, Malvern","host":{"contactIq":null}}}}
---
Content-Type: application/json
Content-Length: 61

{"path":["room","host","contactIq"],"data":{"fullName":null}}
-----

Looking at what facebook.com does with their @defer they definitely have label in their response payload

{"data":{"node":{"__typename":"User","id":"726995694","timeline_list_feed_units":{"edges":[{"node": 
.....
{"label":"ProfileCometTimelineFeed_user$stream$ProfileCometTimelineFeed_user_timeline_list_feed_units","path":["node","timeline_list_feed_units","edges",1],"data":{"node":

I rewrote the code of DatsSource. The DataSource implemented for Stream has been temporarily removed, and this modification will be added after everyone agrees.

Expected Behavior

Should build correct spans tree

Actual Behavior

Inconsistent span trees, some spans are missing parent. Don't think span.with_subscriber(|(id, d)| d.enter(id)) works in multi threaded runtime

Steps to Reproduce the Problem

1. Clone this repo https://github.com/ibralu/async-graphql-tracing. I've used starwars example with sleep on resolvers
2. Start jaeger

docker run -d --name jaeger \
  -e COLLECTOR_ZIPKIN_HOST_PORT=:9411 \
  -p 5775:5775/udp \
  -p 6831:6831/udp \
  -p 6832:6832/udp \
  -p 5778:5778 \
  -p 16686:16686 \
  -p 14268:14268 \
  -p 14250:14250 \
  -p 9411:9411 \
  jaegertracing/all-in-one:1.22

3. Test with query

{
  hero(episode: EMPIRE) {
    id
    name
    friends {
      id
      name
    }
    appearsIn
  }
}

Specifications

• Version: 2.6
• Platform: macOS
• Subsystem: 11.2

So, basically, async-graphql is already a great library, but it's performance isn't so great yet. I think some performance focus it's pretty good fit for rust GraphQL library :)

We had a discussion about it with @sunli829 via email and highlight some possible weak points.

The performance problems of async-graphql are mainly due to the following reasons:

1. Parser too much memory allocation, such as String. In fact, I have optimized it with unsafe code, and the performance has been improved. Parsing a very complex query 40,000 times has improved by 100 milliseconds. I think that it is not worthwhile to exchange some unsafe factors for such a little performance improvement. So I changed it back.

2. The performance loss caused by the Box future returned by the async-trait. (This may not be easy to solve) I found a new library async-trait-ext, maybe it can avoid extra memory allocation, but I haven't tried it yet.

3. Performance loss caused by asynchronous resolver function. (I have n’t thought of a method that is compatible with both synchronous and asynchronous, because it may mean that a lot of infrastructure needs to provide both synchronous and asynchronous)

Some solutions:

According to my tests, replacing https://github.com/async-graphql/benchmark with jemalloc can bring great performance improvements.

Query parsing/validation caching can be really great feature, especially because it's almost required for https://www.apollographql.com/docs/apollo-server/performance/apq/ Our app clients have in total less than 1000 queries/mutations/subscriptions, and all of it purely static, only variables is changed. So, basically, caching all of this queries documents can get rid of parsing/validation phase entirely in whole server and it's not really hard to implement - fast string hashing, simple LRU cache and additional setting to enable/disable this feature. There is can be additional option - cache only persisted queries, when they will be implemented.

But, of course,

We need a more complete benchmark test, we should first complete this work, and then first to improve the part with the greatest impact on performance.

We already have some benchmarks at https://github.com/async-graphql/benchmark but it should be improved.

Maybe it's worth to move benchmark to main repo and add https://github.com/marketplace/actions/continuous-benchmark to have clear baseline and performance history.

Async-graphql lacks an important feature that most graphql implementations do not. Support both static and dynamic schema, and only with dynamic schema can write something like hasaru.

I have some preliminary ideas about the implementation of this feature. Do you think this feature is important?

@nicolaiunrein @phated

This what I have so far I can't find the button to mark the PR as Draft, is that something that should be enabled at project level ?

what's missing:

• [x] GqlError
• [x] GqlInputValueResult
• [x] GqlQueryBuilder
• [x] GqlResult
• [x] GqlValue
• [x] GqlID

Expected Behavior

When creating a field with a Float type argument and passing the value for the argument as a query variable, the request should succeed in parsing the query argument as a Float. I am executing the query with Content-Type: application/json to ensure that the variables are not send as query params since this often leads to string serialization of floats.

Actual Behavior

When passing a Float argument, the server returns an error indicating that the query can not be executed because the variable is not a Float:

{
  "data": null,
  "errors": [
    {
      "message": "Invalid value for argument \"location.latitude\", expected type \"Float\"",
      "locations": [
        {
          "line": 2,
          "column": 24
        }
      ]
    }
  ]
}

Steps to Reproduce the Problem

1. Create a schema containing a query accepting an InputObject type, which contains a Float field using dynamic schema.
2. Create a query passing the argument as a variable (passing the argument inline of the query works as expected):

query SearchNearbyQuery($location:ScoreLocationInput!) {
  allNearby(location:$location) {
    edges {
      node {
        score
      }
    }
  }
}

{"location":{"latitude":39.8617,"longitude":-104.6732}}

3. To confirm that the query args are being sent over JSON, and that the issue is with variable parsing also test via curl with positive and negative cases:

curl 'http://localhost:8080/' -H 'Accept-Encoding: gzip, deflate, br' \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Connection: keep-alive' \
  -H 'DNT: 1' \
  -H 'Origin: http://localhost:8080' \
  --data-binary '{"query":"query SearchNearbyQuery { allNearby(location:{latitude:39.8617,longitude:-104.6732}) { edges { node { score } } }"}'

curl 'http://localhost:8080/' -H 'Accept-Encoding: gzip, deflate, br' \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Connection: keep-alive' \
  -H 'DNT: 1' \
  -H 'Origin: http://localhost:8080' \
  --data-binary '{"query":"query SearchNearbyQuery { allNearby(location:{latitude:39.8617,longitude:-104.6732}) { edges { node { score } } }","variables":{"location":{"latitude":39.8617,"longitude":-104.6732}}}'

Specifications

• Version: 5.0.1 and master
• Platform: macos and linux
• Web Server Integration: tested with both poem and axum, producing the same behavior

Description of the feature

References to documentation code using [crate::.....] syntax should refer to the correct GraphQL field

Code example (if possible)

In the following example, the enum value PRIVATE is referring to a struct that derives SimpleObject. It'd be awesome if these references would translate to the equally named GraphQL field within my QueryRoot.

use async_graphql::Enum;

#[derive(PartialEq, Eq, Copy, Clone, Enum)]
pub enum ScenarioRunnerKind {
    /// A shared runner which is meant for multiple users. A restriction is that virtual
    /// machines can not be started if the runner is shared.
    SHARED,

    /// A private runner which is meant for one particular [crate::graphql::user::CognitoUser]
    PRIVATE,
}

I'm using async-graphql with no problem at all, thanks for your work!

I have a feature request (or, if it is already possible, just a request for clarification).

I have the graphql mod which has this code:

#[derive(InputObject)]
pub struct PlayerFilters {
    pub id: Option<String>,
    pub created_at: Option<time::OffsetDateTime>,
    pub name: Option<String>,
    pub name_night: Option<String>,
    pub team: Option<String>,
    pub team_night: Option<String>,
    // ... and many many others ...
}

impl From<PlayerFilters> for app::PlayerFilters {
    fn from(o: PlayerFilters) -> Self {
        Self {
            id: o.id,
            created_at: o.created_at.map(Into::into),
            name: o.name,
            name_night: o.name_night,
            team: o.team,
            team_night: o.team_night,
            // ... and many many others ...
        }
    }
}

and the app mod which has:

pub struct PlayerFilters {
    pub id: Option<String>,
    pub created_at: Option<time::OffsetDateTime>,
    pub name: Option<String>,
    pub name_night: Option<String>,
    pub team: Option<String>,
    pub team_night: Option<String>,
    // ... and many many others ...
}

as you can see they have exactly the same fields: I did this because I cannot edit the code in app mod.

But since they have the exact same fields, is there a way to tell async-graphql to use app's struct as the InputObject rather than repeating all the code twice?

Something like:

#[derive(InputObject)]
pub struct PlayerFilters(pub app::PlayerFilters)

or

#[derive(InputObject)]
#[graphql(from="app::PlayerFilters")]
pub struct PlayerFilters{}

Thank you again for this amazing project!

Expected Behavior

User do not be able to send a request for the object defined bellow with a doc_price field, when has_admin_role return false

#[derive(Default, InputObject, Debug)]
#[graphql(input_name = "contract")]
pub struct ContractInput {
    doc_type: Option<String>,
    doc_conditions: Option<String>,
    doc_number: Option<String>,
    #[graphql(visible = "has_admin_role")]
    doc_price: Option<Decimal>,
}

Actual Behavior

Request sent successfully

Steps to Reproduce the Problem

1. Code

#[derive(Default, InputObject, Debug)]
#[graphql(input_name = "contract")]
pub struct ContractInput {
    doc_type: Option<String>,
    doc_conditions: Option<String>,
    doc_number: Option<String>,
    #[graphql(visible = "has_admin_role")]
    doc_price: Option<Decimal>,
}

pub fn has_admin_role(ctx: &Context<'_>) -> bool {
   false
}

#[derive(Default)]
pub struct ContractMutation;

#[Object]
impl ContractMutation {
    async fn insert(&self, ctx: &Context<'_>, contract: ContractInput) -> async_graphql::Result<bool> {
        println!("Contract price: {}", contract.doc_price)
        Ok(true)
    }
}

3. Sending request with payload:

mutation {
  insert(contract:{
    docType: "contract",
    docConditions:"Unknown",
    docNumber:"00005",
    docPrice: 101.02
  })
}

4. In console "Contract price 101.02" will be printed

Specifications

• Version: async-graphql = { version = "5.0.4", features = ["decimal", "opentelemetry", "chrono", "dataloader"] }
• Platform: MacOS

Expected Behavior

I would expect the @oneof directive to be included in the result of an introspection query whenever the #[derive(OneofObject)] macro is used on a struct.

Actual Behavior

The directive is not listed in the introspection query result:

Steps to Reproduce the Problem

1. Clone this minimal example: https://github.com/bvanneerven/introspection-example
2. Run with cargo run
3. Go to http://localhost:8001 and open the network tab in the browser developer tools
4. Trigger an introspection query by clicking the 'Re-fetch GraphQL schema' button
5. Verify that the @oneof directive is not listed in the response from the server

Specifications

• Version: { git = "https://github.com/async-graphql/async-graphql" }
• Platform: WSL (Ubuntu-20.04)