Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

6.1 KB
Raw Blame
use axum::{
    Json,
    extract::{Path, Query, State},
    http::StatusCode,
    response::{IntoResponse, Redirect, Response},
};
use std::collections::HashMap;
use tower_cookies::Cookies;

use crate::api::{
    context::ApiContext,
    utils::{
        append_signed_up_param_if_new_user, create_access_token_cookie, create_refresh_token_cookie,
    },
};
use fusionauth::error::FusionAuthClientError;

use model::response::{ErrorResponse, UserTokensResponse};

#[derive(serde::Deserialize)]
pub struct Params {
    pub code: String,
}

/// Handles oauth redirect
#[utoipa::path(
        get,
        path = "/oauth/passwordless/{code}",
        operation_id = "passwordless_callback",
        params(
            ("code" = String, Path, description = "Code"),
            ("email" = String, Query, description = "Email"),
        ),
        responses(
            (status = 200, body = UserTokensResponse),
            (status = 400, body=String),
            (status = 401, body=String),
            (status = 500, body=String),
        )
    )]
#[tracing::instrument(skip(ctx, cookies))]
pub async fn handler(
    State(ctx): State<ApiContext>,
    cookies: Cookies,
    Path(Params { code }): Path<Params>,
    Query(params): Query<HashMap<String, String>>,
) -> Result<Response, Response> {
    let disable_redirect = if let Some(disable_redirect) = params.get("disable_redirect") {
        disable_redirect == "true"
    } else {
        false
    };

    // validate email matches code
    let raw_email = params
        .get("email")
        .ok_or((StatusCode::BAD_REQUEST, "email required").into_response())?;

    let email = urlencoding::decode(raw_email).map_err(|e| {
        tracing::error!(error=?e, "unable to decode email");
        (StatusCode::BAD_REQUEST, "unable to decode email").into_response()
    })?;

    let passwordless_code = ctx
        .macro_cache_client
        .get_passwordless_login_code(&email)
        .await
        .map_err(|e| {
            tracing::error!(error=?e, email=%email, "unable to get passwordless login code");
            (StatusCode::UNAUTHORIZED, "no passwordless login found").into_response()
        })?;

    if passwordless_code != code {
        return Err((StatusCode::UNAUTHORIZED, "invalid code").into_response());
    }

    let passwordless_response = ctx
        .auth_client
        .complete_passwordless_login(&code)
        .await
        .map_err(|e| {
            tracing::error!(error=?e, "complete_passwordless_login: unable to complete passwordless login");
            match e {
                FusionAuthClientError::IncorrectCode => (
                    StatusCode::UNAUTHORIZED,
                    Json(ErrorResponse {
                        message: "invalid code".into(),
                    }),
                )
                    .into_response(),
                _ => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
            }
        })?;

    // Ensure that the user email matches what email we associated with the code
    // Only perform this check if the email param was not provided
    if !params.contains_key("email") {
        tracing::trace!("no email param provided, performing additional verification");
        let email = passwordless_response.user.email.to_lowercase();
        let passwordless_code = ctx.macro_cache_client.get_passwordless_login_code(&email).await.map_err(|e| {
            tracing::error!(error=?e, email=%passwordless_response.user.email, "unable to get passwordless login code");
            (StatusCode::INTERNAL_SERVER_ERROR, "unable to get passwordless login code").into_response()
        })?;

        if code != passwordless_code {
            tracing::error!("passwordless code does not match");
            return Err((StatusCode::UNAUTHORIZED, "invalid code").into_response());
        }
    }

    cookies.add(create_access_token_cookie(&passwordless_response.token));
    cookies.add(create_refresh_token_cookie(
        &passwordless_response.refresh_token,
    ));

    // remove the users passwordless login rate limits
    tokio::spawn({
        let macro_cache_client = ctx.macro_cache_client.clone();
        let email = passwordless_response.user.email.clone();
        async move {
            let _ = macro_cache_client
                .delete_passwordless_rate_limit(&email)
                .await
                .inspect_err(|e| {
                    tracing::error!(error=?e, "unable to delete passwordless rate limit");
                });

            let _ = macro_cache_client
                .delete_passwordless_daily_rate_limit(&email)
                .await
                .inspect_err(|e| {
                    tracing::error!(error=?e, "unable to delete passwordless daily rate limit");
                });

            let _ = macro_cache_client
                .delete_code_rate_limit(&email)
                .await
                .inspect_err(|e| {
                    tracing::error!(error=?e, "unable to delete login code rate limit");
                });

            let _ = macro_cache_client
                .delete_daily_code_rate_limit(&email)
                .await
                .inspect_err(|e| {
                    tracing::error!(error=?e, "unable to delete login code daily rate limit");
                });
        }
    });

    if disable_redirect {
        return Ok((
            StatusCode::OK,
            Json(UserTokensResponse {
                access_token: passwordless_response.token,
                refresh_token: passwordless_response.refresh_token,
            }),
        )
            .into_response());
    }

    let mut redirect_uri = passwordless_response.state.redirect_uri.clone();
    match url::Url::parse(&redirect_uri) {
        Ok(mut url) => {
            append_signed_up_param_if_new_user(
                &ctx.macro_cache_client,
                &passwordless_response.user.email.to_lowercase(),
                &mut url,
            )
            .await;
            redirect_uri = url.to_string();
        }
        Err(e) => {
            tracing::error!(error=?e, "unable to parse redirect uri for signup attribution");
        }
    }

    Ok(Redirect::to(&redirect_uri).into_response())
}