How to split tauri handlers registration properly?

[erikpa1]

Hi, I plan a liitle bit bigger logic on rust side, than javascript side, and I'm asking, how to split my code?

Every example I saw on github is having really big main.rs file, where everything is written, but I want to split my code to multiple modules. But when I do it tauri, don't register the handlers.

I have:

fn create_tauri_app() -> Builder<Wry> {
    let mut tApp = tauri::Builder::default();
    tApp = handlers::register_handlers(tApp);
    return tApp;
}


fn main() {
    create_tauri_app()
        .plugin(tauri_plugin_window_state::Builder::default()
            .build())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

and then

main.rs

mod projects;
mod licences;

pub fn register_handlers(mut app: Builder<Wry>) -> Builder<Wry> {
    let mut app = licences::register_licence_handlers(app);
    app = projects::register_projects_handlers(app);

    return app;
}

**/handlers/mod.rs**

and finaly:

/handlers/licences.rs

pub fn register_licence_handlers(mut app: Builder<Wry>) -> Builder<Wry> {
    return app.invoke_handler(tauri::generate_handler![
        licence_get_hardware_id,
        licenses_is_valid,
        licenses_list_usb
    ]);
}

After printl, my code reach every function. But functions are not registered:

localhost/:1      
       Uncaught (in promise) command licenses_list_usb not found

[erikpa1]

Ok, I found 1 solution for this:

pub fn get_handlers() -> Box<dyn Fn(tauri::Invoke<tauri::Wry>) + Send + Sync> {
    Box::new(tauri::generate_handler![
        licence_get_hardware_id,
        licenses_is_valid,
        licenses_list_usb
    ])
}

with:
tApp.invoke_handler(handlers::licences::get_handlers())
for main.rs.

But this one still don't answer my question, why the my previous design don't work, and raises second question, there is some macro or something for this ? Box<dyn Fn(tauri::Invoke<tauri::Wry>) + Send + Sync> because from my view (as api user) this is type of code people are copying, not writing it :D :D. Like c'mon, we can't have 52 characters long return type (we were supposed to kill c++ not join it :D ).

[FabianLars]

why the my previous design don't work

Because you can call app.invoke_handler only once. Every subsequent call will overwrite the prior ones. Because of this i'm not sure if your Box stuff actually fixed this 🤔

... Box<dyn Fn(tauri::Invoke<tauri::Wry>) + Send + Sync> ...

Well, you could specify a type in your main.rs or lib.rs file and use that instead, but this type really isn't supposed to be used by many people - only the generate_handler! macro which i guess is better than that return type

Like c'mon, we can't have 52 characters long return type

New to Rust? :P types can get pretty wild at times

---

A possible solution to splitting up invoke handlers is using plugins https://tauri.app/v1/guides/features/plugin - each plugin has its own invoke_handler. This way you could also have fancy stuff like private state, and with the plugin-name: prefix you could have multiple commands with the same name 🤷

[erikpa1]

@FabianLars Thanks for your answer, I will try plugins approach :)