Implement batches in Hrana over HTTP

sqld/src/http/hrana_over_http.rs

@@ -12,6 +12,8 @@ enum ResponseError {
 
     #[error(transparent)]
     Stmt(batch::StmtError),
+    #[error(transparent)]
+    Batch(batch::BatchError),
 }
 
 pub async fn handle_index(
@@ -62,6 +64,43 @@ pub async fn handle_execute(
     })
 }
 
+pub async fn handle_batch(
+    db_factory: Arc<dyn DbFactory>,
+    req: hyper::Request<hyper::Body>,
+) -> Result<hyper::Response<hyper::Body>> {
+    #[derive(Debug, Deserialize)]
+    struct ReqBody {
+        batch: batch::proto::Batch,
+    }
+
+    #[derive(Debug, Serialize)]
+    struct RespBody {
+        result: batch::proto::BatchResult,
+    }
+
+    let res: Result<_> = async move {
+        let req_body = json_request_body::<ReqBody>(req.into_body()).await?;
+        let db = db_factory
+            .create()
+            .await
+            .context("Could not create a database connection")?;
+        let result = batch::execute_batch(&*db, &req_body.batch)
+            .await
+            .map_err(|err| match err.downcast::<batch::BatchError>() {
+                Ok(batch_err) => anyhow!(ResponseError::Batch(batch_err)),
+                Err(err) => err,
+            })
+            .context("Could not execute batch")?;
+        Ok(json_response(hyper::StatusCode::OK, &RespBody { result }))
+    }
+    .await;
+
+    Ok(match res {
+        Ok(resp) => resp,
+        Err(err) => error_response(err.downcast::<ResponseError>()?),
+    })
+}
+
 async fn json_request_body<T: DeserializeOwned>(body: hyper::Body) -> Result<T> {
     let body = hyper::body::to_bytes(body).await?;
     let body =
@@ -70,7 +109,7 @@ async fn json_request_body<T: DeserializeOwned>(body: hyper::Body) -> Result<T>
 }
 
 fn error_response(err: ResponseError) -> hyper::Response<hyper::Body> {
-    use batch::StmtError;
+    use batch::{BatchError, StmtError};
     let status = match &err {
         ResponseError::BadRequestBody { .. } => hyper::StatusCode::BAD_REQUEST,
         ResponseError::Stmt(err) => match err {
@@ -85,6 +124,9 @@ fn error_response(err: ResponseError) -> hyper::Response<hyper::Body> {
             }
             StmtError::SqliteError { .. } => hyper::StatusCode::INTERNAL_SERVER_ERROR,
         },
+        ResponseError::Batch(err) => match err {
+            BatchError::CondBadStep => hyper::StatusCode::BAD_REQUEST,
+        },
     };
 
     json_response(

sqld/src/http/mod.rs

@@ -254,6 +254,7 @@ async fn handle_request(
         (&Method::GET, "/health") => Ok(handle_health()),
         (&Method::GET, "/v1") => hrana_over_http::handle_index(req).await,
         (&Method::POST, "/v1/execute") => hrana_over_http::handle_execute(db_factory, req).await,
+        (&Method::POST, "/v1/batch") => hrana_over_http::handle_batch(db_factory, req).await,
         _ => Ok(Response::builder().status(404).body(Body::empty()).unwrap()),
     }
 }