persistent websocket

crates/backend/src/main.rs

@@ -16,6 +16,7 @@ use common::CreateMilestone;
 use common::DeleteAchievement;
 use common::DeleteMilestone;
 use common::Milestone;
+use common::RestResponse;
 use common::ToggleAchievement;
 use serde::Deserialize;
 use serde::Serialize;
@@ -37,6 +38,20 @@ struct SharedStateParts {
     watcher_tx: tokio::sync::watch::Sender<common::State>,
 }
 
+type Response<T> = Result<(StatusCode, Json<RestResponse<T>>), HandlerError>;
+// TODO: still needed?
+#[derive(Debug, thiserror::Error)]
+enum HandlerError {
+    // #[error("Failed to lock state")]
+    // LockAppStateError,
+}
+impl IntoResponse for HandlerError {
+    fn into_response(self) -> axum::response::Response {
+        let error_message = format!("{self}");
+        (StatusCode::INTERNAL_SERVER_ERROR, error_message).into_response()
+    }
+}
+
 #[tokio::main]
 async fn main() {
     tracing_subscriber::fmt::init();
@@ -168,7 +183,7 @@ async fn handle_socket(mut socket: WebSocket, state_watch_rx: tokio::sync::watch
 async fn create_achievement(
     Extension(app_state): Extension<SharedState>,
     Json(create_achievement): Json<CreateAchievement>,
-) -> Result<(StatusCode, ()), HandlerError> {
+) -> Response<()> {
     tracing::debug!("Creating achievement: {create_achievement:?}.");
     let achievement = Achievement {
         goal: create_achievement.goal,
@@ -180,17 +195,21 @@ async fn create_achievement(
     lock.watcher_tx
         .send(lock.app_state.state.clone())
         .expect("watch channel is closed, every receiver was dropped.");
-    Ok((StatusCode::CREATED, ()))
+    Ok((StatusCode::CREATED, Json(Ok(()))))
 }
 
 async fn create_milestone(
     Extension(app_state): Extension<SharedState>,
     Json(create_milestone): Json<CreateMilestone>,
-) -> Result<(StatusCode, ()), HandlerError> {
+) -> Response<()> {
     tracing::debug!("Creating milestone: {create_milestone:?}.");
 
-    if create_milestone.goal > 100 {
-        return Ok((StatusCode::BAD_REQUEST, ()));
+    let goal_max = 100;
+    if create_milestone.goal > goal_max {
+        return Ok((
+            StatusCode::BAD_REQUEST,
+            Json(Err(format!("Max goal allowed: {goal_max}.").into())),
+        ));
     }
 
     let milestone = Milestone {
@@ -202,13 +221,13 @@ async fn create_milestone(
     lock.watcher_tx
         .send(lock.app_state.state.clone())
         .expect("watch channel is closed, every receiver was dropped.");
-    Ok((StatusCode::CREATED, ()))
+    Ok((StatusCode::CREATED, Json(Ok(()))))
 }
 
 async fn delete_milestone(
     Extension(app_state): Extension<SharedState>,
     Json(delete_milestone): Json<DeleteMilestone>,
-) -> Result<(StatusCode, ()), HandlerError> {
+) -> Response<()> {
     tracing::debug!("Deleting milestone: {delete_milestone:?}.");
     let mut lock = app_state.write().await;
     if let Some(pos) = lock
@@ -223,13 +242,13 @@ async fn delete_milestone(
             .send(lock.app_state.state.clone())
             .expect("watch channel is closed, every receiver was dropped.");
     }
-    Ok((StatusCode::OK, ()))
+    Ok((StatusCode::OK, Json(Ok(()))))
 }
 
 async fn toggle_achievement(
     Extension(app_state): Extension<SharedState>,
     Json(toggle_achievement): Json<ToggleAchievement>,
-) -> Result<(StatusCode, ()), HandlerError> {
+) -> Response<()> {
     tracing::debug!("Toggling achievement: {toggle_achievement:?}.");
     let mut lock = app_state.write().await;
     if let Some(achievement) = lock
@@ -244,13 +263,13 @@ async fn toggle_achievement(
             .send(lock.app_state.state.clone())
             .expect("watch channel is closed, every receiver was dropped.");
     }
-    Ok((StatusCode::OK, ()))
+    Ok((StatusCode::OK, Json(Ok(()))))
 }
 
 async fn delete_achievement(
     Extension(app_state): Extension<SharedState>,
     Json(delete_achievement): Json<DeleteAchievement>,
-) -> Result<(StatusCode, ()), HandlerError> {
+) -> Response<()> {
     tracing::debug!("Deleting achievement: {delete_achievement:?}.");
     let mut lock = app_state.write().await;
     if let Some(pos) = lock
@@ -265,7 +284,7 @@ async fn delete_achievement(
             .send(lock.app_state.state.clone())
             .expect("watch channel is closed, every receiver was dropped.");
     }
-    Ok((StatusCode::OK, ()))
+    Ok((StatusCode::OK, Json(Ok(()))))
 }
 
 async fn shutdown_signal() {
@@ -335,17 +354,3 @@ pub enum AppStateWriteError {
     #[error("Failed to serialize the state")]
     SerializationError(#[from] serde_json::Error),
 }
-
-// TODO: still needed?
-#[derive(Debug, thiserror::Error)]
-enum HandlerError {
-    // #[error("Failed to lock state")]
-    // LockAppStateError,
-}
-
-impl IntoResponse for HandlerError {
-    fn into_response(self) -> axum::response::Response {
-        let error_message = format!("{self}");
-        (StatusCode::INTERNAL_SERVER_ERROR, error_message).into_response()
-    }
-}