Implement more database methods and basic API routes (#50)

* feat: Implement more database methods & add mod and version routes

* feat: Implement deleting mods/versions & implement categories

* feat: Implement routes for categories, game versions & loaders

* feat: Reorganize API routes in a (hopefully) usable way

src/routes/mod.rs

@@ -1,12 +1,64 @@
+use actix_web::web;
+
 mod index;
 mod mod_creation;
 mod mods;
 mod not_found;
+mod tags;
 mod version_creation;
+mod versions;
+
+pub use tags::config as tags_config;
 
 pub use self::index::index_get;
-pub use self::mod_creation::mod_create;
-pub use self::mods::mod_search;
 pub use self::not_found::not_found;
-pub use self::version_creation::upload_file_to_version;
-pub use self::version_creation::version_create;
+
+pub fn mods_config(cfg: &mut web::ServiceConfig) {
+    cfg.service(mods::mod_search);
+    cfg.service(mod_creation::mod_create);
+
+    cfg.service(
+        web::scope("mod")
+            .service(mods::mod_get)
+            .service(mods::mod_delete)
+            .service(web::scope("{mod_id}").configure(versions_config)),
+    );
+}
+
+pub fn versions_config(cfg: &mut web::ServiceConfig) {
+    cfg.service(versions::version_list)
+        .service(version_creation::version_create)
+        .service(
+            web::scope("version")
+                .service(versions::version_get)
+                .service(versions::version_delete)
+                .service(
+                    web::scope("{version_id}").service(version_creation::upload_file_to_version),
+                ),
+        );
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum ApiError {
+    #[error("Internal server error")]
+    DatabaseError(#[from] crate::database::models::DatabaseError),
+}
+
+impl actix_web::ResponseError for ApiError {
+    fn status_code(&self) -> actix_web::http::StatusCode {
+        match self {
+            ApiError::DatabaseError(..) => actix_web::http::StatusCode::INTERNAL_SERVER_ERROR,
+        }
+    }
+
+    fn error_response(&self) -> actix_web::web::HttpResponse {
+        actix_web::web::HttpResponse::build(self.status_code()).json(
+            crate::models::error::ApiError {
+                error: match self {
+                    ApiError::DatabaseError(..) => "database_error",
+                },
+                description: &self.to_string(),
+            },
+        )
+    }
+}

src/routes/mod_creation.rs

@@ -36,6 +36,12 @@ pub enum CreateError {
     InvalidIconFormat(String),
     #[error("Error with multipart data: {0}")]
     InvalidInput(String),
+    #[error("Invalid game version: {0}")]
+    InvalidGameVersion(String),
+    #[error("Invalid loader: {0}")]
+    InvalidLoader(String),
+    #[error("Invalid category: {0}")]
+    InvalidCategory(String),
 }
 
 impl actix_web::ResponseError for CreateError {
@@ -50,6 +56,9 @@ impl actix_web::ResponseError for CreateError {
             CreateError::MissingValueError(..) => StatusCode::BAD_REQUEST,
             CreateError::InvalidIconFormat(..) => StatusCode::BAD_REQUEST,
             CreateError::InvalidInput(..) => StatusCode::BAD_REQUEST,
+            CreateError::InvalidGameVersion(..) => StatusCode::BAD_REQUEST,
+            CreateError::InvalidLoader(..) => StatusCode::BAD_REQUEST,
+            CreateError::InvalidCategory(..) => StatusCode::BAD_REQUEST,
         }
     }
 
@@ -65,6 +74,9 @@ impl actix_web::ResponseError for CreateError {
                 CreateError::MissingValueError(..) => "invalid_input",
                 CreateError::InvalidIconFormat(..) => "invalid_input",
                 CreateError::InvalidInput(..) => "invalid_input",
+                CreateError::InvalidGameVersion(..) => "invalid_input",
+                CreateError::InvalidLoader(..) => "invalid_input",
+                CreateError::InvalidCategory(..) => "invalid_input",
             },
             description: &self.to_string(),
         })
@@ -112,7 +124,7 @@ pub async fn undo_uploads(
     Ok(())
 }
 
-#[post("api/v1/mod")]
+#[post("mod")]
 pub async fn mod_create(
     payload: Multipart,
     client: Data<PgPool>,
@@ -256,6 +268,22 @@ async fn mod_create_inner(
                     VersionType::Alpha => models::ChannelId(5),
                 };
 
+                let mut game_versions = Vec::with_capacity(version_data.game_versions.len());
+                for v in &version_data.game_versions {
+                    let id = models::categories::GameVersion::get_id(&v.0, &mut *transaction)
+                        .await?
+                        .ok_or_else(|| CreateError::InvalidGameVersion(v.0.clone()))?;
+                    game_versions.push(id);
+                }
+
+                let mut loaders = Vec::with_capacity(version_data.loaders.len());
+                for l in &version_data.loaders {
+                    let id = models::categories::Loader::get_id(&l.0, &mut *transaction)
+                        .await?
+                        .ok_or_else(|| CreateError::InvalidLoader(l.0.clone()))?;
+                    loaders.push(id);
+                }
+
                 let version = models::version_item::VersionBuilder {
                     version_id: version_id.into(),
                     mod_id: mod_id.into(),
@@ -268,9 +296,8 @@ async fn mod_create_inner(
                         .iter()
                         .map(|x| (*x).into())
                         .collect::<Vec<_>>(),
-                    // TODO: add game_versions and loaders info
-                    game_versions: vec![],
-                    loaders: vec![],
+                    game_versions,
+                    loaders,
                     release_channel,
                 };
 
@@ -329,6 +356,14 @@ async fn mod_create_inner(
         )));
     };
 
