async_op.hpp

Go to the documentation of this file.

#pragma once
 
#include "barretenberg/serialize/msgpack_impl.hpp"
#include <memory>
#include <napi.h>
#include <thread>
#include <utility>
 
namespace bb::nodejs {
 
using async_fn = std::function<void(msgpack::sbuffer&)>;
 
class AsyncOperation : public Napi::AsyncWorker {
  public:
    AsyncOperation(Napi::Env env, std::shared_ptr<Napi::Promise::Deferred> deferred, async_fn fn)
        : Napi::AsyncWorker(env)
        , _fn(std::move(fn))
        , _deferred(std::move(deferred))
    {}
 
    AsyncOperation(const AsyncOperation&) = delete;
    AsyncOperation& operator=(const AsyncOperation&) = delete;
    AsyncOperation(AsyncOperation&&) = delete;
    AsyncOperation& operator=(AsyncOperation&&) = delete;
 
    ~AsyncOperation() override = default;
 
    void Execute() override
    {
        try {
            _fn(_result);
        } catch (const std::exception& e) {
            SetError(e.what());
        } catch (...) {
            // Catch any other exception type that's not derived from std::exception
            // This ensures the promise is always rejected rather than leaving it hanging
            SetError("Unknown exception occurred during async operation");
        }
    }
 
    void OnOK() override
    {
        auto buf = Napi::Buffer<char>::Copy(Env(), _result.data(), _result.size());
        _deferred->Resolve(buf);
    }
    void OnError(const Napi::Error& e) override { _deferred->Reject(e.Value()); }
 
  private:
    async_fn _fn;
    std::shared_ptr<Napi::Promise::Deferred> _deferred;
    msgpack::sbuffer _result;
};
 
class ThreadedAsyncOperation {
  public:
    ThreadedAsyncOperation(Napi::Env env, std::shared_ptr<Napi::Promise::Deferred> deferred, async_fn fn)
        : _fn(std::move(fn))
        , _deferred(std::move(deferred))
    {
        // Create a no-op JS function as the TSFN target — we use the native callback form of BlockingCall
        // to resolve/reject the promise, so the JS function is never actually called directly.
        auto dummy = Napi::Function::New(env, [](const Napi::CallbackInfo&) {});
        _completion_tsfn = Napi::ThreadSafeFunction::New(env, dummy, "ThreadedAsyncOpComplete", 0, 1);
    }
 
    ThreadedAsyncOperation(const ThreadedAsyncOperation&) = delete;
    ThreadedAsyncOperation& operator=(const ThreadedAsyncOperation&) = delete;
    ThreadedAsyncOperation(ThreadedAsyncOperation&&) = delete;
    ThreadedAsyncOperation& operator=(ThreadedAsyncOperation&&) = delete;
 
    ~ThreadedAsyncOperation() = default;
 
    void Queue()
    {
        std::thread([this]() {
            try {
                _fn(_result);
                _success = true;
            } catch (const std::exception& e) {
                _error = e.what();
                _success = false;
            } catch (...) {
                _error = "Unknown exception occurred during threaded async operation";
                _success = false;
            }
 
            // Post completion back to the JS main thread
            _completion_tsfn.BlockingCall(
                this, [](Napi::Env env, Napi::Function /*js_callback*/, ThreadedAsyncOperation* op) {
                    if (op->_success) {
                        auto buf = Napi::Buffer<char>::Copy(env, op->_result.data(), op->_result.size());
                        op->_deferred->Resolve(buf);
                    } else {
                        auto error = Napi::Error::New(env, op->_error);
                        op->_deferred->Reject(error.Value());
                    }
                    // Release the TSFN and self-destruct
                    op->_completion_tsfn.Release();
                    delete op;
                });
        }).detach();
    }
 
  private:
    async_fn _fn;
    std::shared_ptr<Napi::Promise::Deferred> _deferred;
    Napi::ThreadSafeFunction _completion_tsfn;
    msgpack::sbuffer _result;
    bool _success = false;
    std::string _error;
};
 
} // namespace bb::nodejs