Return errors to Dart

[poborin]

What would be the best approach to return errors back to dart? So far I'm thinking that creating a protobuf message with an enum is the only available option e.g.

syntax = "proto3";

// [DART-SIGNAL]
message MyMessage {}

// [RUST-SIGNAL]
message MyMessageResult {
    oneof result {
       string message = 1;         // Contains a message if the Rust code was successful
       Error error = 2;            // returns an error if the Rust code fails
    }
}

// Your implementation of an error. It might include a call stack, or an error code etc. 
message Error {
    string message = 1;            // Human-readable explanation of the error
}

[temeddix]

As stated in the documentation, Rinf expects developers to use Flutter exclusively for the UI layer, while keeping all business logic in Rust. This approach encourages handling errors and logging directly in Rust.

Personally, I use the anyhow and tracing crates for these purposes.

[poborin]

Let's assume an authentication case:

From rust I'm making an API call to authenticate a user. There might be multiple errors:

1. HTTP
   a. 404 user doesn't exist or incorrect password
   b. 500 server issues
2. No network
3. rust punic
   etc.

I need to notify a user that authentication failed with a hint how to mitigate a problem: check a network connection, try again later, check username/password etc.

Moreover, as an application will be internationalised, I want to pass some error code or error id, so I can display a message in the locale language.

How would you do it?

[temeddix]

// [RUST-SIGNAL]
// Your implementation of an error.
// It might include a call stack, or an error code etc. 
message ErrorNotify {
    string message = 1; // Human-readable explanation of the error
    int32 error_code = 2;
}

I think this message type is a good idea in general. However I use this error message independently with [RUST-SIGNAL], not by including it inside another message, when I write my app.

Also I recommend you not to write panicking code at all, since Rust have idiomatic Result<T, E>. Also, Rust cannot catch panics on the web platform(wasm32-unknown-unknown), making all callers wait forever.

The function signature of your intent would look like this:

async fn make_http_request() -> Result<MyResponse, anyhow::Error> {
    // ...
}

Then, I would define a trait used on Result like this:

use std::fmt::Debug;

// Define the Report trait
pub trait Report<T, E: Debug> {
    fn report(self);
}

// Implement the Report trait for Result<T, anyhow::Error>
impl<T> Report<T> for Result<T, anyhow::Error> {
    fn report(self) {
        match self {
            Ok(value) => (),
            Err(err) => {
                ErrorNotify {
                    message: "Custom message".into(),
                    error_code: 25,
                }
                .send_signal_to_dart()
            }
        }
    }
}

Then from the caller:

use crate::module_where_report_was_declared::Report;

async fn do_work() {
    let result = make_http_request().await;
    result.report();
}

You will almost always use the .report(), because Rust automatically warns you about unused Results.

[temeddix]

Perhaps I should add this information to the docs, if the explanation was clear enough. Please tell me the missing pieces, if any :)

[poborin]

I like this Idea!