mdbxmou 0.2.5 → 0.2.7

package/README.md

@@ -132,8 +132,11 @@ const result = await env.query([
 
 #### Methods
 
-**createMap(db_name | keyMode, [keyMode | valueMode], [valueMode]) → DBI**
+**createMap([db_name | keyMode], [keyMode | valueMode], [valueMode]) → DBI**
 ```javascript
+// No arguments - default DB with string keys
+const dbi = txn.createMap();
+
 // One argument - keyMode only
 const dbi = txn.createMap(MDBX_Param.keyMode.ordinal);
 
@@ -152,8 +155,11 @@ const namedDbi = txn.createMap("my-table", MDBX_Param.keyMode.ordinal, MDBX_Para
 
 > **Note**: Use `createMap` in write transactions - it will create the database if it doesn't exist, or open it if it does. This is safer for new environments.
 
-**openMap(db_name | keyMode, [keyMode]) → DBI**
+**openMap([db_name | keyMode], [keyMode]) → DBI**
 ```javascript
+// No arguments - default DB with string keys
+const dbi = txn.openMap();
+
 // One argument - keyMode only
 // Number keyMode - keys returned as numbers
 const dbi = txn.openMap(MDBX_Param.keyMode.ordinal);

package/package.json

@@ -46,7 +46,8 @@
   ],
   "dependencies": {
     "cmake-js": "^7.3.1",
-    "node-addon-api": "^8.5.0"
+    "node-addon-api": "^8.5.0",
+    "uuid": "^13.0.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
@@ -65,7 +66,7 @@
   },
   "gypfile": true,
   "name": "mdbxmou",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Node bindings for mdbx",
   "repository": {
     "type": "git",

package/src/dbimou.cpp

@@ -51,6 +51,7 @@ Napi::Value dbimou::put(const Napi::CallbackInfo& info)
         auto key = (key_mode_.val & key_mode::ordinal) ?
             keymou::from(info[1], env, t) : 
             keymou::from(info[1], env, key_buf_);
+
         auto val = valuemou::from(info[2], env, val_buf_);
         dbi::put(*txn, key, val, *this);
     } catch (const std::exception& e) {
@@ -139,7 +140,7 @@ Napi::Value dbimou::has(const Napi::CallbackInfo& info) {
         auto key = (key_mode_.val & key_mode::ordinal) ?
             keymou::from(info[1], env, t) : 
             keymou::from(info[1], env, key_buf_);
-        
+
         bool result = dbi::has(*txn, key);
         return Napi::Value::From(env, result);
     } catch (const std::exception& e) {
@@ -177,7 +178,6 @@ Napi::Value dbimou::for_each(const Napi::CallbackInfo& info) {
             }
             
             uint32_t index{};
-
             if (key_mode_.val & key_mode::ordinal) {
                 cursor.scan([&](const mdbx::pair& f) {
                     keymou key{f.key};

package/src/env_arg0.hpp

@@ -1,9 +1,6 @@
 #pragma once
 
 #include "valuemou.hpp"
-#ifdef _WIN32
-typedef unsigned short mode_t;
-#endif
 
 namespace mdbxmou {
 
@@ -12,7 +9,7 @@ struct env_arg0 {
     MDBX_dbi max_dbi{32};
     mdbx::env::geometry geom{};
     env_flag flag{};
-    mode_t file_mode{0664};
+    mdbx_mode_t file_mode{0664};
     std::uint32_t max_readers{128};
     base_flag key_flag{};
     base_flag value_flag{};

package/src/envmou.cpp

@@ -103,7 +103,7 @@ env_arg0 envmou::parse(const Napi::Value& arg0)
 
     if (obj.Has("mode")) {
         auto value = obj.Get("mode").As<Napi::Number>();
-        rc.file_mode = static_cast<mode_t>(value.Int32Value());
+        rc.file_mode = static_cast<mdbx_mode_t>(value.Int32Value());
     }
 
     if (obj.Has("keyFlag")) {
@@ -234,7 +234,7 @@ Napi::Value envmou::close(const Napi::CallbackInfo& info)
             return env.Undefined();
         }
 
-        if (trx_count_.load() > 0) {
+        if (trx_count_ > 0) {
             throw std::runtime_error("active transactions");
         }
 
@@ -392,10 +392,10 @@ Napi::Value envmou::query(const Napi::CallbackInfo& info)
         auto* worker = new async_query(env, *this, mode, 
             std::move(query), arg0.IsObject());
         auto promise = worker->GetPromise();
-        worker->Queue();
         
-        // Увеличиваем счетчик транзакций после успешного создания
+        // Увеличиваем счетчик ДО Queue() — worker гарантированно вызовет --env_
         ++(*this);
+        worker->Queue();
 
         return promise;
     } catch (const std::exception& e) {
@@ -433,10 +433,10 @@ Napi::Value envmou::keys(const Napi::CallbackInfo& info)
         auto* worker = new async_keys(env, *this, mode, 
             std::move(query), arg0.IsObject());
         auto promise = worker->GetPromise();
-        worker->Queue();
         
-        // Увеличиваем счетчик транзакций после успешного создания
+        // Увеличиваем счетчик ДО Queue() — worker гарантированно вызовет --env_
         ++(*this);
+        worker->Queue();
 
         return promise;
     } catch (const std::exception& e) {

package/src/envmou.hpp

@@ -27,7 +27,8 @@ class envmou final
     };
         
     std::unique_ptr<MDBX_env, free_env> env_{};
-    std::atomic<std::size_t> trx_count_{};
+    // счетчик транзакицй, не требующий атомарности
+    std::size_t trx_count_{};
     env_arg0 arg0_{};
     std::mutex lock_{};
 
@@ -106,7 +107,7 @@ public:
     }
 
     void do_close() {
-        if (trx_count_.load() > 0) {
+        if (trx_count_ > 0) {
             throw std::runtime_error("transaction in progress");
         }
         env_.reset();

package/src/txnmou.cpp

@@ -21,18 +21,14 @@ void txnmou::init(const char *class_name, Napi::Env env) {
 Napi::Value txnmou::commit(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
 
-    try {
-        check();
-        
-        auto rc = mdbx_txn_commit(*this);
-        if (rc != MDBX_SUCCESS) {
-            throw Napi::Error::New(env, std::string("txn: ") + mdbx_strerror(rc));
-        }
-
-        dec_counter();
-        txn_.release();
-    } catch (const std::exception& e) {
-        throw Napi::Error::New(env, e.what());
+    if (!txn_) {
+        throw Napi::Error::New(env, "txn already completed");
+    }
+    
+    dec_counter();
+    auto rc = mdbx_txn_commit(txn_.release());
+    if (rc != MDBX_SUCCESS) {
+        throw Napi::Error::New(env, std::string("txn commit: ") + mdbx_strerror(rc));
     }
     
     return env.Undefined();
@@ -41,18 +37,14 @@ Napi::Value txnmou::commit(const Napi::CallbackInfo& info) {
 Napi::Value txnmou::abort(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
-    try {
-        check();
-        
-        auto rc = mdbx_txn_abort(*this);
-        if (rc != MDBX_SUCCESS) {
-            throw Napi::Error::New(env, std::string("txn: ") + mdbx_strerror(rc));
-        }
-
-        dec_counter();
-        txn_.release();
-    } catch (const std::exception& e) {
-        throw Napi::Error::New(env, e.what());
+    if (!txn_) {
+        throw Napi::Error::New(env, "txn already completed");
+    }
+    
+    dec_counter();
+    auto rc = mdbx_txn_abort(txn_.release());
+    if (rc != MDBX_SUCCESS) {
+        throw Napi::Error::New(env, std::string("txn abort: ") + mdbx_strerror(rc));
     }
     
     return env.Undefined();
@@ -70,72 +62,66 @@ Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
 {
     Napi::Env env = info.Env();
 
-    try
-    {
-        if ((mode_.val & txn_mode::ro) && (db_mode.val & db_mode::create)) {
-            throw std::runtime_error("dbi: cannot open DB in read-only transaction");
-        }
+    if ((mode_.val & txn_mode::ro) && (db_mode.val & db_mode::create)) {
+        throw Napi::Error::New(env, "dbi: cannot open DB in read-only transaction");
+    }
 
-        key_mode key_mode{};
-        value_mode value_mode{};
-        std::string db_name{};
-        auto conf = get_env_userctx(*env_);
-        auto key_flag = conf->key_flag;
-        auto value_flag = conf->value_flag;
-        auto arg_count = info.Length();
-        if (arg_count == 3) {
-            auto arg0 = info[0]; // db_name
-            auto arg1 = info[1]; // key_mode
-            auto arg2 = info[2]; // value_mode
+    key_mode key_mode{};
+    value_mode value_mode{};
+    std::string db_name{};
+    auto conf = get_env_userctx(*env_);
+    auto key_flag = conf->key_flag;
+    auto value_flag = conf->value_flag;
+    auto arg_count = info.Length();
+    if (arg_count == 3) {
+        auto arg0 = info[0]; // db_name
+        auto arg1 = info[1]; // key_mode
+        auto arg2 = info[2]; // value_mode
+        db_name = arg0.As<Napi::String>().Utf8Value();
+        key_mode = parse_key_mode(env, arg1, key_flag);
+        value_mode = value_mode::parse(arg2);
+    } else if (arg_count == 2) {
+        // db_name + key_mode || key_mode + value_mode
+        auto arg0 = info[0]; 
+        auto arg1 = info[1]; 
+        if (arg0.IsString()) {
             db_name = arg0.As<Napi::String>().Utf8Value();
             key_mode = parse_key_mode(env, arg1, key_flag);
-            value_mode = value_mode::parse(arg2);
-        } else if (arg_count == 2) {
-            // db_name + key_mode || key_mode + value_mode
-            auto arg0 = info[0]; 
-            auto arg1 = info[1]; 
-            if (arg0.IsString()) {
-                db_name = arg0.As<Napi::String>().Utf8Value();
-                key_mode = parse_key_mode(env, arg1, key_flag);
-            } else if (arg0.IsNumber()) {
-                key_mode = parse_key_mode(env, arg0, key_flag);
-                value_mode = value_mode::parse(arg1);
-            } else {
-                throw Napi::Error::New(env, "Invalid argument type for db_name or value_mode");
-            }
-        } else if (arg_count == 1) {
-            // db_name || key_mode
-            auto arg0 = info[0];
-            if (arg0.IsString()) {
-                db_name = arg0.As<Napi::String>().Utf8Value();
-            } else {
-                key_mode = parse_key_mode(env, arg0, key_flag);
-            }
+        } else if (arg0.IsNumber() || arg0.IsBigInt()) {
+            key_mode = parse_key_mode(env, arg0, key_flag);
+            value_mode = value_mode::parse(arg1);
         } else {
-            throw Napi::Error::New(env, "Invalid number of arguments for get_dbi");
+            throw Napi::Error::New(env, "Invalid argument type for db_name or value_mode");
         }
-
-        check();    
-
-        MDBX_dbi dbi{};
-        auto flags = static_cast<MDBX_db_flags_t>(db_mode.val|key_mode.val|value_mode.val);
-        auto rc = mdbx_dbi_open(*this, db_name.empty() ? nullptr : db_name.c_str(), flags, &dbi);
-        if (rc != MDBX_SUCCESS) {
-            throw std::runtime_error(std::string("mdbx_dbi_open ") + mdbx_strerror(rc));
+    } else if (arg_count == 1) {
+        // db_name || key_mode
+        auto arg0 = info[0];
+        if (arg0.IsString()) {
+            db_name = arg0.As<Napi::String>().Utf8Value();
+        } else if (arg0.IsNumber() || arg0.IsBigInt()) {
+            key_mode = parse_key_mode(env, arg0, key_flag);
+        } else {
+            throw Napi::Error::New(env, "Invalid argument type: expected string (db_name) or number (key_mode)");
         }
-        // создаем новый объект dbi
-        auto obj = dbimou::ctor.New({});
-        auto ptr = dbimou::Unwrap(obj);
-        ptr->attach(dbi, db_mode, key_mode, 
-            value_mode, key_flag, value_flag);
-        return obj;
     }
-    catch(const std::exception& e)
-    {
-        throw Napi::Error::New(env, std::string("txn: get_dbi ") + e.what());
+    // arg_count == 0: используем значения по умолчанию (строковый ключ, default db)
+
+    if (!txn_) {
+        throw Napi::Error::New(env, "txn already completed");
     }
-    
-    return env.Undefined();
+
+    MDBX_dbi dbi{};
+    auto flags = static_cast<MDBX_db_flags_t>(db_mode.val|key_mode.val|value_mode.val);
+    auto rc = mdbx_dbi_open(*this, db_name.empty() ? nullptr : db_name.c_str(), flags, &dbi);
+    if (rc != MDBX_SUCCESS) {
+        throw Napi::Error::New(env, std::string("mdbx_dbi_open: ") + mdbx_strerror(rc));
+    }
+    // создаем новый объект dbi
+    auto obj = dbimou::ctor.New({});
+    auto ptr = dbimou::Unwrap(obj);
+    ptr->attach(dbi, db_mode, key_mode, 
+        value_mode, key_flag, value_flag);
+    return obj;
 }
 
 Napi::Value txnmou::is_active(const Napi::CallbackInfo& info) {

package/src/txnmou.hpp

@@ -12,21 +12,16 @@ class txnmou final
 private:
     envmou* env_{nullptr};
     
-    // Простой deleter
-    struct free_txn {
-        void operator()(MDBX_txn* txn) const noexcept {
+    // свободу txn
+    struct free_txn
+    {
+        void operator()(MDBX_txn *txn) const noexcept {
             mdbx_txn_abort(txn);
         }
     };
-    
+
     std::unique_ptr<MDBX_txn, free_txn> txn_{};
     txn_mode mode_{};
-
-    void check() const {
-        if (!txn_) {
-            throw std::runtime_error("txn: inactive");
-        }
-    }
     
     // Уменьшает счетчик транзакций
     void dec_counter() noexcept;
@@ -57,7 +52,7 @@ public:
         return get_dbi(info, {db_mode::create});
     }
 
-    operator MDBX_txn*() const noexcept {
+    operator MDBX_txn*() noexcept {
         return txn_.get();
     }
 

package/src/typemou.hpp

@@ -4,27 +4,72 @@
 #include <mdbx.h++>
 #include <cstdint>
 #include <vector>
+#include <utility>
 
 namespace mdbxmou {
 
 using buffer_type = std::vector<char>;
 
 struct txnmou_managed final
-    : mdbx::txn_managed
+    : mdbx::txn
 {
-    txnmou_managed(MDBX_txn* txn)
-    {  
-        txn::handle_ = txn; 
+    txnmou_managed(MDBX_txn *txn) noexcept
+        : mdbx::txn(txn)
+    {   }
+
+    txnmou_managed(txnmou_managed &&other) noexcept
+        : mdbx::txn(std::exchange(other.txn::handle_, nullptr))
+    {   }
+
+    txnmou_managed(const txnmou_managed&) = delete;
+    txnmou_managed& operator=(const txnmou_managed&) = delete;
+    
+    ~txnmou_managed() noexcept 
+    {
+        if (txn::handle_) {
+            ::mdbx_txn_abort(txn::handle_);
+        }
+    }
+    
+    void commit() 
+    {
+        auto rc = ::mdbx_txn_commit(
+            std::exchange(txn::handle_, nullptr));
+        if (rc != MDBX_SUCCESS) {
+            throw std::runtime_error(::mdbx_strerror(rc));
+        }
+    }
+    
+    void abort() 
+    {
+        auto rc = ::mdbx_txn_abort(
+            std::exchange(txn::handle_, nullptr));
+        if (rc != MDBX_SUCCESS) {
+            throw std::runtime_error(::mdbx_strerror(rc));
+        }
     }
 };
 
 struct cursormou_managed final
-    : mdbx::cursor_managed
+    : mdbx::cursor
 {
-    cursormou_managed(MDBX_cursor* cursor) noexcept
-    {  
-        cursor::handle_ = cursor; 
-    }    
+    explicit cursormou_managed(MDBX_cursor* cursor) noexcept
+        : mdbx::cursor(cursor)
+    {   }
+
+    cursormou_managed(cursormou_managed &&other) noexcept
+        : mdbx::cursor(std::exchange(other.cursor::handle_, nullptr))
+    {   }
+    
+    cursormou_managed(const cursormou_managed&) = delete;
+    cursormou_managed& operator=(const cursormou_managed&) = delete;
+    
+    ~cursormou_managed() noexcept 
+    {
+        if (cursor::handle_) {
+            ::mdbx_cursor_close(cursor::handle_);
+        }
+    }
 };
 
 struct env_flag {

package/src/valuemou.hpp

@@ -4,11 +4,18 @@
 
 namespace mdbxmou {
 
-class valuemou
-    : public mdbx::slice
+// Обёртка над mdbx::slice — НЕ ВЛАДЕЕТ памятью.
+// Хранит указатель на внешний буфер (buffer_type или stack).
+// Copy и move эквивалентны — просто копируют указатель и размер.
+// ВАЖНО: не использовать после уничтожения буфера!
+struct valuemou
+    : mdbx::slice
 {
-public:
     valuemou() = default;
+    valuemou(const valuemou&) = default;
+    valuemou& operator=(const valuemou&) = default;
+    valuemou(valuemou&&) = default;
+    valuemou& operator=(valuemou&&) = default;
 
     valuemou(const mdbx::slice& arg0) noexcept
         : mdbx::slice{arg0}
@@ -38,9 +45,8 @@ public:
         if (status != napi_ok) {
             throw Napi::Error::New(env, "napi_get_value_string_utf8 length");
         }
-
+        
         mem.reserve(length + 1);
-        mem.resize(length);
 
         status = napi_get_value_string_utf8(
             env, arg0, mem.data(), mem.capacity(), nullptr);
@@ -48,6 +54,8 @@ public:
             throw Napi::Error::New(env, "napi_get_value_string_utf8 copyout");
         }
 
+        mem.resize(length);
+
         assign(mem.data(), mem.size());
     }
 
@@ -75,11 +83,14 @@ public:
     }
 };
 
-class keymou final
-    : public valuemou
+struct keymou final
+    : valuemou
 {
-public:    
     keymou() = default;
+    keymou(const keymou&) = default;
+    keymou& operator=(const keymou&) = default;
+    keymou(keymou&&) = default;
+    keymou& operator=(keymou&&) = default;
 
     keymou(const valuemou& arg0) noexcept
         : valuemou{arg0}

package/src/async/envmou_async.cpp

@@ -1,450 +0,0 @@
-#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"
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <pthread.h>
-#endif
-
-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<mdbx_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));
-    }
-
-#ifdef _WIN32
-    auto id = static_cast<std::uint32_t>(GetCurrentThreadId());
-#else
-    auto id = static_cast<std::uint32_t>(pthread_self());
-#endif
-    // выдадим параметры 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");
-    }
-
-    if (info.Length() > 1 || info[1].IsNumber()) {
-        mode = txn_mode::parse(info[1].As<Napi::Number>());
-    }
-
-    try
-    {
-        lock_guard lock(*this);
-
-        check();
-
-        auto conf = get_env_userctx(*this);
-
-        auto arg0 = info[0];
-        query_request query = parse_query(mode, 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 arg0 = info[0];
-        keys_request query = parse_keys(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/async/envmou_async.hpp

@@ -1,116 +0,0 @@
-#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