Awaiting a JsUnknown promise?

[m1212e]

I'm trying to serialize the value behind a JsUnknown.
How do I await the promise in case the JsUnknown is one?

        let response = if response.is_promise()? {
          unsafe {
            let prm: Promise<JsUnknown> = Promise::from_napi_value(ctx.env.raw(), response.raw())?;

            // blocks forever
            tokio::runtime::Runtime::new()?.block_on(prm)?
            
            // *mut napi_env__` cannot be sent between threads safely
            // within `JsUnknown`, the trait `Send` is not implemented for `*mut napi_env__
            let res = ctx.env.execute_tokio_future(
              prm,
              |&mut env, data| Ok(data)
            );
          }
        } else {
          response
        };

After reading #1128 I could not pull it off.

EDIT: see #1337 (reply in thread) for the solution

[m1212e]

A small update on this: Since I was running block_on on the node thread, the promise never could resolve, because the thread was blocked. I still could not manage to run the await via execute_tokio_future since JsUnknown is not send.

[m1212e]

SO: The actual problem I have is, that I want to serialize the JsUnknown, which is the result of the promise, in an async context. Since JsUnknown isn't Send I'll have to figure out how to make that work.

[m1212e]

I'll take a look at that, thanks. Can I use those to get a JSON string representation of the unknown?
This is bascially what I want to do:

unsafe {
            let prm: Promise<JsUnknown> = Promise::from_napi_value(ctx.env.raw(), response.raw())?;

            ctx.env.execute_tokio_future(
              async move {
                let res = prm.await?;
              
               // this doesnt work because ctx isnt Send
                let response: serde_json::Value = ctx.env.from_js_value(response)?;
                let response = serde_json::to_string(&response)?;
                match ctx.value.1.send(response) {
                  Ok(_) => {}
                  Err(_) => eprintln!("Could not send on oneshot"),
                };

                Ok(())
              },
              |_, _| Ok(()),
            )?;
          }

[Brooooooklyn]

How about

let prm: Promise<String> = Promise::from_napi_value(ctx.env.raw(), response.raw())?;

[m1212e]

This results in an error:

node:internal/process/promises:279
            triggerUncaughtException(err, true /* fromPromise */);
            ^

[Error: Failed to convert napi `string` into rust type `String`] {
  code: 'StringExpected'
}

This only works if the unknown is actually a JS String. Response could be anything. Could be a JsObject, Array or string.

[m1212e]

Also this does not return valid JSON

[m1212e]

Well, I do feel IMMENSELY stupid but this is what I needed all the time:
let prm: Promise<serde_json::Value> = Promise::from_napi_value(ctx.env.raw(), response.raw())?;
Whole snippet now looks like this:

          unsafe {
            let prm: Promise<serde_json::Value> = Promise::from_napi_value(ctx.env.raw(), response.raw())?;
            let response_channel = response_channel.clone();
            ctx.env.execute_tokio_future(
              async move {
                let result = prm.await?;
                match response_channel.send(serde_json::to_string(&result)?).await {
                  Ok(_) => {}
                  Err(err) => eprintln!("Could not send on return channel: {err}"),
                };
                Ok(())
              },
              |_, _| Ok(()),
            )?;
          }

Typical case of: I worked so much on this that I lost the view for the actual goal. Now I finally can sleep again.
Thank you so much for your time @Brooooooklyn !