Trying to use Session with Graphql using Poem

[Alfiec7113]

How do I access the session in the query mutation subscription?
Can I add it to a .before() or something like that on the two graphql endpoints?
Not sure if I can add it to the context and if so how.

trying to do authentication with the session, should I be doing it with http headers instead?

Any help greatly appriciated!

[sunli829]

You can do it like this:

#[handler]
fn graphql_subscription(
    session: &Session,
    schema: Data<&MySchema>, // extract the graphql schema
    protocol: GraphQLProtocol,
    websocket: WebSocket,
) -> impl IntoResponse {
    let schema = schema.0.clone();
    let mut data = async_graphql::Data::default();

    // extract the username from session and then insert it to data
    let username = session.get::<String>("username");
    if let Some(username) = username {
        data.insert(username);
    }

    websocket
        .protocols(ALL_WEBSOCKET_PROTOCOLS)
        .on_upgrade(move |stream| {
            GraphQLWebSocket::new(stream, schema, protocol)
                .with_data(data) // attach the data to the graphql context
                .serve()
        })
}

let app = Route::new()
        .at("/ws", get(graphql_subscription))
        .data(schema); // don't forget attach the graphql schema to the incoming http requests

[Alfiec7113]

Thanks a lot!

[Alfiec7113]

#[Object]
impl Query {
    async fn hello(&self, ctx: &Context<'_>) -> &'static str {
        let jwt = ctx.data::<Option<String>>().unwrap();
        "hello"
        }
}

#[handler]
async fn graphql_endpoint(
    session: &Session,
    schema: Data<&Schema>,
    req: GraphQLRequest,
) -> GraphQLResponse {
    let mut req = req.0;
    let schema = schema.0.clone();
    let mut data = async_graphql::Data::default();
    let jwt = session.get::<String>(JWT_COOKIE);
    data.insert(jwt);

    schema.execute(req.data(data)).await.into()
}

#[tokio::main]
async fn main() {
    let ctx = Context::new();

    let basic_schema = schema().data(ctx).finish();

    let app = Route::new()
        .at("/signin", post(signin))
        .at("/logout", get(logout))
        .at("/", get(graphiql).post(graphql_endpoint))
        .at("/subscribe", get(graphql_subscription))
        .data(basic_schema)
        .with(CookieSession::new(CookieConfig::new()));

    println!("GraphiQL IDE: http://localhost:8000");
    Server::new(TcpListener::bind("127.0.0.1:8000"))
        .run(app)
        .await
        .unwrap();
}

thread 'tokio-runtime-worker' panicked at 'called Result::unwrap() on an Err value: Error { message: "Data core::option::Option<alloc::string::String> does not exist.", extensions: None }', src\graphql\user.rs:23:48
note: run with RUST_BACKTRACE=1 environment variable to display a backtrace

Hi sorry to bother you again but do you know why this would be panicking?
I tried to get it from context but I must be doing it wrong, it works for the database I'm sending in my main function (ctx).

[sunli829]

#[handler]
async fn graphql_endpoint(
    session: &Session,
    schema: Data<&Schema>,
    req: GraphQLRequest,
) -> GraphQLResponse {
    let mut req = req.0;
    let schema = schema.0.clone();
    let cookie = session.get::<String>(JWT_COOKIE);
    schema.execute(req.data(cookie)).await.into()
}

[Alfiec7113]

Ah yes makes more sense thanks again

[Bauxitedev]

For those struggling with the same issue in Axum, here's my solution. First define your router like this:

Router::new()
    .route(
        "/api/graphql",
        post(graphql_handler),
    )
    .route("/api/graphql/ws", 
        get(graphql_subscription))

You can use your own graphql_handler for regular GraphQL queries, and this handler for subscriptions. (assuming your schema is stored in your AppState)

async fn graphql_subscription(
    State(AppState { graphql_schema, .. }): State<AppState>,
    protocol: GraphQLProtocol,
    websocket: WebSocketUpgrade,
) -> impl IntoResponse {
    
    let mut data = Data::default();
    data.insert(todo!("insert your context here"));

    websocket
        .protocols(ALL_WEBSOCKET_PROTOCOLS)
        .on_upgrade(move |stream| {
            GraphQLWebSocket::new(stream, graphql_schema, protocol)
                .with_data(data) // attach the data to the graphql context
                .serve()
        })
}

Then in your subscription, you can access your context like this:

#[Subscription]
impl RootSubscription {
    async fn notifications(
        &self,
        ctx: &Context<'_>,
    ) -> impl Stream<Item = YourResponseTypeHere> {

        let ctx = ctx.data_opt::<YourContextHereType>().unwrap();

    }
}

This is useful for e.g. auth and i18n purposes.