Most elegant way of returning from a threadsafe function?

[m1212e]

I'm trying to run a threadsafe function. Calling works fine, but I don't get how I can recieve a return value. If I understand this correctly, I need a callback which gets called inside JS with the return value. So basically:

async function add(params) {
    return {result: /*some calculations*/}
}

async function add_callback(params, callback) {
    const result = await add(...params)
    callback(result)
}

But how would this look on the rust side of things?

let tsf = add_callback.create_threadsafe_function(
  0,
  |ctx: napi::threadsafe_function::ThreadSafeCallContext<(Vec<u16>, Box<dyn Fn(JsObject)>)>| {
    let args = ctx
      .value.0
      .iter()
      .map(|v| ctx.env.to_js_value(v))
      .collect::<Result<Vec<JsNumber>, napi::Error>>()?;

      callback = // somehow create a JsFunction which passes the object to the dyn Fn

      return (args, callback);
  },
).unwrap()

        tsf.call(
          (
            someInputParameters,
            Box::new(|result| {
              println!("result: {:#?}", result);
            }),
          ),
          napi::threadsafe_function::ThreadsafeFunctionCallMode::Blocking,
        );

[Brooooooklyn]

See here #1307

[m1212e]

Ahh I see, thanks a lot. Are you planning on merging it?

[amitrana22]

hi @m1212e , I'm in kind of same situation and newbie with napi-rs. can you please share any working example for it.

[Brooooooklyn]

See https://github.com/napi-rs/napi-rs/blob/main/examples/napi/src/threadsafe_function.rs#L145 for example

[amitrana22]

its very helpful, thank you.

[amitrana22]

hi @Brooooooklyn , need some more help in this.
I'm able to pass value from Rust to JS and making calucations there using following code. But how I can retrieve value at Rust side which is returing after JS side calcualtions.

`let tsfn: ThreadsafeFunction<String, ErrorStrategy::CalleeHandled> = js_func
.create_threadsafe_function(0, |ctx| {
ctx.env.create_string_from_std(ctx.value).map(|v| vec![v])
})
.unwrap();

let tsfn = tsfn.clone();
tsfn.call(
Ok("Return value from Rust to JS".to_string()),
ThreadsafeFunctionCallMode::Blocking,
);`

[Brooooooklyn]

use call_async or call_with_return_value

[amitrana22]

hi @Brooooooklyn please take a look in following code and help me please.
I've used both ways you mentioned, I able to get value back from JS but not able to get value outside rust closure.
I'm sure I'm doing something wrong here.

    let mut store_somehow_here: String = "Default".to_string();
    let pass_value_to_js = "FROM RUST";
    // Option 1
    async {
      let value = func
        .call_async::<Promise<String>>(Ok(pass_value_to_js.to_string()))
        .await
        .unwrap()
        .await
        .unwrap();

      // store_somehow_here = value
    };

    // Option 2
    func.call_with_return_value(
      Ok(pass_value_to_js.to_string()),
      ThreadsafeFunctionCallMode::NonBlocking,
      |value: String| {
        // store_somehow_here = value
        println!("From JS {:?}", value);
        Ok(())
      },
    );

    println!("Use updated value here :: {:?}", store_somehow_here);`

[alshdavid]

I'm also new to napi-rs and am having trouble with this.

I want to return a value to Rust from an async call

const napi = require('./index.node')

napi.myCallback((value, resolve) => {
  console.log(value)
  resolve(42)
})

I have tried to copy the code exactly from the linked example: https://github.com/napi-rs/napi-rs/blob/main/examples/napi/src/threadsafe_function.rs#L145

use std::{thread, time::Duration};

#[macro_use]
extern crate napi_derive;

use napi::{
  bindgen_prelude::*,
  threadsafe_function::{ThreadsafeFunction, ThreadsafeFunctionCallMode, UnknownReturnValue},
  JsString,
};

#[napi]
pub async fn tsfn_return_promise_timeout(
  func: ThreadsafeFunction<u32, Promise<u32>>,
) -> Result<u32> {
  use tokio::time::{self, Duration};
  let promise = func.call_async(Ok(1)).await?;
  let sleep = time::sleep(Duration::from_nanos(1));
  tokio::select! {
    _ = sleep => {
      Err(Error::new(Status::GenericFailure, "Timeout".to_owned()))
    }
    value = promise => {
      Ok(value? + 2)
    }
  }
}

[dependencies]
# Default enable napi4 feature, see https://nodejs.org/api/n-api.html#node-api-version-matrix
napi = { version = "2.12.2", default-features = false, features = ["napi4", "tokio_full", "async", "full"] }
napi-derive = "2.12.2"
tokio = { version = "1.37.0", features = ["full"] }

[build-dependencies]
napi-build = "2.0.1"

However I get the following errors:

the trait bound `napi::bindgen_prelude::Promise<u32>: napi::threadsafe_function::ErrorStrategy::ErrorStrategy` is not satisfied
the following other types implement trait `napi::threadsafe_function::ErrorStrategy::ErrorStrategy`:
  CalleeHandled
  Fatalrustc[Click for full compiler diagnostic](rust-analyzer-diagnostics-view:/diagnostic%20message%20%5B7%5D?7#file%3A%2F%2F%2Fhome%2Fdalsh%2FDevelopment%2Falshdavid%2Fmach%2Fmach-nodejs%2Fsrc%2Flib.rs)
threadsafe_function.rs(236, 47): required by a bound in `ThreadsafeFunction`

and

no method named `call_async` found for struct `ThreadsafeFunction<u32, napi::bindgen_prelude::Promise<u32>>` in the current scope
the method was found for
- `ThreadsafeFunction<T>`
- `ThreadsafeFunction<T, Fatal>`

Is the example up to date or am I missing something?

[Brooooooklyn]

@alshdavid the codes in the examples are for the napi@3.0.0-alpha.2, you can upgrade your napi to make the examples work or you can find v2 examples here: https://github.com/napi-rs/napi-rs/tree/napi2/examples/napi

[alshdavid]

I'm curious, why is the first argument in the threadsafe function call null?

#[napi]
pub fn ping(env: Env, func: JsFunction) -> napi::Result<napi::JsUndefined> {
  let tsfunc: ThreadsafeFunction<i32, ErrorStrategy::CalleeHandled>  = env.create_threadsafe_function(
    &func, 
    0,
    |env| Ok(vec![env.value])
  )?;

  thread::spawn(move || {
    tsfunc.call(Ok(42), ThreadsafeFunctionCallMode::NonBlocking);
  });

  env.get_undefined()
}

const napi = require('./index')

napi.ping((...args) => {
  console.log(args)
})

Output:

[ null, 42 ]

[Brooooooklyn]

https://napi.rs/docs/concepts/threadsafe-function#errorstrategycalleehandled