temp commit

Author: Fleeym

Cargo.lock

@@ -41,4 +41,5 @@ log4rs = { version = "1.3.0", features = [
     "default",
     "threshold_filter",
 ] }
-ring = "0.17.12"
+ring = "0.17.12"
+thiserror = "2.0.12"

Cargo.toml

@@ -1 +1,11 @@
 pub mod github;
+
+#[derive(thiserror::Error, Debug)]
+pub enum AuthenticationError {
+    #[error("No authentication token provided")]
+    NoToken,
+    #[error("Provided token is invalid")]
+    InvalidToken,
+    #[error("Unknown database error")]
+    SqlxError(#[from] sqlx::Error)
+}

src/auth/mod.rs

@@ -1 +1,7 @@
-pub mod repository;
+pub mod repository;
+
+#[derive(thiserror::Error, Debug)]
+pub enum DatabaseError {
+    #[error("Unknown database error")]
+    SqlxError(#[from] sqlx::Error)
+}

src/database/mod.rs

@@ -1,26 +1,19 @@
+use crate::database::DatabaseError;
 use crate::types::api::{ApiError, PaginatedData};
 use crate::types::models::developer::{Developer, ModDeveloper};
 use sqlx::PgConnection;
 use std::collections::HashMap;
 use uuid::Uuid;
 
 pub async fn index(
-    query: &str,
+    query: Option<&str>,
     page: i64,
     per_page: i64,
     conn: &mut PgConnection,
-) -> Result<PaginatedData<Developer>, ApiError> {
+) -> Result<PaginatedData<Developer>, DatabaseError> {
     let limit = per_page;
     let offset = (page - 1) * per_page;
 
-    let display_name_query = {
-        if query.is_empty() {
-            "".into()
-        } else {
-            format!("%{}%", query)
-        }
-    };
-
     let result = sqlx::query_as!(
         Developer,
         "SELECT
@@ -32,23 +25,19 @@ pub async fn index(
             github_user_id as github_id
         FROM developers
         WHERE (
-            ($1 = '' OR username = $1)
-            OR ($2 = '' OR display_name ILIKE $2)
+            ($1::text IS NULL OR username = $1)
+            OR ($1::text IS NULL OR display_name ILIKE '%' || $1 || '%')
         )
         GROUP BY id
-        LIMIT $3
-        OFFSET $4",
+        LIMIT $2
+        OFFSET $3",
         query,
-        &display_name_query,
         limit,
         offset
     )
     .fetch_all(&mut *conn)
     .await
-    .map_err(|e| {
-        log::error!("Failed to fetch developers: {}", e);
-        ApiError::DbError
-    })?;
+    .inspect_err(|e| log::error!("Failed to fetch developers: {}", e))?;
 
     let count = index_count(query, &mut *conn).await?;
 
@@ -58,33 +47,24 @@ pub async fn index(
     })
 }
 
-pub async fn index_count(query: &str, conn: &mut PgConnection) -> Result<i64, ApiError> {
-    let display_name_query = {
-        if query.is_empty() {
-            "".into()
-        } else {
-            format!("%{}%", query)
-        }
-    };
-
-    Ok(sqlx::query!(
+pub async fn index_count(
+    query: Option<&str>,
+    conn: &mut PgConnection,
+) -> Result<i64, DatabaseError> {
+    sqlx::query!(
         "SELECT COUNT(id)
         FROM developers
         WHERE (
-            ($1 = '' OR username = $1)
-            OR ($2 = '' OR display_name ILIKE $2)
+            ($1::text IS NULL OR username = $1)
+            OR ($1::text IS NULL OR display_name ILIKE '%' || $1 || '%')
         )",
-        query,
-        display_name_query
+        query
     )
     .fetch_one(&mut *conn)
     .await
-    .map_err(|e| {
-        log::error!("Failed to fetch developer count: {}", e);
-        ApiError::DbError
-    })?
-    .count
-    .unwrap_or(0))
+    .inspect_err(|e| log::error!("Failed to fetch developer count: {}", e))
+    .map(|x| x.count.unwrap_or(0))
+    .map_err(|e| e.into())
 }
 
 pub async fn fetch_or_insert_github(
@@ -168,7 +148,7 @@ pub async fn get_one(id: i32, conn: &mut PgConnection) -> Result<Option<Develope
 pub async fn get_one_by_username(
     username: &str,
     conn: &mut PgConnection,
-) -> Result<Option<Developer>, ApiError> {
+) -> Result<Option<Developer>, DatabaseError> {
     sqlx::query_as!(
         Developer,
         "SELECT
@@ -184,16 +164,14 @@ pub async fn get_one_by_username(
     )
     .fetch_optional(&mut *conn)
     .await
-    .map_err(|e| {
-        log::error!("Failed to fetch developer {}: {}", username, e);
-        ApiError::DbError
-    })
+    .inspect_err(|e| log::error!("Failed to fetch developer {}: {}", username, e))
+    .map_err(|x| x.into())
 }
 
 pub async fn get_all_for_mod(
     mod_id: &str,
     conn: &mut PgConnection,
-) -> Result<Vec<ModDeveloper>, ApiError> {
+) -> Result<Vec<ModDeveloper>, DatabaseError> {
     sqlx::query_as!(
         ModDeveloper,
         "SELECT
@@ -209,16 +187,14 @@ pub async fn get_all_for_mod(
     )
     .fetch_all(conn)
     .await
-    .map_err(|e| {
-        log::error!("Failed to fetch developers for mod {}: {}", mod_id, e);
-        ApiError::DbError
-    })
+    .inspect_err(|e| log::error!("Failed to fetch developers for mod {}: {}", mod_id, e))
+    .map_err(|e| e.into())
 }
 
 pub async fn get_all_for_mods(
     mod_ids: &[String],
     conn: &mut PgConnection,
-) -> Result<HashMap<String, Vec<ModDeveloper>>, ApiError> {
+) -> Result<HashMap<String, Vec<ModDeveloper>>, DatabaseError> {
     if mod_ids.is_empty() {
         return Ok(HashMap::new());
     }
@@ -246,10 +222,7 @@ pub async fn get_all_for_mods(
     )
     .fetch_all(conn)
     .await
-    .map_err(|e| {
-        log::error!("Failed to fetch developers for mods: {}", e);
-        ApiError::DbError
-    })?;
+    .inspect_err(|e| log::error!("Failed to fetch developers for mods: {}", e))?;
 
     let mut ret: HashMap<String, Vec<ModDeveloper>> = HashMap::new();
 
@@ -271,8 +244,8 @@ pub async fn has_access_to_mod(
     dev_id: i32,
     mod_id: &str,
     conn: &mut PgConnection,
-) -> Result<bool, ApiError> {
-    Ok(sqlx::query!(
+) -> Result<bool, DatabaseError> {
+    sqlx::query!(
         "SELECT developer_id FROM mods_developers
         WHERE developer_id = $1
         AND mod_id = $2",
@@ -281,23 +254,23 @@ pub async fn has_access_to_mod(
     )
     .fetch_optional(&mut *conn)
     .await
-    .map_err(|e| {
+    .inspect_err(|e| {
         log::error!(
             "Failed to find mod {} access for developer {}: {}",
             mod_id,
             dev_id,
             e
         );
-        ApiError::DbError
-    })?
-    .is_some())
+    })
+    .map(|x| x.is_some())
+    .map_err(|e| e.into())
 }
 
 pub async fn owns_mod(
     dev_id: i32,
     mod_id: &str,
     conn: &mut PgConnection,
-) -> Result<bool, ApiError> {
+) -> Result<bool, DatabaseError> {
     Ok(sqlx::query!(
         "SELECT developer_id FROM mods_developers
         WHERE developer_id = $1
@@ -308,14 +281,13 @@ pub async fn owns_mod(
     )
     .fetch_optional(&mut *conn)
     .await
-    .map_err(|e| {
+    .inspect_err(|e| {
         log::error!(
             "Failed to check mod {} owner for developer {}: {}",
             mod_id,
             dev_id,
             e
-        );
-        ApiError::DbError
+        )
     })?
     .is_some())
 }
@@ -439,3 +411,32 @@ pub async fn find_by_refresh_token(
         ApiError::DbError
     })
 }
+
+pub async fn find_by_token(
+    token: &Uuid,
+    conn: &mut PgConnection,
+) -> Result<Option<Developer>, DatabaseError> {
+    let hash = sha256::digest(token.to_string());
+    sqlx::query_as!(
+        Developer,
+        "SELECT
+            d.id,
+            d.username,
+            d.display_name,
+            d.verified,
+            d.admin,
+            d.github_user_id as github_id
+        FROM developers d
+        INNER JOIN auth_tokens a ON d.id = a.developer_id
+        WHERE a.token = $1
+        AND (
+            expires_at IS NULL
+            OR expires_at > NOW()
+        )",
+        hash
+    )
+    .fetch_optional(&mut *conn)
+    .await
+    .inspect_err(|e| log::error!("{}", e))
+    .map_err(|e| e.into())
+}