Make more enum types accept unknown values

crates/handlers/src/oauth2/authorization/callback.rs

@@ -41,12 +41,15 @@ pub struct CallbackDestination {
 }
 
 #[derive(Debug, Error)]
-pub enum InvalidRedirectUriError {
+pub enum IntoCallbackDestinationError {
     #[error("Redirect URI can't have a fragment")]
-    FragmentNotAllowed,
+    RedirectUriFragmentNotAllowed,
 
     #[error("Existing query parameters are not valid")]
-    InvalidQueryParams(#[from] serde_urlencoded::de::Error),
+    RedirectUriInvalidQueryParams(#[from] serde_urlencoded::de::Error),
+
+    #[error("Requested response_mode is not supported")]
+    UnsupportedResponseMode,
 }
 
 #[derive(Debug, Error)]
@@ -59,11 +62,11 @@ pub enum CallbackDestinationError {
 }
 
 impl<S: StorageBackend> TryFrom<&AuthorizationGrant<S>> for CallbackDestination {
-    type Error = InvalidRedirectUriError;
+    type Error = IntoCallbackDestinationError;
 
     fn try_from(value: &AuthorizationGrant<S>) -> Result<Self, Self::Error> {
         Self::try_new(
-            value.response_mode,
+            &value.response_mode,
             value.redirect_uri.clone(),
             value.state.clone(),
         )
@@ -72,12 +75,12 @@ impl<S: StorageBackend> TryFrom<&AuthorizationGrant<S>> for CallbackDestination
 
 impl CallbackDestination {
     pub fn try_new(
-        mode: ResponseMode,
+        mode: &ResponseMode,
         mut redirect_uri: Url,
         state: Option<String>,
-    ) -> Result<Self, InvalidRedirectUriError> {
+    ) -> Result<Self, IntoCallbackDestinationError> {
         if redirect_uri.fragment().is_some() {
-            return Err(InvalidRedirectUriError::FragmentNotAllowed);
+            return Err(IntoCallbackDestinationError::RedirectUriFragmentNotAllowed);
         }
 
         let mode = match mode {
@@ -95,6 +98,7 @@ impl CallbackDestination {
             }
             ResponseMode::Fragment => CallbackDestinationMode::Fragment,
             ResponseMode::FormPost => CallbackDestinationMode::FormPost,
+            _ => return Err(IntoCallbackDestinationError::UnsupportedResponseMode),
         };
 
         Ok(Self {

crates/handlers/src/oauth2/authorization/complete.rs

@@ -39,7 +39,9 @@ use oauth2_types::requests::{AccessTokenResponse, AuthorizationResponse};
 use sqlx::{PgPool, Postgres, Transaction};
 use thiserror::Error;
 
-use super::callback::{CallbackDestination, CallbackDestinationError, InvalidRedirectUriError};
+use super::callback::{
+    CallbackDestination, CallbackDestinationError, IntoCallbackDestinationError,
+};
 
 #[derive(Debug, Error)]
 pub enum RouteError {
@@ -90,8 +92,8 @@ impl From<ActiveSessionLookupError> for RouteError {
     }
 }
 
-impl From<InvalidRedirectUriError> for RouteError {
-    fn from(e: InvalidRedirectUriError) -> Self {
+impl From<IntoCallbackDestinationError> for RouteError {
+    fn from(e: IntoCallbackDestinationError) -> Self {
         Self::Internal(Box::new(e))
     }
 }
@@ -175,8 +177,8 @@ impl From<sqlx::Error> for GrantCompletionError {
     }
 }
 
-impl From<InvalidRedirectUriError> for GrantCompletionError {
-    fn from(e: InvalidRedirectUriError) -> Self {
+impl From<IntoCallbackDestinationError> for GrantCompletionError {
+    fn from(e: IntoCallbackDestinationError) -> Self {
         Self::Internal(Box::new(e))
     }
 }

crates/handlers/src/oauth2/authorization/mod.rs

@@ -58,8 +58,8 @@ pub enum RouteError {
     #[error("could not find client")]
     ClientNotFound,
 
-    #[error("invalid redirect uri")]
-    InvalidRedirectUri(#[from] self::callback::InvalidRedirectUriError),
+    #[error("invalid parameters")]
+    IntoCallbackDestination(#[from] self::callback::IntoCallbackDestinationError),
 
     #[error("invalid redirect uri")]
     UnknownRedirectUri(#[from] mas_data_model::InvalidRedirectUriError),
@@ -78,11 +78,9 @@ impl IntoResponse for RouteError {
             RouteError::ClientNotFound => {
                 (StatusCode::BAD_REQUEST, "could not find client").into_response()
             }
-            RouteError::InvalidRedirectUri(e) => (
-                StatusCode::BAD_REQUEST,
-                format!("Invalid redirect URI ({})", e),
-            )
-                .into_response(),
+            RouteError::IntoCallbackDestination(e) => {
+                (StatusCode::BAD_REQUEST, e.to_string()).into_response()
+            }
             RouteError::UnknownRedirectUri(e) => (
                 StatusCode::BAD_REQUEST,
                 format!("Invalid redirect URI ({})", e),
@@ -175,7 +173,7 @@ pub(crate) async fn get(
 
     // Now we have a proper callback destination to go to on error
     let callback_destination = CallbackDestination::try_new(
-        response_mode,
+        &response_mode,
         redirect_uri.clone(),
         params.auth.state.clone(),
     )?;