reworked api errors, now returning proper error codes

src/routes/messages.rs

@@ -18,6 +18,7 @@ use uuid::Uuid;
 use crate::{
     auth::{verify_jwt, verify_jwt_string},
     db::room_id_from_uuid,
+    errors::APIError,
     routes::{rooms::is_member, ws::WsAuthQuery},
 };
 use crate::{
@@ -72,25 +73,19 @@ async fn list_messages(
     Query(query): Query<MessageFetchQuery>,
     headers: HeaderMap,
     Extension(db): Extension<PgPool>,
-) -> Result<Json<Vec<Message>>, (StatusCode, String)> {
+) -> Result<Json<Vec<Message>>, APIError> {
     let claims = verify_jwt(headers)?;
 
     let user_id = user_id_from_uuid(&db, claims.sub).await?;
     let room_id = room_id_from_uuid(&db, room_uuid).await?;
 
     if !is_member(user_id, room_id, &db).await {
-        return Err((
-            StatusCode::FORBIDDEN,
-            String::from("You are not a member of this room"),
-        ));
+        return Err(APIError::NotAMember);
     }
 
     let limit: i32 = query.limit.unwrap_or(30).abs().min(80);
 
-    let mut tx = db
-        .begin()
-        .await
-        .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "DB error".into()))?;
+    let mut tx = db.begin().await?;
 
     let messages = sqlx::query_as::<_, MessageRow>(
         r#"
@@ -115,13 +110,7 @@ async fn list_messages(
     .bind(query.before)
     .bind(limit)
     .fetch_all(&mut *tx)
-    .await
-    .map_err(|e| {
-        (
-            StatusCode::INTERNAL_SERVER_ERROR,
-            format!("Failed to list messages: {e}"),
-        )
-    })?;
+    .await?;
 
     let mut messages: Vec<Message> = messages
         .into_iter()
@@ -149,18 +138,9 @@ async fn list_messages(
     .bind(user_id)
     .bind(room_id)
     .execute(&mut *tx)
-    .await
-    .map_err(|e| {
-        tracing::error!("Error updating membership timestamp: {e}");
-        (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to "))
-    })?;
+    .await?;
 
-    tx.commit().await.map_err(|_| {
-        (
-            StatusCode::INTERNAL_SERVER_ERROR,
-            "Could not list messages".into(),
-        )
-    })?;
+    tx.commit().await?;
 
     Ok(Json(messages))
 }
@@ -171,17 +151,14 @@ async fn create_message(
     Extension(realtime): Extension<RealtimeMessages>,
     headers: HeaderMap,
     Json(payload): Json<NewMessagePayload>,
-) -> Result<(StatusCode, Json<Message>), (StatusCode, String)> {
+) -> Result<(StatusCode, Json<Message>), APIError> {
     let claims = verify_jwt(headers)?;
 
     let user_id = user_id_from_uuid(&db, claims.sub).await?;
     let room_id = room_id_from_uuid(&db, room_uuid).await?;
 
     if !is_member(user_id, room_id, &db).await {
-        return Err((
-            StatusCode::UNAUTHORIZED,
-            String::from("You are not a member of this room"),
-        ));
+        return Err(APIError::NotAMember);
     }
 
     let uuid = Uuid::now_v7();
@@ -196,8 +173,7 @@ async fn create_message(
     .bind(&payload.content)
     .bind(&uuid)
     .fetch_one(&db)
-    .await
-    .map_err(|_| (StatusCode::BAD_REQUEST, "Could not create message".into()))?;
+    .await?;
 
     let sender_name = username_from_uuid(&db, claims.sub).await?;
 
@@ -221,11 +197,7 @@ async fn create_message(
     )
     .bind(room_id)
     .fetch_all(&db)
-    .await
-    .map_err(|e| {
-        tracing::error!("Error fetching message recipients: {e}");
-        (StatusCode::INTERNAL_SERVER_ERROR, "DB error".into())
-    })?;
+    .await?;
 
     let rt = realtime.clone();
     let msg_clone = message.clone();
@@ -244,7 +216,7 @@ async fn message_ws_handler(
     ConnectInfo(addr): ConnectInfo<SocketAddr>,
     Extension(realtime): Extension<RealtimeMessages>,
     Extension(db): Extension<sqlx::PgPool>,
-) -> Result<impl IntoResponse, (StatusCode, String)> {
+) -> Result<impl IntoResponse, APIError> {
     // tracing::info!("recieved ws handshake: {}", room_uuid);
 
     let claims = verify_jwt_string(&query.token)?;
@@ -260,13 +232,11 @@ async fn message_ws_handler(
     .bind(query.token)
     .execute(&db)
     .await
-    .map_err(|e| {
-        tracing::error!("Failed to get WS token from DB: {e}");
-        (StatusCode::INTERNAL_SERVER_ERROR, "DB error".into())
-    })?;
+    // NOTE: Maybe wrong type of error
+    .map_err(|e| APIError::Internal(format!("Failed to get WS token from DB: {e}")))?;
 
     if result.rows_affected() == 0 {
-        return Err((StatusCode::UNAUTHORIZED, "Wrong token".into()));
+        return Err(APIError::InvalidToken);
     }
 
     let receiver = realtime.get_sender(user_uuid).subscribe();