mdbxmou 0.1.26

package/src/envmou.cpp

@@ -0,0 +1,445 @@
+#include "envmou.hpp"
+#include "txnmou.hpp"
+#include "async/envmou_copy_to.hpp"
+#include "async/envmou_query.hpp"
+#include "async/envmou_open.hpp"
+#include "async/envmou_keys.hpp"
+#include "async/envmou_close.hpp"
+
+namespace mdbxmou {
+
+Napi::FunctionReference envmou::ctor{};
+
+void envmou::init(const char *class_name, Napi::Env env, Napi::Object exports)
+{
+    auto func = DefineClass(env, class_name, {
+        InstanceMethod("open", &envmou::open),
+        InstanceMethod("openSync", &envmou::open_sync),
+        InstanceMethod("close", &envmou::close),
+        InstanceMethod("closeSync", &envmou::close_sync),
+        InstanceMethod("copyTo", &envmou::copy_to),
+        InstanceMethod("copyToSync", &envmou::copy_to_sync),
+        InstanceMethod("version", &envmou::get_version),
+        InstanceMethod("startRead", &envmou::start_read),
+        InstanceMethod("startWrite", &envmou::start_write),
+        InstanceMethod("query", &envmou::query),
+        InstanceMethod("keys", &envmou::keys)
+    });
+    ctor = Napi::Persistent(func);
+    ctor.SuppressDestruct();
+    exports.Set(class_name, func);
+}
+
+mdbx::env::geometry envmou::parse_geometry(const Napi::Value& arg0) 
+{
+    mdbx::env::geometry geom{};
+
+    auto obj = arg0.As<Napi::Object>();
+
+    if (obj.Has("fixedSize")) {
+        auto value = obj.Get("fixedSize").As<Napi::Number>();
+        auto fixed_size = static_cast<intptr_t>(value.Int64Value());
+        return geom.make_fixed(fixed_size);
+    } else if (obj.Has("dynamicSize")) {
+        auto arr = obj.Get("dynamicSize").As<Napi::Array>();
+        if (arr.Length() != 2) {
+            throw Napi::TypeError::New(obj.Env(), "dynamicSize must be an array of two numbers");
+        }
+        auto v1 = arr.Get(0u).As<Napi::Number>();
+        auto v2 = arr.Get(1u).As<Napi::Number>();
+        auto size_lower = static_cast<intptr_t>(v1.Int64Value());
+        auto size_upper = static_cast<intptr_t>(v2.Int64Value());
+        return geom.make_dynamic(size_lower, size_upper);
+    } else {
+        if (obj.Has("sizeNow")) {
+            auto value = obj.Get("sizeNow").As<Napi::Number>();
+            geom.size_now = static_cast<intptr_t>(value.Int64Value());
+        }
+        if (obj.Has("sizeUpper")) {
+            auto value = obj.Get("sizeUpper").As<Napi::Number>();
+            geom.size_upper = static_cast<intptr_t>(value.Int64Value());
+        }
+        if (obj.Has("growthStep")) {
+            auto value = obj.Get("growthStep").As<Napi::Number>();
+            geom.growth_step = static_cast<intptr_t>(value.Int64Value());
+        }
+        if (obj.Has("shrinkThreshold")) {
+            auto value = obj.Get("shrinkThreshold").As<Napi::Number>();
+            geom.shrink_threshold = static_cast<intptr_t>(value.Int64Value());
+        }
+        if (obj.Has("pageSize")) {
+            auto value = obj.Get("pageSize").As<Napi::Number>();
+            geom.pagesize = static_cast<intptr_t>(value.Int64Value());
+        }
+    }
+    return geom;
+}
+
+env_arg0 envmou::parse(const Napi::Value& arg0)
+{
+    env_arg0 rc;
+
+    auto obj = arg0.As<Napi::Object>();
+
+    rc.path = obj.Get("path").As<Napi::String>().Utf8Value();
+    if (obj.Has("maxDbi")) {
+        auto value = obj.Get("maxDbi").As<Napi::Number>();
+        rc.max_dbi = static_cast<MDBX_dbi>(value.Uint32Value());
+    } 
+
+    if (obj.Has("geometry")) {
+        rc.geom = parse_geometry(obj.Get("geometry"));
+    }
+
+    if (obj.Has("flags")) {
+        rc.flag = env_flag::parse(obj.Get("flags"));
+    }
+
+    if (obj.Has("mode")) {
+        auto value = obj.Get("mode").As<Napi::Number>();
+        rc.file_mode = static_cast<mode_t>(value.Int32Value());
+    }
+
+    if (obj.Has("keyFlag")) {
+        rc.key_flag = base_flag::parse_key(obj.Get("keyFlag"));
+    }
+
+    if (obj.Has("valueFlag")) {
+        rc.value_flag = base_flag::parse_value(obj.Get("valueFlag"));
+    }
+
+    return rc;
+}
+
+Napi::Value envmou::open(const Napi::CallbackInfo& info)
+{
+    auto env = info.Env();
+    auto arg0 = parse(info[0].As<Napi::Object>());
+
+    try {
+        // асинхронный вызов разлочится внутри worker'a
+        if (!try_lock()) {
+            throw std::runtime_error("in progress");
+        }
+
+        if (is_open()) {
+            throw std::runtime_error("already opened");
+        }          
+
+        auto* worker = new async_open(env, *this, arg0);
+        Napi::Promise promise = worker->GetPromise();
+        worker->Queue();
+        return promise;
+    } catch (const std::exception& e) {
+        unlock();
+        throw Napi::Error::New(env, e.what());
+    } catch (...) {
+        unlock();
+        throw;
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value envmou::open_sync(const Napi::CallbackInfo& info)
+{
+    auto env = info.Env();
+    auto arg0 = parse(info[0].As<Napi::Object>());
+
+    try {
+        lock_guard l(*this);
+        if (is_open()) {
+            throw std::runtime_error("already opened");
+        }
+        attach(create_and_open(arg0), arg0);
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, e.what());
+    }
+
+    return env.Undefined();
+}
+
+MDBX_env* envmou::create_and_open(const env_arg0& arg0)
+{
+    MDBX_env *env;
+    auto rc = mdbx_env_create(&env);
+    if (rc != MDBX_SUCCESS) {
+        throw std::runtime_error(mdbx_strerror(rc));
+    }
+
+    rc = mdbx_env_set_maxdbs(env, arg0.max_dbi);
+    if (rc != MDBX_SUCCESS) {
+        mdbx_env_close(env);
+        throw std::runtime_error(mdbx_strerror(rc));
+    }
+
+    rc = mdbx_env_set_maxreaders(env, arg0.max_readers);
+    if (rc != MDBX_SUCCESS) {
+        mdbx_env_close(env);
+        throw std::runtime_error(mdbx_strerror(rc));
+    }
+
+    auto& geom = arg0.geom;
+    rc = mdbx_env_set_geometry(env, geom.size_lower, geom.size_now, 
+        geom.size_upper, geom.growth_step, geom.shrink_threshold, geom.pagesize);
+    if (rc != MDBX_SUCCESS) {
+        mdbx_env_close(env);
+        throw std::runtime_error(mdbx_strerror(rc));
+    }
+
+    auto id = static_cast<std::uint32_t>(pthread_self());
+    // выдадим параметры mode, flag и id потока в котором открывается env
+    rc = mdbx_env_open(env, arg0.path.c_str(), arg0.flag, arg0.file_mode);
+    if (rc != MDBX_SUCCESS) {
+        mdbx_env_close(env);
+        throw std::runtime_error(mdbx_strerror(rc));
+    }
+
+    return env;
+}
+
+void envmou::attach(MDBX_env* env, const env_arg0& arg0)
+{
+    arg0_ = arg0;
+    
+    auto rc = mdbx_env_set_userctx(env, &arg0_);
+    if (rc != MDBX_SUCCESS) {
+        mdbx_env_close(env);
+        throw std::runtime_error(mdbx_strerror(rc));
+    }
+
+    env_.reset(env);
+}
+
+Napi::Value envmou::close(const Napi::CallbackInfo& info)
+{
+    auto env = info.Env();
+    try {
+        // асинхронный вызов разлочится внутри worker'a
+        if (!try_lock()) {
+            throw std::runtime_error("in progress");
+        }
+
+        if (!is_open()) {
+            return env.Undefined();
+        }
+
+        if (trx_count_.load() > 0) {
+            throw std::runtime_error("active transactions");
+        }
+
+        auto* worker = new async_close(env, *this);
+        Napi::Promise promise = worker->GetPromise();
+        worker->Queue();
+        return promise;
+    } catch (const std::exception& e) {
+        unlock();
+        throw Napi::Error::New(env, e.what());
+    } catch (...) {
+        unlock();
+        throw;
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value envmou::close_sync(const Napi::CallbackInfo& info)
+{
+    auto env = info.Env();
+    try {
+        lock_guard l(*this);
+
+        do_close();
+
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, e.what());
+    }
+    return env.Undefined();
+}
+
+Napi::Value envmou::copy_to_sync(const Napi::CallbackInfo& info) 
+{
+    auto env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsString()) {
+        throw Napi::TypeError::New(env, "expected a string argument for the destination path");
+    }
+
+    MDBX_copy_flags_t flags{MDBX_CP_COMPACT};
+    if ((info.Length() > 1) && info[1].IsNumber()) {
+        flags = static_cast<MDBX_copy_flags_t>(info[1].As<Napi::Number>().Uint32Value());
+    }
+
+    try {
+        auto dest_path = info[0].As<Napi::String>().Utf8Value();
+
+        lock_guard l(*this);
+
+        check();
+
+        auto rc = mdbx_env_copy(*this, dest_path.c_str(), flags);
+        if (rc != MDBX_SUCCESS) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
+        }
+
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, e.what());
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value envmou::copy_to(const Napi::CallbackInfo& info) 
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsString()) {
+        throw Napi::TypeError::New(env, "copyTo(path: string[, flags?: number]) -> Promise<void>");
+    }
+
+    MDBX_copy_flags_t flags{MDBX_CP_COMPACT};
+    if (info.Length() > 1 && info[1].IsNumber()) {
+        flags = static_cast<MDBX_copy_flags_t>(info[1].As<Napi::Number>().Uint32Value());
+    }
+
+    try {
+        auto dest = info[0].As<Napi::String>().Utf8Value();
+
+        if (!try_lock()) {
+            throw std::runtime_error("in progress");
+        }
+
+        check();
+
+        auto* worker = new mdbxmou::async_copy(env, *this, std::move(dest), flags);
+        Napi::Promise promise = worker->GetPromise();
+        worker->Queue();
+        return promise;
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, e.what());
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value envmou::get_version(const Napi::CallbackInfo& info) 
+{
+    std::string version = "mdbx v" + std::to_string(MDBX_VERSION_MAJOR);
+    version += "." + std::to_string(MDBX_VERSION_MINOR);
+    return Napi::Value::From(info.Env(), version);
+}
+
+Napi::Value envmou::start_transaction(const Napi::CallbackInfo& info, txn_mode mode) 
+{
+    auto env = info.Env();
+    
+    try {
+        lock_guard l(*this);
+
+        check();
+
+        MDBX_txn* txn;
+        auto rc = mdbx_txn_begin(*this, nullptr, mode, &txn);
+        if (rc != MDBX_SUCCESS) {
+            throw Napi::Error::New(env, std::string("Env: ") + mdbx_strerror(rc));
+        }
+
+        // Создаем новый объект txnmou
+        auto txn_obj = txnmou::ctor.New({});
+        auto txn_wrapper = txnmou::Unwrap(txn_obj);
+        txn_wrapper->attach(*this, txn, mode, nullptr);
+
+        return txn_obj;
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, e.what());
+    }
+}
+
+Napi::Value envmou::query(const Napi::CallbackInfo& info)
+{
+    Napi::Env env = info.Env();
+
+    txn_mode mode{};
+
+    if (info.Length() < 1) {
+        throw Napi::TypeError::New(env, 
+            "expected array of requests: [{ db: String, db_mode: Number, key_mode: Number, key_flag: Number, value_mode: Number, value_flag: Number, mode: Number, item: [] }, ...]");
+    }
+
+    if (info.Length() > 1 || info[1].IsNumber()) {
+        mode = txn_mode::parse(info[1].As<Napi::Number>());
+    }
+
+    try
+    {
+        lock_guard lock(*this);
+
+        check();
+
+        auto conf = dbimou::get_env_userctx(*this);
+
+        auto arg0 = info[0];
+        query_request query = parse_query(mode, 
+            conf->key_flag, conf->value_flag, arg0);
+        auto* worker = new async_query(env, *this, mode, 
+            std::move(query), arg0.IsObject());
+        auto promise = worker->GetPromise();
+        worker->Queue();
+        
+        // Увеличиваем счетчик транзакций после успешного создания
+        ++(*this);
+
+        return promise;
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, e.what());
+    } catch (...) {
+        throw Napi::Error::New(env, "envmou::query");
+    }
+    return env.Undefined();
+}
+
+Napi::Value envmou::keys(const Napi::CallbackInfo& info)
+{
+    Napi::Env env = info.Env();
+
+    txn_mode mode{};
+
+    if (info.Length() < 1) {
+        throw Napi::TypeError::New(env, 
+            "expected array of requests: [{ db: String, db_mode: Number, key_mode: Number, key_flag: Number, value_mode: Number, value_flag: Number }, ...]");
+    }
+
+    if (info.Length() > 1 || info[1].IsNumber()) {
+        mode = txn_mode::parse(info[1].As<Napi::Number>());
+    }
+
+    try
+    {
+        lock_guard lock(*this);
+
+        check();
+
+        auto conf = dbimou::get_env_userctx(*this);
+
+        auto arg0 = info[0];
+        keys_request query = parse_keys(mode, 
+            conf->key_flag, conf->value_flag, arg0);
+
+        auto* worker = new async_keys(env, *this, mode, 
+            std::move(query), arg0.IsObject());
+        auto promise = worker->GetPromise();
+        worker->Queue();
+        
+        // Увеличиваем счетчик транзакций после успешного создания
+        ++(*this);
+
+        return promise;
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, e.what());
+    } catch (...) {
+        throw Napi::Error::New(env, "envmou::keys");
+    }
+    return env.Undefined();
+}
+
+} // namespace mdbxmou

