Add a simple database interaction example

[mathiversen]

Hi,
First of all i just want to thank you for making this interesting project public, and for fixing the websocket issue so quickly yesterday!

I've had some more time to play with it but I've run into some issues with how to manage state and share a db connection pool across my handlers/routers. It's probably not so much the framework but rather rust and multi-threading in general, but i think it would help a lot to have such an example somewhere to look at, especially for new rustaceans :)

[jbr]

There are three two layers of answer to this one. (Edit: deleted a third previous example because it is no longer necessary)

As of today

use sqlx::sqlite::SqlitePool;
use trillium::{conn_unwrap, Conn, Handler, State, Init};
use trillium_logger::Logger;
use trillium_router::{Router, RouterConnExt};

async fn hello_world(conn: Conn) -> Conn {
    conn.ok("hello world!")
}

async fn hello_name(conn: Conn) -> Conn {
    let name = conn_unwrap!(conn, conn.param("name"));
    let body = format!("hello, {}!", name);
    let pool = conn.state::<SqlitePool>().unwrap();
    dbg!(&pool);
    conn.ok(body)
}

async fn not_found(conn: Conn) -> Conn {
    let body = format!("Uh oh, I don't have a route for {}", conn.path());
    conn.with_body(body).with_status(404)
}

fn application() -> impl Handler {
    (
        Logger::new(),
        Init::new(|_| async move {
            let db = SqlitePool::connect(&std::env::var("DATABASE_URL").unwrap())
                .await
                .unwrap();
            State::new(db)
        }),
        Router::new()
            .get("/", hello_world)
            .get("/hello/:name", hello_name),
        not_found,
    )
}

fn main() {
    pretty_env_logger::init();
    trillium_smol::run(application())
}

Soon but not today

I intend to make a sqlx-specific database handler that also provides per-conn transaction support.

When that exists, a rough sketch might look something like:

use trillium::{conn_unwrap, Conn, Handler, State};
use trillium_logger::Logger;
use trillium_router::{Router, RouterConnExt};
use trillium_sqlx::{SqlxHandler, SqlxConnExt};

async fn hello_world(conn: Conn) -> Conn {
    conn.ok("hello world!")
}

async fn hello_name(conn: Conn) -> Conn {
    let name = conn_unwrap!(conn, conn.param("name"));
    let user = conn_try!(conn, conn.db().fetch_one("select * from users where name = 'bobby tables'").await);
    let body = format!("hello, {}!", name);
    conn.ok(body)
}

async fn not_found(conn: Conn) -> Conn {
    let body = format!("Uh oh, I don't have a route for {}", conn.path());
    conn.with_body(body).with_status(404)
}

fn application() -> impl Handler {
    (
        Logger::new(),
        SqlxHandler::<Sqlite>::from_env(),
        Router::new()
            .get("/", hello_world)
            .get("/hello/:name", hello_name),
        not_found,
    )
}

fn main() {
    pretty_env_logger::init();
    trillium_smol::run(application())
}

[jbr]

I've opened #73 to represent this, and should have a short term fix up imminently that will involve adding default-features = false, features = ["tokio"] to the trillium-testing dev dependency in Cargo.toml. I don't like the fact that this requires app authors to repeat themselves, but it's the simplest thing to do to resolve this bug

[happysalada]

Amazing, thanks!

[happysalada]

Just a couple of comments on the new trillium testing.
The docs show version 0.2.1 but trying to get that version from cargo.toml doesn't work. The latest that seems to be published seems to be 0.2.0 (not a big deal).
https://docs.trillium.rs/trillium_testing/index.html

