refactor: rewrite entire codebase in axum instead of actix

Replaces actix with axum for web, allows us to use socket.io and gives us access to the tower ecosystem of middleware

breaks compatibility with our current websocket implementation, needs to be reimplemented for socket.io

src/api/v1/auth/verify_email.rs

@@ -1,19 +1,28 @@
 //! `/api/v1/auth/verify-email` Endpoints for verifying user emails
 
-use actix_web::{HttpRequest, HttpResponse, get, post, web};
+use std::sync::Arc;
+
+use axum::{
+    extract::{Query, State},
+    http::StatusCode,
+    response::IntoResponse,
+};
+use axum_extra::{
+    TypedHeader,
+    headers::{Authorization, authorization::Bearer},
+};
 use chrono::{Duration, Utc};
 use serde::Deserialize;
 
 use crate::{
-    Data,
+    AppState,
     api::v1::auth::check_access_token,
     error::Error,
     objects::{EmailToken, Me},
-    utils::get_auth_header,
 };
 
 #[derive(Deserialize)]
-struct Query {
+pub struct QueryParams {
     token: String,
 }
 
@@ -35,37 +44,32 @@ struct Query {
 ///
 /// 401 Unauthorized
 ///
-#[get("/verify-email")]
 pub async fn get(
-    req: HttpRequest,
-    query: web::Query<Query>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
+    State(app_state): State<Arc<AppState>>,
+    Query(query): Query<QueryParams>,
+    TypedHeader(auth): TypedHeader<Authorization<Bearer>>,
+) -> Result<impl IntoResponse, Error> {
+    let mut conn = app_state.pool.get().await?;
 
-    let auth_header = get_auth_header(headers)?;
-
-    let mut conn = data.pool.get().await?;
-
-    let uuid = check_access_token(auth_header, &mut conn).await?;
+    let uuid = check_access_token(auth.token(), &mut conn).await?;
 
     let me = Me::get(&mut conn, uuid).await?;
 
     if me.email_verified {
-        return Ok(HttpResponse::NoContent().finish());
+        return Ok(StatusCode::NO_CONTENT);
     }
 
-    let email_token = EmailToken::get(&data, me.uuid).await?;
+    let email_token = EmailToken::get(&app_state, me.uuid).await?;
 
     if query.token != email_token.token {
-        return Ok(HttpResponse::Unauthorized().finish());
+        return Ok(StatusCode::UNAUTHORIZED);
     }
 
     me.verify_email(&mut conn).await?;
 
-    email_token.delete(&data).await?;
+    email_token.delete(&app_state).await?;
 
-    Ok(HttpResponse::Ok().finish())
+    Ok(StatusCode::OK)
 }
 
 /// `POST /api/v1/auth/verify-email` Sends user verification email
@@ -81,25 +85,23 @@ pub async fn get(
 ///
 /// 401 Unauthorized
 ///
-#[post("/verify-email")]
-pub async fn post(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
+pub async fn post(
+    State(app_state): State<Arc<AppState>>,
+    TypedHeader(auth): TypedHeader<Authorization<Bearer>>,
+) -> Result<impl IntoResponse, Error> {
+    let mut conn = app_state.pool.get().await?;
 
-    let auth_header = get_auth_header(headers)?;
-
-    let mut conn = data.pool.get().await?;
-
-    let uuid = check_access_token(auth_header, &mut conn).await?;
+    let uuid = check_access_token(auth.token(), &mut conn).await?;
 
     let me = Me::get(&mut conn, uuid).await?;
 
     if me.email_verified {
-        return Ok(HttpResponse::NoContent().finish());
+        return Ok(StatusCode::NO_CONTENT);
     }
 
-    if let Ok(email_token) = EmailToken::get(&data, me.uuid).await {
+    if let Ok(email_token) = EmailToken::get(&app_state, me.uuid).await {
         if Utc::now().signed_duration_since(email_token.created_at) > Duration::hours(1) {
-            email_token.delete(&data).await?;
+            email_token.delete(&app_state).await?;
         } else {
             return Err(Error::TooManyRequests(
                 "Please allow 1 hour before sending a new email".to_string(),
@@ -107,7 +109,7 @@ pub async fn post(req: HttpRequest, data: web::Data<Data>) -> Result<HttpRespons
         }
     }
 
-    EmailToken::new(&data, me).await?;
+    EmailToken::new(&app_state, me).await?;
 
-    Ok(HttpResponse::Ok().finish())
+    Ok(StatusCode::OK)
 }