crates/server: add project setup endpoint and update routes

Signed-off-by: NotAShelf <raf@notashelf.dev>
Change-Id: I9087c90a3b81cfa6f148a8d0131e87796a6a6964

crates/server/src/routes/projects.rs

@@ -2,8 +2,9 @@ use axum::{
     Json, Router,
     extract::{Path, Query, State},
     http::Extensions,
-    routing::get,
+    routing::{get, post},
 };
+use fc_common::nix_probe;
 use fc_common::{
     CreateJobset, CreateProject, Jobset, PaginatedResponse, PaginationParams, Project,
     UpdateProject, Validate,
@@ -142,6 +143,8 @@ async fn create_project_jobset(
         enabled: body.enabled,
         flake_mode: body.flake_mode,
         check_interval: body.check_interval,
+        branch: None,
+        scheduling_shares: None,
     };
     input
         .validate()
@@ -152,9 +155,99 @@ async fn create_project_jobset(
     Ok(Json(jobset))
 }
 
+#[derive(Debug, Deserialize)]
+struct ProbeRequest {
+    repository_url: String,
+    revision: Option<String>,
+}
+
+async fn probe_repository(
+    _extensions: Extensions,
+    Json(body): Json<ProbeRequest>,
+) -> Result<Json<nix_probe::FlakeProbeResult>, ApiError> {
+    let result = nix_probe::probe_flake(&body.repository_url, body.revision.as_deref())
+        .await
+        .map_err(ApiError)?;
+    Ok(Json(result))
+}
+
+#[derive(Debug, Deserialize)]
+struct SetupJobsetInput {
+    name: String,
+    nix_expression: String,
+    #[allow(dead_code)]
+    description: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct SetupProjectRequest {
+    repository_url: String,
+    name: String,
+    description: Option<String>,
+    jobsets: Vec<SetupJobsetInput>,
+}
+
+#[derive(serde::Serialize)]
+struct SetupProjectResponse {
+    project: Project,
+    jobsets: Vec<Jobset>,
+}
+
+async fn setup_project(
+    extensions: Extensions,
+    State(state): State<AppState>,
+    Json(body): Json<SetupProjectRequest>,
+) -> Result<Json<SetupProjectResponse>, ApiError> {
+    RequireRoles::check(&extensions, &["create-projects"]).map_err(|s| {
+        ApiError(if s == axum::http::StatusCode::FORBIDDEN {
+            fc_common::CiError::Forbidden("Insufficient permissions".to_string())
+        } else {
+            fc_common::CiError::Unauthorized("Authentication required".to_string())
+        })
+    })?;
+
+    let create_project = CreateProject {
+        name: body.name,
+        repository_url: body.repository_url,
+        description: body.description,
+    };
+    create_project
+        .validate()
+        .map_err(|msg| ApiError(fc_common::CiError::Validation(msg)))?;
+
+    let project = fc_common::repo::projects::create(&state.pool, create_project)
+        .await
+        .map_err(ApiError)?;
+
+    let mut jobsets = Vec::new();
+    for js_input in body.jobsets {
+        let input = CreateJobset {
+            project_id: project.id,
+            name: js_input.name,
+            nix_expression: js_input.nix_expression,
+            enabled: Some(true),
+            flake_mode: Some(true),
+            check_interval: None,
+            branch: None,
+            scheduling_shares: None,
+        };
+        input
+            .validate()
+            .map_err(|msg| ApiError(fc_common::CiError::Validation(msg)))?;
+        let jobset = fc_common::repo::jobsets::create(&state.pool, input)
+            .await
+            .map_err(ApiError)?;
+        jobsets.push(jobset);
+    }
+
+    Ok(Json(SetupProjectResponse { project, jobsets }))
+}
+
 pub fn router() -> Router<AppState> {
     Router::new()
         .route("/projects", get(list_projects).post(create_project))
+        .route("/projects/probe", post(probe_repository))
+        .route("/projects/setup", post(setup_project))
         .route(
             "/projects/{id}",
             get(get_project).put(update_project).delete(delete_project),