Integrating JsRuntime properly with Axum

[Toasterson]

Hello all.

I am using deno_core as a Javascript runtime for me to make a webhook server. I am making the Webserver part in axum and at the moment I make a JsRuntime in every handler, that gets called. I tried to do the more resonable shared state approach but many things inside the JsRuntime do not implement sync so I cant add it to the shared state.

My current handler looks like this:

async fn real_handler(body: serde_json::Value) -> Result<()> {
    info!("Starting Deno Runtime");
    let mut js_runtime = JsRuntime::new(Default::default());
    {
        let mut scope = js_runtime.handle_scope();
        let variable_context = scope.get_current_context();
        let global = variable_context.global(&mut scope);

        let body_value = serde_v8::to_v8(&mut scope, body)?;

        let body_key_str =
            deno_core::v8::String::new(&mut scope, "body").ok_or(Error::JSRuntimePassError)?;
        let _ = global
            .set(&mut scope, body_key_str.into(), body_value)
            .ok_or(Error::JSRuntimePassError)?;
    }

    let result = js_runtime.execute_script_static("handler", "body.pull_request.url;")?;
    let str = {
        let scope = &mut js_runtime.handle_scope();
        let local = deno_core::v8::Local::new(scope, result);
        // Deserialize a `v8` object into a Rust type using `serde_v8`,
        // in this case deserialize to a JSON `Value`.
        let deserialized_value = serde_v8::from_v8::<serde_json::Value>(scope, local)?;
        deserialized_value
    };
    info!("Result of Javascript evaliation: {}", str);

    Ok(())
}

Does it make sense to run the JsRuntime::new() calls globally once or is that ok inside the handler like in the example? If it is better to run global, is it easy to call create_realm to create a realm? Is there a realm example, that cleans up after the functions has ended?

[gvozdvmozgu]

[bartlomieju]

You can have one JsRuntime and send messages to it from as many threads as you want. It just needs to be pinned to a specific thread.