temp commit

Author: Fleeym

Cargo.lock

@@ -25,6 +25,7 @@ reqwest = { version = "0.12", default-features = false, features = [
     "gzip",
     "rustls-tls",
 ] }
+url = { version = "2" }
 uuid = { version = "1.8", features = ["v4", "fast-rng", "macro-diagnostics"] }
 zip = "4.2.0"
 sha256 = "1.5"

Cargo.toml

@@ -1,3 +1,4 @@
+use crate::auth::AuthenticationError;
 use crate::database::repository::github_login_attempts;
 use crate::types::api::ApiError;
 use crate::types::models::github_login_attempt::StoredLoginAttempt;
@@ -16,6 +17,40 @@ pub struct GithubStartAuth {
     interval: i32,
 }
 
+#[derive(Deserialize)]
+pub enum GithubDeviceFlowErrorString {
+    #[serde(rename(deserialize = "authorization_pending"))]
+    AuthorizationPending,
+    #[serde(rename(deserialize = "slow_down"))]
+    SlowDown,
+    #[serde(rename(deserialize = "expired_token"))]
+    ExpiredToken,
+    #[serde(rename(deserialize = "unsupported_grant_type"))]
+    UnsupportedGrantType,
+    #[serde(rename(deserialize = "incorrect_client_credentials"))]
+    IncorrectClientCredentials,
+    #[serde(rename(deserialize = "incorrect_device_code"))]
+    IncorrectDeviceCode,
+    #[serde(rename(deserialize = "access_denied"))]
+    AccessDenied,
+    #[serde(rename(deserialize = "device_flow_disabled"))]
+    DeviceFlowDisabled,
+    Unknown,
+}
+
+impl Default for GithubDeviceFlowErrorString {
+    fn default() -> Self {
+        GithubDeviceFlowErrorString::Unknown
+    }
+}
+
+#[derive(Deserialize)]
+pub struct GithubErrorResponse {
+    error: GithubDeviceFlowErrorString,
+    error_description: String,
+    error_uri: String,
+}
+
 pub struct GithubClient {
     client_id: String,
     client_secret: String,
@@ -55,7 +90,7 @@ impl GithubClient {
         &self,
         ip: IpNetwork,
         pool: &mut PgConnection,
-    ) -> Result<StoredLoginAttempt, ApiError> {
+    ) -> Result<StoredLoginAttempt, AuthenticationError> {
         if let Some(r) = github_login_attempts::get_one_by_ip(ip, pool).await? {
             if r.is_expired() {
                 let uuid = Uuid::parse_str(&r.uuid).unwrap();
@@ -74,26 +109,27 @@ impl GithubClient {
             }))
             .send()
             .await
-            .map_err(|e| {
-                log::error!("Failed to start OAuth device flow with GitHub: {}", e);
-                ApiError::InternalError
-            })?;
+            .inspect_err(|e| log::error!("Failed to start OAuth device flow with GitHub: {e}"))?;
 
         if !res.status().is_success() {
             log::error!(
                 "GitHub OAuth device flow start request failed with code {}",
                 res.status()
             );
-            return Err(ApiError::InternalError);
+            return Err(AuthenticationError::InternalError(
+                "Failed to start GitHub device flow".into(),
+            ));
         }
 
-        let body = res.json::<GithubStartAuth>().await.map_err(|e| {
-            log::error!(
-                "Failed to parse OAuth device flow response from GitHub: {}",
-                e
-            );
-            ApiError::InternalError
-        })?;
+        let body = res
+            .json::<GithubStartAuth>()
+            .await
+            .inspect_err(|e| {
+                log::error!("Failed to parse OAuth device flow response from GitHub: {e}")
+            })
+            .or(Err(AuthenticationError::InternalError(
+                "Failed to parse response from GitHub".into(),
+            )))?;
 
         github_login_attempts::create(
             ip,
@@ -105,6 +141,7 @@ impl GithubClient {
             &mut *pool,
         )
         .await
+        .map_err(|e| e.into())
     }
 
     pub async fn poll_github(

src/auth/github.rs

@@ -6,6 +6,12 @@ pub enum AuthenticationError {
     NoToken,
     #[error("Provided token is invalid")]
     InvalidToken,
+    #[error("Failed to communicate with GitHub")]
+    RequestError(#[from] reqwest::Error),
+    #[error("{0}")]
+    InternalError(String),
+    #[error("{0}")]
+    Database(#[from] crate::database::DatabaseError),
     #[error("Unknown database error")]
-    SqlxError(#[from] sqlx::Error)
+    SqlxError(#[from] sqlx::Error),
 }

src/auth/mod.rs

@@ -2,6 +2,8 @@ pub mod repository;
 
 #[derive(thiserror::Error, Debug)]
 pub enum DatabaseError {
+    #[error("Invalid input: {0}")]
+    InvalidInput(String),
     #[error("Unknown database error")]
     SqlxError(#[from] sqlx::Error)
 }

src/database/mod.rs

@@ -1,4 +1,4 @@
-use crate::types::api::ApiError;
+use crate::database::DatabaseError;
 use chrono::{Days, Utc};
 use sqlx::PgConnection;
 use uuid::Uuid;
@@ -8,7 +8,7 @@ pub async fn generate_token(
     developer_id: i32,
     with_expiry: bool,
     conn: &mut PgConnection,
-) -> Result<Uuid, ApiError> {
+) -> Result<Uuid, DatabaseError> {
     let token = Uuid::new_v4();
     let hash = sha256::digest(token.to_string());
     let expiry = {
@@ -28,19 +28,14 @@ pub async fn generate_token(
     )
     .execute(&mut *conn)
     .await
-    .map_err(|e| {
-        log::error!(
-            "Failed to insert auth_token for developer {}: {}",
-            developer_id,
-            e
-        );
-        ApiError::DbError
+    .inspect_err(|e| {
+        log::error!("Failed to insert auth_token for developer {developer_id}: {e}")
     })?;
 
     Ok(token)
 }
 
-pub async fn remove_token(token: Uuid, conn: &mut PgConnection) -> Result<(), ApiError> {
+pub async fn remove_token(token: Uuid, conn: &mut PgConnection) -> Result<(), DatabaseError> {
     let hash = sha256::digest(token.to_string());
 
     sqlx::query!(
@@ -50,44 +45,35 @@ pub async fn remove_token(token: Uuid, conn: &mut PgConnection) -> Result<(), Ap
     )
     .execute(&mut *conn)
     .await
-    .map_err(|e| {
-        log::error!("Failed to remove auth token: {}", e);
-        ApiError::DbError
-    })?;
+    .inspect_err(|e| log::error!("Failed to remove auth token: {e}"))?;
 
     Ok(())
 }
 
 pub async fn remove_developer_tokens(
     developer_id: i32,
     conn: &mut PgConnection,
-) -> Result<(), ApiError> {
+) -> Result<(), DatabaseError> {
     sqlx::query!(
         "DELETE FROM auth_tokens
         WHERE developer_id = $1",
         developer_id
     )
     .execute(&mut *conn)
     .await
-    .map_err(|e| {
-        log::error!("Failed to wipe developer tokens: {}", e);
-        ApiError::DbError
-    })?;
+    .inspect_err(|e| log::error!("Failed to wipe developer tokens: {e}"))?;
 
     Ok(())
 }
 
-pub async fn cleanup(conn: &mut PgConnection) -> Result<(), ApiError> {
+pub async fn cleanup(conn: &mut PgConnection) -> Result<(), DatabaseError> {
     sqlx::query!(
         "DELETE FROM auth_tokens
         WHERE expires_at < NOW()"
     )
-        .execute(conn)
-        .await
-        .map_err(|e| {
-            log::error!("Auth token cleanup failed: {}", e);
-            ApiError::DbError
-        })?;
+    .execute(conn)
+    .await
+    .inspect_err(|e| log::error!("Auth token cleanup failed: {e}"))?;
 
     Ok(())
 }