cache /v1/mods for up to 10 minutes

Author: dankmeme01

Cargo.lock

@@ -40,3 +40,4 @@ log4rs = { version = "1.3.0", features = [
     "threshold_filter",
 ] }
 thiserror = "2.0.12"
+moka = { version = "0.12.13", features = ["future"] }

Cargo.toml

@@ -1,3 +1,15 @@
+use std::time::Duration;
+
+use moka::future::Cache;
+
+use crate::{
+    endpoints::mods::IndexQueryParams,
+    types::{
+        api::{ApiResponse, PaginatedData},
+        models::mod_entity::Mod,
+    },
+};
+
 #[derive(Clone)]
 pub struct AppData {
     db: sqlx::postgres::PgPool,
@@ -9,6 +21,8 @@ pub struct AppData {
     max_download_mb: u32,
     port: u16,
     debug: bool,
+
+    mods_cache: Cache<IndexQueryParams, ApiResponse<PaginatedData<Mod>>>,
 }
 
 #[derive(Clone)]
@@ -37,6 +51,11 @@ pub async fn build_config() -> anyhow::Result<AppData> {
         .unwrap_or("250".to_string())
         .parse::<u32>()
         .unwrap_or(250);
+    let mods_cache = Cache::builder()
+        .max_capacity(128)
+        .time_to_idle(Duration::from_mins(5))
+        .time_to_live(Duration::from_mins(10))
+        .build();
 
     Ok(AppData {
         db: pool,
@@ -51,6 +70,7 @@ pub async fn build_config() -> anyhow::Result<AppData> {
         max_download_mb,
         port,
         debug,
+        mods_cache,
     })
 }
 
@@ -100,4 +120,8 @@ impl AppData {
     pub fn debug(&self) -> bool {
         self.debug
     }
+
+    pub fn mods_cache(&self) -> &Cache<IndexQueryParams, ApiResponse<PaginatedData<Mod>>> {
+        &self.mods_cache
+    }
 }

src/config.rs

@@ -25,7 +25,7 @@ use serde::Deserialize;
 use serde::Serialize;
 use sqlx::Acquire;
 
-#[derive(Deserialize, Default)]
+#[derive(Deserialize, Default, Hash, Eq, PartialEq)]
 #[serde(rename_all = "snake_case")]
 pub enum IndexSortType {
     #[default]
@@ -37,7 +37,7 @@ pub enum IndexSortType {
     NameReverse,
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Hash, Eq, PartialEq)]
 pub struct IndexQueryParams {
     pub page: Option<i64>,
     pub per_page: Option<i64>,
@@ -67,25 +67,32 @@ pub async fn index(
     query: web::Query<IndexQueryParams>,
     auth: Auth,
 ) -> Result<impl Responder, ApiError> {
-    let mut pool = data.db().acquire().await?;
+    if let Some(s) = query.status
+        && s == ModVersionStatusEnum::Rejected
+    {
+        auth.check_admin()?;
+    }
 
-    if let Some(s) = query.status {
-        if s == ModVersionStatusEnum::Rejected {
-            auth.check_admin()?;
-        }
+    if let Some(cached) = data.mods_cache().get(&query.0).await {
+        return Ok(web::Json(cached));
     }
 
-    let mut result = Mod::get_index(&mut pool, query.0).await?;
+    let mut pool = data.db().acquire().await?;
+
+    let mut result = Mod::get_index(&mut pool, &query.0).await?;
     for i in &mut result.data {
         for j in &mut i.versions {
             j.modify_metadata(data.app_url(), false);
         }
     }
-
-    Ok(web::Json(ApiResponse {
+    let resp = ApiResponse {
         error: "".into(),
-        payload: result,
-    }))
+        payload: result.clone(),
+    };
+
+    data.mods_cache().insert(query.0, resp.clone()).await;
+
+    Ok(web::Json(resp))
 }
 
 #[get("/v1/mods/{id}")]

src/endpoints/mods.rs

@@ -1,15 +1,15 @@
-use actix_web::{error::QueryPayloadError, HttpRequest};
+use actix_web::{HttpRequest, error::QueryPayloadError};
 use serde::{Deserialize, Serialize};
 
 use crate::endpoints::ApiError;
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct PaginatedData<T> {
     pub data: Vec<T>,
     pub count: i64,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct ApiResponse<T> {
     pub error: String,
     pub payload: T,

src/types/api.rs

@@ -29,7 +29,7 @@ use sqlx::{
 };
 use std::collections::HashMap;
 
-#[derive(Serialize, Debug, sqlx::FromRow)]
+#[derive(Serialize, Debug, Clone, sqlx::FromRow)]
 pub struct Mod {
     pub id: String,
     pub repository: Option<String>,
@@ -141,10 +141,10 @@ impl Mod {
 
     pub async fn get_index(
         pool: &mut PgConnection,
-        query: IndexQueryParams,
+        query: &IndexQueryParams,
     ) -> Result<PaginatedData<Mod>, ApiError> {
-        let tags = match query.tags {
-            Some(t) => Some(Tag::parse_tags(&t, pool).await?),
+        let tags = match &query.tags {
+            Some(t) => Some(Tag::parse_tags(t, pool).await?),
             None => None,
         };
         let page: i64 = query.page.unwrap_or(1).max(1);
@@ -154,14 +154,15 @@ impl Mod {
         let offset = (page - 1) * per_page;
         let platforms = query
             .platforms
-            .map(|p| VerPlatform::parse_query_string(&p))
+            .as_ref()
+            .map(|p| VerPlatform::parse_query_string(p))
             .transpose()?;
         let status = query.status.unwrap_or(ModVersionStatusEnum::Accepted);
         // We only want to filter anything if jitless is true
         let requires_patching = query.jitless.filter(|&j| j).map(|_| false);
 
-        let developer = match query.developer {
-            Some(d) => match developers::get_one_by_username(&d, pool).await? {
+        let developer = match &query.developer {
+            Some(d) => match developers::get_one_by_username(d, pool).await? {
                 Some(d) => Some(d),
                 None => {
                     return Ok(PaginatedData {
@@ -184,7 +185,8 @@ impl Mod {
 
         let geode = query
             .geode
-            .map(|x| Version::parse(&x))
+            .as_ref()
+            .map(|x| Version::parse(x))
             .transpose()
             .or(Err(ApiError::BadRequest("Invalid geode version".into())))?;
 

src/types/models/mod_entity.rs

@@ -5,7 +5,7 @@ use sqlx::PgConnection;
 
 use crate::{database::DatabaseError, types::mod_json::ModJson};
 
-#[derive(sqlx::Type, Debug, Deserialize, Serialize, Clone, Copy)]
+#[derive(sqlx::Type, Debug, Deserialize, Serialize, Clone, Copy, Hash, PartialEq, Eq)]
 #[sqlx(type_name = "gd_version")]
 pub enum GDVersionEnum {
     #[serde(rename = "*")]

src/types/models/mod_gd_version.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(sqlx::Type, Debug, Deserialize, Serialize, Clone, Copy, PartialEq)]
+#[derive(sqlx::Type, Debug, Deserialize, Serialize, Clone, Copy, Hash, PartialEq, Eq)]
 #[serde(rename_all = "lowercase")]
 #[sqlx(rename_all = "lowercase", type_name = "mod_version_status")]
 pub enum ModVersionStatusEnum {