Seeking better error handling for multiple Resources/Signals #2784

osmano807 · 2024-08-06T14:09:15Z

osmano807
Aug 6, 2024

I'm currently using a custom SignalResult enum to handle multiple signals in my Leptos application. While it works, I'm wondering if there's a more idiomatic or efficient way to achieve this. Here's a simplified version of my current approach:

let res_id: Memo<Result<ResId, AppError>> = fetch_res_id_param();
let res: Resource<Result<Resource, AppError>> = fetch_res(res_id().unwrap());
let other_res_id: Memo<Result<OtherResId, AppError>> = fetch_other_res_id_param();
let other_res: Resource<Result<OtherResource, AppError>> = fetch_other_res(other_res_id().unwrap());

view! {
    <Suspense>
        {move || {
            let validate = SignalResult::from_result(res.get())
                .combine(SignalResult::from_option_result(other_res.get()));
            match validate {
                SignalResult::Ok(hlist_pat!(res, other_res)) => {
                    EitherOf3::A(
                        view! {
                           <p>Res: {res.inner}</p>
                           <p>OtherRes: {other_res.inner}</p>
                        },
                    )
                }
                SignalResult::Err(errors) => EitherOf3::B(view! { <ErrorReporter errors /> }),
                SignalResult::Loading => EitherOf3::C(view! { <p>"Loading..."<p> }),
            }
        }}
    </Suspense>
}

enum SignalResult<T>
where
    T: frunk::HList, // Heterogenous list, so that we can handle different Ok values
{
    Loading,
    Ok(T),
    Err(Vec<AppError>),
}

This approach allows me to handle loading states, errors, and successful data fetching for multiple signals. However, I'm concerned about:

Complexity: Is this over-engineered for what should be a common use case?
Performance: Are there any performance implications I should be aware of?
Maintainability: As the number of signals grows, this pattern might become unwieldy. Also I couldn't make this work directly with From<Option<Result<T, E>>> as it was conflicting with From<Option<T>>

Are there any built-in Leptos features or community patterns that could simplify this error handling while maintaining the ability to show loading states and aggregate errors from multiple signals?

Any insights or alternative approaches would be greatly appreciated!