khadhroony-bot3/kb-app-demo-desktop/src/tauri.rs

// file: kb-app-demo-desktop/src/tauri.rs
// version: 24

//! Tauri runtime assembly and private command wrappers.

use tauri::Manager; // rust-rules: trait-import

/// Runs the desktop demo application.
#[cfg_attr(mobile, tauri::mobile_entry_point)]
#[allow(clippy::question_mark_used)]
pub fn run() -> kb_core::Result<()> {
    let rustls_result = install_default_rustls_provider();
    if let std::result::Result::Err(error) = rustls_result {
        return std::result::Result::Err(error);
    }
    let app_state = match crate::AppState::initialize() {
        std::result::Result::Ok(state) => state,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    tracing::info!(
        target: crate::TRACING_TARGET,
        config_path = app_state.config_path(),
        active_profile = app_state.active_profile().name.as_str(),
        logging_routes = app_state.logging_route_count(),
        configured_profiles = app_state.app_config().profiles.len(),
        "starting desktop demo application"
    );
    let tracing_builder = tauri_plugin_tracing::Builder::new();
    let mut builder = tauri::Builder::default();
    builder = builder.manage(app_state);
    builder = builder.invoke_handler(tauri::generate_handler![
        demo_backfill_cancel,
        open_demo_backfill_window,
        demo_backfill_options,
        demo_backfill_execute,
        open_demo_core_extraction_window,
        demo_core_extraction_options,
        demo_core_extraction_execute,
        demo_core_extraction_cancel,
        open_demo_decode_replay_window,
        demo_decode_replay_options,
        demo_decode_replay_execute,
        demo_decode_replay_cancel,
        demo_decode_replay_diagnostics,
        demo_decode_replay_annotations,
        open_demo_execution_solana_core_window,
        demo_execution_devnet_prepare_profile,
        demo_execution_solana_core_options,
        demo_execution_solana_core_generate_recipient,
        demo_execution_solana_core_execute,
        demo_execution_spl_memo_execute,
        demo_execution_solana_core_cancel,
        demo_execution_spl_validation_scenarios,
        open_demo_execution_spl_window,
        demo_execution_spl_token_execute,
        demo_spl_token_journal,
        demo_spl_ata_derive,
        demo_execution_spl_ata_execute,
        demo_spl_ata_journal,
        demo_execution_spl_token_2022_execute,
        demo_spl_token_2022_fixture,
        open_demo_config_window,
        load_demo_config,
        emit_frontend_log,
        load_project_readme,
        open_demo_http_window,
        demo_http_list_pool_clients,
        demo_http_options,
        demo_http_execute_request,
        open_demo_sql_diag_window,
        load_demo_sql_diag,
        open_demo_sql_pg_raw_window,
        load_demo_sql_pg_raw,
        open_demo_sql_pg_core_window,
        load_demo_sql_pg_core,
        open_demo_sql_replay_candidates_window,
        export_demo_sql_replay_csv,
        demo_sql_replay_options,
        load_demo_sql_replay_transactions,
        load_demo_sql_replay_programs,
        load_demo_sql_replay_entities,
        open_demo_ws_window,
        demo_ws_list_pool_clients,
        demo_ws_options,
        demo_ws_status,
        demo_ws_connect,
        demo_ws_unsubscribe,
        demo_ws_disconnect,
        splash_frontend_ready,
    ]);
    builder = builder.on_window_event(|window, event| {
        if window.label() != "main" || !matches!(event, tauri::WindowEvent::Destroyed) {
            return;
        }
        let app_handle = window.app_handle().clone();
        tauri::async_runtime::spawn(async move {
            let state = app_handle.state::<crate::AppState>();
            crate::disconnect_demo_ws_app_state(&state, false).await;
        });
    });
    builder = builder.plugin(tracing_builder.build::<tauri::Wry>());
    builder = builder.setup(|app| {
        if app.get_webview_window("splash").is_none() {
            return std::result::Result::Err(std::boxed::Box::new(std::io::Error::new(
                std::io::ErrorKind::NotFound,
                "splash window is missing",
            )));
        }
        if app.get_webview_window("main").is_none() {
            return std::result::Result::Err(std::boxed::Box::new(std::io::Error::new(
                std::io::ErrorKind::NotFound,
                "main window is missing",
            )));
        }
        return std::result::Result::Ok(());
    });
    let run_result = builder.run(tauri::generate_context!());
    return match run_result {
        std::result::Result::Ok(()) => std::result::Result::Ok(()),
        std::result::Result::Err(error) => std::result::Result::Err(kb_core::Error::tauri(
            format!("cannot run desktop demo application: {error:?}"),
        )),
    };
}

fn install_default_rustls_provider() -> kb_core::Result<()> {
    if rustls::crypto::CryptoProvider::get_default().is_some() {
        return std::result::Result::Ok(());
    }
    let provider_result = rustls::crypto::aws_lc_rs::default_provider().install_default();
    return match provider_result {
        std::result::Result::Ok(()) => std::result::Result::Ok(()),
        std::result::Result::Err(error) => std::result::Result::Err(kb_core::Error::invalid_state(
            format!("cannot install default rustls crypto provider: {error:?}"),
        )),
    };
}

fn open_or_focus_demo_window(
    app_handle: tauri::AppHandle,
    label: &str,
    html_path: &str,
    title: &str,
) -> std::result::Result<(), std::string::String> {
    tracing::info!(target: crate::TRACING_TARGET, action = "open_window", window = label, "open demo window");
    if let std::option::Option::Some(window) = app_handle.get_webview_window(label) {
        if let std::result::Result::Err(error) = window.show() {
            return std::result::Result::Err(
                kb_core::Error::tauri(format!("cannot show {label} window: {error}")).to_string(),
            );
        }
        if let std::result::Result::Err(error) = window.set_focus() {
            return std::result::Result::Err(
                kb_core::Error::tauri(format!("cannot focus {label} window: {error}")).to_string(),
            );
        }
        return std::result::Result::Ok(());
    }
    let build_result = tauri::WebviewWindowBuilder::new(
        &app_handle,
        label,
        tauri::WebviewUrl::App(html_path.into()),
    )
    .title(title)
    .inner_size(1500.0, 960.0)
    .min_inner_size(1024.0, 768.0)
    .resizable(true)
    .visible(true)
    .build();
    return match build_result {
        std::result::Result::Ok(window) => match window.set_focus() {
            std::result::Result::Ok(()) => std::result::Result::Ok(()),
            std::result::Result::Err(error) => std::result::Result::Err(
                kb_core::Error::tauri(format!("cannot focus created {label} window: {error}"))
                    .to_string(),
            ),
        },
        std::result::Result::Err(error) => std::result::Result::Err(
            kb_core::Error::tauri(format!("cannot create {label} window: {error}")).to_string(),
        ),
    };
}

#[tauri::command]
fn emit_frontend_log(payload: crate::FrontendLogPayload) {
    return crate::emit_frontend_log(payload);
}

#[tauri::command]
async fn splash_frontend_ready(
    app: tauri::AppHandle,
    window: tauri::WebviewWindow,
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<(), std::string::String> {
    return crate::splash_frontend_ready(app, window, &state).await;
}

#[tauri::command]
fn load_project_readme() -> std::result::Result<std::string::String, std::string::String> {
    return match crate::load_project_readme() {
        std::result::Result::Ok(readme) => std::result::Result::Ok(readme),
        std::result::Result::Err(error) => std::result::Result::Err(error.to_string()),
    };
}

#[tauri::command]
fn open_demo_config_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return open_or_focus_demo_window(
        app_handle,
        "demo_config",
        "demo_config.html",
        "Configuration",
    );
}

#[tauri::command]
fn load_demo_config(state: tauri::State<'_, crate::AppState>) -> crate::DemoConfigPayload {
    return crate::demo_config_payload(state.inner());
}

#[tauri::command]
fn open_demo_backfill_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return open_or_focus_demo_window(
        app_handle,
        "demo_backfill",
        "demo_backfill.html",
        "Backfill HTTP",
    );
}

