R2D2, Diesel, Postgres, and Juniper

mod.rs

pub struct Ctx {
    pub db: request::PooledConnection,
}

impl Context for Ctx {}

pub fn context_factory(req: &mut Request) -> Ctx {
    Ctx {
        db: request::get_db(req),
    }
}

query.rs

struct QueryRoot;

graphql_object!(QueryRoot: Ctx |&self| {
    field do_stuff_with_db(&executor) -> FieldResult<i32> {
        let db = &executor.context().db;
      
        db.transaction(|| {
            // Do stuff...
        });

        Ok(0)
    }
});

request.rs

pub type ConnectionManager = r2d2_diesel::ConnectionManager<diesel::pg::PgConnection>;
pub type ConnectionPool = r2d2::Pool<ConnectionManager>;
pub type PooledConnection = r2d2::PooledConnection<ConnectionManager>;

struct DatabaseMarker;                              

impl Key for DatabaseMarker {                       
    type Value = ConnectionPool;                    
}                                                                                                        

pub fn get_db(req: &mut Request) -> PooledConnection {
    req.get::<Read<DatabaseMarker>>()
        .expect("Could not get DatabaseMarker from request")
        .get()
        .expect("Could not acquire read lock on connection pool")
}

pub fn prepare_chain(chain: &mut Chain, pool: ConnectionPool) {                                          
    chain.link(Read::<DatabaseMarker>::both(pool));
}