How does graphql know which resolvers to use?

[twiclo]

Say I have this setup with actix_web:

struct Ticket {
  ticket_id: i32,
  author_id: i32,
  title: String,
}

impl Ticket {
  async fn get_by_id(pool: &sqlx::PgPool, id: i32) -> Self {
    sqlx::query_as!(Self, "select * from ticket where ticket_id = $1", id)
      .fetch_one(pool).await.unwrap()
  }
}

#[graphql_object(context = Database)]
impl Ticket {
  fn ticket_id(&self) -> i32 {
    self.ticket_id
  }

  async fn author(&self, context: &Database) -> User {
    User::get_by_id(&context.pool, self.author_id).await
  }

  fn title(&self) -> String {
    self.title.clone()
  }

  async fn updates(&self, context: &Database) -> Vec<TicketUpdate> {
    sqlx::query_as!(TicketUpdate, "select * from ticket_update where ticket_id = $1", self.ticket_id)
      .fetch_all(&context.pool).await.unwrap()
  }
}


impl juniper::Context for Database {}
struct Query;

#[graphql_object(context = Database)]
impl Query {
  fn api_version() -> &'static str {
    "0.1"
  }

  async fn ticket(context: &Database, id: i32) -> Option<Ticket> {
    Some(Ticket::get_by_id(&context.pool, id).await)
  }

  async fn user(context: &Database, id: i32) -> Option<User> {
    Some(User::get_by_id(&context.pool, id).await)
  }
}


#[actix_rt::main]
async fn main() -> Result<(), std::io::Error> {
  let db_url = std::env::var("DATABASE_URL").expect("Set DATABASE_URL idiot");
  let pool = PgPoolOptions::new().max_connections(10).connect(&db_url).await.unwrap();
  env::set_var("RUST_LOG", "info");
  env_logger::init();

  HttpServer::new(move || {
    App::new()
      .app_data(Data::new(schema()))
      .app_data(Data::new(pool.clone()))
      .wrap(middleware::Logger::default())
      .service(
        web::resource("/graphql")
          .route(web::post().to(graphql_route))
          .route(web::get().to(graphql_route))
      )
      .service(web::resource("/playground").route(web::get().to(playground_route)))
      .service(web::resource("/graphiql").route(web::get().to(graphiql_route)))
  }).bind("localhost:8080")?.run().await

When I request a ticket it calls to Ticket::get_by_id() but I don't see how something like Ticket::updates() ever gets called. get_by_id doesn't call to it. Neither does Query::ticket() so then how is this working?

[ilslv]

@twiclo juniper only calls resolvers, when they are actually requested. So if you query looks something like:

query {
    ticket(id: 3) {
        ticketId
    }
}

You don't need to execute Ticket::updates() in that case.

but I don't see how something like Ticket::updates() ever gets called.

To see updates you have to request it explicitly:

query {
    ticket(id: 3) {
        ticketId
        updates
    }
}

---

so then how is this working?

So with GraphQL object this is pretty easy. Macros generate GraphQLValue/GraphQLValueAsync impls, where you have a simple match:

// Very simplified, just to give an idea
impl GraphQLValueAsync for Ticket {
    fn resolve_field_async(&self, field: &str) -> BoxFuture<ExecutionResult> {
        async {
            match field {
                "ticketId" => self.ticket_id().as_graphql_value(),
                "updates" => self.updates().await?.as_graphql_value(),
                _ => Err("unknown field")
            }
        }
        .boxed_local()
    }
}

juniper just parses query and calls resolve_field_async() for every requested field.

With GraphQL interfaces this is whole another story, which is way more complicated and involves compile-time reflection and const panics for error messages. You can dive deeper by reading our discussions around the implementation: #1009