How to correctly handle exceptions in op2 asynchronous functions?

[Think-M]

I try to return an exception through the following code:

#[op2(async)]
#[buffer]
pub async fn op_my_send(
    state: Rc<RefCell<OpState>>,
    #[buffer] data: JsBuffer,
) -> Result<Vec<u8>, deno_error::JsErrorBox> {
    ...

    let result = match msg_type.as_str() {
        "sum" => {
            handle_sum(json_data, bin_data).await;
            return Err(deno_error::JsErrorBox::new(
                "buffer Error",
                "buffer Error",
            ));
        }
        ...

The js reported an error:

TypeError: invalid_argument
    at captureStackTrace (<anonymous>)
    at ext:core/00_infra.js:148:9
    at eventLoopTick (ext:core/01_core.js:178:7)

When normal data is returned, there is no problem

[Anipaleja]

Hi @Think-M,

From your snippet and the error (TypeError: invalid_argument), it looks like the way the error is constructed or returned in your op_my_send async op might not be fully aligned with how Deno expects errors to be propagated from Rust to JavaScript.

Here are some pointers to handle exceptions properly in #[op2(async)] functions:

Return a proper Rust error type that converts into JS error
The return type Result<Vec<u8>, deno_error::JsErrorBox> is fine, but creating the error needs to be done carefully. Instead of manually calling JsErrorBox::new with two string arguments, you might want to use JsErrorBox::from or return a standard Rust error that implements std::error::Error and let Deno convert it automatically.

Avoid returning error after await without handling result
Your handle_sum(json_data, bin_data).await; call ignores the result. If it returns a Result, handle it properly — either propagate errors with ? or map them.

Example pattern for error handling:

#[op2(async)]
#[buffer]
pub async fn op_my_send(
    state: Rc<RefCell<OpState>>,
    #[buffer] data: JsBuffer,
) -> Result<Vec<u8>, deno_error::JsErrorBox> {
    let result = match msg_type.as_str() {
        "sum" => {
            handle_sum(json_data, bin_data).await?;
            // on success, return your data here
            Ok(some_vec)
        }
        _ => Err(deno_error::JsErrorBox::from("Unsupported msg_type")),
    };
    result
}

Here, handle_sum should return Result<_, JsErrorBox> so ? propagates any errors correctly.

Creating JS Errors manually
If you need to create a custom JS error, consider:

use deno_core::error::type_error;

return Err(type_error("buffer Error"));

The type_error helper creates a proper JS TypeError which integrates smoothly.

TL;DR

• Use ? to propagate errors from async functions.
• Use built-in helpers like type_error for JS error creation instead of manually calling JsErrorBox::new.
• Make sure all awaited async calls return Result and handle or propagate errors properly.

Try these adjustments and the TypeError: invalid_argument should resolve.