create

Author: epompeii

lib/api_projects/src/benchmarks.rs

@@ -14,7 +14,7 @@ use bencher_schema::{
     error::{resource_conflict_err, resource_not_found_err},
     model::{
         project::{
-            benchmark::{InsertBenchmark, QueryBenchmark, UpdateBenchmark},
+            benchmark::{QueryBenchmark, UpdateBenchmark},
             QueryProject,
         },
         user::auth::{AuthUser, BearerToken, PubBearerToken},
@@ -220,19 +220,9 @@ async fn post_inner(
         Permission::Create,
     )?;
 
-    let insert_benchmark =
-        InsertBenchmark::from_json(conn_lock!(context), query_project.id, json_benchmark)?;
-
-    diesel::insert_into(schema::benchmark::table)
-        .values(&insert_benchmark)
-        .execute(conn_lock!(context))
-        .map_err(resource_conflict_err!(Benchmark, insert_benchmark))?;
-
-    schema::benchmark::table
-        .filter(schema::benchmark::uuid.eq(&insert_benchmark.uuid))
-        .first::<QueryBenchmark>(conn_lock!(context))
+    QueryBenchmark::create(context, query_project.id, json_benchmark)
+        .await
         .map(|benchmark| benchmark.into_json_for_project(&query_project))
-        .map_err(resource_not_found_err!(Benchmark, insert_benchmark))
 }
 
 #[derive(Deserialize, JsonSchema)]

lib/api_projects/src/branches.rs

@@ -15,7 +15,7 @@ use bencher_schema::{
     },
     model::{
         project::{
-            branch::{head::QueryHead, InsertBranch, QueryBranch, UpdateBranch},
+            branch::{head::QueryHead, QueryBranch, UpdateBranch},
             QueryProject,
         },
         user::auth::{AuthUser, BearerToken, PubBearerToken},
@@ -231,10 +231,9 @@ async fn post_inner(
         Permission::Create,
     )?;
 
-    let (query_branch, _query_head) =
-        InsertBranch::from_json(log, context, query_project.id, json_branch).await?;
-
-    query_branch.into_json_for_project(conn_lock!(context), &query_project)
+    QueryBranch::create(log, context, query_project.id, json_branch)
+        .await?
+        .into_json_for_project(conn_lock!(context), &query_project)
 }
 
 #[derive(Deserialize, JsonSchema)]

lib/api_projects/src/measures.rs

@@ -13,7 +13,7 @@ use bencher_schema::{
     error::{resource_conflict_err, resource_not_found_err},
     model::{
         project::{
-            measure::{InsertMeasure, QueryMeasure, UpdateMeasure},
+            measure::{QueryMeasure, UpdateMeasure},
             QueryProject,
         },
         user::auth::{AuthUser, BearerToken, PubBearerToken},
@@ -219,19 +219,9 @@ async fn post_inner(
         Permission::Create,
     )?;
 
-    let insert_measure =
-        InsertMeasure::from_json(conn_lock!(context), query_project.id, json_measure)?;
-
-    diesel::insert_into(schema::measure::table)
-        .values(&insert_measure)
-        .execute(conn_lock!(context))
-        .map_err(resource_conflict_err!(Measure, insert_measure))?;
-
-    schema::measure::table
-        .filter(schema::measure::uuid.eq(&insert_measure.uuid))
-        .first::<QueryMeasure>(conn_lock!(context))
+    QueryMeasure::create(context, query_project.id, json_measure)
+        .await
         .map(|measure| measure.into_json_for_project(&query_project))
-        .map_err(resource_not_found_err!(Measure, insert_measure))
 }
 
 #[derive(Deserialize, JsonSchema)]

lib/api_projects/src/testbeds.rs

@@ -13,7 +13,7 @@ use bencher_schema::{
     error::{resource_conflict_err, resource_not_found_err},
     model::{
         project::{
-            testbed::{InsertTestbed, QueryTestbed, UpdateTestbed},
+            testbed::{QueryTestbed, UpdateTestbed},
             QueryProject,
         },
         user::auth::{AuthUser, BearerToken, PubBearerToken},
@@ -219,19 +219,9 @@ async fn post_inner(
         Permission::Create,
     )?;
 
-    let insert_testbed =
-        InsertTestbed::from_json(conn_lock!(context), query_project.id, json_testbed.clone())?;
-
-    diesel::insert_into(schema::testbed::table)
-        .values(&insert_testbed)
-        .execute(conn_lock!(context))
-        .map_err(resource_conflict_err!(Testbed, insert_testbed))?;
-
-    schema::testbed::table
-        .filter(schema::testbed::uuid.eq(&insert_testbed.uuid))
-        .first::<QueryTestbed>(conn_lock!(context))
+    QueryTestbed::create(context, query_project.id, json_testbed)
+        .await
         .map(|testbed| testbed.into_json_for_project(&query_project))
-        .map_err(resource_not_found_err!(Testbed, insert_testbed))
 }
 
 #[derive(Deserialize, JsonSchema)]

lib/bencher_schema/src/model/project/benchmark.rs

@@ -89,9 +89,17 @@ impl QueryBenchmark {
             return Ok(benchmark);
         }
 
-        let benchmark = JsonNewBenchmark { name, slug: None };
+        let json_benchmark = JsonNewBenchmark { name, slug: None };
+        Self::create(context, project_id, json_benchmark).await
+    }
+
+    pub async fn create(
+        context: &ApiContext,
+        project_id: ProjectId,
+        json_benchmark: JsonNewBenchmark,
+    ) -> Result<Self, HttpError> {
         let insert_benchmark =
-            InsertBenchmark::from_json(conn_lock!(context), project_id, benchmark)?;
+            InsertBenchmark::from_json(conn_lock!(context), project_id, json_benchmark)?;
         diesel::insert_into(schema::benchmark::table)
             .values(&insert_benchmark)
             .execute(conn_lock!(context))

lib/bencher_schema/src/model/project/branch/mod.rs

@@ -141,6 +141,19 @@ impl QueryBranch {
         InsertBranch::from_json(log, context, project_id, branch).await
     }
 
+    pub async fn create(
+        log: &Logger,
+        context: &ApiContext,
+        project_id: ProjectId,
+        json_branch: JsonNewBranch,
+    ) -> Result<Self, HttpError> {
+        Ok(
+            InsertBranch::from_json(log, context, project_id, json_branch)
+                .await?
+                .0,
+        )
+    }
+
     pub async fn update_start_point_if_changed(
         self,
         log: &Logger,

lib/bencher_schema/src/model/project/measure.rs

@@ -89,7 +89,7 @@ impl QueryMeasure {
         // Or recreate default measures if they were previously deleted
         let measure_str = measure.as_ref();
 
-        let measure = if let Some(measure) = built_in::default::Latency::from_str(measure_str)
+        let json_measure = if let Some(measure) = built_in::default::Latency::from_str(measure_str)
             .or_else(|| built_in::default::Throughput::from_str(measure_str))
             .or_else(|| built_in::json::BuildTime::from_str(measure_str))
             .or_else(|| built_in::json::FileSize::from_str(measure_str))
@@ -134,7 +134,16 @@ impl QueryMeasure {
             }
         };
 
-        let insert_measure = InsertMeasure::from_json(conn_lock!(context), project_id, measure)?;
+        Self::create(context, project_id, json_measure).await
+    }
+
+    pub async fn create(
+        context: &ApiContext,
+        project_id: ProjectId,
+        json_measure: JsonNewMeasure,
+    ) -> Result<Self, HttpError> {
+        let insert_measure =
+            InsertMeasure::from_json(conn_lock!(context), project_id, json_measure)?;
         diesel::insert_into(schema::measure::table)
             .values(&insert_measure)
             .execute(conn_lock!(context))

lib/bencher_schema/src/model/project/testbed.rs

@@ -82,15 +82,25 @@ impl QueryTestbed {
         let Ok(kind) = NameIdKind::<ResourceName>::try_from(testbed) else {
             return Err(http_error);
         };
-        let testbed = match kind {
+        let json_testbed = match kind {
             NameIdKind::Uuid(_) => return Err(http_error),
             NameIdKind::Slug(slug) => JsonNewTestbed {
                 name: slug.clone().into(),
                 slug: Some(slug),
             },
             NameIdKind::Name(name) => JsonNewTestbed { name, slug: None },
         };
-        let insert_testbed = InsertTestbed::from_json(conn_lock!(context), project_id, testbed)?;
+
+        Self::create(context, project_id, json_testbed).await
+    }
+
+    pub async fn create(
+        context: &ApiContext,
+        project_id: ProjectId,
+        json_testbed: JsonNewTestbed,
+    ) -> Result<Self, HttpError> {
+        let insert_testbed =
+            InsertTestbed::from_json(conn_lock!(context), project_id, json_testbed)?;
         diesel::insert_into(schema::testbed::table)
             .values(&insert_testbed)
             .execute(conn_lock!(context))