refactor: Clean up Outcome<->Result conversions

stadust · stadust · commit 1a8a1e91f5de · 2025-06-29T14:03:33.000+01:00
Stop defining a try_outcome! macro that shadows the same-named macro
from rocket core. Provide a specialized version of
`rocket::outcome::IntoOutcome` that works with `PointercrateError`s
only, and use this to avoid manually specifying the status code when
returning an Outcome::Error from a FromRequest or FromData impl.

Signed-off-by: stadust &lt;43299462+stadust@users.noreply.github.com&gt;
diff --git a/pointercrate-core-api/src/error.rs b/pointercrate-core-api/src/error.rs
@@ -2,6 +2,7 @@ use crate::response::Page;
 use log::info;
 use pointercrate_core::error::PointercrateError;
 use pointercrate_core_pages::error::ErrorFragment;
+use rocket::outcome::Outcome;
 use rocket::{
     http::{MediaType, Status},
     response::Responder,
@@ -60,3 +61,40 @@ impl<E: PointercrateError> From<E> for ErrorResponder {
         }
     }
 }
+
+/// A version of [`IntoOutcome`](rocket::outcome::IntoOutcome) specially crafted for [`PointercrateError`]s
+pub trait IntoOutcome2<S, E> {
+    fn into_outcome<F, E2: From<E>>(self) -> Outcome<S, (Status, E2), F>;
+}
+
+impl<S, E: PointercrateError> IntoOutcome2<S, E> for std::result::Result<S, E> {
+    fn into_outcome<F, E2: From<E>>(self) -> Outcome<S, (Status, E2), F> {
+        self.map(Outcome::Success).unwrap_or_else(|e| e.into_outcome())
+    }
+}
+
+impl<S, E: PointercrateError> IntoOutcome2<S, E> for E {
+    fn into_outcome<F, E2: From<E>>(self) -> Outcome<S, (Status, E2), F> {
+        Outcome::Error((Status::new(self.status_code()), self.into()))
+    }
+}
+
+#[macro_export]
+macro_rules! tryo_result {
+    ($result: expr) => {
+        rocket::outcome::try_outcome!($crate::error::IntoOutcome2::into_outcome($result))
+    };
+}
+
+#[macro_export]
+macro_rules! tryo_state {
+    ($request: expr, $typ: ty) => {
+        $crate::tryo_result!($request
+            .rocket()
+            .state::<$typ>()
+            .ok_or_else(|| pointercrate_core::error::CoreError::internal_server_error(format!(
+                "Missing required state: '{}'",
+                stringify!($typ)
+            ))))
+    };
+}
diff --git a/pointercrate-core-api/src/etag.rs b/pointercrate-core-api/src/etag.rs
@@ -1,3 +1,4 @@
+use crate::error::IntoOutcome2;
 use crate::response::Response2;
 use pointercrate_core::{error::CoreError, etag::Taggable};
 use rocket::{
@@ -35,10 +36,12 @@ impl<'r> FromRequest<'r> for Precondition {
     type Error = CoreError;
 
     async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self::Error> {
-        match request.headers().get_one("if-match") {
-            Some(if_match) => Outcome::Success(Precondition(if_match.split(',').map(ToString::to_string).collect())),
-            None => Outcome::Error((Status::PreconditionRequired, CoreError::PreconditionRequired)),
-        }
+        request
+            .headers()
+            .get_one("if-match")
+            .map(|if_match| Precondition(if_match.split(',').map(ToString::to_string).collect()))
+            .ok_or(CoreError::PreconditionFailed)
+            .into_outcome()
     }
 }
 
diff --git a/pointercrate-user-api/src/auth.rs b/pointercrate-user-api/src/auth.rs
@@ -1,18 +1,20 @@
 use base64::{engine::general_purpose::STANDARD, Engine};
 use log::warn;
 use pointercrate_core::{
-    error::{CoreError, PointercrateError},
+    error::CoreError,
     permission::{Permission, PermissionsManager},
     pool::{audit_connection, PointercratePool},
 };
+use pointercrate_core_api::error::IntoOutcome2;
+use pointercrate_core_api::{tryo_result, tryo_state};
 use pointercrate_user::{
     auth::{AccessClaims, ApiToken, AuthenticatedUser, NonMutating, PasswordOrBrowser},
     error::UserError,
 };
 use rocket::{
     http::{Method, Status},
     request::{FromRequest, Outcome},
-    Request, State,
+    Request,
 };
 use sqlx::{Postgres, Transaction};
 use std::collections::HashSet;
@@ -44,29 +46,6 @@ impl<A> Auth<A> {
     }
 }
 
