Write docs for using Context with a lifetime

[pyrossh]

Right now my context has a lifetime

use juniper::Context as JuniperContext;
use postgres::transaction::Transaction;

pub struct Context<'a> {
    pub tx: Transaction<'a>,
}

impl<'a> JuniperContext for Context<'a> {}

impl<'a> Context<'a> {
    pub fn new(tx: Transaction<'a>) -> Context<'a> {
        Context { tx: tx }
    }
}

But when I try to specify the same lifetime in a resolver then it gives me this error,

error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait, self type, or predicates
 --> src/schema/query.rs:7:18
  |
7 | graphql_object!(<'a> QueryRoot: Context<'a> as "Query" |&self| {
  |                  ^^ unconstrained lifetime parameter

use models::user::User;
use schema::context::Context;

pub struct QueryRoot;

graphql_object!(<'a> QueryRoot: Context<'a> as "Query" |&self| {
    field users(&executor) -> FieldResult<Vec<User>> {
      Ok(vec![])
    }
});

[carlosdp]

Did you ever figure this out? I'm struggling with the same issue.

[pyrossh]

Nope. Its go something to do with the macro implementation and the executor. Basically the lifetime parameter needs to be specified at the resolver level context also. But its not being done.
https://github.com/graphql-rust/juniper/blob/master/juniper_codegen/src/derive_object.rs#L174
I don't know how we would be able to do that.
One Other solution I can think of is trying to implement the impl ::juniper::GraphQLType for #ident trait yourself for the type and seeing if it works.

I have decided to not go with this approach and create a transaction only when needed in the mutation. So my context doesn't require a lifetime parameter anymore.

[mhallin]

Hello, and sorry for the late answer.

As far as I know, this is not possible in Rust since the context is an associated type on the underlying GraphQLType trait. The graphql_object! macro expands to something like this:

graphql_object!(<'a> QueryRoot: Context<'a> as "Query" |&self| {
    field users(&executor) -> FieldResult<Vec<User>> {
      Ok(vec![])
    }
});

// Expands into:

impl<'a> GraphQLType for QueryRoot { // <- no constraint on 'a here
    type Context = Context<'a>;

    // ...
}

As you can see, the 'a parameter is unconstrained in the impl line, which is an error in Rust.

It might work with adding a lifetime parameter to QueryRoot, by using e.g. PhantomData, but I would advise against it since it's might cause trouble when we introduce asynchronous resolvers.

[LegNeato]

I doubt it does, but does the latest master with #226 help here?

[carlosdp]

@LegNeato nah, those are for the derives, not the declarative macros.

[nitingupta910]

I'm hitting the same issue. I'm using an embedded Graph DB, so context needs to be defined as: struct Context<'a> { graph: &'a Graph } but I can't due to this issue. As a workaround I can something horrible like this:

type GraphPtr = *const Graph;

impl<'a> From<&'a Graph> for GraphPtr {
    fn from(graph: &Graph) -> Self {
        graph as GraphPtr
    }
}
impl<'a> Into<&'a Graph> for GraphPtr {
    fn into(self) -> &'a Graph {
        unsafe { &*self }
    }
}

struct Context {
    graphPtr: GraphPtr,
}

[LegNeato]

I haven't touched this area of Juniper but I have some time tomorrow and will try to take a crack at it

[mrceperka]

Same issue, any "not-so-ugly" solution?

// context.rs
pub struct GraphQLContext<'a> {
    pub language: Language,
    pub db_pool: DbPool,
    pub cookies: Cookies<'a>
}

impl <'a>Context for GraphQLContext<'a> {}

// mutation.rs is similar as query.rs
// query.rs
graphql_object!(<'a> &'a Query: GraphQLContext<'a> as "Query" |&self| {
    field recipe(&executor, id: RecipeId) -> FieldResult<RecipeGql> {
        get_recipe(&id, executor)
    }

    field recipePreparationStep(&executor, id: RecipePreparationStepId) -> FieldResult<RecipePreparationStepGql> {
       get_rps(&id, executor)
    }
});

//schema.rs
pub type Schema = RootNode<'static,  Query, Mutation>;

