Add endpoints for deleting channels and messages.

It is deliberate that the expire() functions do not use them. To avoid races, the transactions must be committed before events get sent, in both cases, which makes them structurally pretty different.

1 files changed, 43 insertions, 18 deletions

diff --git a/src/channel/routes.rs b/src/channel/routes.rs
index 5bb1ee9..bce634e 100644
--- a/src/channel/routes.rs
+++ b/src/channel/routes.rs
@@ -2,20 +2,18 @@ use axum::{
     extract::{Json, Path, State},
     http::StatusCode,
     response::{IntoResponse, Response},
-    routing::{get, post},
+    routing::{delete, get, post},
     Router,
 };
 use axum_extra::extract::Query;
 
-use super::app;
+use super::{
+    app::{self, DeleteError},
+    Channel, Id,
+};
 use crate::{
-    app::App,
-    channel::{self, Channel},
-    clock::RequestedAt,
-    error::Internal,
-    event::Sequence,
-    login::Login,
-    message::app::Error as MessageError,
+    app::App, clock::RequestedAt, error::Internal, event::Sequence, login::Login,
+    message::app::SendError,
 };
 
 #[cfg(test)]
@@ -26,6 +24,7 @@ pub fn router() -> Router<App> {
         .route("/api/channels", get(list))
         .route("/api/channels", post(on_create))
         .route("/api/channels/:channel", post(on_send))
+        .route("/api/channels/:channel", delete(on_delete))
 }
 
 #[derive(Default, serde::Deserialize)]
@@ -95,28 +94,54 @@ struct SendRequest {
 
 async fn on_send(
     State(app): State<App>,
-    Path(channel): Path<channel::Id>,
+    Path(channel): Path<Id>,
     RequestedAt(sent_at): RequestedAt,
     login: Login,
     Json(request): Json<SendRequest>,
-) -> Result<StatusCode, ErrorResponse> {
+) -> Result<StatusCode, SendErrorResponse> {
     app.messages()
         .send(&channel, &login, &sent_at, &request.message)
-        .await
-        // Could impl `From` here, but it's more code and this is used once.
-        .map_err(ErrorResponse)?;
+        .await?;
 
     Ok(StatusCode::ACCEPTED)
 }
 
-#[derive(Debug)]
-struct ErrorResponse(MessageError);
+#[derive(Debug, thiserror::Error)]
+#[error(transparent)]
+struct SendErrorResponse(#[from] SendError);
+
+impl IntoResponse for SendErrorResponse {
+    fn into_response(self) -> Response {
+        let Self(error) = self;
+        match error {
+            not_found @ SendError::ChannelNotFound(_) => {
+                (StatusCode::NOT_FOUND, not_found.to_string()).into_response()
+            }
+            other => Internal::from(other).into_response(),
+        }
+    }
+}
+
+async fn on_delete(
+    State(app): State<App>,
+    Path(channel): Path<Id>,
+    RequestedAt(deleted_at): RequestedAt,
+    _: Login,
+) -> Result<StatusCode, DeleteErrorResponse> {
+    app.channels().delete(&channel, &deleted_at).await?;
+
+    Ok(StatusCode::ACCEPTED)
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error(transparent)]
+struct DeleteErrorResponse(#[from] DeleteError);
 
-impl IntoResponse for ErrorResponse {
+impl IntoResponse for DeleteErrorResponse {
     fn into_response(self) -> Response {
         let Self(error) = self;
         match error {
-            not_found @ MessageError::ChannelNotFound(_) => {
+            not_found @ DeleteError::NotFound(_) => {
                 (StatusCode::NOT_FOUND, not_found.to_string()).into_response()
             }
             other => Internal::from(other).into_response(),