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 std::enable_shared_from_this<ThreadedAsyncOperation> {
  public:
    ThreadedAsyncOperation(Napi::Env env, std::shared_ptr<Napi::Promise::Deferred> deferred, async_fn fn)
        : _fn(std::move(fn))
        , _deferred(std::move(deferred))
    {
        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;
 
    static void Run(Napi::Env env, std::shared_ptr<Napi::Promise::Deferred> deferred, async_fn fn)
    {
        auto op = std::make_shared<ThreadedAsyncOperation>(env, std::move(deferred), std::move(fn));
        op->Queue();
    }
 
  private:
    void Queue()
    {
        auto self = shared_from_this();
        std::thread([self]() {
            try {
                self->_fn(self->_result);
                self->_success = true;
            } catch (const std::exception& e) {
                self->_error = e.what();
                self->_success = false;
            } catch (...) {
                self->_error = "Unknown exception occurred during threaded async operation";
                self->_success = false;
            }
 
            // Post completion to the JS main thread. The callback captures `self`
            // (shared_ptr) so the object stays alive until the callback runs.
            // napi_tsfn_blocking only blocks on queue insertion, not on callback
            // completion, so we cannot use raw pointers here.
            self->_completion_tsfn.BlockingCall([self](Napi::Env env, Napi::Function /*js_callback*/) {
                if (self->_success) {
                    auto buf = Napi::Buffer<char>::Copy(env, self->_result.data(), self->_result.size());
                    self->_deferred->Resolve(buf);
                } else {
                    auto error = Napi::Error::New(env, self->_error);
                    self->_deferred->Reject(error.Value());
                }
                self->_completion_tsfn.Release();
            });
        }).detach();
    }
 
    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