// router.rs
#[post("/", data = "<request>")]
fn post_graphql_handler(
    language_guard: LanguageGuard,
    ctx: State<Context>,
    request: juniper_rocket::GraphQLRequest,
    schema: State<Schema>,
    mut cookies: Cookies
) -> juniper_rocket::GraphQLResponse {
    let gql_ctx = GraphQLContext::new(
        language_guard.language,
        ctx.db_pool.clone(),
        cookies
    );
    request.execute(&schema, &gql_ctx)
}

gives me

  --> src/router/graphql.rs:9:1
   |
9  | / fn post_graphql_handler(
10 | |     language_guard: LanguageGuard,
11 | |     ctx: State<Context>,
12 | |     request: juniper_rocket::GraphQLRequest,
...  |
21 | |     request.execute(&schema, &gql_ctx)
22 | | }
   | |_^ the trait `juniper::GraphQLType` is not implemented for `graphql::query::Query`
   |
   = help: the following implementations were found:
             <&'a graphql::query::Query as juniper::GraphQLType>
   = note: required by `juniper::RootNode`

error[E0277]: the trait bound `graphql::mutation::Mutation: juniper::GraphQLType` is not satisfied
  --> src/router/graphql.rs:9:1
   |
9  | / fn post_graphql_handler(
10 | |     language_guard: LanguageGuard,
11 | |     ctx: State<Context>,
12 | |     request: juniper_rocket::GraphQLRequest,
...  |
21 | |     request.execute(&schema, &gql_ctx)
22 | | }
   | |_^ the trait `juniper::GraphQLType` is not implemented for `graphql::mutation::Mutation`
   |
   = help: the following implementations were found:
             <&'a graphql::mutation::Mutation as juniper::GraphQLType>
   = note: required by `juniper::RootNode`

I really need those cookies in context. Or is there better way how to pass them?

Don't mind me. I've just wanted to set cookies in login resolver, and that's probably not possible, dunno. Classic REST route will be better for this purpose.

[LucasPickering]

@mrceperka Did you find a solution for this? I'm trying to do the exact same thing (pass cookies into the context with Rocket) and ran into the same issue.

[mrceperka]

Nope I did not. I've continued without cookies... (cos I just wanted to do something and I did not want to be stuck on this cookie thing :D) But one day, I will have to fix it anyways.

[WillSquire]

I'm doing something like this which compiles:

pub struct Query<'a> {
  _marker: PhantomData<&'a ()>,
}

graphql_object!(<'a> Query<'a>: Context<'a> as "Query" |&self| {
  field getUser(&executor, id: Uuid) -> FieldResult<User> {
    Ok(User::read(&executor.context().db.connect()?, &id)?)
  }
});

pub struct Mutation<'a> {
  _marker: PhantomData<&'a ()>,
}

graphql_object!(<'a> Mutation<'a>: Context<'a> as "Mutation" |&self| {
  field createUser(&executor, user: UserCreate) -> FieldResult<String> {
    Ok(User::create(
      &executor.context().db.connect()?,
      executor.context().hasher,
      executor.context().tokeniser,
      &user
    )?)
  }

  field updateUser(&executor, user: UserEdit) -> FieldResult<bool> {
    Ok(User::update(
      &executor.context().db.connect()?,
      executor.context().hasher,
      &user
    )?)
  }

  field deleteUser(&executor, id: Uuid) -> FieldResult<bool> {
    Ok(User::delete(&executor.context().db.connect()?, &id)?)
  }
  
  field login(&executor, user: UserLogin) -> FieldResult<String> {
    Ok(User::login(
      &executor.context().db.connect()?,
      *executor.context().hash_verify,
      executor.context().tokeniser,
      &user
    )?)
  }
});

pub type Schema<'a> = RootNode<'static, Query<'a>, Mutation<'a>>;

pub fn new<'a>() -> Schema<'a> {
  Schema::new(Query { _marker: PhantomData }, Mutation { _marker: PhantomData })
}

But crashes horribly when handling the request through Rocket (although it could be down to Rocket's State for me, I've got a question here regarding: https://stackoverflow.com/questions/55884872/rockets-state-errors-with-attempted-to-retrieve-unmanaged-state-when-using-an)