mdbxmou 0.3.2 → 0.3.3

package/lib/types.d.ts

@@ -147,6 +147,36 @@ export interface MDBX_Cursor<K extends MDBXKey = MDBXKey, V extends MDBXValue =
    */
   forEach(callback: (item: MDBXCursorResult<K, V>) => boolean | void, backward?: boolean): void;
   
+  /** 
+   * Check if cursor is at end-of-data (beyond first or last record).
+   * @returns true if cursor has no valid position
+   */
+  eof(): boolean;
+  
+  /** 
+   * Check if cursor is on first record in database.
+   * @returns true if on first record
+   */
+  onFirst(): boolean;
+  
+  /** 
+   * Check if cursor is on last record in database.
+   * @returns true if on last record
+   */
+  onLast(): boolean;
+  
+  /** 
+   * Check if cursor is on first value of current key (DUPSORT databases).
+   * @returns true if on first value for current key
+   */
+  onFirstMultival(): boolean;
+  
+  /** 
+   * Check if cursor is on last value of current key (DUPSORT databases).
+   * @returns true if on last value for current key
+   */
+  onLastMultival(): boolean;
+  
   /** 
    * Close cursor. Must be called before transaction commit/abort.
    * Safe to call multiple times.

package/package.json

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

package/src/cursormou.cpp

@@ -2,272 +2,234 @@
 #include "dbimou.hpp"
 #include "txnmou.hpp"
 
-namespace mdbxmou {
-
-Napi::FunctionReference cursormou::ctor{};
-
-void cursormou::init(const char *class_name, Napi::Env env)
-{
-    auto func = DefineClass(env, class_name, {
-        InstanceMethod("first", &cursormou::first),
-        InstanceMethod("last", &cursormou::last),
-        InstanceMethod("next", &cursormou::next),
-        InstanceMethod("prev", &cursormou::prev),
-        InstanceMethod("seek", &cursormou::seek),
-        InstanceMethod("seekGE", &cursormou::seek_ge),
-        InstanceMethod("current", &cursormou::current),
-        InstanceMethod("put", &cursormou::put),
-        InstanceMethod("del", &cursormou::del),
-        InstanceMethod("forEach", &cursormou::for_each),
-        InstanceMethod("close", &cursormou::close),
-    });
-
-    ctor = Napi::Persistent(func);
-    ctor.SuppressDestruct();
-}
-
-void cursormou::do_close() noexcept
+namespace mdbxmou
 {
-    if (cursor_) {
-        ::mdbx_cursor_close(std::exchange(cursor_, nullptr));
-        if (txn_) {
-            --(*txn_);
-        }
-    }
-}
 
-cursormou::~cursormou() 
-{
-    do_close();
-}
+    Napi::FunctionReference cursormou::ctor{};
 
-void cursormou::attach(txnmou& txn, dbimou& dbi, MDBX_cursor* cursor)
-{
-    txn_ = &txn;
-    dbi_ = &dbi;
-    cursor_ = cursor;
-    ++(*txn_);
-}
-
-// Внутренний хелпер для навигации
-Napi::Value cursormou::move(const Napi::Env& env, MDBX_cursor_op op)
-{
-    if (!cursor_) {
-        throw Napi::Error::New(env, "cursor closed");
-    }
-    
-    keymou key{};
-    valuemou val{};   
-    auto rc = mdbx_cursor_get(cursor_, key, val, op);
-    if (rc == MDBX_NOTFOUND) {
-        return env.Undefined();
-    }
-    
-    if (rc != MDBX_SUCCESS) {
-        throw Napi::Error::New(env, mdbx_strerror(rc));
+    void cursormou::init(const char *class_name, Napi::Env env)
+    {
+        auto func = DefineClass(env, class_name, {
+            InstanceMethod("first", &cursormou::first),
+            InstanceMethod("last", &cursormou::last),
+            InstanceMethod("next", &cursormou::next),
+            InstanceMethod("prev", &cursormou::prev),
+            InstanceMethod("seek", &cursormou::seek),
+            InstanceMethod("seekGE", &cursormou::seek_ge),
+            InstanceMethod("current", &cursormou::current),
+            InstanceMethod("eof", &cursormou::eof),
+            InstanceMethod("onFirst", &cursormou::on_first),
+            InstanceMethod("onLast", &cursormou::on_last),
+            InstanceMethod("onFirstMultival", &cursormou::on_first_multival),
+            InstanceMethod("onLastMultival", &cursormou::on_last_multival),
+            InstanceMethod("put", &cursormou::put),
+            InstanceMethod("del", &cursormou::del),
+            InstanceMethod("forEach", &cursormou::for_each),
+            InstanceMethod("close", &cursormou::close),
+        });
+
+        ctor = Napi::Persistent(func);
+        ctor.SuppressDestruct();
     }
-    
-    // Возвращаем {key, value}
-    auto result = Napi::Object::New(env);
-    
-    auto key_mode = dbi_->get_key_mode();
-    auto key_flag = dbi_->get_key_flag();
-    auto value_flag = dbi_->get_value_flag();
-    
-    // Ключ
-    if (key_mode.val & key_mode::ordinal) {
-        if (key_flag.val & base_flag::bigint) {
-            result.Set("key", key.to_bigint(env));
-        } else {
-            result.Set("key", key.to_number(env));
+
+    void cursormou::do_close() noexcept
+    {
+        if (cursor_) {
+            ::mdbx_cursor_close(std::exchange(cursor_, nullptr));
+            if (txn_) {
+                --(*txn_);
+            }
         }
-    } else {
-        result.Set("key", key.to_string(env));
     }
-    
-    // Значение
-    if (value_flag.val & base_flag::string) {
-        result.Set("value", val.to_string(env));
-    } else {
-        result.Set("value", val.to_buffer(env));
+
+    cursormou::~cursormou()
+    {
+        do_close();
     }
-    
-    return result;
-}
 
-Napi::Value cursormou::first(const Napi::CallbackInfo& info) {
-    return move(info.Env(), MDBX_FIRST);
-}
+    void cursormou::attach(txnmou &txn, dbimou &dbi, MDBX_cursor *cursor)
+    {
+        txn_ = &(++txn);
+        dbi_ = &dbi;
+        cursor_ = cursor;
+    }
 
-Napi::Value cursormou::last(const Napi::CallbackInfo& info) {
-    return move(info.Env(), MDBX_LAST);
-}
+    // Внутренний хелпер для навигации
+    Napi::Value cursormou::move(const Napi::Env &env, MDBX_cursor_op op)
+    {
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
 
-Napi::Value cursormou::next(const Napi::CallbackInfo& info) {
-    return move(info.Env(), MDBX_NEXT);
-}
+        keymou key{};
+        valuemou val{};
+        auto rc = mdbx_cursor_get(cursor_, key, val, op);
+        if (rc == MDBX_NOTFOUND) {
+            return env.Undefined();
+        }
 
-Napi::Value cursormou::prev(const Napi::CallbackInfo& info) {
-    return move(info.Env(), MDBX_PREV);
-}
+        if (rc != MDBX_SUCCESS) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
+        }
 
-Napi::Value cursormou::current(const Napi::CallbackInfo& info) {
-    return move(info.Env(), MDBX_GET_CURRENT);
-}
+        // Возвращаем {key, value}
+        auto result = Napi::Object::New(env);
 
-// Хелпер для поиска
-Napi::Value cursormou::seek_impl(const Napi::CallbackInfo& info, MDBX_cursor_op op)
-{
-    Napi::Env env = info.Env();
-    
-    if (!cursor_) {
-        throw Napi::Error::New(env, "cursor closed");
-    }
-    
-    if (info.Length() < 1) {
-        throw Napi::Error::New(env, "key required");
-    }
-    
-    auto key_mode = dbi_->get_key_mode();
-    
-    keymou key = (key_mode.val & key_mode::ordinal) ?
-        keymou::from(info[0], env, key_num_) : 
-        keymou::from(info[0], env, key_buf_);
-    
-    valuemou val{};
-    auto rc = mdbx_cursor_get(cursor_, key, val, op);
-    if (MDBX_NOTFOUND == rc) {
-        return env.Undefined();
-    }
+        auto key_mode = dbi_->get_key_mode();
+        auto key_flag = dbi_->get_key_flag();
+        auto value_flag = dbi_->get_value_flag();
 
-    if (MDBX_SUCCESS != rc) {
-        throw Napi::Error::New(env, mdbx_strerror(rc));
-    }
-    
-    // Возвращаем {key, value}
-    auto result = Napi::Object::New(env);
-    
-    auto key_flag = dbi_->get_key_flag();
-    auto value_flag = dbi_->get_value_flag();
-    
-    // Ключ
-    if (key_mode.val & key_mode::ordinal) {
-        if (key_flag.val & base_flag::bigint) {
-            result.Set("key", key.to_bigint(env));
+        // Ключ
+        if (key_mode.val & key_mode::ordinal) {
+            if (key_flag.val & base_flag::bigint) {
+                result.Set("key", key.to_bigint(env));
+            } else {
+                result.Set("key", key.to_number(env));
+            }
         } else {
-            result.Set("key", key.to_number(env));
+            result.Set("key", key.to_string(env));
         }
-    } else {
-        result.Set("key", key.to_string(env));
-    }
-    
-    // Значение
-    if (value_flag.val & base_flag::string) {
-        result.Set("value", val.to_string(env));
-    } else {
-        result.Set("value", val.to_buffer(env));
+
+        // Значение
+        if (value_flag.val & base_flag::string) {
+            result.Set("value", val.to_string(env));
+        } else {
+            result.Set("value", val.to_buffer(env));
+        }
+
+        return result;
     }
-    
-    return result;
-}
-
-Napi::Value cursormou::seek(const Napi::CallbackInfo& info) {
-    return seek_impl(info, MDBX_SET_KEY);
-}
-
-Napi::Value cursormou::seek_ge(const Napi::CallbackInfo& info) {
-    return seek_impl(info, MDBX_SET_RANGE);
-}
-
-Napi::Value cursormou::put(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    if (!cursor_) {
-        throw Napi::Error::New(env, "cursor closed");
+
+    Napi::Value cursormou::first(const Napi::CallbackInfo &info)
+    {
+        return move(info.Env(), MDBX_FIRST);
     }
-    
-    if (info.Length() < 2) {
-        throw Napi::Error::New(env, "key and value required");
+
+    Napi::Value cursormou::last(const Napi::CallbackInfo &info)
+    {
+        return move(info.Env(), MDBX_LAST);
     }
-    
-    auto key_mode = dbi_->get_key_mode();
-    
-    keymou key = (key_mode.val & key_mode::ordinal) ?
-        keymou::from(info[0], env, key_num_) : 
-        keymou::from(info[0], env, key_buf_);
-    
-    valuemou val = valuemou::from(info[1], env, val_buf_);
-    
-    // Опциональный флаг put_mode (по умолчанию MDBX_UPSERT)
-    MDBX_put_flags_t flags = MDBX_UPSERT;
-    if (info.Length() > 2 && info[2].IsNumber()) {
-        flags = static_cast<MDBX_put_flags_t>(info[2].As<Napi::Number>().Int32Value());
+
+    Napi::Value cursormou::next(const Napi::CallbackInfo &info)
+    {
+        return move(info.Env(), MDBX_NEXT);
     }
-    
-    auto rc = mdbx_cursor_put(cursor_, key, val, flags);
-    if (MDBX_SUCCESS != rc) {
-        throw Napi::Error::New(env, mdbx_strerror(rc));
+
+    Napi::Value cursormou::prev(const Napi::CallbackInfo &info)
+    {
+        return move(info.Env(), MDBX_PREV);
     }
-    
-    return env.Undefined();
-}
-
-Napi::Value cursormou::del(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    if (!cursor_) {
-        throw Napi::Error::New(env, "cursor closed");
+
+    Napi::Value cursormou::current(const Napi::CallbackInfo &info)
+    {
+        return move(info.Env(), MDBX_GET_CURRENT);
     }
-    
-    // Опциональный флаг (MDBX_NODUPDATA для удаления только текущего значения в multi-value)
-    MDBX_put_flags_t flags = MDBX_CURRENT;
-    if (info.Length() > 0 && info[0].IsNumber()) {
-        flags = static_cast<MDBX_put_flags_t>(info[0].As<Napi::Number>().Int32Value());
+
+    Napi::Value cursormou::eof(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+        auto rc = ::mdbx_cursor_eof(cursor_);
+        if (rc == MDBX_RESULT_TRUE)
+            return Napi::Boolean::New(env, true);
+        if (rc == MDBX_RESULT_FALSE)
+            return Napi::Boolean::New(env, false);
+        throw Napi::Error::New(env, mdbx_strerror(rc));
     }
-    
-    auto rc = mdbx_cursor_del(cursor_, flags);
-    if (MDBX_NOTFOUND == rc) {
-        return Napi::Boolean::New(env, false);
+
+    Napi::Value cursormou::on_first(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+        auto rc = ::mdbx_cursor_on_first(cursor_);
+        if (rc == MDBX_RESULT_TRUE)
+            return Napi::Boolean::New(env, true);
+        if (rc == MDBX_RESULT_FALSE)
+            return Napi::Boolean::New(env, false);
+        throw Napi::Error::New(env, mdbx_strerror(rc));
     }
-    
-    if (MDBX_SUCCESS != rc) {
+
+    Napi::Value cursormou::on_last(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+        auto rc = ::mdbx_cursor_on_last(cursor_);
+        if (rc == MDBX_RESULT_TRUE)
+            return Napi::Boolean::New(env, true);
+        if (rc == MDBX_RESULT_FALSE)
+            return Napi::Boolean::New(env, false);
         throw Napi::Error::New(env, mdbx_strerror(rc));
     }
-    
-    return Napi::Boolean::New(env, true);
-}
-
-// forEach(callback, backward = false)
-// callback({key, value}) => true продолжить, false/undefined остановить
-Napi::Value cursormou::for_each(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    if (!cursor_) {
-        throw Napi::Error::New(env, "cursor closed");
+
+    Napi::Value cursormou::on_first_multival(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+        auto rc = ::mdbx_cursor_on_first_dup(cursor_);
+        if (rc == MDBX_RESULT_TRUE)
+            return Napi::Boolean::New(env, true);
+        if (rc == MDBX_RESULT_FALSE)
+            return Napi::Boolean::New(env, false);
+        throw Napi::Error::New(env, mdbx_strerror(rc));
     }
-    
-    if (info.Length() < 1 || !info[0].IsFunction()) {
-        throw Napi::TypeError::New(env, "forEach: callback function required");
+
+    Napi::Value cursormou::on_last_multival(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+        auto rc = ::mdbx_cursor_on_last_dup(cursor_);
+        if (rc == MDBX_RESULT_TRUE)
+            return Napi::Boolean::New(env, true);
+        if (rc == MDBX_RESULT_FALSE)
+            return Napi::Boolean::New(env, false);
+        throw Napi::Error::New(env, mdbx_strerror(rc));
     }
-    
-    auto callback = info[0].As<Napi::Function>();
-    bool backward = info.Length() > 1 && info[1].ToBoolean().Value();
-    
-    auto key_mode = dbi_->get_key_mode();
-    auto key_flag = dbi_->get_key_flag();
-    auto value_flag = dbi_->get_value_flag();
-    
-    MDBX_cursor_op start_op = backward ? MDBX_LAST : MDBX_FIRST;
-    MDBX_cursor_op move_op = backward ? MDBX_PREV : MDBX_NEXT;
-    
-    keymou key{};
-    valuemou val{};
-    // Первое позиционирование
-    auto rc = mdbx_cursor_get(cursor_, key, val, start_op);
-    while (MDBX_SUCCESS == rc) 
+
+    // Хелпер для поиска
+    Napi::Value cursormou::seek_impl(const Napi::CallbackInfo &info, MDBX_cursor_op op)
     {
+        Napi::Env env = info.Env();
+
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+
+        if (info.Length() < 1) {
+            throw Napi::Error::New(env, "key required");
+        }
+
+        auto key_mode = dbi_->get_key_mode();
+
+        keymou key = (key_mode.val & key_mode::ordinal) ? 
+            keymou::from(info[0], env, key_num_) : 
+            keymou::from(info[0], env, key_buf_);
+
+        valuemou val{};
+        auto rc = mdbx_cursor_get(cursor_, key, val, op);
+        if (MDBX_NOTFOUND == rc) {
+            return env.Undefined();
+        }
+
+        if (MDBX_SUCCESS != rc) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
+        }
+
+        // Возвращаем {key, value}
         auto result = Napi::Object::New(env);
-        
+
+        auto key_flag = dbi_->get_key_flag();
+        auto value_flag = dbi_->get_value_flag();
+
         // Ключ
         if (key_mode.val & key_mode::ordinal) {
             if (key_flag.val & base_flag::bigint) {
@@ -278,36 +240,160 @@ Napi::Value cursormou::for_each(const Napi::CallbackInfo& info) {
         } else {
             result.Set("key", key.to_string(env));
         }
-        
+
         // Значение
         if (value_flag.val & base_flag::string) {
             result.Set("value", val.to_string(env));
         } else {
             result.Set("value", val.to_buffer(env));
         }
-        
-        // Вызов callback
-        auto ret = callback.Call({result});
-        
-        // true stops the scan, false/undefined continues (same as dbi.forEach)
-        if (ret.IsBoolean() && ret.As<Napi::Boolean>().Value()) {
-            break;
+
+        return result;
+    }
+
+    Napi::Value cursormou::seek(const Napi::CallbackInfo &info)
+    {
+        return seek_impl(info, MDBX_SET_KEY);
+    }
+
+    Napi::Value cursormou::seek_ge(const Napi::CallbackInfo &info)
+    {
+        return seek_impl(info, MDBX_SET_RANGE);
+    }
+
+    Napi::Value cursormou::put(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+
+        if (info.Length() < 2) {
+            throw Napi::Error::New(env, "key and value required");
+        }
+
+        auto key_mode = dbi_->get_key_mode();
+
+        keymou key = (key_mode.val & key_mode::ordinal) ? 
+            keymou::from(info[0], env, key_num_) : 
+            keymou::from(info[0], env, key_buf_);
+
+        valuemou val = valuemou::from(info[1], env, val_buf_);
+
+        // Опциональный флаг put_mode (по умолчанию MDBX_UPSERT)
+        MDBX_put_flags_t flags = MDBX_UPSERT;
+        if (info.Length() > 2 && info[2].IsNumber()) {
+            flags = static_cast<MDBX_put_flags_t>(info[2].As<Napi::Number>().Int32Value());
+        }
+
+        auto rc = mdbx_cursor_put(cursor_, key, val, flags);
+        if (MDBX_SUCCESS != rc) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
         }
-        
-        // Следующий элемент
-        rc = mdbx_cursor_get(cursor_, key, val, move_op);
+
+        return env.Undefined();
     }
-    
-    if (rc != MDBX_SUCCESS && rc != MDBX_NOTFOUND) {
-        throw Napi::Error::New(env, mdbx_strerror(rc));
+
+    Napi::Value cursormou::del(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+
+        // Опциональный флаг (MDBX_NODUPDATA для удаления только текущего значения в multi-value)
+        MDBX_put_flags_t flags = MDBX_CURRENT;
+        if (info.Length() > 0 && info[0].IsNumber()) {
+            flags = static_cast<MDBX_put_flags_t>(info[0].As<Napi::Number>().Int32Value());
+        }
+
+        auto rc = mdbx_cursor_del(cursor_, flags);
+        if (MDBX_NOTFOUND == rc) {
+            return Napi::Boolean::New(env, false);
+        }
+
+        if (MDBX_SUCCESS != rc) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
+        }
+
+        return Napi::Boolean::New(env, true);
+    }
+
+    // forEach(callback, backward = false)
+    // callback({key, value}) => true продолжить, false/undefined остановить
+    Napi::Value cursormou::for_each(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+
+        if (info.Length() < 1 || !info[0].IsFunction()) {
+            throw Napi::TypeError::New(env, "forEach: callback function required");
+        }
+
+        auto callback = info[0].As<Napi::Function>();
+        bool backward = info.Length() > 1 && info[1].ToBoolean().Value();
+
+        auto key_mode = dbi_->get_key_mode();
+        auto key_flag = dbi_->get_key_flag();
+        auto value_flag = dbi_->get_value_flag();
+
+        MDBX_cursor_op start_op = backward ? MDBX_LAST : MDBX_FIRST;
+        MDBX_cursor_op move_op = backward ? MDBX_PREV : MDBX_NEXT;
+
+        keymou key{};
+        valuemou val{};
+        // Первое позиционирование
+        auto rc = mdbx_cursor_get(cursor_, key, val, start_op);
+        while (MDBX_SUCCESS == rc)
+        {
+            auto result = Napi::Object::New(env);
+
+            // Ключ
+            if (key_mode.val & key_mode::ordinal) {
+                if (key_flag.val & base_flag::bigint) {
+                    result.Set("key", key.to_bigint(env));
+                } else {
+                    result.Set("key", key.to_number(env));
+                }
+            } else {
+                result.Set("key", key.to_string(env));
+            }
+
+            // Значение
+            if (value_flag.val & base_flag::string) {
+                result.Set("value", val.to_string(env));
+            } else {
+                result.Set("value", val.to_buffer(env));
+            }
+
+            // Вызов callback
+            auto ret = callback.Call({result});
+
+            // true stops the scan, false/undefined continues (same as dbi.forEach)
+            if (ret.IsBoolean() && ret.ToBoolean()) {
+                break;
+            }
+
+            // Следующий элемент
+            rc = mdbx_cursor_get(cursor_, key, val, move_op);
+        }
+
+        if (rc != MDBX_SUCCESS && rc != MDBX_NOTFOUND) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
+        }
+
+        return env.Undefined();
+    }
+
+    Napi::Value cursormou::close(const Napi::CallbackInfo &info)
+    {
+        do_close();
+        return info.Env().Undefined();
     }
-    
-    return env.Undefined();
-}
-
-Napi::Value cursormou::close(const Napi::CallbackInfo& info) {
-    do_close();
-    return info.Env().Undefined();
-}
 
 } // namespace mdbxmou

package/src/cursormou.hpp

@@ -53,6 +53,13 @@ public:
     // Текущая позиция
     Napi::Value current(const Napi::CallbackInfo&);
     
+    // Статус курсора
+    Napi::Value eof(const Napi::CallbackInfo&);
+    Napi::Value on_first(const Napi::CallbackInfo&);
+    Napi::Value on_last(const Napi::CallbackInfo&);
+    Napi::Value on_first_multival(const Napi::CallbackInfo&);
+    Napi::Value on_last_multival(const Napi::CallbackInfo&);
+    
     // Модификация
     Napi::Value put(const Napi::CallbackInfo&);
     Napi::Value del(const Napi::CallbackInfo&);

package/src/envmou.cpp

@@ -193,11 +193,6 @@ MDBX_env* envmou::create_and_open(const env_arg0& arg0)
         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) {

package/src/txnmou.cpp

@@ -155,8 +155,7 @@ Napi::Value txnmou::open_cursor(const Napi::CallbackInfo& info) {
     auto* dbi = dbimou::Unwrap(arg0);
     
     MDBX_cursor* cursor{};
-    int rc = mdbx_cursor_open(txn_.get(), dbi->get_id(), &cursor);
-    
+    auto rc = mdbx_cursor_open(txn_.get(), dbi->get_id(), &cursor);
     if (rc != MDBX_SUCCESS) {
         throw Napi::Error::New(env, std::string("mdbx_cursor_open: ") + mdbx_strerror(rc));
     }
@@ -174,10 +173,8 @@ Napi::Value txnmou::is_active(const Napi::CallbackInfo& info) {
 
 void txnmou::attach(envmou& env, MDBX_txn* txn, txn_mode mode) 
 {
-    env_ = &env;
+    env_ = &(++env);
     mode_ = mode;
-    
-    ++(*env_);
     txn_.reset(txn);
 }
 

package/src/txnmou.hpp

@@ -46,6 +46,7 @@ public:
 
     Napi::Value commit(const Napi::CallbackInfo&);
     Napi::Value abort(const Napi::CallbackInfo&);
+    
     Napi::Value open_map(const Napi::CallbackInfo& info) {
         return get_dbi(info, db_mode{});
     }
@@ -60,9 +61,17 @@ public:
     }
 
     // Cursor counting
-    txnmou& operator++() noexcept { ++cursor_count_; return *this; }
-    txnmou& operator--() noexcept { --cursor_count_; return *this; }
-    std::size_t cursor_count() const noexcept { return cursor_count_; }
+    txnmou& operator++() noexcept { 
+        ++cursor_count_; return *this; 
+    }
+    
+    txnmou& operator--() noexcept { 
+        --cursor_count_; return *this; 
+    }
+    
+    std::size_t cursor_count() const noexcept { 
+        return cursor_count_; 
+    }
 
     Napi::Value is_active(const Napi::CallbackInfo&);