How to make a method in a class async using neon - node.js

Question

I am trying to make the method with a class created with neon and Rust async. but I m not sure how to do so for a class's method.
For example, I would want to have myMethod as an async.
use neon::prelude::*;
pub struct SomeClass{
path: String,
}
declare_types! {
pub class MyClass for SomeClass {
init(mut cx) {
let path = cx.argument::<JsString>(0)?.value();
Ok(Predictor {
path: path ,
})
}
method myMethod(mut cx) {
let this = cx.this();
let guard = cx.lock();
let test = this.borrow(&guard).path.unwrap();
let vector = vec![1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3,];
// Iterate over the Rust Vec and map each value in the Vec to the JS array
let js_array = JsArray::new(&mut cx, vector.len() as u32);
for (i, obj) in preds.iter().enumerate() {
let element = cx.number(f64::from(*obj));
js_array.set(&mut cx, i as u32, element).unwrap();
}
Ok(js_array.upcast())
}
}
}
// Export the class
register_module!(mut m, {
// <JsEmployee> tells neon what class we are exporting
// "Employee" is the name of the export that the class is exported as
m.export_class::<myClass>("MyClass")?;
Ok(())
});

Answer 1

This is currently a todo in neon. But you can create a simple background task and wrap it in Promise pretty easily. See documentation for examples.
Rust
use neon::prelude::*;
struct BackgroundTask;
impl Task for BackgroundTask {
type Output = i32;
type Error = String;
type JsEvent = JsNumber;
fn perform(&self) -> Result<Self::Output, Self::Error> {
Ok(17)
}
fn complete(self, mut cx: TaskContext, result: Result<Self::Output, Self::Error>) -> JsResult<Self::JsEvent> {
Ok(cx.number(result.unwrap()))
}
}
pub fn perform_async_task(mut cx: FunctionContext) -> JsResult<JsUndefined> {
let f = cx.argument::<JsFunction>(0)?;
BackgroundTask.schedule(f);
Ok(cx.undefined())
}
register_module!(mut m, {
m.export_function("performAsyncTask", perform_async_task)
});
JS
// ./lib/index.js
const { performAsyncTask } = require("../native");
// Iterate 10,0000 times in background thread
const promisePerformAsyncTask = () => {
return new Promise((resolve, reject) => {
performAsyncTask((err, res) => {
let count = 10;
for (let i = 0; i < 100000; i++) {
count++;
}
console.log(count, "first sum from background thread");
});
});
};