feat(api): implement PKError in rust-api

crates/api/src/endpoints/private.rs

@@ -2,6 +2,7 @@ use crate::ApiContext;
 use axum::{extract::State, response::Json};
 use fred::interfaces::*;
 use libpk::state::ShardState;
+use pk_macros::api_endpoint;
 use serde::Deserialize;
 use serde_json::{json, Value};
 use std::collections::HashMap;
@@ -13,34 +14,33 @@ struct ClusterStats {
     pub channel_count: i32,
 }
 
+#[api_endpoint]
 pub async fn discord_state(State(ctx): State<ApiContext>) -> Json<Value> {
     let mut shard_status = ctx
         .redis
         .hgetall::<HashMap<String, String>, &str>("pluralkit:shardstatus")
-        .await
-        .unwrap()
+        .await?
         .values()
         .map(|v| serde_json::from_str(v).expect("could not deserialize shard"))
         .collect::<Vec<ShardState>>();
 
     shard_status.sort_by(|a, b| b.shard_id.cmp(&a.shard_id));
 
-    Json(json!({
+    Ok(Json(json!({
         "shards": shard_status,
-    }))
+    })))
 }
 
+#[api_endpoint]
 pub async fn meta(State(ctx): State<ApiContext>) -> Json<Value> {
     let stats = serde_json::from_str::<Value>(
         ctx.redis
             .get::<String, &'static str>("statsapi")
-            .await
-            .unwrap()
+            .await?
             .as_str(),
-    )
-    .unwrap();
+    )?;
 
-    Json(stats)
+    Ok(Json(stats))
 }
 
 use std::time::Duration;

crates/api/src/endpoints/system.rs

@@ -1,22 +1,18 @@
-use axum::{
-    extract::State,
-    http::StatusCode,
-    response::{IntoResponse, Response},
-    Extension, Json,
-};
-use serde_json::json;
+use axum::{extract::State, response::IntoResponse, Extension, Json};
+use pk_macros::api_endpoint;
+use serde_json::{json, Value};
 use sqlx::Postgres;
-use tracing::error;
 
 use pluralkit_models::{PKSystem, PKSystemConfig, PrivacyLevel};
 
-use crate::{auth::AuthState, util::json_err, ApiContext};
+use crate::{auth::AuthState, error::fail, ApiContext};
 
+#[api_endpoint]
 pub async fn get_system_settings(
     Extension(auth): Extension<AuthState>,
     Extension(system): Extension<PKSystem>,
     State(ctx): State<ApiContext>,
-) -> Response {
+) -> Json<Value> {
     let access_level = auth.access_level_for(&system);
 
     let mut config = match sqlx::query_as::<Postgres, PKSystemConfig>(
@@ -27,23 +23,11 @@ pub async fn get_system_settings(
     .await
     {
         Ok(Some(config)) => config,
-        Ok(None) => {
-            error!(
-                system = system.id,
-                "failed to find system config for existing system"
-            );
-            return json_err(
-                StatusCode::INTERNAL_SERVER_ERROR,
-                r#"{"message": "500: Internal Server Error", "code": 0}"#.to_string(),
-            );
-        }
-        Err(err) => {
-            error!(?err, "failed to query system config");
-            return json_err(
-                StatusCode::INTERNAL_SERVER_ERROR,
-                r#"{"message": "500: Internal Server Error", "code": 0}"#.to_string(),
-            );
-        }
+        Ok(None) => fail!(
+            system = system.id,
+            "failed to find system config for existing system"
+        ),
+        Err(err) => fail!(?err, "failed to query system config"),
     };
 
     // fix this
@@ -51,7 +35,7 @@ pub async fn get_system_settings(
         config.name_format = Some("{name} {tag}".to_string());
     }
 
-    Json(&match access_level {
+    Ok(Json(match access_level {
         PrivacyLevel::Private => config.to_json(),
         PrivacyLevel::Public => json!({
             "pings_enabled": config.pings_enabled,
@@ -64,6 +48,5 @@ pub async fn get_system_settings(
             "proxy_switch": config.proxy_switch,
             "name_format": config.name_format,
         }),
-    })
-    .into_response()
+    }))
 }