cleanup and fix int overflow

Author: 0x7d8

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "api"
-version = "2.2.0"
+version = "2.2.1"
 edition = "2024"
 
 [dependencies]

Cargo.toml

@@ -62,29 +62,24 @@ impl Cache {
     }
 
     #[inline(always)]
-    pub async fn cached<T, F, Fut>(
-        &self,
-        key: &str,
-        ttl: u64,
-        fn_compute: F,
-    ) -> Result<T, Box<dyn std::error::Error>>
+    pub async fn cached<T, F, Fut>(&self, key: &str, ttl: u64, fn_compute: F) -> T
     where
         T: Serialize + DeserializeOwned,
         F: FnOnce() -> Fut,
-        Fut: Future<Output = Result<T, Box<dyn std::error::Error>>>,
+        Fut: Future<Output = T>,
     {
-        let cached_value: Option<String> = self.client.get(key).await?;
+        let cached_value: Option<String> = self.client.get(key).await.unwrap();
 
         match cached_value {
             Some(value) => {
-                let result: T = serde_json::from_str(&value)?;
+                let result: T = serde_json::from_str(&value).unwrap();
 
-                Ok(result)
+                result
             }
             None => {
-                let result = fn_compute().await?;
+                let result = fn_compute().await;
 
-                let serialized = serde_json::to_string(&result)?;
+                let serialized = serde_json::to_string(&result).unwrap();
                 self.client
                     .set_with_options(
                         key,
@@ -93,9 +88,10 @@ impl Cache {
                         SetExpiration::Ex(ttl),
                         false,
                     )
-                    .await?;
+                    .await
+                    .unwrap();
 
-                Ok(result)
+                result
             }
         }
     }

src/cache.rs

@@ -20,13 +20,18 @@ mod index {
         let extension = state
             .cache
             .cached(&format!("extensions::{}", extension), 300, || async {
-                Ok(match extension.parse::<u32>() {
-                    Ok(id) => Extension::by_id(&state.database, id as i32).await,
+                match extension.parse::<i32>() {
+                    Ok(id) => {
+                        if id < 1 {
+                            None
+                        } else {
+                            Extension::by_id(&state.database, id).await
+                        }
+                    }
                     Err(_) => Extension::by_identifier(&state.database, &extension).await,
-                })
+                }
             })
-            .await
-            .unwrap();
+            .await;
 
         if extension.is_none() {
             return (

src/routes/extensions/_extension_/mod.rs

@@ -20,13 +20,18 @@ mod index {
         let extension = state
             .cache
             .cached(&format!("extensions::{}", extension), 300, || async {
-                Ok(match extension.parse::<u32>() {
-                    Ok(id) => Extension::by_id(&state.database, id as i32).await,
+                match extension.parse::<i32>() {
+                    Ok(id) => {
+                        if id < 1 {
+                            None
+                        } else {
+                            Extension::by_id(&state.database, id).await
+                        }
+                    }
                     Err(_) => Extension::by_identifier(&state.database, &extension).await,
-                })
+                }
             })
-            .await
-            .unwrap();
+            .await;
 
         if extension.is_none() {
             return (

src/routes/extensions/_extension_/versions.rs

@@ -13,12 +13,9 @@ mod index {
         let data = state
             .cache
             .cached("extensions::all", 300, || async {
-                Extension::all(&state.database)
-                    .await
-                    .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)
+                Extension::all(&state.database).await.unwrap()
             })
-            .await
-            .unwrap();
+            .await;
 
         axum::Json(serde_json::to_value(data).unwrap())
     }

src/routes/extensions/mod.rs

@@ -61,10 +61,9 @@ mod get {
                     );
                 }
 
-                Ok(flags)
+                flags
             })
-            .await
-            .unwrap();
+            .await;
 
         axum::Json(serde_json::to_value(flags).unwrap())
     }

src/routes/stats/flags.rs

@@ -51,7 +51,7 @@ mod get {
                 .await
                 .unwrap();
 
-                Ok(Response {
+                Response {
                     total: data.total_panels.unwrap(),
                     docker: data.docker_panels.unwrap(),
                     standalone: data.total_panels.unwrap() - data.docker_panels.unwrap(),
@@ -61,10 +61,9 @@ mod get {
                         max: data.max_extensions.unwrap(),
                         average: (data.avg_extensions.unwrap() * 100.0).round() / 100.0,
                     },
-                })
+                }
             })
-            .await
-            .unwrap();
+            .await;
 
         axum::Json(serde_json::to_value(response).unwrap())
     }

src/routes/stats/panels.rs

@@ -54,10 +54,9 @@ mod get {
                     );
                 }
 
-                Ok(versions)
+                versions
             })
-            .await
-            .unwrap();
+            .await;
 
         axum::Json(serde_json::to_value(versions).unwrap())
     }