Error handling refactor and 500 page/message templates

src/routes.rs

@@ -20,18 +20,50 @@ use reqwest::StatusCode;
 pub use subscriptions::*;
 pub use subscriptions_confirm::*;
 
-use crate::templates::MessageTemplate;
+use crate::{
+    authentication::AuthError,
+    templates::{InternalErrorTemplate, MessageTemplate},
+};
 
 #[derive(thiserror::Error)]
 pub enum AppError {
     #[error("An unexpected error was encountered.")]
-    UnexpectedError(#[from] anyhow::Error),
+    UnexpectedError {
+        #[source]
+        error: anyhow::Error,
+        full_page: bool,
+    },
     #[error("A validation error happened.")]
-    ValidationError(#[source] anyhow::Error),
-    #[error("An authentication is required.")]
+    FormError(#[source] anyhow::Error),
+    #[error("Authentication is required.")]
     NotAuthenticated,
 }
 
+impl From<anyhow::Error> for AppError {
+    fn from(value: anyhow::Error) -> Self {
+        Self::UnexpectedError {
+            error: value,
+            full_page: false,
+        }
+    }
+}
+
+impl AppError {
+    pub fn unexpected_page(error: anyhow::Error) -> Self {
+        Self::UnexpectedError {
+            error,
+            full_page: true,
+        }
+    }
+
+    pub fn unexpected_message(error: anyhow::Error) -> Self {
+        Self::UnexpectedError {
+            error,
+            full_page: false,
+        }
+    }
+}
+
 impl std::fmt::Debug for AppError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         error_chain_fmt(self, f)
@@ -43,13 +75,21 @@ impl IntoResponse for AppError {
         tracing::error!("{:?}", self);
 
         match &self {
-            AppError::UnexpectedError(_) => {
-                let template = MessageTemplate::Error {
-                    message: "An internal server error occured.".into(),
+            AppError::UnexpectedError {
+                error: _,
+                full_page,
+            } => {
+                let html = if *full_page {
+                    Html(InternalErrorTemplate.render().unwrap())
+                } else {
+                    let template = MessageTemplate::Error {
+                        message: "An internal server error occured.".into(),
+                    };
+                    Html(template.render().unwrap())
                 };
-                Html(template.render().unwrap()).into_response()
+                (StatusCode::INTERNAL_SERVER_ERROR, html).into_response()
             }
-            AppError::ValidationError(error) => {
+            AppError::FormError(error) => {
                 let template = MessageTemplate::Error {
                     message: error.to_string(),
                 };
@@ -58,7 +98,7 @@ impl IntoResponse for AppError {
             AppError::NotAuthenticated => {
                 let mut headers = HeaderMap::new();
                 headers.insert("HX-Redirect", "/login".parse().unwrap());
-                (StatusCode::UNAUTHORIZED, headers).into_response()
+                (StatusCode::OK, headers).into_response()
             }
         }
     }
@@ -67,11 +107,25 @@ impl IntoResponse for AppError {
 impl From<AdminError> for AppError {
     fn from(value: AdminError) -> Self {
         match value {
-            AdminError::UnexpectedError(error) => AppError::UnexpectedError(error),
+            AdminError::UnexpectedError(error) => AppError::unexpected_message(error),
             AdminError::NotAuthenticated => AppError::NotAuthenticated,
-            AdminError::ChangePassword(s) => AppError::ValidationError(anyhow::anyhow!(s)),
-            AdminError::Publish(e) => AppError::ValidationError(e),
-            AdminError::Idempotency(s) => AppError::UnexpectedError(anyhow::anyhow!(s)),
+            AdminError::ChangePassword(s) => AppError::FormError(anyhow::anyhow!(s)),
+            AdminError::Publish(e) => AppError::FormError(e),
+            AdminError::Idempotency(s) => AppError::UnexpectedError {
+                error: anyhow::anyhow!(s),
+                full_page: false,
+            },
+        }
+    }
+}
+
+impl From<AuthError> for AppError {
+    fn from(value: AuthError) -> Self {
+        match value {
+            AuthError::UnexpectedError(error) => AppError::unexpected_message(error),
+            AuthError::InvalidCredentials(error) => {
+                AppError::FormError(error.context("Invalid credentials."))
+            }
         }
     }
 }