remove stale dependency oxide-auth-axum

src/web/Cargo.toml

@@ -36,7 +36,6 @@ serde.workspace = true
 url.workspace = true
 percent-encoding.workspace = true
 oxide-auth.workspace = true
-oxide-auth-axum.workspace = true
 
 [lints]
 workspace = true

src/web/oidc.rs

@@ -7,11 +7,13 @@ use crate::{
 
 mod authorize;
 mod consent;
+mod error;
 mod login;
 mod response;
 mod request;
 pub use authorize::AuthorizationQuery;
 pub use consent::oidc_consent_form;
+pub use error::OidcError;
 pub use login::{LoginQuery, LoginError, oidc_login_form};
 pub use request::OidcRequest;
 pub use response::OidcResponse;

src/web/oidc/error.rs

@@ -0,0 +1,80 @@
+use super::OidcRequest;
+use axum::{
+    http::{header::InvalidHeaderValue, StatusCode},
+    response::{IntoResponse, Response},
+};
+use oxide_auth::frontends::{dev::OAuthError, simple::endpoint::Error};
+
+#[derive(Debug)]
+/// The error type for Oxide Auth operations
+pub enum OidcError {
+    /// Errors occuring in Endpoint operations
+    Endpoint(OAuthError),
+    /// Errors occuring in Endpoint operations
+    Header(InvalidHeaderValue),
+    /// Errors with the request encoding
+    Encoding,
+    /// Request body could not be parsed as a form
+    Form,
+    /// Request query was absent or could not be parsed
+    Query,
+    /// Request query was absent or could not be parsed
+    Body,
+    /// The Authorization header was invalid
+    Authorization,
+    /// General internal server error
+    InternalError(Option<String>),
+}
+
+impl std::fmt::Display for OidcError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match *self {
+            OidcError::Endpoint(ref e) => write!(f, "Endpoint, {}", e),
+            OidcError::Header(ref e) => write!(f, "Couldn't set header, {}", e),
+            OidcError::Encoding => write!(f, "Error decoding request"),
+            OidcError::Form => write!(f, "Request is not a form"),
+            OidcError::Query => write!(f, "No query present"),
+            OidcError::Body => write!(f, "No body present"),
+            OidcError::Authorization => write!(f, "Request has invalid Authorization headers"),
+            OidcError::InternalError(None) => write!(f, "An internal server error occured"),
+            OidcError::InternalError(Some(ref e)) => write!(f, "An internal server error occured: {}", e),
+        }
+    }
+}
+
+impl std::error::Error for OidcError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            OidcError::Endpoint(ref e) => e.source(),
+            OidcError::Header(ref e) => e.source(),
+            _ => None,
+        }
+    }
+}
+
+impl IntoResponse for OidcError {
+    fn into_response(self) -> Response {
+        (StatusCode::INTERNAL_SERVER_ERROR, self.to_string()).into_response()
+    }
+}
+
+impl From<Error<OidcRequest>> for OidcError {
+    fn from(e: Error<OidcRequest>) -> Self {
+        match e {
+            Error::Web(e) => e,
+            Error::OAuth(e) => e.into(),
+        }
+    }
+}
+
+impl From<OAuthError> for OidcError {
+    fn from(e: OAuthError) -> Self {
+        OidcError::Endpoint(e)
+    }
+}
+
+impl From<InvalidHeaderValue> for OidcError {
+    fn from(e: InvalidHeaderValue) -> Self {
+        Self::Header(e)
+    }
+}

src/web/oidc/request.rs

@@ -1,6 +1,5 @@
-use super::OidcResponse;
+use super::{OidcError, OidcResponse};
 use oxide_auth::endpoint::{NormalizedParameter, QueryParameter, WebRequest};
