mdbxmou 0.3.8 → 0.3.9

package/README.md

@@ -162,6 +162,20 @@ env.openSync({
 env.closeSync();
 ```
 
+**setOption(option, value)**
+```javascript
+env.setOption(MDBX_Param.envOption.syncBytes, 4 * 1024 * 1024);
+env.setOption(MDBX_Param.envOption.syncPeriod, 0.2); // 200 ms
+```
+
+> **Note**: `syncPeriod` is passed in **seconds** and may be fractional. Other options are passed as non-negative integer values.
+> **Note**: `maxDb` and `maxReaders` are pre-open options. Set them through `open/openSync` (`maxDbi`, `maxReaders`) instead of `setOption()`.
+
+**syncEx(force, nonblock) → number**
+```javascript
+env.syncEx(true, false);
+```
+
 **startWrite() → Transaction**
 ```javascript
 const txn = env.startWrite();
@@ -895,6 +909,29 @@ Note: For ordinal (integer) keys, use keyFlag.number or keyFlag.bigint to specif
 - `MDBX_Param.envFlag.safeNosync` - Safe nosync mode
 - `MDBX_Param.envFlag.utterlyNosync` - Utterly nosync mode
 
+### Environment Options
+- `MDBX_Param.envOption.maxDb` - Raw `MDBX_opt_max_db` option id
+- `MDBX_Param.envOption.maxReaders` - Raw `MDBX_opt_max_readers` option id
+- `MDBX_Param.envOption.syncBytes` - Threshold for forced flushes in weak sync modes
+- `MDBX_Param.envOption.syncPeriod` - Sync period in **seconds** when used with `setOption()`
+- `MDBX_Param.envOption.rpAugmentLimit` - Raw `MDBX_opt_rp_augment_limit`
+- `MDBX_Param.envOption.looseLimit` - Raw `MDBX_opt_loose_limit`
+- `MDBX_Param.envOption.dpReserveLimit` - Raw `MDBX_opt_dp_reserve_limit`
+- `MDBX_Param.envOption.txnDpLimit` - Raw `MDBX_opt_txn_dp_limit`
+- `MDBX_Param.envOption.txnDpInitial` - Raw `MDBX_opt_txn_dp_initial`
+- `MDBX_Param.envOption.spillMaxDenominator` - Raw `MDBX_opt_spill_max_denominator`
+- `MDBX_Param.envOption.spillMinDenominator` - Raw `MDBX_opt_spill_min_denominator`
+- `MDBX_Param.envOption.spillParent4childDenominator` - Raw `MDBX_opt_spill_parent4child_denominator`
+- `MDBX_Param.envOption.mergeThreshold16dot16Percent` - Raw `MDBX_opt_merge_threshold_16dot16_percent`
+- `MDBX_Param.envOption.writethroughThreshold` - Raw `MDBX_opt_writethrough_threshold`
+- `MDBX_Param.envOption.prefaultWriteEnable` - Raw `MDBX_opt_prefault_write_enable`
+- `MDBX_Param.envOption.gcTimeLimit` - Raw `MDBX_opt_gc_time_limit`
+- `MDBX_Param.envOption.preferWafInsteadofBalance` - Raw `MDBX_opt_prefer_waf_insteadof_balance`
+- `MDBX_Param.envOption.subpageLimit` - Raw `MDBX_opt_subpage_limit`
+- `MDBX_Param.envOption.subpageRoomThreshold` - Raw `MDBX_opt_subpage_room_threshold`
+- `MDBX_Param.envOption.subpageReservePrereq` - Raw `MDBX_opt_subpage_reserve_prereq`
+- `MDBX_Param.envOption.subpageReserveLimit` - Raw `MDBX_opt_subpage_reserve_limit`
+
 ### Database Modes  
 - `MDBX_Param.dbMode.create` - Create database if it doesn't exist
 - `MDBX_Param.dbMode.accede` - Open existing database with any flags

package/lib/types.d.ts

@@ -291,6 +291,9 @@ export declare class MDBX_Env {
 
   query(request: MDBXQueryRequest | MDBXQueryRequest[], txnMode?: number): Promise<MDBXQueryResult>;
   keys(request: MDBXKeysRequest | MDBXKeysRequest[], txnMode?: number): Promise<MDBXKeysResult>;
+  /** syncPeriod expects seconds and may be fractional; other options use integer values. */
+  setOption(option: number, value: number | bigint): void;
+  syncEx(force: boolean, nonblock: boolean): number;
 }
 
 export interface MDBX_Param {
@@ -309,6 +312,30 @@ export interface MDBX_Param {
     readonly utterlyNosync: number;
   };
 
+  readonly envOption: {
+    readonly maxDb: number;
+    readonly maxReaders: number;
+    readonly syncBytes: number;
+    readonly syncPeriod: number;
+    readonly rpAugmentLimit: number;
+    readonly looseLimit: number;
+    readonly dpReserveLimit: number;
+    readonly txnDpLimit: number;
+    readonly txnDpInitial: number;
+    readonly spillMaxDenominator: number;
+    readonly spillMinDenominator: number;
+    readonly spillParent4childDenominator: number;
+    readonly mergeThreshold16dot16Percent: number;
+    readonly writethroughThreshold: number;
+    readonly prefaultWriteEnable: number;
+    readonly gcTimeLimit: number;
+    readonly preferWafInsteadofBalance: number;
+    readonly subpageLimit: number;
+    readonly subpageRoomThreshold: number;
+    readonly subpageReservePrereq: number;
+    readonly subpageReserveLimit: number;
+  };
+
   readonly txnMode: {
     readonly ro: number;
   };
@@ -373,4 +400,3 @@ export interface MDBX_Native {
   MDBX_Env: typeof MDBX_Env;
   MDBX_Param: MDBX_Param;
 }
-

package/package.json

@@ -65,7 +65,7 @@
   },
   "gypfile": true,
   "name": "mdbxmou",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "Node bindings for mdbx",
   "repository": {
     "type": "git",

package/src/envmou.cpp

@@ -5,6 +5,8 @@
 #include "async/envmou_open.hpp"
 #include "async/envmou_keys.hpp"
 #include "async/envmou_close.hpp"
+#include <cmath>
+#include <limits>
 
 #ifdef _WIN32
 #include <windows.h>
@@ -14,6 +16,39 @@
 
 namespace mdbxmou {
 
+namespace {
+
+std::uint64_t parse_option_value(const Napi::Env &env, const Napi::Value &arg0)
+{
+    if (arg0.IsBigInt())
+    {
+        bool lossless = false;
+        const auto value = arg0.As<Napi::BigInt>().Uint64Value(&lossless);
+        if (!lossless)
+            throw Napi::TypeError::New(env, "option value BigInt must fit uint64");
+
+        return value;
+    }
+
+    return static_cast<std::uint64_t>(arg0.As<Napi::Number>().DoubleValue());
+}
+
+double parse_sync_period_seconds(const Napi::Env &env, const Napi::Value &arg0)
+{
+    if (!arg0.IsNumber()) {
+        throw Napi::TypeError::New(env, "syncPeriod must be a Number in seconds");
+    }
+
+    const double seconds = arg0.As<Napi::Number>().DoubleValue();
+    if (!std::isfinite(seconds) || seconds < 0) {
+        throw Napi::TypeError::New(env, "syncPeriod must be a non-negative finite Number");
+    }
+
+    return seconds;
+}
+
+} // namespace
+
 Napi::FunctionReference envmou::ctor{};
 
 void envmou::init(const char *class_name, Napi::Env env, Napi::Object exports)
@@ -29,7 +64,9 @@ void envmou::init(const char *class_name, Napi::Env env, Napi::Object exports)
         InstanceMethod("startRead", &envmou::start_read),
         InstanceMethod("startWrite", &envmou::start_write),
         InstanceMethod("query", &envmou::query),
-        InstanceMethod("keys", &envmou::keys)
+        InstanceMethod("keys", &envmou::keys),
+        InstanceMethod("setOption", &envmou::set_option),
+        InstanceMethod("syncEx", &envmou::sync_ex),
     });
     ctor = Napi::Persistent(func);
     ctor.SuppressDestruct();
@@ -93,6 +130,11 @@ env_arg0 envmou::parse(const Napi::Value& arg0)
         rc.max_dbi = static_cast<MDBX_dbi>(value.Uint32Value());
     } 
 
+    if (obj.Has("maxReaders")) {
+        auto value = obj.Get("maxReaders").As<Napi::Number>();
+        rc.max_readers = value.Uint32Value();
+    }
+
     if (obj.Has("geometry")) {
         rc.geom = parse_geometry(obj.Get("geometry"));
     }
@@ -442,4 +484,61 @@ Napi::Value envmou::keys(const Napi::CallbackInfo& info)
     return env.Undefined();
 }
 