-macro_rules! try_outcome {
-    ($outcome:expr) => {
-        match $outcome {
-            Ok(success) => success,
-            Err(error) => return Outcome::Error((Status::from_code(error.status_code()).unwrap(), error.into())),
-        }
-    };
-}
-
-macro_rules! try_state {
-    ($request: expr, $typ: ty) => {
-        match $request.guard::<&State<$typ>>().await {
-            Outcome::Success(state) => state.inner(),
-            _ => {
-                return Outcome::Error((
-                    Status::InternalServerError,
-                    CoreError::internal_server_error(format!("Missing required state: '{}'", stringify!($typ))).into(),
-                ))
-            },
-        }
-    };
-}
-
 #[rocket::async_trait]
 impl<'r> FromRequest<'r> for Auth<NonMutating> {
     type Error = UserError;
@@ -76,17 +55,17 @@ impl<'r> FromRequest<'r> for Auth<NonMutating> {
             return Outcome::Forward(Status::NotFound);
         }
 
-        let pool = try_state!(request, PointercratePool);
-        let permission_manager = try_state!(request, PermissionsManager).clone();
+        let pool = tryo_state!(request, PointercratePool);
+        let permission_manager = tryo_state!(request, PermissionsManager).clone();
 
-        let mut connection = try_outcome!(pool.transaction().await);
+        let mut connection = tryo_result!(pool.transaction().await);
 
         if let Some(access_token) = request.cookies().get("access_token") {
-            let access_claims = try_outcome!(AccessClaims::decode(access_token.value()));
-            let user = try_outcome!(AuthenticatedUser::by_id(try_outcome!(access_claims.id()), &mut connection).await);
-            let authenticated_for_get = try_outcome!(user.validate_cookie_claims(access_claims));
+            let access_claims = tryo_result!(AccessClaims::decode(access_token.value()));
+            let user = tryo_result!(AuthenticatedUser::by_id(tryo_result!(access_claims.id()), &mut connection).await);
+            let authenticated_for_get = tryo_result!(user.validate_cookie_claims(access_claims));
 
-            try_outcome!(audit_connection(&mut connection, authenticated_for_get.user().id).await);
+            tryo_result!(audit_connection(&mut connection, authenticated_for_get.user().id).await);
 
             return Outcome::Success(Auth {
                 user: authenticated_for_get,
@@ -95,7 +74,7 @@ impl<'r> FromRequest<'r> for Auth<NonMutating> {
             });
         }
 
-        Outcome::Error((Status::Unauthorized, CoreError::Unauthorized.into()))
+        CoreError::Unauthorized.into_outcome()
     }
 }
 
@@ -109,18 +88,18 @@ impl<'r> FromRequest<'r> for Auth<ApiToken> {
             return Outcome::Forward(Status::NotFound);
         }
 
-        let pool = try_state!(request, PointercratePool);
-        let permission_manager = try_state!(request, PermissionsManager).clone();
+        let pool = tryo_state!(request, PointercratePool);
+        let permission_manager = tryo_state!(request, PermissionsManager).clone();
 