+    let mut categories = Vec::with_capacity(create_data.categories.len());
+    for category in &create_data.categories {
+        let id = models::categories::Category::get_id(&category, &mut *transaction)
+            .await?
+            .ok_or_else(|| CreateError::InvalidCategory(category.clone()))?;
+        categories.push(id);
+    }
+
     let body_url = format!("data/{}/body.md", mod_id);
 
     let upload_data = file_host
@@ -367,8 +402,7 @@ async fn mod_create_inner(
         source_url: create_data.source_url,
         wiki_url: create_data.wiki_url,
 
-        // TODO: convert `create_data.categories` from Vec<String> to Vec<CategoryId>
-        categories: Vec::new(),
+        categories,
         initial_versions: created_versions,
     };
 

src/routes/mods.rs

@@ -1,11 +1,68 @@
+use super::ApiError;
+use crate::database;
+use crate::models;
 use crate::models::mods::SearchRequest;
 use crate::search::{search_for_mod, SearchError};
-use actix_web::{get, web, HttpResponse};
+use actix_web::{delete, get, web, HttpResponse};
+use sqlx::PgPool;
 
-#[get("api/v1/mod")]
+#[get("mod")]
 pub async fn mod_search(
     web::Query(info): web::Query<SearchRequest>,
 ) -> Result<HttpResponse, SearchError> {
     let results = search_for_mod(&info).await?;
     Ok(HttpResponse::Ok().json(results))
 }
+
+#[get("{id}")]
+pub async fn mod_get(
+    info: web::Path<(models::ids::ModId,)>,
+    pool: web::Data<PgPool>,
+) -> Result<HttpResponse, ApiError> {
+    let id = info.0;
+    let mod_data = database::models::Mod::get_full(id.into(), &**pool)
+        .await
+        .map_err(|e| ApiError::DatabaseError(e.into()))?;
+
+    if let Some(data) = mod_data {
+        let m = data.inner;
+        let response = models::mods::Mod {
+            id: m.id.into(),
+            team: m.team_id.into(),
+            title: m.title,
+            description: m.description,
+            body_url: m.body_url,
+            published: m.published,
+
+            downloads: m.downloads as u32,
+            categories: data.categories,
+            versions: data.versions.into_iter().map(|v| v.into()).collect(),
+            icon_url: m.icon_url,
+            issues_url: m.issues_url,
+            source_url: m.source_url,
+            wiki_url: m.wiki_url,
+        };
+        Ok(HttpResponse::Ok().json(response))
+    } else {
+        Ok(HttpResponse::NotFound().body(""))
+    }
+}
+
+// TODO: This really needs auth
+// TODO: The mod remains in meilisearch's index until the index is deleted
+#[delete("{id}")]
+pub async fn mod_delete(
+    info: web::Path<(models::ids::ModId,)>,
+    pool: web::Data<PgPool>,
+) -> Result<HttpResponse, ApiError> {
+    let id = info.0;
+    let result = database::models::Mod::remove_full(id.into(), &**pool)
+        .await
+        .map_err(|e| ApiError::DatabaseError(e.into()))?;
+
+    if result.is_some() {
+        Ok(HttpResponse::Ok().body(""))
+    } else {
+        Ok(HttpResponse::NotFound().body(""))
+    }
+}

