refactor: change asset handling

read assets from the template state instead of path to be able to embed
them into the binary instead of reading them form a path

src/error.rs

@@ -6,7 +6,7 @@ use tracing::debug;
 
 pub type Result<T> = std::result::Result<T, Error>;
 
-pub type ResultTemplate = std::result::Result<Html<String>, Error>;
+pub type ResultTemplate = Result<Html<String>>;
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
@@ -33,15 +33,35 @@ pub enum Error {
 
     #[error(transparent)]
     Config(#[from] figment::Error),
+
+    #[error("")]
+    HTTP(StatusCode),
+}
+
+impl From<StatusCode> for Error {
+    fn from(value: StatusCode) -> Self {
+        Self::HTTP(value)
+    }
 }
 
 impl IntoResponse for Error {
     fn into_response(self) -> axum::response::Response {
+        let catch_all = (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "An unexpected error has ocurred!",
+        );
         let (status, message) = match self {
-            _ => (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                "An unexpected error has ocurred!",
-            ),
+            Error::Template(ref error) => {
+                if let minijinja::ErrorKind::TemplateNotFound = error.kind() {
+                    (
+                        StatusCode::NOT_FOUND,
+                        "The requested resource was not found.",
+                    )
+                } else {
+                    catch_all
+                }
+            }
+            _ => catch_all,
         };
 
         debug!(error = ?self);

src/router.rs

@@ -1,17 +1,39 @@
-use axum::{extract::State, response::Html, routing::get, Router};
+use axum::{
+    extract::{Path, State},
+    http::{header, HeaderMap, HeaderValue},
+    response::Html,
+    routing::get,
+    Router,
+};
 use axum_htmx::HxRequest;
 use chrono::Utc;
 use minijinja::context;
 use serde::Serialize;
 use sqlx::prelude::FromRow;
-use tower_http::services::ServeDir;
 
-use crate::{AppState, ResultTemplate, Tx};
+use crate::{AppState, Result, ResultTemplate, Tx};
 
 pub fn new() -> Router<AppState> {
     Router::new()
         .route("/", get(handler_home))
-        .nest_service("/assets", ServeDir::new("dist/assets"))
+        .route("/assets/{*asset}", get(handle_assets))
+}
+
+async fn handle_assets(
+    State(state): State<AppState>,
+    Path(asset): Path<String>,
+) -> Result<(HeaderMap, String)> {
+    let mut headers = HeaderMap::new();
+
+    let mime = mime_guess::from_path(&asset).first_raw();
+
+    if let Some(mime) = mime {
+        headers.insert(header::CONTENT_TYPE, HeaderValue::from_static(mime));
+    }
+
+    let template = state.tmpl_env.get_template(&format!("assets/{}", asset))?;
+
+    Ok((headers, template.render(context!())?))
 }
 
 #[derive(FromRow, Debug, Serialize)]