#[tauri::command]
fn open_demo_http_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return open_or_focus_demo_window(app_handle, "demo_http", "demo_http.html", "HTTP JSON-RPC");
}

#[tauri::command]
fn demo_http_list_pool_clients(
    state: tauri::State<'_, crate::AppState>,
) -> std::vec::Vec<kb_onchain_transport::HttpPoolClientSnapshot> {
    return crate::demo_http_list_pool_clients(state);
}

#[tauri::command]
fn demo_http_options(state: tauri::State<'_, crate::AppState>) -> crate::DemoHttpOptionsPayload {
    return crate::demo_http_options(state);
}

#[tauri::command]
async fn demo_http_execute_request(
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoHttpRequest,
) -> std::result::Result<crate::DemoHttpExecutionPayload, std::string::String> {
    return crate::demo_http_execute_request(state, request).await;
}

#[tauri::command]
fn open_demo_ws_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return open_or_focus_demo_window(app_handle, "demo_ws", "demo_ws.html", "WebSocket standard");
}

#[tauri::command]
fn demo_ws_list_pool_clients(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<
    std::vec::Vec<kb_onchain_transport::WsPoolClientSnapshot>,
    std::string::String,
> {
    return crate::demo_ws_list_pool_clients(state);
}

#[tauri::command]
fn demo_ws_options(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoWsOptionsPayload, std::string::String> {
    return crate::demo_ws_options(state);
}

#[tauri::command]
async fn demo_ws_status(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoWsStatusPayload, std::string::String> {
    return crate::demo_ws_status(state.inner()).await;
}

#[tauri::command]
async fn demo_ws_connect(
    app_handle: tauri::AppHandle,
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoWsRequest,
) -> std::result::Result<crate::DemoWsExecutionPayload, std::string::String> {
    return crate::demo_ws_connect(app_handle, state.inner(), request).await;
}

#[tauri::command]
async fn demo_ws_unsubscribe(
    app_handle: tauri::AppHandle,
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoWsUnsubscribeRequest,
) -> std::result::Result<crate::DemoWsStatusPayload, std::string::String> {
    return crate::demo_ws_unsubscribe(app_handle, state.inner(), request.subscription_id).await;
}

#[tauri::command]
async fn demo_ws_disconnect(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoWsStatusPayload, std::string::String> {
    return crate::demo_ws_disconnect(state.inner()).await;
}

#[tauri::command]
fn demo_backfill_options(
    state: tauri::State<'_, crate::AppState>,
) -> crate::DemoBackfillOptionsPayload {
    return crate::demo_backfill_options(state);
}

#[tauri::command]
async fn demo_backfill_execute(
    app_handle: tauri::AppHandle,
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoBackfillRequest,
) -> std::result::Result<crate::DemoBackfillSummaryPayload, std::string::String> {
    return crate::demo_backfill_execute(app_handle, state, request).await;
}

#[tauri::command]
fn demo_backfill_cancel(state: tauri::State<'_, crate::AppState>) -> bool {
    return crate::demo_backfill_cancel(state);
}

#[tauri::command]
fn open_demo_core_extraction_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return open_or_focus_demo_window(
        app_handle,
        "demo_core_extraction",
        "demo_core_extraction.html",
        "Extraction canonical vers core",
    );
}

#[tauri::command]
fn demo_core_extraction_options(
    state: tauri::State<'_, crate::AppState>,
) -> crate::DemoCoreExtractionOptionsPayload {
    return crate::demo_core_extraction_options_payload(&state);
}

#[tauri::command]
async fn demo_core_extraction_execute(
    app_handle: tauri::AppHandle,
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoCoreExtractionRequest,
) -> std::result::Result<crate::DemoCoreExtractionSummaryPayload, std::string::String> {
    return crate::demo_core_extraction_execute(app_handle, &state, request).await;
}

#[tauri::command]
fn demo_core_extraction_cancel(state: tauri::State<'_, crate::AppState>) -> bool {
    return crate::demo_core_extraction_cancel(&state);
}

#[tauri::command]
fn open_demo_decode_replay_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return open_or_focus_demo_window(
        app_handle,
        "demo_decode_replay",
        "demo_decode_replay.html",
        "Décodage et matérialisation",
    );
}

#[tauri::command]
fn demo_decode_replay_options(
    state: tauri::State<'_, crate::AppState>,
) -> crate::DemoDecodeReplayOptionsPayload {
    return crate::demo_decode_replay_options(state);
}

#[tauri::command]
async fn demo_decode_replay_execute(
    app_handle: tauri::AppHandle,
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoDecodeReplayRequest,
) -> std::result::Result<crate::DemoDecodeReplaySummaryPayload, std::string::String> {
    return crate::demo_decode_replay_execute(app_handle, state, request).await;
}

#[tauri::command]
fn demo_decode_replay_cancel(state: tauri::State<'_, crate::AppState>) -> bool {
    return crate::demo_decode_replay_cancel(state);
}

#[tauri::command]
async fn demo_decode_replay_diagnostics(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoDecodeDiagnosticsPayload, std::string::String> {
    return crate::demo_decode_replay_diagnostics(state).await;
}

#[tauri::command]
async fn demo_decode_replay_annotations(
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoTransactionAnnotationRequest,
) -> std::result::Result<std::vec::Vec<crate::DemoTransactionAnnotationRow>, std::string::String> {
    return crate::demo_decode_replay_annotations(state, request).await;
}

#[tauri::command]
fn open_demo_sql_diag_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return open_or_focus_demo_window(
        app_handle,
        "demo_sql_diag",
        "demo_sql_diag.html",
        "SQL diagnostics",
    );
}

#[tauri::command]
async fn load_demo_sql_diag(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoSqlDiagPayload, std::string::String> {
    return crate::load_demo_sql_diag(state).await;
}

#[tauri::command]
fn open_demo_sql_pg_raw_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return open_or_focus_demo_window(
        app_handle,
        "demo_sql_pg_raw",
        "demo_sql_pg_raw.html",
        "PostgreSQL canonical acquisition",
    );
}

#[tauri::command]
async fn load_demo_sql_pg_raw(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoSqlPgRawPayload, std::string::String> {
    return crate::load_demo_sql_pg_raw(state).await;
}

#[tauri::command]
fn open_demo_sql_pg_core_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return open_or_focus_demo_window(
        app_handle,
        "demo_sql_pg_core",
        "demo_sql_pg_core.html",
        "PostgreSQL core store",
    );
}

#[tauri::command]
async fn load_demo_sql_pg_core(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoSqlPgCorePayload, std::string::String> {
    return crate::load_demo_sql_pg_core(state).await;
}

#[tauri::command]
fn open_demo_sql_replay_candidates_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return open_or_focus_demo_window(
        app_handle,
        "demo_sql_replay_candidates",
        "demo_sql_replay_candidates.html",
        "SQL replay candidates",
    );
}

#[tauri::command]
async fn export_demo_sql_replay_csv(
    file_name: std::string::String,
    content: std::string::String,
) -> std::result::Result<std::string::String, std::string::String> {
    return crate::export_demo_sql_replay_csv(file_name, content).await;
}

#[tauri::command]
async fn demo_sql_replay_options(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoSqlReplayOptionsPayload, std::string::String> {
    return crate::demo_sql_replay_options(state).await;
}

#[tauri::command]
async fn load_demo_sql_replay_transactions(
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoSqlReplayTransactionRequest,
) -> std::result::Result<std::vec::Vec<crate::DemoSqlReplayTransactionRow>, std::string::String> {
    return crate::load_demo_sql_replay_transactions(state, request).await;
}

#[tauri::command]
async fn load_demo_sql_replay_programs(
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoSqlReplayProgramRequest,
) -> std::result::Result<std::vec::Vec<crate::DemoSqlReplayProgramRow>, std::string::String> {
    return crate::load_demo_sql_replay_programs(state, request).await;
}

#[tauri::command]
async fn load_demo_sql_replay_entities(
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoSqlReplayEntityRequest,
) -> std::result::Result<std::vec::Vec<crate::DemoSqlReplayEntityRow>, std::string::String> {
    return crate::load_demo_sql_replay_entities(state, request).await;
}

#[tauri::command]
fn open_demo_execution_solana_core_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return open_or_focus_demo_window(
        app_handle,
        "demo_execution_solana_core",
        "demo_execution_solana_core.html",
        "Exécution Solana Devnet",
    );
}

#[tauri::command]
async fn demo_execution_devnet_prepare_profile(
    state: tauri::State<'_, crate::AppState>,
    profile_name: std::string::String,
) -> std::result::Result<crate::DemoExecutionDevnetStoreReadinessPayload, std::string::String> {
    return crate::demo_execution_devnet_prepare_profile(state, profile_name).await;
}

#[tauri::command]
fn demo_execution_solana_core_options(
    state: tauri::State<'_, crate::AppState>,
) -> crate::DemoExecutionSolanaCoreOptionsPayload {
    return crate::demo_execution_solana_core_options(state);
}

#[tauri::command]
fn demo_execution_solana_core_generate_recipient()
-> std::result::Result<crate::DemoExecutionSolanaCoreGeneratedRecipientPayload, std::string::String>
{
    return crate::demo_execution_solana_core_generate_recipient();
}

#[tauri::command]
async fn demo_execution_solana_core_execute(
    app_handle: tauri::AppHandle,
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoExecutionSolanaCoreRequest,
) -> std::result::Result<crate::DemoExecutionSolanaCoreSummaryPayload, std::string::String> {
    return crate::demo_execution_solana_core_execute(app_handle, state, request).await;
}

#[tauri::command]
async fn demo_execution_spl_memo_execute(
    app_handle: tauri::AppHandle,
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoExecutionMemoRequest,
) -> std::result::Result<crate::DemoExecutionMemoSummaryPayload, std::string::String> {
    return crate::demo_execution_spl_memo_execute(app_handle, state, request).await;
}

#[tauri::command]
fn demo_execution_solana_core_cancel(state: tauri::State<'_, crate::AppState>) -> bool {
    return crate::demo_execution_solana_core_cancel(state);
}

#[tauri::command]
fn demo_execution_spl_validation_scenarios()
-> std::vec::Vec<crate::DevnetSplValidationScenarioPayload> {
    return crate::demo_execution_spl_validation_scenarios();
}

#[tauri::command]
fn open_demo_execution_spl_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return open_or_focus_demo_window(
        app_handle,
        "demo_execution_spl",
        "demo_execution_spl.html",
        "Exécution SPL Devnet",
    );
}

#[tauri::command]
async fn demo_execution_spl_token_execute(
    app_handle: tauri::AppHandle,
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoExecutionSplTokenRequest,
) -> std::result::Result<crate::DemoExecutionSplTokenSummaryPayload, std::string::String> {
    return crate::demo_execution_spl_token_execute(app_handle, state, request).await;
}

#[tauri::command]
async fn demo_spl_token_journal(
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoSplTokenJournalRequest,
) -> std::result::Result<std::vec::Vec<crate::DemoSplTokenJournalRow>, std::string::String> {
    return crate::demo_spl_token_journal(state, request).await;
}

#[tauri::command]
async fn demo_spl_ata_derive(
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoSplAtaDerivationRequest,
) -> std::result::Result<crate::DemoSplAtaDerivationPayload, std::string::String> {
    return crate::demo_spl_ata_derive(state, request).await;
}

#[tauri::command]
async fn demo_execution_spl_ata_execute(
    app_handle: tauri::AppHandle,
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoExecutionSplAtaRequest,
) -> std::result::Result<crate::DemoExecutionSplAtaSummaryPayload, std::string::String> {
    return crate::demo_execution_spl_ata_execute(app_handle, state, request).await;
}

#[tauri::command]
async fn demo_spl_ata_journal(
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoSplAtaJournalRequest,
) -> std::result::Result<std::vec::Vec<crate::DemoSplAtaJournalRow>, std::string::String> {
    return crate::demo_spl_ata_journal(state, request).await;
}

#[tauri::command]
async fn demo_execution_spl_token_2022_execute(
    app_handle: tauri::AppHandle,
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoExecutionSplToken2022Request,
) -> std::result::Result<crate::DemoExecutionSplToken2022SummaryPayload, std::string::String> {
    return crate::demo_execution_spl_token_2022_execute(app_handle, state, request).await;
}

#[tauri::command]
fn demo_spl_token_2022_fixture(
    state: tauri::State<'_, crate::AppState>,
    profile_name: std::string::String,
) -> std::result::Result<crate::DemoSplToken2022FixturePayload, std::string::String> {
    return crate::demo_spl_token_2022_fixture(state, profile_name);
}