Non-exposed/serialized argument in #[command]

[smolck]

This is kind of hard to explain in a short sentence, so apologies if the title isn't very descriptive.

Basically, I'd like to make something like this work:

#[command]
fn command_one(js_arg: i32, ...) {
    println!("Just a normal command.");
}

#[command]
fn command_two(argument_js_cant_pass: &T, other_args_js_can_pass: V) {
}

fn main() {
  let some_value_some_commands_want: T = ...;
  tauri::Builder::default()
      .invoke_handler(tauri::generate_handler![command_one, command_two])
      .run(tauri::generate_context!())
      .expect("error while running tauri application");
}

Where command_two is called with &some_value_some_commands_want as the first argument, and the rest from the JS side when calling invoke('command_two', ...).

I think this could theoretically be done with a custom invoke_handler, but tauri::hooks::InvokeError is private/inaccessible and I think I might need that, as I already tried writing a macro_rules version of generate_handler tailored to my usecase, but trying to make it work with async functions it seems I need to access InvokeError (I can elaborate on why this is the case if necessary, for brevity's sake I'll leave that out here).

Overall though, implementing my own version of generate_handler feels really wrong. The other alternative is some sort of global variable, but that's not really idiomatic Rust and feels wrong/overcomplicated as well.

If a change were to be made in Tauri to facilitate the above (if it's not already possible), it would perhaps take some extra attr to #[command]? Then have some sort of .with_state(...) function or something on a tauri::Builder which, coupled with #[command(with_state)] would enable the above functionality that I want. Unless, of course, this is already possible in some way that I'm just unaware of.

As an aside, I poked around a relevant issue/PR or two and it seems #[command(with_manager)] was a thing at some point/is a thing, and it's kind of what I have in mind, but I don't know if that could be used here since the documentation is nonexistent as far as I can tell. My guess then is that this was perhaps removed at some point?

In any case, some help here would really be appreciated, as I'm not really sure how to continue/if I can continue until I have a solution to this.

Thanks in advance!

[FabianLars]

What about using state?
See: https://tauri.studio/en/docs/guides/command/#accessing-managed-state
And: https://github.com/tauri-apps/tauri/tree/dev/examples/state
And while we're at it this one too: https://github.com/tauri-apps/tauri/tree/dev/examples/commands

As you suggested a use_state thingy yourself I think that's exactly what you'd want?

[smolck]

Yes, thank you for the links! I had just found .manage from rust-analyzer's autocomplete right before you replied haha, looks like I should've looked harder before posting this; somehow I missed that part of the guide(s)/examples!