Help with async fetch

[mlafeldt]

Hey, I've implemented a very basic/hacky version of fetch that looks like this:

pub fn fetch(_this: &JsValue, args: &[JsValue], ctx: &mut Context<'_>) -> JsResult<JsValue> {
    let url = args
        .get(0)
        .ok_or_else(|| JsNativeError::typ().with_message("fetch: URL required"))?
        .as_string()
        .ok_or_else(|| JsNativeError::typ().with_message("fetch: URL must be a string"))?
        .to_std_string_escaped();

    let data = futures::executor::block_on(async {
        reqwest::Client::builder()
            .user_agent(env!("CARGO_PKG_NAME"))
            .build()
            .expect("building the client should not fail")
            .get(&url)
            .send()
            .await?
            .error_for_status()?
            .json()
            .await
    })
    .map_err(|e| JsNativeError::error().with_message(e.to_string()))?;

    let json = JsValue::from_json(&data, ctx)?;

    let obj = ObjectInitializer::new(ctx)
        .function(
            unsafe { NativeFunction::from_closure(move |_, _, _| Ok(json.clone())) },
            "json",
            0,
        )
        .build();

    let promise = JsPromise::new(
        |resolvers, context| {
            resolvers
                .resolve
                .call(&JsValue::undefined(), &[obj.into()], context)?;
            Ok(JsValue::undefined())
        },
        ctx,
    )?;

    Ok(promise.into())
}

After registering the function via

ctx.register_global_callable("fetch", 0, NativeFunction::from_fn_ptr(Fetch::fetch))`

I'm able to run JS code like this, which is awesome:

const json = await fetch("https://example.com").then(r => r.json());

However, using block_on isn't ideal, and I'd like to convert the code to be fully async. Something along the lines of:

pub async fn fetch(
    _this: &JsValue,
    args: &[JsValue],
    ctx: &mut Context<'_>,
) -> JsResult<JsValue> {
    let url = args
        .get(0)
        .ok_or_else(|| JsNativeError::typ().with_message("fetch: URL required"))?
        .as_string()
        .ok_or_else(|| JsNativeError::typ().with_message("fetch: URL must be a string"))?
        .to_std_string_escaped();

    let data = reqwest::Client::builder()
        .user_agent(env!("CARGO_PKG_NAME"))
        .build()
        .expect("building the client should not fail")
        .get(&url)
        .send()
        .and_then(|r| r.json())
        .await
        .map_err(|e| JsNativeError::error().with_message(e.to_string()))?;

    let json = JsValue::from_json(&data, ctx)?;

    let obj = ObjectInitializer::new(ctx)
        .function(
            unsafe { NativeFunction::from_closure(move |_, _, _| Ok(json.clone())) },
            "json",
            0,
        )
        .build();

    Ok(obj.into())
}

I've been trying to pass that function to NativeFunction::from_async_fn, which converts the returned object to a promise, but I couldn't figure out the right lifetimes since the future has to be static.

There's only a single example of from_async_fn in the repo, and I was wondering if you could point me in the right direction. "It's not possible right now" is also a valid answer. 😃

[jedel1043]

Yeah, the main problem here is that you need to use the &mut Context reference after awaiting, which catches the mutable reference and makes the whole future not static. Fortunately, we added an escape hatch to the async API where you can de-sugar the utility function into its internal representation as a future job, which removes this limitation with the downside of some increased verbosity:

boa/boa_engine/src/object/builtins/jspromise.rs

Lines 287 to 303 in 1e10f07

	let (promise, resolvers) = Self::new_pending(context);
	let future = async move {
	let result = future.await;
	NativeJob::new(move |context| match result {
	Ok(v) => resolvers.resolve.call(&JsValue::undefined(), &[v], context),
	Err(e) => {
	let e = e.to_opaque(context);
	resolvers.reject.call(&JsValue::undefined(), &[e], context)
	}
	})
	};
	context
	.job_queue()
	.enqueue_future_job(Box::pin(future), context);

Just substitute let result = future.await with your specific async operations and put let json = JsValue::from_json(&data, ctx)?; inside the job closure. Something like:

let future = async move {
    let data = async_reqwest().await;
    
    NativeJob::new(move |context| match JsValue::from_json(&data, context) { 
         Ok(v) => resolvers.resolve.call(&JsValue::undefined(), &[v], context), 
         Err(e) => { 
             let e = e.to_opaque(context); 
             resolvers.reject.call(&JsValue::undefined(), &[e], context) 
         } 
     }) 
}

[jedel1043]

Hopefully when/if async coroutines + transient lifetimes arrive to Rust we'll be able to make this easier to use. It would be cool to make it so that you just have to do something like:

let gen = async move |context|
    let data = async_reqwest().await;
    let context = yield; // `context` is passed as a resume argument to the async generator
    JsValue::from_json(&data, context)
}

[mlafeldt]

Just substitute let result = future.await with your specific async operations and put let json = JsValue::from_json(&data, ctx)?; inside the job closure. Something like:

let future = async move {
    let data = async_reqwest().await;
    
    NativeJob::new(move |context| match JsValue::from_json(&data, context) { 
         Ok(v) => resolvers.resolve.call(&JsValue::undefined(), &[v], context), 
         Err(e) => { 
             let e = e.to_opaque(context); 
             resolvers.reject.call(&JsValue::undefined(), &[e], context) 
         } 
     }) 
}

Thanks. That definitely helped. Unfortunately, fetch is pretty complicated in that it returns a promise, and json() and text() return promises too. I hacked together something that seems to work, though all async work needs to happen outside of NativeJob::new(move |...|), which is really tricky with the way reqwest::get works (I had to download the body immediately as bytes and then cloned it for json and text, which converted the data accordingly).