src/routes/tags.rs

@@ -0,0 +1,153 @@
+use super::ApiError;
+use crate::database::models;
+use actix_web::{delete, get, put, web, HttpResponse};
+use models::categories::{Category, GameVersion, Loader};
+use sqlx::PgPool;
+
+pub fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(
+        web::scope("/tag/")
+            .service(category_list)
+            .service(category_create)
+            .service(category_delete)
+            .service(loader_list)
+            .service(loader_create)
+            .service(loader_delete)
+            .service(game_version_list)
+            .service(game_version_create)
+            .service(game_version_delete),
+    );
+}
+
+// TODO: searching / filtering? Could be used to implement a live
+// searching category list
+#[get("category")]
+pub async fn category_list(pool: web::Data<PgPool>) -> Result<HttpResponse, ApiError> {
+    let results = Category::list(&**pool).await?;
+    Ok(HttpResponse::Ok().json(results))
+}
+
+// At some point this may take more info, but it should be able to
+// remain idempotent
+// TODO: don't fail if category already exists
+#[put("category/{name}")]
+pub async fn category_create(
+    pool: web::Data<PgPool>,
+    category: web::Path<(String,)>,
+) -> Result<HttpResponse, ApiError> {
+    let name = category.into_inner().0;
+
+    let _id = Category::builder().name(&name)?.insert(&**pool).await?;
+
+    Ok(HttpResponse::Ok().body(""))
+}
+
+#[delete("category/{name}")]
+pub async fn category_delete(
+    pool: web::Data<PgPool>,
+    category: web::Path<(String,)>,
+) -> Result<HttpResponse, ApiError> {
+    let name = category.into_inner().0;
+    let mut transaction = pool.begin().await.map_err(models::DatabaseError::from)?;
+
+    let result = Category::remove(&name, &mut transaction).await?;
+
+    transaction
+        .commit()
+        .await
+        .map_err(models::DatabaseError::from)?;
+
+    if result.is_some() {
+        Ok(HttpResponse::Ok().body(""))
+    } else {
+        Ok(HttpResponse::NotFound().body(""))
+    }
+}
+
+#[get("loader")]
+pub async fn loader_list(pool: web::Data<PgPool>) -> Result<HttpResponse, ApiError> {
+    let results = Loader::list(&**pool).await?;
+    Ok(HttpResponse::Ok().json(results))
+}
+
+// At some point this may take more info, but it should be able to
+// remain idempotent
+// TODO: don't fail if loader already exists
+#[put("loader/{name}")]
+pub async fn loader_create(
+    pool: web::Data<PgPool>,
+    loader: web::Path<(String,)>,
+) -> Result<HttpResponse, ApiError> {
+    let name = loader.into_inner().0;
+
+    let _id = Loader::builder().name(&name)?.insert(&**pool).await?;
+
+    Ok(HttpResponse::Ok().body(""))
+}
+
+#[delete("loader/{name}")]
+pub async fn loader_delete(
+    pool: web::Data<PgPool>,
+    loader: web::Path<(String,)>,
+) -> Result<HttpResponse, ApiError> {
+    let name = loader.into_inner().0;
+    let mut transaction = pool.begin().await.map_err(models::DatabaseError::from)?;
+
+    let result = Loader::remove(&name, &mut transaction).await?;
+
+    transaction
+        .commit()
+        .await
+        .map_err(models::DatabaseError::from)?;
+
+    if result.is_some() {
+        Ok(HttpResponse::Ok().body(""))
+    } else {
+        Ok(HttpResponse::NotFound().body(""))
+    }
+}
+
+#[get("game_version")]
+pub async fn game_version_list(pool: web::Data<PgPool>) -> Result<HttpResponse, ApiError> {
+    let results = GameVersion::list(&**pool).await?;
+    Ok(HttpResponse::Ok().json(results))
+}
+
+// At some point this may take more info, but it should be able to
+// remain idempotent
+#[put("game_version/{name}")]
+pub async fn game_version_create(
+    pool: web::Data<PgPool>,
+    game_version: web::Path<(String,)>,
+) -> Result<HttpResponse, ApiError> {
+    let name = game_version.into_inner().0;
+
+    let _id = GameVersion::builder()
+        .version(&name)?
+        .insert(&**pool)
+        .await?;
+
+    Ok(HttpResponse::Ok().body(""))
+}
+
+#[delete("game_version/{name}")]
+pub async fn game_version_delete(
+    pool: web::Data<PgPool>,
+    game_version: web::Path<(String,)>,
+) -> Result<HttpResponse, ApiError> {
+    let name = game_version.into_inner().0;
+    let mut transaction = pool.begin().await.map_err(models::DatabaseError::from)?;
+
+    let result = GameVersion::remove(&name, &mut transaction).await?;
+
+    transaction
+        .commit()
+        .await
+        .map_err(models::DatabaseError::from)?;
+
+    if result.is_some() {
+        Ok(HttpResponse::Ok().body(""))
+    } else {
+        Ok(HttpResponse::NotFound().body(""))
+    }
+}

