Krys4lide/crates/desktop/src/lib.rs

use axum::body::{to_bytes, Body};
use axum::Router;
use bytes::Bytes;
use http::{request, response, Request, Response};
use std::path::PathBuf;
use std::sync::Arc;
use tauri::path::BaseDirectory;
use tauri::Manager;
use thiserror::Error;
use tokio::sync::{Mutex, MutexGuard};
use tower::{Service, ServiceExt};

#[derive(Error, Debug)]
pub enum DesktopError {
    #[error("Axum error:\n{0}")]
    Axum(#[from] axum::Error),
    #[error("Infallible error")]
    Infallible(#[from] std::convert::Infallible),
}

/// Process requests sent to Tauri (with the `axum://` protocol) and handle them with Axum
/// When an error occurs, this function is expected to panic, which should result in a 500 error
/// being sent to the client, so we let the client handle the error recovering
async fn process_tauri_request(
    tauri_request: Request<Vec<u8>>,
    mut router: MutexGuard<'_, Router>,
) -> Result<Response<Vec<u8>>, DesktopError> {
    let (parts, body): (request::Parts, Vec<u8>) = tauri_request.into_parts();
    let axum_request: Request<Body> = Request::from_parts(parts, body.into());

    let axum_response: Response<Body> = router
        .as_service()
        .ready()
        .await
        .map_err(DesktopError::Infallible)?
        .call(axum_request)
        .await
        .map_err(DesktopError::Infallible)?;

    let (parts, body): (response::Parts, Body) = axum_response.into_parts();
    let body: Bytes = to_bytes(body, usize::MAX).await?;

    let tauri_response: Response<Vec<u8>> = Response::from_parts(parts, body.into());
    Ok(tauri_response)
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .setup(|app| {
            let assets_path: PathBuf = app
                .path()
                .resolve("assets", BaseDirectory::Resource)
                .expect("Assets path should be resolvable");

            // Adds Axum router to application state
            // This makes it so we can retrieve it from any app instance (see bellow)
            let router = Arc::new(Mutex::new(app::get_router(&assets_path)));

            app.manage(router);

            Ok(())
        })
        .register_asynchronous_uri_scheme_protocol("axum", move |app, request, responder| {
            // Retrieve the router from the application state and clone it for the async block
            let router = Arc::clone(&app.state::<Arc<Mutex<axum::Router>>>());

            // Spawn a new async task to process the request
            tauri::async_runtime::spawn(async move {
                let router = router.lock().await;
                match process_tauri_request(request, router).await {
                    Ok(response) => responder.respond(response),
                    Err(err) => {
                        let body = format!("Failed to process an axum:// request:\n{}", err);
                        responder.respond(
                            http::Response::builder()
                                .status(http::StatusCode::BAD_REQUEST)
                                .header(http::header::CONTENT_TYPE, "text/plain")
                                .body::<Vec<u8>>(body.into())
                                .expect("BAD_REQUEST response should be valid"),
                        )
                    }
                }
            });
        })
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}
feat: [desktop] Use thiserror and expect to properly handle errors instead of unwrap 2024-08-14 10:58:09 +02:00			`use axum::body::{to_bytes, Body};`
			`use axum::Router;`
chore: reduce verbosity and propose alternative to named types 2024-07-26 14:06:53 +02:00			`use bytes::Bytes;`
			`use http::{request, response, Request, Response};`
			`use std::path::PathBuf;`
feat: restructure project, implement askama templating 2024-07-23 20:08:45 +02:00			`use std::sync::Arc;`
chore: reduce verbosity and propose alternative to named types 2024-07-26 14:06:53 +02:00			`use tauri::path::BaseDirectory;`
			`use tauri::Manager;`
feat: [desktop] Use thiserror and expect to properly handle errors instead of unwrap 2024-08-14 10:58:09 +02:00			`use thiserror::Error;`
extract protocol logic to external function 2024-07-24 14:21:37 +02:00			`use tokio::sync::{Mutex, MutexGuard};`
feat: restructure project, implement askama templating 2024-07-23 20:08:45 +02:00			`use tower::{Service, ServiceExt};`

feat: [desktop] Use thiserror and expect to properly handle errors instead of unwrap 2024-08-14 10:58:09 +02:00			`#[derive(Error, Debug)]`
			`pub enum DesktopError {`
			`#[error("Axum error:\n{0}")]`
			`Axum(#[from] axum::Error),`
			`#[error("Infallible error")]`
			`Infallible(#[from] std::convert::Infallible),`
			`}`

			/// Process requests sent to Tauri (with the `axum://` protocol) and handle them with Axum
			`/// When an error occurs, this function is expected to panic, which should result in a 500 error`
			`/// being sent to the client, so we let the client handle the error recovering`
extract protocol logic to external function 2024-07-24 14:21:37 +02:00			`async fn process_tauri_request(`
chore: reduce verbosity and propose alternative to named types 2024-07-26 14:06:53 +02:00			`tauri_request: Request<Vec<u8>>,`
			`mut router: MutexGuard<'_, Router>,`
feat: [desktop] Use thiserror and expect to properly handle errors instead of unwrap 2024-08-14 10:58:09 +02:00			`) -> Result<Response<Vec<u8>>, DesktopError> {`
chore: reduce verbosity and propose alternative to named types 2024-07-26 14:06:53 +02:00			`let (parts, body): (request::Parts, Vec<u8>) = tauri_request.into_parts();`
			`let axum_request: Request<Body> = Request::from_parts(parts, body.into());`
fix: revert back to crates dir layout 2024-07-24 11:58:03 +02:00
chore: reduce verbosity and propose alternative to named types 2024-07-26 14:06:53 +02:00			`let axum_response: Response<Body> = router`
chore: Refactor process_tauri_request function for improved readability and error handling 2024-07-24 23:39:27 +02:00			`.as_service()`
chore: run cargo fmt 2024-07-25 09:21:17 +02:00			`.ready()`
			`.await`
feat: [desktop] Use thiserror and expect to properly handle errors instead of unwrap 2024-08-14 10:58:09 +02:00			`.map_err(DesktopError::Infallible)?`
chore: reduce verbosity and propose alternative to named types 2024-07-26 14:06:53 +02:00			`.call(axum_request)`
chore: run cargo fmt 2024-07-25 09:21:17 +02:00			`.await`
feat: [desktop] Use thiserror and expect to properly handle errors instead of unwrap 2024-08-14 10:58:09 +02:00			`.map_err(DesktopError::Infallible)?;`
fix: revert back to crates dir layout 2024-07-24 11:58:03 +02:00
chore: reduce verbosity and propose alternative to named types 2024-07-26 14:06:53 +02:00			`let (parts, body): (response::Parts, Body) = axum_response.into_parts();`
feat: [desktop] Use thiserror and expect to properly handle errors instead of unwrap 2024-08-14 10:58:09 +02:00			`let body: Bytes = to_bytes(body, usize::MAX).await?;`
extract protocol logic to external function 2024-07-24 14:21:37 +02:00
chore: reduce verbosity and propose alternative to named types 2024-07-26 14:06:53 +02:00			`let tauri_response: Response<Vec<u8>> = Response::from_parts(parts, body.into());`
feat: [desktop] Use thiserror and expect to properly handle errors instead of unwrap 2024-08-14 10:58:09 +02:00			`Ok(tauri_response)`
fix: revert back to crates dir layout 2024-07-24 11:58:03 +02:00			`}`

feat: restructure project, implement askama templating 2024-07-23 20:08:45 +02:00			`#[cfg_attr(mobile, tauri::mobile_entry_point)]`
			`pub fn run() {`
			`tauri::Builder::default()`
			`.setup(\|app\| {`
chore: reduce verbosity and propose alternative to named types 2024-07-26 14:06:53 +02:00			`let assets_path: PathBuf = app`
feat: restructure project, implement askama templating 2024-07-23 20:08:45 +02:00			`.path()`
			`.resolve("assets", BaseDirectory::Resource)`
feat: [desktop] Use thiserror and expect to properly handle errors instead of unwrap 2024-08-14 10:58:09 +02:00			`.expect("Assets path should be resolvable");`
feat: restructure project, implement askama templating 2024-07-23 20:08:45 +02:00
chore: reduce verbosity and propose alternative to named types 2024-07-26 14:06:53 +02:00			`// Adds Axum router to application state`
extract protocol logic to external function 2024-07-24 14:21:37 +02:00			`// This makes it so we can retrieve it from any app instance (see bellow)`
chore: reduce verbosity and propose alternative to named types 2024-07-26 14:06:53 +02:00			`let router = Arc::new(Mutex::new(app::get_router(&assets_path)));`

feat: restructure project, implement askama templating 2024-07-23 20:08:45 +02:00			`app.manage(router);`

			`Ok(())`
			`})`
chore: run cargo fmt 2024-07-25 09:21:17 +02:00			`.register_asynchronous_uri_scheme_protocol("axum", move \|app, request, responder\| {`
			`// Retrieve the router from the application state and clone it for the async block`
			`let router = Arc::clone(&app.state::<Arc<Mutex<axum::Router>>>());`
extract protocol logic to external function 2024-07-24 14:21:37 +02:00
chore: run cargo fmt 2024-07-25 09:21:17 +02:00			`// Spawn a new async task to process the request`
			`tauri::async_runtime::spawn(async move {`
			`let router = router.lock().await;`
feat: [desktop] Use thiserror and expect to properly handle errors instead of unwrap 2024-08-14 10:58:09 +02:00			`match process_tauri_request(request, router).await {`
			`Ok(response) => responder.respond(response),`
			`Err(err) => {`
			`let body = format!("Failed to process an axum:// request:\n{}", err);`
			`responder.respond(`
			`http::Response::builder()`
			`.status(http::StatusCode::BAD_REQUEST)`
			`.header(http::header::CONTENT_TYPE, "text/plain")`
			`.body::<Vec<u8>>(body.into())`
			`.expect("BAD_REQUEST response should be valid"),`
			`)`
			`}`
			`}`
chore: run cargo fmt 2024-07-25 09:21:17 +02:00			`});`
			`})`
feat: restructure project, implement askama templating 2024-07-23 20:08:45 +02:00			`.run(tauri::generate_context!())`
			`.expect("error while running tauri application");`
			`}`