nefarious-login/examples/noop/src/main.rs

use std::{net::SocketAddr, str::FromStr};

use axum::{
    extract::{FromRef, State},
    response::IntoResponse,
    routing::get,
    Router,
};
use nefarious_login::{
    auth::AuthService,
    axum::{AuthController, UserFromSession},
    login::{
        auth_clap::{AuthEngine, ZitadelClap},
        config::ConfigClap,
        AuthClap,
    },
    session::{PostgresqlSessionClap, SessionBackend},
};
use tracing_subscriber::EnvFilter;

#[derive(Clone)]
struct AppState {
    auth: AuthService,
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .init();

    let auth = AuthClap {
        engine: AuthEngine::Noop,
        session_backend: SessionBackend::InMemory,
        zitadel: ZitadelClap {
            ..Default::default()
        },
        session: nefarious_login::session::SessionClap {
            postgresql: PostgresqlSessionClap {
                ..Default::default()
            },
        },
        config: ConfigClap {
            return_url: "http://localhost:3000/authed".into(),
        },
    };

    let auth_service = AuthService::new(&auth).await?;

    let state = AppState {
        auth: auth_service.clone(),
    };

    let app = Router::new()
        .route("/unauthed", get(unauthed))
        .route("/authed", get(authed))
        .with_state(state)
        .nest("/auth", AuthController::new_router(auth_service).await?);

    let addr = SocketAddr::from_str(&format!("{}:{}", "127.0.0.1", "3000"))?;
    let listener = tokio::net::TcpListener::bind(&addr).await?;

    axum::serve(listener, app).await?;

    Ok(())
}

impl FromRef<AppState> for AuthService {
    fn from_ref(input: &AppState) -> Self {
        input.auth.clone()
    }
}

async fn unauthed() -> String {
    "Hello Unauthorized User".into()
}

#[axum::debug_handler()]
async fn authed(
    user: UserFromSession,
    State(_auth_service): State<AuthService>,
) -> impl IntoResponse {
    format!("Hello authorized user: {:?}", user.user.id)
}