Getting the result of promises

[mlafeldt]

Hey, how can I figure out that the following code throws an exception?

let code = r#"
    (async () => {
        throw new Error("boom")
    })()
"#;

let mut ctx = Context::default();

match ctx.eval(Source::from_bytes(code)) {
    Ok(res) => {
        ctx.run_jobs();
        println!("Result: {res:?}"); // Result: Object((Promise) 0x153F3E0C8)
    }
    Err(e) => {
        println!("Error: {e}");
    }
}

run_jobs is handy in that promises get fulfilled/rejected, but right now it's not clear to me how to access the state of promises.

[HalidOdat]

We can use the JsPromise::from_object() static method for this after extracting the object from the JsValue result, then use the JsPromise::state() method to get the state of the promise enum PromiseState

The JsPromise::from_object() doc, has a good example :)

Adjusted to the given code, it would look something like this:

let code = r#"
    (async () => {
        throw new Error("boom")
    })()
"#;

let mut ctx = Context::default();

match ctx.eval(Source::from_bytes(code)) {
    Ok(res) => {
        ctx.run_jobs();
        let promise = res.as_object().cloned().unwrap();
        
        let promise = JsPromise::from_object(promise)?;
        
        assert!(promise.state()?.as_rejected().is_some());
    }
    Err(e) => {
        println!("Error: {e}");
    }
}

[mlafeldt]

@HalidOdat Thank you! That works like a charm for scripts. 🚀

Now I only need to figure out how to do the same with modules.

let module = Module::parse(Source::from_bytes(code), None, &mut self.ctx)?;
let promise = module.load_link_evaluate(&mut self.ctx)?;
self.ctx.run_jobs();

match promise.state().expect("promise always has a state") {
    PromiseState::Fulfilled(val) => {
        debug!("Module execution successful: {val:?}");
        Ok(...)
    }
    PromiseState::Rejected(reason) => {
        let err = JsError::from_opaque(reason);
        error!("Module execution failed: {err}");
        Err(err
            .try_native(&mut self.ctx)
            .map(|e| e.into())
            .unwrap_or(err))
    }
    PromiseState::Pending => {
        error!("Module execution pending");
        Err(JsNativeError::error()
            .with_message("Module execution pending")
            .into())
    }
}

AFAIK, modules return undefined if they're successfully evaluated. That means the promise's state doesn't tell me anything about the promise used inside the code. Can I still access it somehow?

[HalidOdat]

Yes, it can be accessed! We just need to export it:

export default (async () => {
    throw new Error("boom")
})()

// ...or named

export const promise = (async () => {
    throw new Error("boom")
})()

Then we can access it by getting the namespace object.

let value = module.namespace(&mut context).get("default", &mut context)?;
// ... or named
let value = module.namespace(&mut context).get("promise", &mut context)?;

The value is a JsValue so we need to use JsPromise::from_object() like the script :)

[mlafeldt]

Perfect. Thanks a lot!