outsource backend stuff

prepare makepkg command execution to store output in db and stdout

src/api/add.rs

@@ -0,0 +1,56 @@
+use crate::aur::aur::get_info_by_name;
+use crate::builder::types::Action;
+use crate::db::{packages, versions};
+use rocket::serde::json::Json;
+use rocket::serde::Deserialize;
+use rocket::{post, State};
+use rocket_okapi::okapi::schemars;
+use rocket_okapi::{openapi, JsonSchema};
+use sea_orm::ActiveModelTrait;
+use sea_orm::{DatabaseConnection, Set};
+use tokio::sync::broadcast::Sender;
+
+#[derive(Deserialize, JsonSchema)]
+#[serde(crate = "rocket::serde")]
+pub struct AddBody {
+    name: String,
+}
+
+#[openapi(tag = "test")]
+#[post("/packages/add", data = "<input>")]
+pub async fn package_add(
+    db: &State<DatabaseConnection>,
+    input: Json<AddBody>,
+    tx: &State<Sender<Action>>,
+) -> Result<(), String> {
+    let db = db as &DatabaseConnection;
+    let pkg_name = &input.name;
+
+    let pkg = get_info_by_name(pkg_name)
+        .await
+        .map_err(|_| "couldn't download package metadata".to_string())?;
+
+    let new_package = packages::ActiveModel {
+        name: Set(pkg_name.clone()),
+        ..Default::default()
+    };
+
+    let pkt_model = new_package.save(db).await.expect("TODO: panic message");
+
+    let new_version = versions::ActiveModel {
+        version: Set(pkg.version.clone()),
+        package_id: Set(pkt_model.id.clone().unwrap()),
+        ..Default::default()
+    };
+
+    let version_model = new_version.save(db).await.expect("TODO: panic message");
+
+    let _ = tx.send(Action::Build(
+        pkg.name,
+        pkg.version,
+        pkg.url_path.unwrap(),
+        version_model,
+    ));
+
+    Ok(())
+}

src/api/backend.rs

