IT BUILDS!

Author: Fleeym

src/auth/github.rs

@@ -1,6 +1,5 @@
 use crate::auth::AuthenticationError;
 use crate::database::repository::github_login_attempts;
-use crate::types::api::ApiError;
 use crate::types::models::github_login_attempt::StoredLoginAttempt;
 use reqwest::{header::HeaderValue, Client};
 use serde::{Deserialize, Serialize};
@@ -150,7 +149,7 @@ impl GithubClient {
         code: &str,
         is_device: bool,
         redirect_uri: Option<&str>,
-    ) -> Result<String, ApiError> {
+    ) -> Result<String, AuthenticationError> {
         let json = {
             if is_device {
                 json!({
@@ -183,99 +182,115 @@ impl GithubClient {
             .json(&json)
             .send()
             .await
-            .map_err(|e| {
-                log::error!("Failed to poll GitHub for developer access token: {}", e);
-                ApiError::InternalError
+            .inspect_err(|e| {
+                log::error!("Failed to poll GitHub for developer access token: {e}")
             })?;
 
         Ok(resp
             .json::<serde_json::Value>()
             .await
-            .map_err(|e| {
-                log::error!("Failed to decode GitHub response: {}", e);
-                ApiError::InternalError
-            })?
+            .inspect_err(|e| log::error!("Failed to decode GitHub response: {e}"))?
             .get("access_token")
-            .ok_or(ApiError::BadRequest("Request not accepted by user".into()))?
+            .ok_or(AuthenticationError::UserAuthPending)?
             .as_str()
             .ok_or_else(|| {
                 log::error!("Invalid access_token received from GitHub");
-                ApiError::InternalError
+                AuthenticationError::InternalError(
+                    "Failed to retrieve access token from GitHub".into(),
+                )
             })?
             .to_string())
     }
-
-    pub async fn get_user(&self, token: &str) -> Result<GitHubFetchedUser, ApiError> {
+    pub async fn get_user(&self, token: &str) -> Result<GitHubFetchedUser, AuthenticationError> {
         let resp = Client::new()
             .get("https://api.github.com/user")
             .header("Accept", HeaderValue::from_str("application/json").unwrap())
             .header("User-Agent", "geode_index")
             .bearer_auth(token)
             .send()
-            .await
-            .map_err(|e| {
-                log::error!("Request to https://api.github.com/user failed: {}", e);
-                ApiError::InternalError
-            })?;
+            .await?;
 
         if !resp.status().is_success() {
-            return Err(ApiError::InternalError);
+            log::error!(
+                "github::get_user: received non-2xx response: {}. Body: {}",
+                resp.status(),
+                resp.text().await.unwrap_or("No response body".into())
+            );
+            return Err(AuthenticationError::InternalError(
+                "Failed to fetch user from GitHub API, received non 2xx response".into(),
+            ));
         }
 
-        resp.json::<GitHubFetchedUser>().await.map_err(|e| {
-            log::error!("Failed to create GitHubFetchedUser: {}", e);
-            ApiError::InternalError
-        })
+        resp.json::<GitHubFetchedUser>()
+            .await
+            .inspect_err(|e| log::error!("github::get_user: failed to parse response: {e}"))
+            .or(Err(AuthenticationError::InternalError(
+                "Failed to parse user JSON received from GitHub".into(),
+            )))
     }
 
-    pub async fn get_installation(&self, token: &str) -> Result<GitHubFetchedUser, ApiError> {
+    pub async fn get_installation(
+        &self,
+        token: &str,
+    ) -> Result<GitHubFetchedUser, AuthenticationError> {
         let client = Client::new();
-        let resp = match client
+        let resp = client
             .get("https://api.github.com/installation/repositories")
             .header("Accept", HeaderValue::from_str("application/json").unwrap())
             .header("User-Agent", "geode_index")
             .bearer_auth(token)
             .send()
             .await
-        {
-            Err(e) => {
-                log::info!("{}", e);
-                return Err(ApiError::InternalError);
-            }
-            Ok(r) => r,
-        };
+            .inspect_err(|e| {
+                log::error!("github::get_installation: failed to fetch repositories: {e}")
+            })?;
 
         if !resp.status().is_success() {
-            return Err(ApiError::InternalError);
+            log::error!(
+                "github::get_installation: received non-2xx response: {}. Body: {}",
+                resp.status(),
+                resp.text().await.unwrap_or("No response body".into())
+            );
+            return Err(AuthenticationError::InternalError(
+                "Received non-2xx response from GitHub".into(),
+            ));
         }
 
-        let body = match resp.json::<serde_json::Value>().await {
-            Err(e) => {
-                log::error!("{}", e);
-                return Err(ApiError::InternalError);
-            }
-            Ok(b) => b,
-        };
+        let body = resp
+            .json::<serde_json::Value>()
+            .await
+            .inspect_err(|e| log::error!("github::get_installation: failed to parse response: {e}"))
+            .or(Err(AuthenticationError::InternalError(
+                "Failed to parse response from GitHub".into(),
+            )))?;
 
-        let repos = match body.get("repositories").and_then(|r| r.as_array()) {
-            None => {
-                return Err(ApiError::InternalError);
-            }
-            Some(r) => r,
-        };
+        let repos = body.get("repositories").and_then(|r| r.as_array()).ok_or(
+            AuthenticationError::InternalError(
+                "Failed to get repository array from GitHub response".into(),
+            ),
+        )?;
 
         if repos.len() != 1 {
-            return Err(ApiError::InternalError);
+            return Err(AuthenticationError::InternalError(
+                "Failed to get repository from GitHub: array size isn't 1".into(),
+            ));
         }
 
         let owner = repos[0]
             .get("owner")
-            .ok_or(ApiError::InternalError)?
+            .ok_or(AuthenticationError::InternalError(
+                "Didn't find owner key on repository".into(),
+            ))?
             .clone();
 
-        serde_json::from_value(owner).map_err(|e| {
-            log::error!("Failed to create GitHubFetchedUser: {}", e);
-            ApiError::InternalError
-        })
+        serde_json::from_value(owner)
+            .inspect_err(|e| {
+                log::error!(
+                    "github::get_installation: failed to extract owner from serde_json value: {e}"
+                )
+            })
+            .or(Err(AuthenticationError::InternalError(
+                "Failed to get GitHub user from installation".into(),
+            )))
     }
 }

src/auth/mod.rs

@@ -6,6 +6,10 @@ pub enum AuthenticationError {
     NoToken,
     #[error("Provided token is invalid")]
     InvalidToken,
+    #[error("User didn't accept authentication")]
+    UserRejectedAuth,
+    #[error("User auth pending")]
+    UserAuthPending,
     #[error("Failed to communicate with GitHub")]
     RequestError(#[from] reqwest::Error),
     #[error("{0}")]

src/database/repository/dependencies.rs

@@ -1,17 +1,21 @@
 use sqlx::PgConnection;
 
-use crate::types::{
-    api::ApiError,
-    mod_json::ModJson,
-    models::dependency::{DependencyImportance, FetchedDependency, ModVersionCompare},
+use crate::{
+    database::DatabaseError,
+    types::{
+        mod_json::ModJson,
+        models::dependency::{DependencyImportance, FetchedDependency, ModVersionCompare},
+    },
 };
 
 pub async fn create(
     mod_version_id: i32,
     json: &ModJson,
     conn: &mut PgConnection,
-) -> Result<Vec<FetchedDependency>, ApiError> {
-    let dependencies = json.prepare_dependencies_for_create()?;
+) -> Result<Vec<FetchedDependency>, DatabaseError> {
+    let dependencies = json.prepare_dependencies_for_create().map_err(|e| {
+        DatabaseError::InvalidInput(format!("Failed to parse dependencies from mod.json: {e}"))
+    })?;
     if dependencies.is_empty() {
         return Ok(vec![]);
     }
@@ -55,20 +59,19 @@ pub async fn create(
     )
     .fetch_all(conn)
     .await
-    .inspect_err(|e| log::error!("Failed to insert dependencies: {}", e))
-    .or(Err(ApiError::DbError))
+    .inspect_err(|e| log::error!("dependenceis::create query failed: {e}"))
+    .map_err(|e| e.into())
 }
 
-pub async fn clear(id: i32, conn: &mut PgConnection) -> Result<(), ApiError> {
+pub async fn clear(id: i32, conn: &mut PgConnection) -> Result<(), DatabaseError> {
     sqlx::query!(
         "DELETE FROM dependencies
             WHERE dependent_id = $1",
         id
     )
     .execute(conn)
     .await
-    .inspect_err(|e| log::error!("Failed to clear deps: {}", e))
-    .or(Err(ApiError::DbError))?;
-
-    Ok(())
+    .inspect_err(|e| log::error!("dependencies::clear query failed: {e}"))
+    .map_err(|e| e.into())
+    .map(|_| ())
 }

src/database/repository/incompatibilities.rs

@@ -1,20 +1,26 @@
 use sqlx::PgConnection;
 
-use crate::types::{
-    api::ApiError,
-    mod_json::ModJson,
-    models::{
-        dependency::ModVersionCompare,
-        incompatibility::{FetchedIncompatibility, IncompatibilityImportance},
+use crate::{
+    database::DatabaseError,
+    types::{
+        mod_json::ModJson,
+        models::{
+            dependency::ModVersionCompare,
+            incompatibility::{FetchedIncompatibility, IncompatibilityImportance},
+        },
     },
 };
 
 pub async fn create(
     mod_version_id: i32,
     json: &ModJson,
     conn: &mut PgConnection,
-) -> Result<Vec<FetchedIncompatibility>, ApiError> {
-    let incompats = json.prepare_incompatibilities_for_create()?;
+) -> Result<Vec<FetchedIncompatibility>, DatabaseError> {
+    let incompats = json.prepare_incompatibilities_for_create().map_err(|e| {
+        DatabaseError::InvalidInput(format!(
+            "Failed to parse incompatibilities from mod.json: {e}"
+        ))
+    })?;
     if incompats.is_empty() {
         return Ok(vec![]);
     }
@@ -58,20 +64,19 @@ pub async fn create(
     )
     .fetch_all(conn)
     .await
-    .inspect_err(|e| log::error!("Failed to insert dependencies: {}", e))
-    .or(Err(ApiError::DbError))
+    .inspect_err(|e| log::error!("incompatibilities::create query failed: {e}"))
+    .map_err(|e| e.into())
 }
 
-pub async fn clear(id: i32, conn: &mut PgConnection) -> Result<(), ApiError> {
+pub async fn clear(id: i32, conn: &mut PgConnection) -> Result<(), DatabaseError> {
     sqlx::query!(
         "DELETE FROM incompatibilities
             WHERE mod_id = $1",
         id
     )
     .execute(conn)
     .await
-    .inspect_err(|e| log::error!("Failed to clear incompats: {}", e))
-    .or(Err(ApiError::DbError))?;
-
-    Ok(())
+    .inspect_err(|e| log::error!("incompatibilities::clear query failed: {e}"))
+    .map_err(|e| e.into())
+    .map(|_| ())
 }

src/database/repository/mod_gd_versions.rs

@@ -1,16 +1,18 @@
 use sqlx::PgConnection;
 
-use crate::types::{
-    api::ApiError,
-    mod_json::ModJson,
-    models::mod_gd_version::{DetailedGDVersion, GDVersionEnum, VerPlatform},
+use crate::{
+    database::DatabaseError,
+    types::{
+        mod_json::ModJson,
+        models::mod_gd_version::{DetailedGDVersion, GDVersionEnum, VerPlatform},
+    },
 };
 
 pub async fn create(
     mod_version_id: i32,
     json: &ModJson,
     conn: &mut PgConnection,
-) -> Result<DetailedGDVersion, ApiError> {
+) -> Result<DetailedGDVersion, DatabaseError> {
     let create = json.gd.to_create_payload(json);
 
     let gd: Vec<GDVersionEnum> = create.iter().map(|x| x.gd).collect();
@@ -31,22 +33,20 @@ pub async fn create(
     )
     .execute(conn)
     .await
-    .inspect_err(|e| log::error!("Failed to insert mod_gd_versions: {}", e))
-    .or(Err(ApiError::DbError))?;
+    .inspect_err(|e| log::error!("mod_gd_versions::create query failed: {e}"))?;
 
     Ok(json.gd.clone())
 }
 
-pub async fn clear(mod_version_id: i32, conn: &mut PgConnection) -> Result<(), ApiError> {
+pub async fn clear(mod_version_id: i32, conn: &mut PgConnection) -> Result<(), DatabaseError> {
     sqlx::query!(
         "DELETE FROM mod_gd_versions mgv
             WHERE mgv.mod_id = $1",
         mod_version_id
     )
     .execute(&mut *conn)
     .await
-    .inspect_err(|e| log::error!("Failed to remove GD versions: {}", e))
-    .or(Err(ApiError::DbError))?;
-
-    Ok(())
+    .inspect_err(|e| log::error!("incompatibilities::clear query failed: {e}"))
+    .map_err(|e| e.into())
+    .map(|_| ())
 }

src/database/repository/mod_links.rs

@@ -1,14 +1,14 @@
 use sqlx::PgConnection;
 
-use crate::types::{api::ApiError, models::mod_link::ModLinks};
+use crate::{database::DatabaseError, types::models::mod_link::ModLinks};
 
 pub async fn upsert(
     mod_id: &str,
     community: Option<String>,
     homepage: Option<String>,
     source: Option<String>,
     conn: &mut PgConnection,
-) -> Result<ModLinks, ApiError> {
+) -> Result<ModLinks, DatabaseError> {
     sqlx::query!(
         "INSERT INTO mod_links
             (mod_id, community, homepage, source)
@@ -26,8 +26,7 @@ pub async fn upsert(
     )
     .execute(&mut *conn)
     .await
-    .inspect_err(|x| log::error!("Failed to upsert mod_links for id {}: {}", mod_id, x))
-    .or(Err(ApiError::DbError))?;
+    .inspect_err(|x| log::error!("Failed to upsert mod_links for id {mod_id}: {x}"))?;
 
     Ok(ModLinks {
         mod_id: mod_id.into(),

src/database/repository/mod_versions.rs

@@ -141,8 +141,7 @@ pub async fn create_from_json(
     sqlx::query!("SET CONSTRAINTS mod_versions_status_id_fkey DEFERRED")
         .execute(&mut *conn)
         .await
-        .inspect_err(|e| log::error!("Failed to update constraint: {e}"))
-        .map_err(|e| e.into())?;
+        .inspect_err(|e| log::error!("Failed to update constraint: {e}"))?;
 
     let geode = Version::parse(&json.geode).or(Err(DatabaseError::InvalidInput(
         "mod.json geode version is invalid semver".into(),