fix: fix some clippy warnings

Author: Fleeym

src/types/models/dependency.rs

@@ -8,12 +8,7 @@ use crate::types::api::ApiError;
 use super::mod_gd_version::{GDVersionEnum, VerPlatform};
 
 #[derive(sqlx::FromRow, Clone)]
-pub struct Dependency {
-    pub dependent_id: i32,
-    pub dependency_id: String,
-    pub compare: ModVersionCompare,
-    pub importance: DependencyImportance,
-}
+pub struct Dependency {}
 
 pub struct DependencyCreate {
     pub dependency_id: String,
@@ -172,7 +167,7 @@ impl Dependency {
             (!pre.is_empty()).then_some(pre)
         });
 
-        let q = sqlx::query_as::<Postgres, QueryResult>(
+        let result: Vec<QueryResult> = sqlx::query_as(
             r#"
             WITH RECURSIVE dep_tree AS (
                 SELECT * FROM (
@@ -301,15 +296,11 @@ impl Dependency {
         .bind(geode.map(|x| i32::try_from(x.major).unwrap_or_default()))
         .bind(geode.map(|x| i32::try_from(x.minor).unwrap_or_default()))
         .bind(geode.map(|x| i32::try_from(x.patch).unwrap_or_default()))
-        .bind(geode_pre);
-
-        let result = match q.fetch_all(&mut *pool).await {
-            Ok(d) => d,
-            Err(e) => {
-                log::error!("{}", e);
-                return Err(ApiError::DbError);
-            }
-        };
+        .bind(geode_pre)
+        .fetch_all(&mut *pool)
+        .await
+        .inspect_err(|x| log::error!("Failed to fetch dependencies: {}", x))
+        .or(Err(ApiError::DbError))?;
 
         let mut ret: HashMap<i32, Vec<FetchedDependency>> = HashMap::new();
         for i in result {

src/types/models/incompatibility.rs

@@ -27,12 +27,7 @@ pub struct IncompatibilityCreate {
 }
 
 #[derive(sqlx::FromRow)]
-pub struct Incompatibility {
-    pub mod_id: i32,
-    pub incompatibility_id: String,
-    pub compare: ModVersionCompare,
-    pub importance: IncompatibilityImportance,
-}
+pub struct Incompatibility {}
 
 #[derive(Debug, Serialize, Clone)]
 pub struct Replacement {
@@ -110,25 +105,23 @@ impl Incompatibility {
         Ok(())
     }
 
-    pub async fn clear_for_mod_version(
-        id: i32,
-        pool: &mut PgConnection
-    ) -> Result<(), ApiError> {
+    pub async fn clear_for_mod_version(id: i32, pool: &mut PgConnection) -> Result<(), ApiError> {
         sqlx::query!(
             "DELETE FROM incompatibilities
             WHERE mod_id = $1",
             id
         )
-            .execute(&mut *pool)
-            .await
-            .map(|_| ())
-            .map_err(|err| {
-                log::error!(
-                    "Failed to remove incompatibilities for mod version {}: {}",
-                    id, err
-                );
-                ApiError::DbError
-            })
+        .execute(&mut *pool)
+        .await
+        .map(|_| ())
+        .map_err(|err| {
+            log::error!(
+                "Failed to remove incompatibilities for mod version {}: {}",
+                id,
+                err
+            );
+            ApiError::DbError
+        })
     }
 
     pub async fn get_for_mod_version(
@@ -162,10 +155,14 @@ impl Incompatibility {
         geode: Option<&semver::Version>,
         pool: &mut PgConnection,
     ) -> Result<HashMap<i32, Vec<FetchedIncompatibility>>, ApiError> {
-        let geode_pre = geode.map(|x| {
-            let pre = x.pre.to_string();
-            (!pre.is_empty()).then(|| pre)
-        }).flatten();
+        let geode_pre = geode
+            .and_then(|x| {
+                if x.pre.is_empty() {
+                    None
+                } else {
+                    Some(x.pre.to_string())
+                }
+            });
 
         let q = sqlx::query_as::<Postgres, FetchedIncompatibility>(
             r#"SELECT icp.compare,
@@ -227,8 +224,11 @@ impl Incompatibility {
         pool: &mut PgConnection,
     ) -> Result<HashMap<String, Replacement>, ApiError> {
         let mut ret: HashMap<String, Replacement> = HashMap::new();
-        let pre = geode.pre.to_string();
-        let pre = (!pre.is_empty()).then(|| pre);
+        let pre = if geode.pre.is_empty() {
+            None
+        } else {
+            Some(geode.pre.to_string())
+        };
         let r = match sqlx::query!(
             r#"
             SELECT 

src/types/models/mod_version_status.rs

@@ -13,13 +13,7 @@ pub enum ModVersionStatusEnum {
     Unlisted,
 }
 
-pub struct ModVersionStatus {
-    pub id: i32,
-    pub mod_version_id: i32,
-    pub status: ModVersionStatusEnum,
-    pub info: Option<String>,
-    pub admin_id: i32,
-}
+pub struct ModVersionStatus {}
 
 impl ModVersionStatus {
     pub async fn create_for_mod_version(