aerro 0.2.1

Cross-service gRPC error framework for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

//! `#[derive(aerro::AerroHandler)]` — typed RPC handler that converts errors to `tonic::Status`.
//!
//! Define a unit struct, derive `AerroHandler` with service metadata, then implement
//! `Handler` with the actual logic. Calling `call_tonic` wraps the typed error into a
//! `tonic::Status` with an inline frame and the correct exposure redaction applied.

#![cfg(feature = "macro")]

use aerro::{AerroHandler, Handler, ServiceFailure, StatusIntoResultExt};

#[derive(Debug, aerro::Aerro)]
pub enum CreateUser {
    #[aerro(
        category = Business,
        code = AlreadyExists,
        error = "email already taken: {email}"
    )]
    EmailTaken { email: String },

    #[aerro(category = System, code = Internal)]
    Db,
}

#[derive(aerro::AerroHandler)]
#[aerro(service = "users", rpc = "create_user", exposure = Public, max_frames = 4)]
struct CreateUserHandler;

impl Handler for CreateUserHandler {
    type Request = String;
    type Response = String;
    type Error = CreateUser;

    async fn handle(&self, email: String) -> Result<String, CreateUser> {
        if email == "taken@example.com" {
            Err(CreateUser::EmailTaken { email })
        } else {
            Ok(format!("created user with email {email}"))
        }
    }
}

#[tokio::main]
async fn main() {
    println!(
        "handler metadata: service={} rpc={} exposure={:?} max_frames={}",
        CreateUserHandler::SERVICE,
        CreateUserHandler::RPC,
        CreateUserHandler::EXPOSURE,
        CreateUserHandler::MAX_FRAMES,
    );

    // Happy path — call_tonic passes the Ok value through unchanged.
    let ok = CreateUserHandler
        .call_tonic("alice@example.com".into())
        .await
        .unwrap();
    println!("ok: {ok}");

    // Error path — typed error is encoded into tonic::Status with a call frame.
    let status = CreateUserHandler
        .call_tonic("taken@example.com".into())
        .await
        .unwrap_err();
    println!(
        "error status: code={:?} message={:?}",
        status.code(),
        status.message()
    );

    // The client side can recover the typed error back out.
    let sf: ServiceFailure<CreateUser> = status.into_aerro::<CreateUser>().unwrap();
    match sf.into_inner() {
        CreateUser::EmailTaken { email } => println!("recovered: email={email}"),
        CreateUser::Db => unreachable!(),
    }
}