package/src/envmou.hpp

@@ -0,0 +1,116 @@
+#pragma once
+
+#include "txnmou.hpp"
+#include <memory>
+#include <atomic>
+#include <mutex>
+
+namespace mdbxmou {
+
+// Forward declaration
+class txnmou;
+
+class envmou final
+    : public Napi::ObjectWrap<envmou>
+{  
+    static Napi::FunctionReference ctor;
+    static mdbx::env::geometry parse_geometry(const Napi::Value& obj);
+    static env_arg0 parse(const Napi::Value& obj);
+
+    struct free_env {
+        void operator()(MDBX_env* env) const {
+            auto rc = mdbx_env_close(env);
+            if (rc != MDBX_SUCCESS) {
+                fprintf(stderr, "mdbx_env_close %s\n", mdbx_strerror(rc));
+            }
+        }
+    };
+        
+    std::unique_ptr<MDBX_env, free_env> env_{};
+    std::atomic<std::size_t> trx_count_{};
+    env_arg0 arg0_{};
+    std::mutex lock_{};
+
+    bool is_open() const {
+        return env_ != nullptr;
+    }
+
+    // Inline метод для проверки что база данных открыта
+    void check() const {
+        if (!is_open()) {
+            throw std::runtime_error("closed");
+        }
+    }
+
+    // Общий метод для создания транзакций
+    Napi::Value start_transaction(const Napi::CallbackInfo& info, txn_mode mode);
+
+public:    
+    envmou(const Napi::CallbackInfo& i)
+        : ObjectWrap{i}
+    {   }
+
+    static MDBX_env* create_and_open(const env_arg0& arg0);
+    void attach(MDBX_env* env, const env_arg0& arg0);
+
+    operator MDBX_env*() const noexcept {
+        return env_.get();
+    }
+
+    static void init(const char *class_name, Napi::Env env, Napi::Object exports);
+
+    envmou& operator++() noexcept {
+        ++trx_count_;
+        return *this;
+    }
+
+    envmou& operator--() noexcept {
+        --trx_count_;
+        return *this;
+    }
+
+    Napi::Value open(const Napi::CallbackInfo&);
+    Napi::Value open_sync(const Napi::CallbackInfo&);
+    Napi::Value close(const Napi::CallbackInfo&);
+    Napi::Value close_sync(const Napi::CallbackInfo&);
+    Napi::Value get_version(const Napi::CallbackInfo&);
+    Napi::Value copy_to_sync(const Napi::CallbackInfo&);
+    Napi::Value copy_to(const Napi::CallbackInfo&);
+    // метод для групповых вставок или чтения
+    // внутри транзакция, получение db и чтение/запись
+    Napi::Value query(const Napi::CallbackInfo&);
+    Napi::Value keys(const Napi::CallbackInfo&);
+    
+    // Методы для создания транзакций
+    Napi::Value start_read(const Napi::CallbackInfo& info) {
+        return start_transaction(info, {txn_mode::ro});
+    }
+    Napi::Value start_write(const Napi::CallbackInfo& info) {
+        return start_transaction(info, {});
+    }
+
+    using lock_guard = std::lock_guard<envmou>;
+    //  для защиты асинхронных операций
+    void lock() {
+        auto rc = lock_.try_lock();
+        if (!rc) {
+            throw std::runtime_error("operation in progress");
+        }
+    }
+    void unlock()  {
+        lock_.unlock();
+    }
+    bool try_lock() {
+        bool locked = lock_.try_lock();
+        return locked;
+    }
+
+    void do_close() {
+        if (trx_count_.load() > 0) {
+            throw std::runtime_error("transaction in progress");
+        }
+        env_.reset();
+    }
+};
+
+} // namespace mdbxmou