@@ -1,147 +1,13 @@
-use crate::aur::aur::get_info_by_name;
-use crate::builder::types::Action;
-use crate::db::{packages, versions};
-use crate::query_aur;
-use rocket::serde::json::Json;
-use rocket::serde::{Deserialize, Serialize};
-use rocket::State;
-use rocket::{get, post, Route};
-use rocket_okapi::okapi::schemars;
-use rocket_okapi::{openapi, openapi_get_routes, JsonSchema};
-use sea_orm::EntityTrait;
-use sea_orm::{ActiveModelTrait, DatabaseConnection, FromQueryResult, JoinType, QuerySelect, Set};
-use sea_orm::{ColumnTrait, RelationTrait};
-use tokio::sync::broadcast::Sender;
-
-use crate::db::prelude::Packages;
-use crate::repo::repo::{remove_pkg, remove_version};
-
-#[derive(Serialize, JsonSchema)]
-#[serde(crate = "rocket::serde")]
-struct ApiPackage {
-    name: String,
-    version: String,
-}
-
-#[openapi(tag = "test")]
-#[get("/search?<query>")]
-async fn search(query: &str) -> Result<Json<Vec<ApiPackage>>, String> {
-    match query_aur(query).await {
-        Ok(v) => {
-            let mapped = v
-                .iter()
-                .map(|x| ApiPackage {
-                    name: x.name.clone(),
-                    version: x.version.clone(),
-                })
-                .collect();
-            return Ok(Json(mapped));
-        }
-        Err(e) => {
-            return Err(format!("{}", e));
-        }
-    }
-}
-
-#[derive(FromQueryResult, Deserialize, JsonSchema, Serialize)]
-#[serde(crate = "rocket::serde")]
-struct ListPackageModel {
-    name: String,
-    count: i32,
-}
-
-#[openapi(tag = "test")]
-#[get("/packages/list")]
-async fn package_list(
-    db: &State<DatabaseConnection>,
-) -> Result<Json<Vec<ListPackageModel>>, String> {
-    let db = db as &DatabaseConnection;
-
-    let all: Vec<ListPackageModel> = Packages::find()
-        .join_rev(JoinType::InnerJoin, versions::Relation::Packages.def())
-        .select_only()
-        .column_as(versions::Column::Id.count(), "count")
-        .column(packages::Column::Name)
-        .group_by(packages::Column::Name)
-        .into_model::<ListPackageModel>()
-        .all(db)
-        .await
-        .unwrap();
-
-    Ok(Json(all))
-}
-
-#[derive(Deserialize, JsonSchema)]
-#[serde(crate = "rocket::serde")]
-struct AddBody {
-    name: String,
-}
-
-#[openapi(tag = "test")]
-#[post("/packages/add", data = "<input>")]
-async fn package_add(
-    db: &State<DatabaseConnection>,
-    input: Json<AddBody>,
-    tx: &State<Sender<Action>>,
-) -> Result<(), String> {
-    let db = db as &DatabaseConnection;
-    let pkg_name = &input.name;
-
-    let pkg = get_info_by_name(pkg_name)
-        .await
-        .map_err(|_| "couldn't download package metadata".to_string())?;
-
-    let new_package = packages::ActiveModel {
-        name: Set(pkg_name.clone()),
-        ..Default::default()
-    };
-
-    let pkt_model = new_package.save(db).await.expect("TODO: panic message");
-
-    let new_version = versions::ActiveModel {
-        version: Set(pkg.version.clone()),
-        package_id: Set(pkt_model.id.clone().unwrap()),
-        ..Default::default()
-    };
-
-    let version_model = new_version.save(db).await.expect("TODO: panic message");
-
-    let _ = tx.send(Action::Build(
-        pkg.name,
-        pkg.version,
-        pkg.url_path.unwrap(),
-        version_model,
-    ));
-
-    Ok(())
-}
-
-#[derive(Deserialize, JsonSchema)]
-#[serde(crate = "rocket::serde")]
-struct DelBody {
-    id: i32,
-}
-
-#[openapi(tag = "test")]
-#[post("/packages/delete", data = "<input>")]
-async fn package_del(db: &State<DatabaseConnection>, input: Json<DelBody>) -> Result<(), String> {
-    let db = db as &DatabaseConnection;
-    let pkg_id = input.id.clone();
-
-    remove_pkg(db, pkg_id).await.map_err(|e| e.to_string())?;
-
-    Ok(())
-}
-
-#[openapi(tag = "test")]
-#[post("/versions/delete/<id>")]
-async fn version_del(db: &State<DatabaseConnection>, id: i32) -> Result<(), String> {
-    let db = db as &DatabaseConnection;
-
-    remove_version(db, id).await.map_err(|e| e.to_string())?;
-
-    Ok(())
-}
+use crate::api::add::okapi_add_operation_for_package_add_;
+use crate::api::add::package_add;
+use crate::api::list::okapi_add_operation_for_package_list_;
+use crate::api::list::okapi_add_operation_for_search_;
+use crate::api::list::{package_list, search};
+use crate::api::remove::okapi_add_operation_for_package_del_;
+use crate::api::remove::okapi_add_operation_for_version_del_;
+use crate::api::remove::{package_del, version_del};
+use rocket::Route;
+use rocket_okapi::openapi_get_routes;
 
 pub fn build_api() -> Vec<Route> {
     openapi_get_routes![search, package_list, package_add, package_del, version_del]

src/api/list.rs

@@ -0,0 +1,66 @@
+use crate::aur::aur::query_aur;
+use crate::db::migration::JoinType;
+use crate::db::prelude::Packages;
+use crate::db::{packages, versions};
+use rocket::serde::json::Json;
+use rocket::serde::{Deserialize, Serialize};
+use rocket::{get, State};
+use rocket_okapi::okapi::schemars;
+use rocket_okapi::{openapi, JsonSchema};
+use sea_orm::ColumnTrait;
+use sea_orm::{DatabaseConnection, EntityTrait, FromQueryResult, QuerySelect, RelationTrait};
+
+#[derive(Serialize, JsonSchema)]
+#[serde(crate = "rocket::serde")]
+pub struct ApiPackage {
+    name: String,
+    version: String,
+}
+
+#[openapi(tag = "test")]
+#[get("/search?<query>")]
+pub async fn search(query: &str) -> Result<Json<Vec<ApiPackage>>, String> {
+    match query_aur(query).await {
+        Ok(v) => {
+            let mapped = v
+                .iter()
+                .map(|x| ApiPackage {
+                    name: x.name.clone(),
+                    version: x.version.clone(),
+                })
+                .collect();
+            return Ok(Json(mapped));
+        }
+        Err(e) => {
+            return Err(format!("{}", e));
+        }
+    }
+}
+
+#[derive(FromQueryResult, Deserialize, JsonSchema, Serialize)]
+#[serde(crate = "rocket::serde")]
+pub struct ListPackageModel {
+    name: String,
+    count: i32,
+}
+
+#[openapi(tag = "test")]
+#[get("/packages/list")]
+pub async fn package_list(
+    db: &State<DatabaseConnection>,
+) -> Result<Json<Vec<ListPackageModel>>, String> {
+    let db = db as &DatabaseConnection;
+
+    let all: Vec<ListPackageModel> = Packages::find()
+        .join_rev(JoinType::InnerJoin, versions::Relation::Packages.def())
+        .select_only()
+        .column_as(versions::Column::Id.count(), "count")
+        .column(packages::Column::Name)
+        .group_by(packages::Column::Name)
+        .into_model::<ListPackageModel>()
+        .all(db)
+        .await
+        .unwrap();
+
+    Ok(Json(all))
+}

src/api/mod.rs

@@ -1 +1,4 @@
+mod add;
 pub mod backend;
+mod list;
+mod remove;

src/api/remove.rs

@@ -0,0 +1,37 @@
+use crate::repo::repo::{remove_pkg, remove_version};
+use rocket::serde::json::Json;
+use rocket::serde::Deserialize;
+use rocket::{post, State};
+use rocket_okapi::okapi::schemars;
+use rocket_okapi::{openapi, JsonSchema};
+use sea_orm::DatabaseConnection;
+
+#[derive(Deserialize, JsonSchema)]
+#[serde(crate = "rocket::serde")]
+pub struct DelBody {
+    id: i32,
+}
+
+#[openapi(tag = "test")]
+#[post("/packages/delete", data = "<input>")]
+pub async fn package_del(
+    db: &State<DatabaseConnection>,
+    input: Json<DelBody>,
+) -> Result<(), String> {
+    let db = db as &DatabaseConnection;
+    let pkg_id = input.id.clone();
+
+    remove_pkg(db, pkg_id).await.map_err(|e| e.to_string())?;
+
+    Ok(())
+}
+
+#[openapi(tag = "test")]
+#[post("/versions/delete/<id>")]
+pub async fn version_del(db: &State<DatabaseConnection>, id: i32) -> Result<(), String> {
+    let db = db as &DatabaseConnection;
+
+    remove_version(db, id).await.map_err(|e| e.to_string())?;
+
+    Ok(())
+}