como/como_bin/src/main.rs

use std::env::{self, current_dir};

mod gqlx;
mod graphql;
mod services;

use axum::{
    extract::Extension,
    http::Method,
    response::{Html, IntoResponse},
    routing::get,
    Json, Router,
};

use async_graphql::{
    http::{playground_source, GraphQLPlaygroundConfig},
    EmptySubscription, Request, Response, Schema,
};
use graphql::CibusSchema;
use services::users_service;
use sqlx::PgPool;
use tower_http::{cors::CorsLayer, trace::TraceLayer};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

use crate::graphql::{MutationRoot, QueryRoot};

async fn graphql_handler(schema: Extension<CibusSchema>, req: Json<Request>) -> Json<Response> {
    schema.execute(req.0).await.into()
}

async fn graphql_playground() -> impl IntoResponse {
    Html(playground_source(GraphQLPlaygroundConfig::new("/")))
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Environment
    tracing::info!("Loading dotenv");
    dotenv::dotenv()?;

    // Logging
    tracing_subscriber::registry()
        .with(tracing_subscriber::EnvFilter::new(
            std::env::var("RUST_LOG").unwrap_or_else(|_| {
                "como_bin=debug,tower_http=debug,axum_extra=debug,hyper=info,mio=info,sqlx=info,async_graphql=debug"
                    .into()
            }),
        ))
        .with(tracing_subscriber::fmt::layer())
        .init();

    // Database
    tracing::info!("Creating pool");
    let db_url = env::var("DATABASE_URL")?;
    let pool = PgPool::connect(&db_url).await?;

    // Database Migrate
    tracing::info!("Migrating db");
    sqlx::migrate!("db/migrations").run(&pool).await?;

    tracing::info!("current path: {}", current_dir()?.to_string_lossy());

    // Schema
    println!("Building schema");
    let schema = Schema::build(QueryRoot, MutationRoot, EmptySubscription)
        .data(users_service::UserService::new(pool))
        .finish();

    // CORS
    let cors = vec!["http://localhost:3000".parse().unwrap()];

    // Webserver
    tracing::info!("Building router");
    let app = Router::new()
        .route("/", get(graphql_playground).post(graphql_handler))
        .layer(Extension(schema))
        .layer(TraceLayer::new_for_http())
        .layer(
            CorsLayer::new()
                .allow_origin(cors)
                .allow_headers([axum::http::header::CONTENT_TYPE])
                .allow_methods([Method::GET, Method::POST, Method::OPTIONS]),
        );

    tracing::info!("Starting webserver");
    axum::Server::bind(&"0.0.0.0:3001".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();

    Ok(())
}