add support for unlisting mods

Author: Fleeym

migrations/20251224132727_add_mod_unlist.down.sql

@@ -0,0 +1,6 @@
+-- Add down migration script here
+
+ALTER TABLE mods
+DROP IF EXISTS unlisted;
+
+DROP TABLE IF EXISTS mod_unlist_history;

migrations/20251224132727_add_mod_unlist.up.sql

@@ -0,0 +1,18 @@
+-- Add up migration script here
+
+ALTER TABLE mods
+ADD unlisted BOOLEAN DEFAULT FALSE NOT NULL;
+
+CREATE TABLE mod_unlist_history(
+    id BIGINT GENERATED ALWAYS AS IDENTITY,
+    mod_id TEXT NOT NULL,
+    unlisted BOOLEAN NOT NULL,
+    details TEXT,
+    modified_by INTEGER NOT NULL,
+    created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
+
+    FOREIGN KEY (mod_id) REFERENCES mods(id),
+    FOREIGN KEY (modified_by) REFERENCES developers(id)
+);
+
+CREATE INDEX idx_mod_unlist_history_mod_id ON mod_unlist_history(mod_id);

src/database/repository/mod.rs

@@ -12,3 +12,4 @@ pub mod mod_version_statuses;
 pub mod mod_versions;
 pub mod mods;
 pub mod refresh_tokens;
+pub mod mod_unlist_history;

src/database/repository/mod_unlist_history.rs

@@ -0,0 +1,70 @@
+use crate::database::DatabaseError;
+use crate::types::models::mod_unlist_history::ModUnlistHistory;
+use sqlx::PgConnection;
+
+pub async fn create(
+    mod_id: &str,
+    unlisted: bool,
+    details: Option<String>,
+    modified_by: i32,
+    conn: &mut PgConnection,
+) -> Result<ModUnlistHistory, DatabaseError> {
+    sqlx::query_as!(
+        ModUnlistHistory,
+        "INSERT INTO mod_unlist_history
+        (mod_id, unlisted, details, modified_by)
+        VALUES ($1, $2, $3, $4)
+        RETURNING
+            id, mod_id, unlisted,
+            details, modified_by, created_at",
+        mod_id,
+        unlisted,
+        details,
+        modified_by
+    )
+    .fetch_one(conn)
+    .await
+    .inspect_err(|e| log::error!("mod_unlist_history::create failed: {e}"))
+    .map_err(|e| e.into())
+}
+
+pub async fn get_last_for_mod(
+    mod_id: &str,
+    conn: &mut PgConnection,
+) -> Result<Option<ModUnlistHistory>, DatabaseError> {
+    sqlx::query_as!(
+        ModUnlistHistory,
+        "SELECT
+            id, mod_id, unlisted,
+            details, modified_by, created_at
+        FROM mod_unlist_history
+        WHERE mod_id = $1
+        ORDER BY id DESC
+        LIMIT 1",
+        mod_id,
+    )
+        .fetch_optional(conn)
+        .await
+        .inspect_err(|e| log::error!("mod_unlist_history::get_last_for_mod failed: {e}"))
+        .map_err(|e| e.into())
+}
+
+pub async fn get_for_mod(
+    mod_id: &str,
+    conn: &mut PgConnection,
+) -> Result<Vec<ModUnlistHistory>, DatabaseError> {
+    sqlx::query_as!(
+        ModUnlistHistory,
+        "SELECT
+            id, mod_id, unlisted,
+            details, modified_by, created_at
+        FROM mod_unlist_history
+        WHERE mod_id = $1
+        ORDER BY id DESC",
+        mod_id,
+    )
+    .fetch_all(conn)
+    .await
+    .inspect_err(|e| log::error!("mod_unlist_history::get_for_mod failed: {e}"))
+    .map_err(|e| e.into())
+}

src/database/repository/mod_versions.rs