-use oxide_auth_axum::WebError;
 use async_trait::async_trait;
 use axum::{
 	extract::{Form, FromRequest, FromRequestParts, Query, Request},
@@ -45,21 +44,21 @@ impl OidcRequest {
 }
 
 impl WebRequest for OidcRequest {
-    type Error = WebError;
+    type Error = OidcError;
     type Response = OidcResponse;
 
     fn query(&mut self) -> Result<Cow<'_, dyn QueryParameter + 'static>, Self::Error> {
         self.query
             .as_ref()
             .map(|q| Cow::Borrowed(q as &dyn QueryParameter))
-            .ok_or(WebError::Query)
+            .ok_or(OidcError::Query)
     }
 
     fn urlbody(&mut self) -> Result<Cow<'_, dyn QueryParameter + 'static>, Self::Error> {
         self.body
             .as_ref()
             .map(|b| Cow::Borrowed(b as &dyn QueryParameter))
-            .ok_or(WebError::Body)
+            .ok_or(OidcError::Body)
     }
 
     fn authheader(&mut self) -> Result<Option<Cow<'_, str>>, Self::Error> {
@@ -72,14 +71,14 @@ impl<S> FromRequest<S> for OidcRequest
 where
     S: Send + Sync,
 {
-    type Rejection = WebError;
+    type Rejection = OidcError;
 
     async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
         let mut all_auth = req.headers().get_all(header::AUTHORIZATION).iter();
         let optional = all_auth.next();
 
         let auth = if all_auth.next().is_some() {
-            return Err(WebError::Authorization);
+            return Err(OidcError::Authorization);
         } else {
             optional.and_then(|hv| hv.to_str().ok().map(str::to_owned))
         };

src/web/oidc/response.rs

@@ -1,14 +1,11 @@
-use super::{OidcRequest, oidc_consent_form};
-
-use crate::oidc::LoginQuery;
+use super::{oidc_consent_form, LoginQuery, OidcError, OidcRequest};
 use oxide_auth::{
 	endpoint::{OwnerConsent, OwnerSolicitor, Solicitation, WebRequest, WebResponse},
 	frontends::simple::request::{Body as OAuthRequestBody, Status},
 };
-use oxide_auth_axum::WebError;
 use axum::{
 	body::Body,
-    http::{Response, header},
+    http::{header, Response},
 	response::IntoResponse,
 };
 use url::Url;
@@ -26,7 +23,7 @@ pub struct OidcResponse {
 
 impl OidcResponse {
 	/// Instanciate from a response body. Used to send login or consent forms.
-	pub fn from_body(body: &str) -> Result<Self, WebError> {
+	pub fn from_body(body: &str) -> Result<Self, OidcError> {
 		let mut result = OidcResponse::default();
 		result.body_text(body)?;
 
@@ -50,22 +47,16 @@ impl IntoResponse for OidcResponse {
 	}
 }
 
+/// OidcResponse uses [super::oidc_consent_form] to be turned into an owner
+/// consent solicitation.
 impl OwnerSolicitor<OidcRequest> for OidcResponse {
 	fn check_consent(
 		&mut self,
 		request: &mut OidcRequest,
 		_: Solicitation<'_>,
 	) -> OwnerConsent<<OidcRequest as WebRequest>::Response> {
-		//let hostname = self.location.map(|l| l.as_str()).unwrap_or("Continuwuity");
+		// TODO find a way to pass the hostname to the template.
 		let hostname = "Continuwuity";
-		/*
-		let hostname = request
-			.query()
-			.expect("query in OAuth request")
-			.unique_value("hostname")
-			.expect("hostname in OAuth request")
-			.as_str();
-		*/
 		let query: LoginQuery = request
 			.clone()
 			.try_into()
@@ -79,7 +70,7 @@ impl OwnerSolicitor<OidcRequest> for OidcResponse {
 }
 
 impl WebResponse for OidcResponse {
-	type Error = WebError;
+	type Error = OidcError;
 
 	fn ok(&mut self) -> Result<(), Self::Error> {
 		self.status = Status::Ok;