-} // namespace mdbxmou
+Napi::Value envmou::set_option(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2)
+    {
+        throw Napi::TypeError::New(env,
+            "expected: option and value");
+    }
+    
+    auto opt = evn_option::parse(info[0]);
+
+    lock_guard lock(*this);
+
+    check();
+
+    uint64_t val = 0;
+    if (static_cast<MDBX_option>(opt) == MDBX_opt_sync_period)
+        val = info[1].As<Napi::Number>().DoubleValue() * 65536u;
+    else
+        val = parse_option_value(env, info[1]);
+
+    auto rc = mdbx_env_set_option(*this, opt, val);
+    if (rc != MDBX_SUCCESS)
+    {
+        throw Napi::Error::New(env, mdbx_strerror(rc));
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value envmou::sync_ex(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2)
+    {
+        throw Napi::TypeError::New(env,
+            "expected: force and nonblock");
+    }
+
+    auto force = info[0].As<Napi::Boolean>().Value();
+    auto nonblock = info[1].As<Napi::Boolean>().Value();
+
+    lock_guard lock(*this);
+
+    check();
+
+    auto rc = mdbx_env_sync_ex(*this, force, nonblock);
+    if (rc != MDBX_SUCCESS)
+    {
+        throw Napi::Error::New(env, mdbx_strerror(rc));
+    }
+
+    return Napi::Number::New(env, rc);
+}
+
+} // namespace mdbxmou