package/src/modulemou.cpp

@@ -0,0 +1,113 @@
+#include "envmou.hpp"
+
+using namespace Napi;
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) 
+{
+#define MDBXMOU_DECLARE_FLAG_NAME(obj, name, value) \
+    obj.Set(name, Napi::Number::New(env, value))
+
+    Napi::Object mdbx_mou = Napi::Object::New(env);
+
+    using mdbxmou::env_flag;
+    Napi::Object envFlag = Napi::Object::New(env);
+    MDBXMOU_DECLARE_FLAG_NAME(envFlag, "validation", env_flag::validation);
+    MDBXMOU_DECLARE_FLAG_NAME(envFlag, "rdonly", env_flag::rdonly);
+    MDBXMOU_DECLARE_FLAG_NAME(envFlag, "exclusive", env_flag::exclusive);
+    MDBXMOU_DECLARE_FLAG_NAME(envFlag, "accede", env_flag::accede);
+    MDBXMOU_DECLARE_FLAG_NAME(envFlag, "writemap", env_flag::writemap);
+    MDBXMOU_DECLARE_FLAG_NAME(envFlag, "nostickythreads", env_flag::nostickythreads);
+    MDBXMOU_DECLARE_FLAG_NAME(envFlag, "nordahead", env_flag::nordahead);
+    MDBXMOU_DECLARE_FLAG_NAME(envFlag, "nomeminit", env_flag::nomeminit);
+    MDBXMOU_DECLARE_FLAG_NAME(envFlag, "liforeclaim", env_flag::liforeclaim);
+    MDBXMOU_DECLARE_FLAG_NAME(envFlag, "nometasync", env_flag::nometasync);
+    MDBXMOU_DECLARE_FLAG_NAME(envFlag, "safeNosync", env_flag::safe_nosync);
+    MDBXMOU_DECLARE_FLAG_NAME(envFlag, "utterlyNosync", env_flag::utterly_nosync);
+    mdbx_mou.Set("envFlag", envFlag);
+
+    using mdbxmou::txn_mode;
+    Napi::Object txn_mode = Napi::Object::New(env);
+    MDBXMOU_DECLARE_FLAG_NAME(txn_mode, "ro", txn_mode::ro);
+    mdbx_mou.Set("txnMode", txn_mode);
+
+    using mdbxmou::key_mode;
+    Napi::Object key_mode = Napi::Object::New(env);
+    MDBXMOU_DECLARE_FLAG_NAME(key_mode, "reverse", key_mode::reverse);
+    MDBXMOU_DECLARE_FLAG_NAME(key_mode, "ordinal", key_mode::ordinal);
+    mdbx_mou.Set("keyMode", key_mode);
+
+    using mdbxmou::base_flag;
+    Napi::Object key_flag = Napi::Object::New(env);
+    MDBXMOU_DECLARE_FLAG_NAME(key_flag, "string", base_flag::string);
+    MDBXMOU_DECLARE_FLAG_NAME(key_flag, "number", base_flag::number);
+    MDBXMOU_DECLARE_FLAG_NAME(key_flag, "bigint", base_flag::bigint);
+    mdbx_mou.Set("keyFlag", key_flag);
+
+    using mdbxmou::value_mode;
+    Napi::Object value_mode = Napi::Object::New(env);
+    MDBXMOU_DECLARE_FLAG_NAME(value_mode, "multi", value_mode::multi);
+    MDBXMOU_DECLARE_FLAG_NAME(value_mode, "multiReverse", value_mode::multi_reverse);
+    MDBXMOU_DECLARE_FLAG_NAME(value_mode, "multiSamelength", value_mode::multi_samelength);
+    MDBXMOU_DECLARE_FLAG_NAME(value_mode, "multiOrdinal", value_mode::multi_ordinal);
+    MDBXMOU_DECLARE_FLAG_NAME(value_mode, "multiReverseSamelength", 
+        value_mode::multi_reverse_samelength);
+    mdbx_mou.Set("valueMode", value_mode);
+
+    Napi::Object value_flag = Napi::Object::New(env);
+    MDBXMOU_DECLARE_FLAG_NAME(value_flag, "string", base_flag::string);
+    mdbx_mou.Set("valueFlag", value_flag);
+
+    using mdbxmou::db_mode;
+    Napi::Object db_mode = Napi::Object::New(env);
+    MDBXMOU_DECLARE_FLAG_NAME(db_mode, "create", db_mode::create);
+    MDBXMOU_DECLARE_FLAG_NAME(db_mode, "accede", db_mode::accede);
+    mdbx_mou.Set("dbMode", db_mode);
+
+    using mdbxmou::query_mode;
+    Napi::Object query_mode = Napi::Object::New(env);
+    MDBXMOU_DECLARE_FLAG_NAME(query_mode, "upsert", query_mode::upsert);
+    MDBXMOU_DECLARE_FLAG_NAME(query_mode, "update", query_mode::update);
+    MDBXMOU_DECLARE_FLAG_NAME(query_mode, "insertUnique", query_mode::insert_unique);
+    MDBXMOU_DECLARE_FLAG_NAME(query_mode, "get", query_mode::get);
+    MDBXMOU_DECLARE_FLAG_NAME(query_mode, "del", query_mode::del);
+    mdbx_mou.Set("queryMode", query_mode);
+
+    using move_operation = mdbx::cursor::move_operation;
+    Napi::Object cursor_mode = Napi::Object::New(env);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "first", move_operation::first);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "last", move_operation::last);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "next", move_operation::next);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "prev", move_operation::previous);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "key_lesser_than", 
+        move_operation::key_lesser_than);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "key_lesser_or_equal", 
+        move_operation::key_lesser_or_equal);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "key_equal", move_operation::key_equal);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "key_greater_or_equal", 
+        move_operation::key_greater_or_equal);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "key_greater_than", 
+        move_operation::key_greater_than);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multi_exactkey_value_lesser_than", 
+        move_operation::multi_exactkey_value_lesser_than);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multi_exactkey_value_lesser_or_equal", 
+        move_operation::multi_exactkey_value_lesser_or_equal);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multi_exactkey_value_equal", 
+        move_operation::multi_exactkey_value_equal);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multi_exactkey_value_greater_or_equal", 
+        move_operation::multi_exactkey_value_greater_or_equal);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multi_exactkey_value_greater", 
+        move_operation::multi_exactkey_value_greater);
+    mdbx_mou.Set("cursorMode", cursor_mode);
+
+    exports.Set("MDBX_Param", mdbx_mou);
+
+#undef MDBXMOU_DECLARE_FLAG_NAME
+
+    mdbxmou::envmou::init("MDBX_Env", env, exports);
+    mdbxmou::txnmou::init("MDBX_Txn", env);
+    mdbxmou::dbimou::init("MDBX_Dbi", env);
+
+    return exports;
+}
+
+NODE_API_MODULE(addon, Init)