-        let mut connection = try_outcome!(pool.transaction().await);
+        let mut connection = tryo_result!(pool.transaction().await);
 
         for authorization in request.headers().get("Authorization") {
             if let ["Bearer", token] = authorization.split(' ').collect::<Vec<_>>()[..] {
-                let access_claims = try_outcome!(AccessClaims::decode(token));
-                let user = try_outcome!(AuthenticatedUser::by_id(try_outcome!(access_claims.id()), &mut connection).await);
-                let authenticated_user = try_outcome!(user.validate_api_access(access_claims));
+                let access_claims = tryo_result!(AccessClaims::decode(token));
+                let user = tryo_result!(AuthenticatedUser::by_id(tryo_result!(access_claims.id()), &mut connection).await);
+                let authenticated_user = tryo_result!(user.validate_api_access(access_claims));
 
-                try_outcome!(audit_connection(&mut connection, authenticated_user.user().id).await);
+                tryo_result!(audit_connection(&mut connection, authenticated_user.user().id).await);
 
                 return Outcome::Success(Auth {
                     user: authenticated_user,
@@ -132,12 +111,12 @@ impl<'r> FromRequest<'r> for Auth<ApiToken> {
 
         // no matching auth header, lets try the cookie
         if let (Some(access_token), Some(csrf_token)) = (request.cookies().get("access_token"), request.headers().get_one("X-CSRF-TOKEN")) {
-            let access_claims = try_outcome!(AccessClaims::decode(access_token.value()));
-            let user = try_outcome!(AuthenticatedUser::by_id(try_outcome!(access_claims.id()), &mut connection).await);
-            let authenticated_for_get = try_outcome!(user.validate_cookie_claims(access_claims));
-            let authenticated = try_outcome!(authenticated_for_get.validate_csrf_token(csrf_token));
+            let access_claims = tryo_result!(AccessClaims::decode(access_token.value()));
+            let user = tryo_result!(AuthenticatedUser::by_id(tryo_result!(access_claims.id()), &mut connection).await);
+            let authenticated_for_get = tryo_result!(user.validate_cookie_claims(access_claims));
+            let authenticated = tryo_result!(authenticated_for_get.validate_csrf_token(csrf_token));
 
-            try_outcome!(audit_connection(&mut connection, authenticated.user().id).await);
+            tryo_result!(audit_connection(&mut connection, authenticated.user().id).await);
 
             return Outcome::Success(Auth {
                 user: authenticated.downgrade_auth_type().unwrap(), // cannot fail: we are not password authenticated
@@ -146,7 +125,7 @@ impl<'r> FromRequest<'r> for Auth<ApiToken> {
             });
         }
 
-        Outcome::Error((Status::Unauthorized, CoreError::Unauthorized.into()))
+        CoreError::Unauthorized.into_outcome()
     }
 }
 
@@ -156,25 +135,22 @@ impl<'r> FromRequest<'r> for Auth<PasswordOrBrowser> {
 
     async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self::Error> {
         if request.method() == Method::Get {
-            return Outcome::Error((
-                Status::InternalServerError,
-                CoreError::internal_server_error("Requiring higher authentication on a GET request. This is nonsense").into(),
-            ));
+            return CoreError::internal_server_error("Requiring higher authentication on a GET request. This is nonsense").into_outcome();
         }
 
         // No auth header set, forward to the request handler that doesnt require authorization (if one exists)
         if request.headers().get_one("Authorization").is_none() && request.cookies().get("access_token").is_none() {
             return Outcome::Forward(Status::NotFound);
         }
 
-        let pool = try_state!(request, PointercratePool);
-        let permission_manager = try_state!(request, PermissionsManager).clone();
+        let pool = tryo_state!(request, PointercratePool);
+        let permission_manager = tryo_state!(request, PermissionsManager).clone();
 
-        let mut connection = try_outcome!(pool.transaction().await);
+        let mut connection = tryo_result!(pool.transaction().await);
 
         for authorization in request.headers().get("Authorization") {
             if let ["Basic", basic_auth] = authorization.split(' ').collect::<Vec<_>>()[..] {
-                let decoded = try_outcome!(STANDARD
+                let decoded = tryo_result!(STANDARD
                     .decode(basic_auth)
                     .map_err(|_| ())
                     .and_then(|bytes| String::from_utf8(bytes).map_err(|_| ()))
@@ -185,10 +161,10 @@ impl<'r> FromRequest<'r> for Auth<PasswordOrBrowser> {
                     }));
 
                 if let [username, password] = &decoded.splitn(2, ':').collect::<Vec<_>>()[..] {
-                    let user = try_outcome!(AuthenticatedUser::by_name(username, &mut connection).await);
-                    let authenticated = try_outcome!(user.verify_password(password));
+                    let user = tryo_result!(AuthenticatedUser::by_name(username, &mut connection).await);
+                    let authenticated = tryo_result!(user.verify_password(password));
 
-                    try_outcome!(audit_connection(&mut connection, authenticated.user().id).await);
+                    tryo_result!(audit_connection(&mut connection, authenticated.user().id).await);
 
                     return Outcome::Success(Auth {
                         user: authenticated,
@@ -200,12 +176,12 @@ impl<'r> FromRequest<'r> for Auth<PasswordOrBrowser> {
         }
         // no matching auth header, lets try the cookie
         if let (Some(access_token), Some(csrf_token)) = (request.cookies().get("access_token"), request.headers().get_one("X-CSRF-TOKEN")) {
-            let access_claims = try_outcome!(AccessClaims::decode(access_token.value()));
-            let user = try_outcome!(AuthenticatedUser::by_id(try_outcome!(access_claims.id()), &mut connection).await);
-            let authenticated_for_get = try_outcome!(user.validate_cookie_claims(access_claims));
-            let authenticated = try_outcome!(authenticated_for_get.validate_csrf_token(csrf_token));
+            let access_claims = tryo_result!(AccessClaims::decode(access_token.value()));
+            let user = tryo_result!(AuthenticatedUser::by_id(tryo_result!(access_claims.id()), &mut connection).await);
+            let authenticated_for_get = tryo_result!(user.validate_cookie_claims(access_claims));
+            let authenticated = tryo_result!(authenticated_for_get.validate_csrf_token(csrf_token));
 
-            try_outcome!(audit_connection(&mut connection, authenticated.user().id).await);
+            tryo_result!(audit_connection(&mut connection, authenticated.user().id).await);
 
             return Outcome::Success(Auth {
                 user: authenticated,
@@ -214,6 +190,6 @@ impl<'r> FromRequest<'r> for Auth<PasswordOrBrowser> {
             });
         }
 
-        Outcome::Error((Status::Unauthorized, CoreError::Unauthorized.into()))
+        CoreError::Unauthorized.into_outcome()
     }
 }
