[tauri::command]

fn open_file(path: String) -> Result { if !std::path::Path::new(&path).exists() { return Err(AppError::FileNotFound(path)); } let content = std::fs::read_to_string(&path)?; Ok(content) }

Structured Error Responses use serde::Serialize;

[derive(Debug, Serialize)]

struct ErrorResponse { code: String, message: String }

[tauri::command]

fn validate_input(input: String) -> Result { if input.is_empty() { return Err(ErrorResponse { code: "EMPTY_INPUT".into(), message: "Input cannot be empty".into(), }); } Ok(input.to_uppercase()) }

interface ErrorResponse { code: string; message: string; }

try { const result = await invoke('validate_input', { input: '' }); } catch (error) { const err = error as ErrorResponse; console.error(Error ${err.code}: ${err.message}); }

Async Commands Defining Async Commands

Use the async keyword:

[tauri::command]

async fn fetch_data(url: String) -> Result { let response = reqwest::get(&url).await.map_err(|e| e.to_string())?; let body = response.text().await.map_err(|e| e.to_string())?; Ok(body) }

Async with Borrowed Types Limitation

Async commands cannot use borrowed types like &str directly:

// Will NOT compile: // async fn bad_command(value: &str) -> String { ... }

// Use owned types instead:

[tauri::command]

async fn good_command(value: String) -> String { some_async_operation(&value).await; value }

// Or wrap in Result as workaround:

[tauri::command]

async fn with_borrowed(value: &str) -> Result { some_async_operation(value).await; Ok(value.to_string()) }

Frontend Invocation

Async commands work identically to sync since invoke returns a Promise:

const result = await invoke('fetch_data', { url: 'https://api.example.com/data' });

Accessing Tauri Internals WebviewWindow, AppHandle, and State use std::sync::Mutex;

struct AppState { counter: Mutex }

[tauri::command]

async fn get_window_label(window: tauri::WebviewWindow) -> String { window.label().to_string() }

[tauri::command]

async fn get_app_version(app: tauri::AppHandle) -> String { app.package_info().version.to_string() }

[tauri::command]

fn increment_counter(state: tauri::State) -> i32 { let mut counter = state.counter.lock().unwrap(); counter += 1; counter }

pub fn run() { tauri::Builder::default() .manage(AppState { counter: Mutex::new(0) }) .invoke_handler(tauri::generate_handler![ get_window_label, get_app_version, increment_counter ]) .run(tauri::generate_context!()) .expect("error while running tauri application") }

Advanced Features Raw Request Access

Access headers and raw body:

use tauri::ipc::{Request, InvokeBody};

[tauri::command]

fn upload(request: Request) -> Result { let InvokeBody::Raw(data) = request.body() else { return Err("Expected raw body".into()); }; let auth = request.headers() .get("Authorization") .and_then(|v| v.to_str().ok()) .ok_or("Missing Authorization header")?; Ok(format!("Received {} bytes", data.len())) }

const data = new Uint8Array([1, 2, 3, 4, 5]); await invoke('upload', data, { headers: { Authorization: 'Bearer token123' } });

Channels for Streaming use tauri::ipc::Channel; use tokio::io::AsyncReadExt;

[tauri::command]

async fn stream_file(path: String, channel: Channel>) -> Result<(), String> { let mut file = tokio::fs::File::open(&path).await.map_err(|e| e.to_string())?; let mut buffer = vec![0u8; 4096]; loop { let len = file.read(&mut buffer).await.map_err(|e| e.to_string())?; if len == 0 { break; } channel.send(buffer[..len].to_vec()).map_err(|e| e.to_string())?; } Ok(()) }

import { Channel } from '@tauri-apps/api/core';

const channel = new Channel(); channel.onmessage = (chunk) => console.log('Received:', chunk.length, 'bytes'); await invoke('stream_file', { path: '/path/to/file', channel });

Organizing Commands in Modules // src-tauri/src/commands/user.rs use serde::{Deserialize, Serialize};

[derive(Deserialize)]

pub struct CreateUserRequest { pub name: String, pub email: String }

[derive(Serialize)]

pub struct User { pub id: u32, pub name: String, pub email: String }

[tauri::command]

pub fn create_user(request: CreateUserRequest) -> User { User { id: 1, name: request.name, email: request.email } }

// src-tauri/src/commands/mod.rs pub mod user;

// src-tauri/src/lib.rs mod commands;

pub fn run() { tauri::Builder::default() .invoke_handler(tauri::generate_handler![commands::user::create_user]) .run(tauri::generate_context!()) .expect("error while running tauri application") }

TypeScript Type Safety

Create a typed wrapper:

import { invoke } from '@tauri-apps/api/core';

export interface User { id: number; name: string; email: string; } export interface CreateUserRequest { name: string; email: string; }

export const commands = { createUser: (request: CreateUserRequest): Promise => invoke('create_user', { request }), greet: (name: string): Promise => invoke('greet', { name }), };

// Usage const user = await commands.createUser({ name: 'Bob', email: 'bob@example.com' });

Quick Reference Task Rust JavaScript Define command #[tauri::command] fn name() {} - Register command tauri::generate_handler![name] - Invoke command - await invoke('name', { args }) Return value -> T where T: Serialize const result = await invoke(...) Return error -> Result try/catch Async command async fn name() Same as sync Access window window: tauri::WebviewWindow - Access app app: tauri::AppHandle - Access state state: tauri::State - Key Constraints Command names must be unique across the entire application Commands in lib.rs cannot be pub (use modules for organization) All commands must be registered in a single generate_handler! call Async commands cannot use borrowed types like &str directly Arguments must implement Deserialize, return types must implement Serialize