package/src/envmou.hpp

@@ -81,9 +81,13 @@ public:
     // внутри транзакция, получение db и чтение/запись
     Napi::Value query(const Napi::CallbackInfo&);
     Napi::Value keys(const Napi::CallbackInfo&);
-    
+
+    Napi::Value set_option(const Napi::CallbackInfo &);
+    Napi::Value sync_ex(const Napi::CallbackInfo &);
+
     // Методы для создания транзакций
-    Napi::Value start_read(const Napi::CallbackInfo& info) {
+    Napi::Value start_read(const Napi::CallbackInfo &info)
+    {
         return start_transaction(info, {txn_mode::ro});
     }
     Napi::Value start_write(const Napi::CallbackInfo& info) {

package/src/modulemou.cpp

@@ -26,6 +26,31 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
     MDBXMOU_DECLARE_FLAG_NAME(envFlag, "utterlyNosync", env_flag::utterly_nosync);
     mdbx_mou.Set("envFlag", envFlag);
 
+    using mdbxmou::evn_option;
+    Napi::Object envOption = Napi::Object::New(env);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "maxDb", evn_option::max_db);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "maxReaders", evn_option::max_readers);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "syncBytes", evn_option::sync_bytes);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "syncPeriod", evn_option::sync_period);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "rpAugmentLimit", evn_option::rp_augment_limit);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "looseLimit", evn_option::loose_limit);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "dpReserveLimit", evn_option::dp_reserve_limit);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "txnDpLimit", evn_option::txn_dp_limit);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "txnDpInitial", evn_option::txn_dp_initial);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "spillMaxDenominator", evn_option::spill_max_denominator);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "spillMinDenominator", evn_option::spill_min_denominator);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "spillParent4childDenominator", evn_option::spill_parent4child_denominator);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "mergeThreshold16dot16Percent", evn_option::merge_threshold_16dot16_percent);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "writethroughThreshold", evn_option::writethrough_threshold);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "prefaultWriteEnable", evn_option::prefault_write_enable);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "gcTimeLimit", evn_option::gc_time_limit);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "preferWafInsteadofBalance", evn_option::prefer_waf_insteadof_balance);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "subpageLimit", evn_option::subpage_limit);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "subpageRoomThreshold", evn_option::subpage_room_threshold);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "subpageReservePrereq", evn_option::subpage_reserve_prereq);
+    MDBXMOU_DECLARE_FLAG_NAME(envOption, "subpageReserveLimit", evn_option::subpage_reserve_limit);
+    mdbx_mou.Set("envOption", envOption);
+
     using mdbxmou::txn_mode;
     Napi::Object txnMode = Napi::Object::New(env);
     MDBXMOU_DECLARE_FLAG_NAME(txnMode, "ro", txn_mode::ro);

package/src/typemou.hpp

@@ -130,6 +130,43 @@ struct env_flag {
     }
 };
 
+struct evn_option {
+    enum type : int {
+        max_db = MDBX_opt_max_db,
+        max_readers = MDBX_opt_max_readers,
+        sync_bytes = MDBX_opt_sync_bytes,
+        sync_period = MDBX_opt_sync_period,
+        rp_augment_limit = MDBX_opt_rp_augment_limit,
+        loose_limit = MDBX_opt_loose_limit,
+        dp_reserve_limit = MDBX_opt_dp_reserve_limit,
+        txn_dp_limit = MDBX_opt_txn_dp_limit,
+        txn_dp_initial = MDBX_opt_txn_dp_initial,
+        spill_max_denominator = MDBX_opt_spill_max_denominator,
+        spill_min_denominator = MDBX_opt_spill_min_denominator,
+        spill_parent4child_denominator = MDBX_opt_spill_parent4child_denominator,
+        merge_threshold_16dot16_percent = MDBX_opt_merge_threshold_16dot16_percent,
+        writethrough_threshold = MDBX_opt_writethrough_threshold,
+        prefault_write_enable = MDBX_opt_prefault_write_enable,
+        gc_time_limit = MDBX_opt_gc_time_limit,
+        prefer_waf_insteadof_balance = MDBX_opt_prefer_waf_insteadof_balance,
+        subpage_limit = MDBX_opt_subpage_limit,
+        subpage_room_threshold = MDBX_opt_subpage_room_threshold,
+        subpage_reserve_prereq = MDBX_opt_subpage_reserve_prereq,
+        subpage_reserve_limit = MDBX_opt_subpage_reserve_limit
+    };
+    int val{};
+
+    static inline evn_option parse(const Napi::Value &arg0)
+    {
+        return {arg0.As<Napi::Number>().Int32Value()};
+    }
+
+    operator MDBX_option() const noexcept
+    {
+        return static_cast<MDBX_option>(val);
+    }
+};
+
 struct txn_mode {
     enum type : int {
         ro = MDBX_TXN_RDONLY

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