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/refresh.rs

@@ -1,32 +1,45 @@
-use actix_web::{HttpRequest, HttpResponse, post, web};
+use axum::{
+    extract::State,
+    http::{HeaderValue, StatusCode},
+    response::IntoResponse,
+};
+use axum_extra::extract::CookieJar;
 use diesel::{ExpressionMethods, QueryDsl, delete, update};
 use diesel_async::RunQueryDsl;
 use log::error;
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::{
+    sync::Arc,
+    time::{SystemTime, UNIX_EPOCH},
+};
 
 use crate::{
-    Data,
+    AppState,
     error::Error,
     schema::{
         access_tokens::{self, dsl},
         refresh_tokens::{self, dsl as rdsl},
     },
-    utils::{generate_token, new_refresh_token_cookie},
+    utils::{generate_token, new_access_token_cookie, new_refresh_token_cookie},
 };
 
-use super::Response;
+pub async fn post(
+    State(app_state): State<Arc<AppState>>,
+    jar: CookieJar,
+) -> Result<impl IntoResponse, Error> {
+    let mut refresh_token_cookie = jar
+        .get("refresh_token")
+        .ok_or(Error::Unauthorized(
+            "request has no refresh token".to_string(),
+        ))?
+        .to_owned();
 
-#[post("/refresh")]
-pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    let mut refresh_token_cookie = req.cookie("refresh_token").ok_or(Error::Unauthorized(
-        "request has no refresh token".to_string(),
-    ))?;
+    let access_token_cookie = jar.get("access_token");
 
-    let mut refresh_token = String::from(refresh_token_cookie.value());
+    let refresh_token = String::from(refresh_token_cookie.value_trimmed());
 
     let current_time = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs() as i64;
 
-    let mut conn = data.pool.get().await?;
+    let mut conn = app_state.pool.get().await?;
 
     if let Ok(created_at) = rdsl::refresh_tokens
         .filter(rdsl::token.eq(&refresh_token))
@@ -45,15 +58,29 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
                 error!("{error}");
             }
 
-            refresh_token_cookie.make_removal();
+            let mut response = StatusCode::UNAUTHORIZED.into_response();
 
-            return Ok(HttpResponse::Unauthorized()
-                .cookie(refresh_token_cookie)
-                .finish());
+            refresh_token_cookie.make_removal();
+            response.headers_mut().append(
+                "Set-Cookie",
+                HeaderValue::from_str(&refresh_token_cookie.to_string())?,
+            );
+
+            if let Some(cookie) = access_token_cookie {
+                let mut cookie = cookie.clone();
+                cookie.make_removal();
+                response
+                    .headers_mut()
+                    .append("Set-Cookie2", HeaderValue::from_str(&cookie.to_string())?);
+            }
+
+            return Ok(response);
         }
 
         let current_time = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs() as i64;
 
+        let mut response = StatusCode::OK.into_response();
+
         if lifetime > 1987200 {
             let new_refresh_token = generate_token::<32>()?;
 
@@ -67,7 +94,13 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
                 .await
             {
                 Ok(_) => {
-                    refresh_token = new_refresh_token;
+                    response.headers_mut().append(
+                        "Set-Cookie",
+                        HeaderValue::from_str(
+                            &new_refresh_token_cookie(&app_state.config, new_refresh_token)
+                                .to_string(),
+                        )?,
+                    );
                 }
                 Err(error) => {
                     error!("{error}");
@@ -86,14 +119,40 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
             .execute(&mut conn)
             .await?;
 
-        return Ok(HttpResponse::Ok()
-            .cookie(new_refresh_token_cookie(&data.config, refresh_token))
-            .json(Response { access_token }));
+        if response.headers().get("Set-Cookie").is_some() {
+            response.headers_mut().append(
+                "Set-Cookie2",
+                HeaderValue::from_str(
+                    &new_access_token_cookie(&app_state.config, access_token).to_string(),
+                )?,
+            );
+        } else {
+            response.headers_mut().append(
+                "Set-Cookie",
+                HeaderValue::from_str(
+                    &new_access_token_cookie(&app_state.config, access_token).to_string(),
+                )?,
+            );
+        }
+
+        return Ok(response);
     }
 
-    refresh_token_cookie.make_removal();
+    let mut response = StatusCode::UNAUTHORIZED.into_response();
 
-    Ok(HttpResponse::Unauthorized()
-        .cookie(refresh_token_cookie)
-        .finish())
+    refresh_token_cookie.make_removal();
+    response.headers_mut().append(
+        "Set-Cookie",
+        HeaderValue::from_str(&refresh_token_cookie.to_string())?,
+    );
+
+    if let Some(cookie) = access_token_cookie {
+        let mut cookie = cookie.clone();
+        cookie.make_removal();
+        response
+            .headers_mut()
+            .append("Set-Cookie2", HeaderValue::from_str(&cookie.to_string())?);
+    }
+
+    Ok(response)
 }