src/routes/version_creation.rs

@@ -14,7 +14,6 @@ use sqlx::postgres::PgPool;
 
 #[derive(Serialize, Deserialize, Clone)]
 pub struct InitialVersionData {
-    pub mod_id: ModId,
     pub file_parts: Vec<String>,
     pub version_number: String,
     pub version_title: String,
@@ -30,8 +29,10 @@ struct InitialFileData {
     // TODO: hashes?
 }
 
-#[post("api/v1/version")]
+// under `/api/v1/mod/{mod_id}`
+#[post("version")]
 pub async fn version_create(
+    url_data: actix_web::web::Path<(ModId,)>,
     payload: Multipart,
     client: Data<PgPool>,
     file_host: Data<std::sync::Arc<dyn FileHost + Send + Sync>>,
@@ -39,11 +40,14 @@ pub async fn version_create(
     let mut transaction = client.begin().await?;
     let mut uploaded_files = Vec::new();
 
+    let mod_id = url_data.into_inner().0.into();
+
     let result = version_create_inner(
         payload,
         &mut transaction,
         &***file_host,
         &mut uploaded_files,
+        mod_id,
     )
     .await;
 
@@ -69,6 +73,7 @@ async fn version_create_inner(
     transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
     file_host: &dyn FileHost,
     uploaded_files: &mut Vec<UploadedFile>,
+    mod_id: models::ModId,
 ) -> Result<HttpResponse, CreateError> {
     let cdn_url = dotenv::var("CDN_URL")?;
 
@@ -94,12 +99,9 @@ async fn version_create_inner(
             initial_version_data = Some(version_create_data);
             let version_create_data = initial_version_data.as_ref().unwrap();
 
-            // TODO: get mod_id from path (POST `/api/v1/mod/{mod_id}/version`)
-            let mod_id: ModId = version_create_data.mod_id;
-
             let results = sqlx::query!(
                 "SELECT EXISTS(SELECT 1 FROM mods WHERE id=$1)",
-                models::ModId::from(mod_id) as models::ModId
+                mod_id as models::ModId
             )
             .fetch_one(&mut *transaction)
             .await?;
@@ -113,7 +115,7 @@ async fn version_create_inner(
             let results = sqlx::query!(
                 "SELECT EXISTS(SELECT 1 FROM versions WHERE (version_number=$1) AND (mod_id=$2))",
                 version_create_data.version_number,
-                models::ModId::from(mod_id) as models::ModId,
+                mod_id as models::ModId,
             )
             .fetch_one(&mut *transaction)
             .await?;
@@ -125,7 +127,11 @@ async fn version_create_inner(
             }
 
             let version_id: VersionId = models::generate_version_id(transaction).await?.into();
-            let body_url = format!("data/{}/changelogs/{}/body.md", mod_id, version_id);
+            let body_url = format!(
+                "data/{}/changelogs/{}/body.md",
+                ModId::from(mod_id),
+                version_id
+            );
 
             let uploaded_text = file_host
                 .upload_file(
@@ -149,7 +155,7 @@ async fn version_create_inner(
 
             version_builder = Some(VersionBuilder {
                 version_id: version_id.into(),
-                mod_id: mod_id.into(),
+                mod_id,
                 name: version_create_data.version_title.clone(),
                 version_number: version_create_data.version_number.clone(),
                 changelog_url: Some(format!("{}/{}", cdn_url, body_url)),
@@ -246,16 +252,19 @@ async fn version_create_inner(
                 hashes: file
                     .hashes
                     .iter()
-                    .map(|hash| crate::models::mods::FileHash {
-                        algorithm: hash.algorithm.clone(),
-                        // This is a hack since the hashes are currently stored as ASCII
-                        // in the database, but represented here as a Vec<u8>.  At some
-                        // point we need to change the hash to be the real bytes  in the
-                        // database and add more processing here.
-                        hash: String::from_utf8(hash.hash.clone()).unwrap(),
+                    .map(|hash| {
+                        (
+                            hash.algorithm.clone(),
+                            // This is a hack since the hashes are currently stored as ASCII
+                            // in the database, but represented here as a Vec<u8>.  At some
+                            // point we need to change the hash to be the real bytes  in the
+                            // database and add more processing here.
+                            String::from_utf8(hash.hash.clone()).unwrap(),
+                        )
                     })
                     .collect(),
                 url: file.url.clone(),
+                filename: file.filename.clone(),
             })
             .collect::<Vec<_>>(),
         dependencies: version_data_safe.dependencies,
@@ -270,9 +279,10 @@ async fn version_create_inner(
 
 // TODO: file deletion, listing, etc
 
-#[post("api/v1/version/{version_id}/file")]
+// under /api/v1/mod/{mod_id}/version/{version_id}
+#[post("file")]
 pub async fn upload_file_to_version(
-    url_data: actix_web::web::Path<(VersionId,)>,
+    url_data: actix_web::web::Path<(ModId, VersionId)>,
     payload: Multipart,
     client: Data<PgPool>,
     file_host: Data<std::sync::Arc<dyn FileHost + Send + Sync>>,
@@ -280,7 +290,9 @@ pub async fn upload_file_to_version(
     let mut transaction = client.begin().await?;
     let mut uploaded_files = Vec::new();
 
-    let version_id = models::VersionId::from(url_data.into_inner().0);
+    let data = url_data.into_inner();
+    let mod_id = models::ModId::from(data.0);
+    let version_id = models::VersionId::from(data.1);
 
     let result = upload_file_to_version_inner(
         payload,
@@ -288,6 +300,7 @@ pub async fn upload_file_to_version(
         &***file_host,
         &mut uploaded_files,
         version_id,
+        mod_id,
     )
     .await;
 
@@ -314,6 +327,7 @@ async fn upload_file_to_version_inner(
     file_host: &dyn FileHost,
     uploaded_files: &mut Vec<UploadedFile>,
     version_id: models::VersionId,
+    mod_id: models::ModId,
 ) -> Result<HttpResponse, CreateError> {
     let cdn_url = dotenv::var("CDN_URL")?;
 
@@ -339,6 +353,12 @@ async fn upload_file_to_version_inner(
             ));
         }
     };
+    if version.mod_id as u64 != mod_id.0 as u64 {
+        return Err(CreateError::InvalidInput(
+            "An invalid version id was supplied".to_string(),
+        ));
+    }
+
     let mod_id = ModId(version.mod_id as u64);
     let version_number = version.version_number;
 

src/routes/versions.rs

@@ -0,0 +1,131 @@
+use super::ApiError;
+use crate::database;
+use crate::models;
+use actix_web::{delete, get, web, HttpResponse};
+use sqlx::PgPool;
+
+// TODO: this needs filtering, and a better response type
+// Currently it only gives a list of ids, which have to be
+// requested manually.  This route could give a list of the
+// ids as well as the supported versions and loaders, or
+// other info that is needed for selecting the right version.
+#[get("version")]
+pub async fn version_list(
+    info: web::Path<(models::ids::ModId,)>,
+    pool: web::Data<PgPool>,
+) -> Result<HttpResponse, ApiError> {
+    let id = info.0.into();
+
+    let mod_exists = sqlx::query!(
+        "SELECT EXISTS(SELECT 1 FROM mods WHERE id = $1)",
+        id as database::models::ModId,
+    )
+    .fetch_one(&**pool)
+    .await
+    .map_err(|e| ApiError::DatabaseError(e.into()))?
+    .exists;
+
+    if mod_exists.unwrap_or(false) {
+        let mod_data = database::models::Version::get_mod_versions(id, &**pool)
+            .await
+            .map_err(|e| ApiError::DatabaseError(e.into()))?;
+
+        let response = mod_data
+            .into_iter()
+            .map(|v| v.into())
+            .collect::<Vec<models::ids::VersionId>>();
+
+        Ok(HttpResponse::Ok().json(response))
+    } else {
+        Ok(HttpResponse::NotFound().body(""))
+    }
+}
+
+#[get("{version_id}")]
+pub async fn version_get(
+    info: web::Path<(models::ids::ModId, models::ids::VersionId)>,
+    pool: web::Data<PgPool>,
+) -> Result<HttpResponse, ApiError> {
+    let id = info.1;
+    let version_data = database::models::Version::get_full(id.into(), &**pool)
+        .await
+        .map_err(|e| ApiError::DatabaseError(e.into()))?;
+
+    if let Some(data) = version_data {
+        use models::mods::VersionType;
+
+        if models::ids::ModId::from(data.mod_id) != info.0 {
+            // Version doesn't belong to that mod
+            return Ok(HttpResponse::NotFound().body(""));
+        }
+
+        let response = models::mods::Version {
+            id: data.id.into(),
+            mod_id: data.mod_id.into(),
+
+            name: data.name,
+            version_number: data.version_number,
+            changelog_url: data.changelog_url,
+            date_published: data.date_published,
+            downloads: data.downloads as u32,
+            version_type: match data.release_channel.as_str() {
+                "release" => VersionType::Release,
+                "beta" => VersionType::Beta,
+                "alpha" => VersionType::Alpha,
+                _ => VersionType::Alpha,
+            },
+
+            files: data
+                .files
+                .into_iter()
+                .map(|f| {
+                    models::mods::VersionFile {
+                        url: f.url,
+                        filename: f.filename,
+                        // FIXME: Hashes are currently stored as an ascii byte slice instead
+                        // of as an actual byte array in the database
+                        hashes: f
+                            .hashes
+                            .into_iter()
+                            .map(|(k, v)| Some((k, String::from_utf8(v).ok()?)))
+                            .collect::<Option<_>>()
+                            .unwrap_or_else(Default::default),
+                    }
+                })
+                .collect(),
+            dependencies: Vec::new(), // TODO: dependencies
+            game_versions: data
+                .game_versions
+                .into_iter()
+                .map(models::mods::GameVersion)
+                .collect(),
+            loaders: data
+                .loaders
+                .into_iter()
+                .map(models::mods::ModLoader)
+                .collect(),
+        };
+        Ok(HttpResponse::Ok().json(response))
+    } else {
+        Ok(HttpResponse::NotFound().body(""))
+    }
+}
+
+// TODO: This really needs auth
+#[delete("{version_id}")]
+pub async fn version_delete(
+    info: web::Path<(models::ids::ModId, models::ids::VersionId)>,
+    pool: web::Data<PgPool>,
+) -> Result<HttpResponse, ApiError> {
+    // TODO: check if the mod exists and matches the version id
+    let id = info.1;
+    let result = database::models::Version::remove_full(id.into(), &**pool)
+        .await
+        .map_err(|e| ApiError::DatabaseError(e.into()))?;
+
+    if result.is_some() {
+        Ok(HttpResponse::Ok().body(""))
+    } else {
+        Ok(HttpResponse::NotFound().body(""))
+    }
+}