feat: move project to crates

Signed-off-by: kjuulh <contact@kjuulh.io>

crates/como_api/src/controllers/auth.rs

@@ -0,0 +1,160 @@
+use std::fmt::Display;
+
+use crate::router::AppState;
+
+use axum::extract::{FromRef, FromRequestParts, Query, State};
+
+use axum::headers::authorization::Basic;
+use axum::headers::{Authorization, Cookie};
+use axum::http::request::Parts;
+use axum::http::StatusCode;
+
+use axum::response::{ErrorResponse, IntoResponse, Redirect};
+use axum::routing::get;
+use axum::{async_trait, Json, RequestPartsExt, Router, TypedHeader};
+
+use como_domain::users::User;
+use como_infrastructure::register::ServiceRegister;
+
+use serde::Deserialize;
+use serde_json::json;
+
+#[derive(Debug, Deserialize)]
+pub struct ZitadelAuthParams {
+    #[allow(dead_code)]
+    return_url: Option<String>,
+}
+
+trait AnyhowExtensions<T, E>
+where
+    E: Display,
+{
+    fn into_response(self) -> Result<T, ErrorResponse>;
+}
+impl<T, E> AnyhowExtensions<T, E> for anyhow::Result<T, E>
+where
+    E: Display,
+{
+    fn into_response(self) -> Result<T, ErrorResponse> {
+        match self {
+            Ok(o) => Ok(o),
+            Err(e) => {
+                tracing::error!("failed with anyhow error: {}", e);
+                Err(ErrorResponse::from((
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json(json!({
+                        "status": "something",
+                    })),
+                )))
+            }
+        }
+    }
+}
+
+pub async fn zitadel_auth(
+    State(services): State<ServiceRegister>,
+) -> Result<impl IntoResponse, ErrorResponse> {
+    let url = services.auth_service.login().await.into_response()?;
+
+    Ok(Redirect::to(&url.to_string()))
+}
+
+#[derive(Debug, Deserialize)]
+#[allow(dead_code)]
+pub struct AuthRequest {
+    code: String,
+    state: String,
+}
+
+pub async fn login_authorized(
+    Query(query): Query<AuthRequest>,
+    State(services): State<ServiceRegister>,
+) -> Result<impl IntoResponse, ErrorResponse> {
+    let (headers, url) = services
+        .auth_service
+        .login_authorized(&query.code, &query.state)
+        .await
+        .into_response()?;
+
+    Ok((headers, Redirect::to(url.as_str())))
+}
+
+pub struct AuthController;
+
+impl AuthController {
+    pub async fn new_router(
+        _service_register: ServiceRegister,
+        app_state: AppState,
+    ) -> anyhow::Result<Router> {
+        Ok(Router::new()
+            .route("/zitadel", get(zitadel_auth))
+            .route("/authorized", get(login_authorized))
+            .with_state(app_state))
+    }
+}
+
+pub struct UserFromSession {
+    pub user: User,
+}
+
+pub static COOKIE_NAME: &str = "SESSION";
+
+#[async_trait]
+impl<S> FromRequestParts<S> for UserFromSession
+where
+    ServiceRegister: FromRef<S>,
+    S: Send + Sync,
+{
+    type Rejection = (StatusCode, &'static str);
+
+    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
+        let services = ServiceRegister::from_ref(state);
+
+        let cookie: Option<TypedHeader<Cookie>> = parts.extract().await.unwrap();
+        let session_cookie = cookie.as_ref().and_then(|cookie| cookie.get(COOKIE_NAME));
+        if let None = session_cookie {
+            let basic: Option<TypedHeader<Authorization<Basic>>> = parts.extract().await.unwrap();
+
+            if let Some(basic) = basic {
+                let token = services
+                    .auth_service
+                    .login_token(basic.username(), basic.password())
+                    .await
+                    .into_response()
+                    .map_err(|_| {
+                        (
+                            StatusCode::INTERNAL_SERVER_ERROR,
+                            "could not get token from basic",
+                        )
+                    })?;
+
+                return Ok(UserFromSession {
+                    user: User { id: token },
+                });
+            }
+
+            return Err(anyhow::anyhow!("No session was found"))
+                .into_response()
+                .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "did not find a cookie"))?;
+        }
+
+        let session_cookie = session_cookie.unwrap();
+
+        // continue to decode the session cookie
+        let user = services
+            .auth_service
+            .get_user_from_session(session_cookie)
+            .await
+            .into_response()
+            .map_err(|_| {
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    "failed to decode session cookie",
+                )
+            })?;
+
+        Ok(UserFromSession {
+            user: User { id: user.id },
+        })
+    }
+}