How to get the result of JavaScript execution in the test_javascript async method?

[o0x1024]

How to get the result of JavaScript execution in the test_javascript async method?

async function search() { 
  try {
      const uu ='https://example.com' 
      const res = await fetch_get(uu);
      return res
  } catch (error) {
        console.log(error)
  }
}

(async () => {
    return await search();
})();

fn fetch_get(
    _this: &JsValue,
    args: &[JsValue],
    context: &mut Context,
) -> impl Future<Output = JsResult<JsValue>> {
    let client = reqwest::Client::new();
    let url = args
        .get_or_undefined(0)
        .to_string(context)
        .unwrap()
        .to_std_string()
        .unwrap();

    async move {
        // tokio::time::sleep(Duration::from_secs(2)).await;
        let response = client.get(url).send().await.unwrap();
        let status = response.status();
        println!("rust response status :{}",status);
        Ok(JsValue::new(js_string!(status.to_string())))
    }
}

#[tauri::command]
pub fn test_javascript(script: String) -> Result<String, String> {
    let mut context = Context::default();
    let console = Console::init(&mut context);

    context
        .register_global_property(js_string!(Console::NAME), console, Attribute::all())
        .expect("the console object shouldn't exist yet");
    context
        .register_global_builtin_callable(
            js_string!("fetch_get"),
            1,
            NativeFunction::from_async_fn(fetch_get),
        )
        .expect("the sleep builtin shouldn't exist yet");

    match context.eval(Source::from_bytes(&script)) {
        Ok(res) => {
            println!(
                "rust eval:{}",
                res.to_string(&mut context).unwrap().to_std_string_escaped()
            );
            Ok(res.to_string(&mut context).unwrap().to_std_string_escaped())
        }
        Err(e) => {
            // Pretty print the error
            eprintln!("Uncaught {e}");
            Err(e.to_string())
        }
    }
}

result is

rust response status :200 OK
rust eval:[object Promise]

should be. is rust eval:200 OK

[jamesthurley]

Roughly, first you need to specify a job executor when creating the context:

let mut context = ContextBuilder::new()
    .job_executor(executor)
    .build().unwrap()

Then after running your script you need to run the async jobs to completion:

context
    .run_jobs_async()
    .await
    .unwrap();

Or use context.run_jobs() if not in an async runtime.

There are examples of implementing an executor here (not in an async runtime) and here (using tokio). You can probably just copy-paste them.

Note this is using the latest on main at time of writing, which is different from v0.20. In v0.20 it used a JobQueue like here. I'm not sure if the other steps differ (I vaguely recall you may have to call .job_queue(..) instead of .job_executor(..) when creating the context, for example).

Finally you can look at the promise result, something like:

    let maybe_promise = res.as_promise();
    match maybe_promise {
        Some(promise) => match promise.state() {
            PromiseState::Pending => panic!("Promise is still pending"),
            PromiseState::Fulfilled(result) => Ok(result), // Do something with JsValue
            PromiseState::Rejected(error) => Err(e.to_string()),
        },
        None => Ok(res),
    }

I'm just figuring this stuff out myself, so take the advice with a grain of salt.