@@ -95,6 +95,14 @@ pub async fn get_for_mod(
     statuses: Option<&[ModVersionStatusEnum]>,
     conn: &mut PgConnection,
 ) -> Result<Vec<ModVersion>, DatabaseError> {
+    let unlisted = {
+        if let Some(s) = statuses {
+            ModVersionStatusEnum::get_unlisted_mod_filter_for_array(s)
+        } else {
+            None
+        }
+    };
+
     sqlx::query_as!(
         ModVersionRow,
         r#"SELECT
@@ -105,12 +113,15 @@ pub async fn get_for_mod(
             mv.created_at, mv.updated_at,
             mvs.status as "status: _", mvs.info
         FROM mod_versions mv
+        INNER JOIN mods m ON mv.mod_id = m.id
         INNER JOIN mod_version_statuses mvs ON mvs.mod_version_id = mv.id
         WHERE mv.mod_id = $1
         AND ($2::mod_version_status[] IS NULL OR mvs.status = ANY($2))
+        AND ($3::bool IS NULL OR m.unlisted = $3)
         ORDER BY mv.id DESC"#,
         mod_id,
-        statuses as Option<&[ModVersionStatusEnum]>
+        statuses as Option<&[ModVersionStatusEnum]>,
+        unlisted
     )
         .fetch_all(conn)
         .await
@@ -119,6 +130,47 @@ pub async fn get_for_mod(
         .map(|opt: Vec<ModVersionRow>| opt.into_iter().map(|x| x.into_mod_version()).collect())
 }
 
+pub async fn get_latest_for_mod(
+    mod_id: &str,
+    statuses: Option<&[ModVersionStatusEnum]>,
+    conn: &mut PgConnection,
+) -> Result<Option<ModVersion>, DatabaseError> {
+    let unlisted = {
+        if let Some(s) = statuses {
+            ModVersionStatusEnum::get_unlisted_mod_filter_for_array(s)
+        } else {
+            None
+        }
+    };
+
+    sqlx::query_as!(
+        ModVersionRow,
+        r#"SELECT
+            mv.id, mv.name, mv.description, mv.version,
+            mv.download_link, mv.download_count, mv.hash,
+            format_semver(mv.geode_major, mv.geode_minor, mv.geode_patch, mv.geode_meta) as "geode!: _",
+            mv.early_load, mv.api, mv.mod_id,
+            mv.created_at, mv.updated_at,
+            mvs.status as "status: _", mvs.info
+        FROM mod_versions mv
+        INNER JOIN mod_version_statuses mvs ON mvs.mod_version_id = mv.id
+        INNER JOIN mods m ON mv.mod_id = m.id
+        WHERE mv.mod_id = $1
+        AND ($2::mod_version_status[] IS NULL OR mvs.status = ANY($2))
+        AND ($3::bool IS NOT NULL OR m.unlisted = $3)
+        ORDER BY mv.id DESC
+        LIMIT 1"#,
+        mod_id,
+        statuses as Option<&[ModVersionStatusEnum]>,
+        unlisted
+    )
+        .fetch_optional(conn)
+        .await
+        .inspect_err(|e| log::error!("Failed to get latest mod_version for mod {mod_id}: {e}"))
+        .map_err(|e| e.into())
+        .map(|opt| opt.map(|x| x.into_mod_version()))
+}
+
 pub async fn increment_downloads(id: i32, conn: &mut PgConnection) -> Result<(), DatabaseError> {
     sqlx::query!(
         "UPDATE mod_versions

src/database/repository/mods.rs

@@ -3,13 +3,14 @@ use crate::{
     types::{mod_json::ModJson, models::mod_entity::Mod},
 };
 use chrono::{DateTime, SecondsFormat, Utc};
-use sqlx::PgConnection;
+use sqlx::{PgConnection, Postgres, QueryBuilder};
 
 #[derive(sqlx::FromRow)]
 struct ModRecordGetOne {
     id: String,
     repository: Option<String>,
     featured: bool,
+    unlisted: bool,
     download_count: i32,
     #[sqlx(default)]
     about: Option<String>,
@@ -25,6 +26,7 @@ impl ModRecordGetOne {
             id: self.id,
             repository: self.repository,
             featured: self.featured,
+            unlisted: self.unlisted,
             download_count: self.download_count,
             versions: Default::default(),
             tags: Default::default(),
@@ -50,7 +52,7 @@ pub async fn get_one(
         sqlx::query_as!(
             ModRecordGetOne,
             "SELECT
-                m.id, m.repository, m.about, m.changelog, m.featured,
+                m.id, m.repository, m.about, m.changelog, m.featured, m.unlisted,
                 m.download_count, m.created_at, m.updated_at
             FROM mods m
             WHERE id = $1",
@@ -65,7 +67,7 @@ pub async fn get_one(
         sqlx::query_as!(
             ModRecordGetOne,
             "SELECT
-            m.id, m.repository, NULL as about, NULL as changelog, m.featured,
+            m.id, m.repository, NULL as about, NULL as changelog, m.featured, m.unlisted,
             m.download_count, m.created_at, m.updated_at
         FROM mods m
         WHERE id = $1",
@@ -92,7 +94,7 @@ pub async fn create(json: &ModJson, conn: &mut PgConnection) -> Result<Mod, Data
         ) VALUES ($1, $2, $3, $4, $5)
         RETURNING
             id, repository, about,
-            changelog, featured,
+            changelog, featured, unlisted,
             download_count, created_at,
             updated_at",
         &json.id,
@@ -234,11 +236,13 @@ pub async fn update_with_json(
         about = $2,
         changelog = $3,
         image = $4,
-        updated_at = NOW()",
+        updated_at = NOW()
+        WHERE id = $5",
         json.repository,
         json.about,
         json.changelog,
-        json.logo
+        json.logo,
+        the_mod.id
     )
     .execute(conn)
     .await
@@ -281,6 +285,48 @@ pub async fn update_with_json_moved(
     Ok(the_mod)
 }
 
+pub async fn user_update(
+    mut the_mod: Mod,
+    featured: Option<bool>,
+    unlisted: Option<bool>,
+    pool: &mut PgConnection,
+) -> Result<Mod, DatabaseError> {
+    if featured.is_none() && unlisted.is_none() {
+        return Err(DatabaseError::InvalidInput(
+            "No new fields were supplied".into(),
+        ));
+    }
+
+    let mut builder: QueryBuilder<Postgres> = QueryBuilder::new("UPDATE mods SET ");
+    let mut split = builder.separated(", ");
+
+    if let Some(featured) = featured {
+        split.push("featured = ");
+        split.push_bind(featured);
+    }
+
+    if let Some(unlisted) = unlisted {
+        split.push("unlisted = ");
+        split.push_bind(unlisted);
+    }
+
+    builder
+        .build()
+        .execute(&mut *pool)
+        .await
+        .inspect_err(|e| log::error!("Failed to update mod {}: {e}", the_mod.id))
+        .map(|_| ())?;
+
+    if let Some(featured) = featured {
+        the_mod.featured = featured;
+    }
+    if let Some(unlisted) = unlisted {
+        the_mod.unlisted = unlisted;
+    }
+
+    Ok(the_mod)
+}
+
 /// Used when first version goes from pending to accepted.
 /// Makes it so versions that stay a lot in pending appear at the top of the newly created lists
 pub async fn touch_created_at(id: &str, conn: &mut PgConnection) -> Result<(), DatabaseError> {