I'm trying to run the tests with a json requests but getting some 500 errors back

    fn graphql_agents() {
        let mut application = application();
        init(&mut application);
        assert_response!(
            post("/graphql")
                .with_request_body(r#"{"query": "agents() {id, name, email}}"#)
                .on(&application),
            StatusCode::Ok,
            "data: []",
        );
    }

I'm guessing here that me passing json like this is not appreciated.
I have two questions? Could you show the way to test a post request with a json input?
I looked at the conn_try code and it seems that an error should be logged when there is a failure. I have enabled RUST_LOG=info are the error messages getting swallowed in the tests? (Just wondering).

Thanks again for updating this!

[jbr]

I think the issue is probably that {"query": "agents() {id, name, email}} is missing a closing " and should be

r#"{ "query": "agents() {id, name, email}" }"#

In order to print log output to stderr in tests, you'd need to env_logger::init() at the top of your test (or in application())

As far as docs: This is bound to be a problem at some point, but the docs represent the latest github main, not the published version. I haven't published 0.2.1 yet, and will probably accumulate a few more changes before doing so, as the only change was adding a with_peer_ip to TestConn

[happysalada]

Thanks a lot for the help, the env_logger::init() was the help (I did it in application as it does not need to be repeated).

I'm posting what I have in case it can help others

use juniper::{http::graphiql, http::GraphQLRequest, EmptySubscription, RootNode};
use lazy_static::lazy_static;
use sqlx::sqlite::SqlitePool;
use trillium::{conn_try, Conn, Handler, Init, State};
use trillium_logger::Logger;
use trillium_router::Router;
mod schema;
use crate::schema::{MutationRoot, QueryRoot};

pub type Schema = RootNode<'static, QueryRoot, MutationRoot, EmptySubscription<Context>>;
lazy_static! {
    static ref SCHEMA: Schema =
        Schema::new(QueryRoot {}, MutationRoot {}, EmptySubscription::new());
}

pub struct Context {
    pool: SqlitePool,
}

impl juniper::Context for Context {}

async fn handle_graphiql(conn: Conn) -> Conn {
    conn.with_header(("content-type", "text/html"))
        .ok(graphiql::graphiql_source("/graphql", None))
}

async fn handle_graphql(mut conn: Conn) -> Conn {
    let raw_body = conn_try!(conn, conn.request_body_string().await);
    let query: GraphQLRequest = conn_try!(conn, serde_json::from_str(&raw_body));
    let context = Context {
        pool: conn.state::<SqlitePool>().unwrap().to_owned(),
    };
    let response = query.execute(&SCHEMA, &context).await;
    let json = conn_try!(conn, serde_json::to_string(&response));
    conn.ok(json)
        .with_header(("Access-Control-Allow-Origin", "*"))
        .with_header(("content-type", "application/json"))
}

async fn cors(conn: Conn) -> Conn {
    conn.with_header(("Access-Control-Allow-Origin", "*"))
        .with_header(("Access-Control-Allow-Headers", "content-type"))
}

async fn not_found(conn: Conn) -> Conn {
    let body = format!("Uh oh, I don't have a route for {}", conn.path());
    conn.with_body(body).with_status(404)
}

pub fn application() -> impl Handler {
    env_logger::init();
    (
        Logger::new(),
        Init::new(|_| async move {
            let db = SqlitePool::connect(
                &std::env::var("DATABASE_URL").expect("DATABASE_URL is not set"),
            )
            .await
            .expect("failed to get a db connection");
            State::new(db)
        }),
        cors,
        Router::new()
            .get("/graphiql", handle_graphiql)
            .post("/graphql", handle_graphql),
        not_found,
    )
}

fn main() {
    trillium_tokio::config()
        .with_port(
            std::env::var("HTTP_PORT")
                .expect("missing http port")
                .parse::<u16>()
                .expect("http port should be a number"),
        )
        .with_host("127.0.0.1")
        .with_nodelay()
        .run(application());
}

#[cfg(test)]
mod tests {
    use super::application;
    use trillium_testing::prelude::*;

    #[test]
    fn graphql_agents() {
        let mut application = application();
        init(&mut application);
        assert_response!(
            post("/graphql")
                .with_request_body(r#"{"query": "{ agents {id, name, email}}"}"#)
                .on(&application),
            StatusCode::Ok,
            r#"{"data":{"agents":[]}}"#,
        );
    }
}

It will depend on what you have in your schema file, but I don't think there is anything complicated going on there.

Thanks again for the help!