Secure Command

Add native authority through a command only when you can validate inputs and explain the permission boundary.

Rust Command

use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct ReadProjectRequest {
    project_id: String,
}

#[derive(Serialize)]
struct ReadProjectResponse {
    title: String,
}

#[tauri::command]
fn read_project(input: ReadProjectRequest) -> Result<ReadProjectResponse, String> {
    if !input.project_id.chars().all(|ch| ch.is_ascii_alphanumeric() || ch == '_') {
        return Err("invalid project id".into());
    }

    Ok(ReadProjectResponse {
        title: "Example".into(),
    })
}

Frontend Wrapper

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

type ReadProjectResponse = {
  title: string;
};

export function readProject(projectId: string) {
  return invoke<ReadProjectResponse>("read_project", { input: { project_id: projectId } });
}

Test With Mocked IPC

import { beforeEach, expect, test, vi } from "vitest";
import { mockIPC } from "@tauri-apps/api/mocks";
import { readProject } from "./tauri-api";

beforeEach(() => {
  vi.clearAllMocks();
});

test("calls the read_project command", async () => {
  mockIPC((cmd, args) => {
    expect(cmd).toBe("read_project");
    expect(args).toEqual({ input: { project_id: "demo_1" } });
    return { title: "Demo" };
  });

  await expect(readProject("demo_1")).resolves.toEqual({ title: "Demo" });
});

Review

Command name registered?
Input validated in Rust?
Frontend wrapper tested?
Error shape handled by UI?
Capability reviewed?
No filesystem, shell, or network access added accidentally?