mdbxmou 0.2.6 → 0.3.0

package/CMakeLists.txt

@@ -24,6 +24,7 @@ add_library(${PROJECT_NAME} SHARED
     "src/envmou.cpp" 
     "src/txnmou.cpp"
     "src/dbimou.cpp"
+    "src/cursormou.cpp"
     "src/dbi.cpp")
 
 # Gives our library file a .node extension without any "lib" prefix

package/README.md

@@ -9,7 +9,7 @@ High-performance Node.js binding for libmdbx — a fast, lightweight, embedded k
 - **Transactions** — ACID transactions with read/write modes
 - **Multiple key/value types** — String, binary, ordinal (integer) keys
 - **Batch operations** — Efficient multi-key read/write
-- **Memory-mapped** — Zero-copy data access
+- **Memory-mapped** — High-performance memory-mapped I/O
 
 ## Installation
 
@@ -266,6 +266,199 @@ dbi.drop(txn, true);
 dbi.drop(txn);
 ```
 
+### Cursor (MDBX_Cursor)
+
+Cursors provide low-level control for database traversal with positioning and iteration capabilities.
+
+#### Creating a Cursor
+```javascript
+const txn = env.startRead();
+const dbi = txn.openMap();
+const cursor = txn.openCursor(dbi);
+```
+
+#### Navigation Methods
+
+**first() → {key, value} | undefined**
+```javascript
+const item = cursor.first();
+if (item) {
+  console.log(item.key, item.value);
+}
+```
+
+**last() → {key, value} | undefined**
+```javascript
+const item = cursor.last();
+```
+
+**next() → {key, value} | undefined**
+```javascript
+const item = cursor.next();
+```
+
+**prev() → {key, value} | undefined**
+```javascript
+const item = cursor.prev();
+```
+
+**current() → {key, value} | undefined**
+```javascript
+const item = cursor.current();
+```
+
+#### Search Methods
+
+**seek(key) → {key, value} | undefined**
+
+Exact key match. Returns `undefined` if key not found.
+```javascript
+const item = cursor.seek('user:123');
+if (item) {
+  console.log('Found:', item.value);
+}
+```
+
+**seekGE(key) → {key, value} | undefined**
+
+Find first key greater or equal to given key (lower_bound).
+```javascript
+const item = cursor.seekGE('user:100');
+// Returns first key >= 'user:100'
+```
+
+#### Modification Methods
+
+**put(key, value, [flags])**
+
+Insert or update a record at cursor position.
+```javascript
+cursor.put('newKey', 'newValue');
+
+// With flags (MDBX_NOOVERWRITE, etc.)
+cursor.put('key', 'value', MDBX_Param.queryMode.insertUnique);
+```
+
+**del([flags]) → boolean**
+
+Delete record at current cursor position. Returns `true` if deleted, `false` if not found.
+```javascript
+cursor.seek('keyToDelete');
+const deleted = cursor.del();
+```
+
+#### Control Methods
+
+**close()**
+```javascript
+cursor.close();
+```
+
+#### Cursor Examples
+
+**Iterate all records:**
+```javascript
+const cursor = txn.openCursor(dbi);
+
+for (let item = cursor.first(); item; item = cursor.next()) {
+  console.log(item.key, item.value.toString());
+}
+
+cursor.close();
+txn.abort();
+```
+
+**Range iteration:**
+```javascript
+const cursor = txn.openCursor(dbi);
+
+// Find all keys starting with 'user:'
+for (let item = cursor.seekGE('user:'); item; item = cursor.next()) {
+  if (!item.key.startsWith('user:')) break;
+  console.log(item.key, item.value.toString());
+}
+
+cursor.close();
+```
+
+**Pagination:**
+```javascript
+function getPage(cursor, offset, limit) {
+  const results = [];
+  
+  let item = cursor.first();
+  
+  // Skip offset
+  for (let i = 0; i < offset && item; i++) {
+    item = cursor.next();
+  }
+  
+  // Collect limit items
+  for (let i = 0; i < limit && item; i++) {
+    results.push({ key: item.key, value: item.value.toString() });
+    item = cursor.next();
+  }
+  
+  return results;
+}
+
+const txn = env.startRead();
+const dbi = txn.openMap();
+const cursor = txn.openCursor(dbi);
+
+const page1 = getPage(cursor, 0, 10);   // First 10 items
+const page2 = getPage(cursor, 10, 10);  // Next 10 items
+
+cursor.close();
+txn.abort();
+```
+
+**Reverse iteration:**
+```javascript
+const cursor = txn.openCursor(dbi);
+
+for (let item = cursor.last(); item; item = cursor.prev()) {
+  console.log(item.key, item.value.toString());
+}
+
+cursor.close();
+```
+
+**Bulk insert with cursor:**
+```javascript
+const txn = env.startWrite();
+const dbi = txn.createMap();
+const cursor = txn.openCursor(dbi);
+
+for (let i = 0; i < 1000; i++) {
+  cursor.put(`key${i}`, `value${i}`);
+}
+
+cursor.close();
+txn.commit();
+```
+
+**Delete with cursor:**
+```javascript
+const txn = env.startWrite();
+const dbi = txn.openMap();
+const cursor = txn.openCursor(dbi);
+
+// Delete specific key
+if (cursor.seek('keyToDelete')) {
+  cursor.del();
+}
+
+// Delete range
+for (let item = cursor.seekGE('prefix:'); item; item = cursor.next()) {
+  if (!item.key.startsWith('prefix:')) break;
+  cursor.del();
+}
+
+cursor.close();
+txn.commit();
+```
+
 ## Key and Value Types
 
 ### Key Modes (MDBX_Param.keyMode)
@@ -623,7 +816,7 @@ Note: For ordinal (integer) keys, use keyFlag.number or keyFlag.bigint to specif
 1. **Use ordinal keys** for integer data - much faster than string keys
 2. **Batch operations** - Use query API for bulk operations
 3. **Reuse transactions** - Keep read transactions open for multiple operations
-4. **Memory mapping** - MDBX uses memory-mapped files for zero-copy access
+4. **Memory mapping** - MDBX uses memory-mapped files for fast I/O
 5. **Transaction scope** - Always pass transaction object to DBI methods
 
 ## License

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.6",
+  "version": "0.3.0",
   "description": "Node bindings for mdbx",
   "repository": {
     "type": "git",

package/src/cursormou.cpp

@@ -0,0 +1,316 @@
+#include "cursormou.hpp"
+#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
+{
+    if (cursor_) {
+        ::mdbx_cursor_close(std::exchange(cursor_, nullptr));
+        if (txn_) {
+            --(*txn_);
+        }
+    }
+}
+
+cursormou::~cursormou() 
+{
+    do_close();
+}
+
+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));
+    }
+    
+    // Возвращаем {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));
+        }
+    } 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));
+    }
+    
+    return result;
+}
+
+Napi::Value cursormou::first(const Napi::CallbackInfo& info) {
+    return move(info.Env(), MDBX_FIRST);
+}
+
+Napi::Value cursormou::last(const Napi::CallbackInfo& info) {
+    return move(info.Env(), MDBX_LAST);
+}
+
+Napi::Value cursormou::next(const Napi::CallbackInfo& info) {
+    return move(info.Env(), MDBX_NEXT);
+}
+
+Napi::Value cursormou::prev(const Napi::CallbackInfo& info) {
+    return move(info.Env(), MDBX_PREV);
+}
+
+Napi::Value cursormou::current(const Napi::CallbackInfo& info) {
+    return move(info.Env(), MDBX_GET_CURRENT);
+}
+
+// Хелпер для поиска
+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) {
+            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));
+    }
+    
+    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));
+    }
+    
+    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");
+    }
+    
+    // Опциональный флаг (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});
+        
+        // Если вернул false или undefined - остановить
+        if (ret.IsBoolean() && !ret.As<Napi::Boolean>().Value()) {
+            break;
+        }
+        if (ret.IsUndefined() || ret.IsNull()) {
+            // undefined/null = продолжаем (как forEach в JS)
+        }
+        
+        // Следующий элемент
+        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();
+}
+
+} // namespace mdbxmou

package/src/cursormou.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "typemou.hpp"
+#include "valuemou.hpp"
+
+namespace mdbxmou {
+
+class dbimou;
+class txnmou;
+
+class cursormou final 
+    : public Napi::ObjectWrap<cursormou>
+{
+private:
+    txnmou* txn_{nullptr};
+    dbimou* dbi_{nullptr};
+    MDBX_cursor* cursor_{nullptr};
+    
+    // Буферы для ключей/значений
+    buffer_type key_buf_{};
+    buffer_type val_buf_{};
+    std::uint64_t key_num_{};
+
+    // Внутренний хелпер для навигации
+    Napi::Value move(const Napi::Env& env, MDBX_cursor_op op);
+    
+    // Хелпер для поиска
+    Napi::Value seek_impl(const Napi::CallbackInfo& info, MDBX_cursor_op op);
+    
+    // Закрытие курсора
+    void do_close() noexcept;
+
+public:    
+    static Napi::FunctionReference ctor;
+    static void init(const char *class_name, Napi::Env env);
+
+    cursormou(const Napi::CallbackInfo& info)
+        : Napi::ObjectWrap<cursormou>(info) 
+    {   }
+
+    ~cursormou();
+
+    // Навигация
+    Napi::Value first(const Napi::CallbackInfo&);
+    Napi::Value last(const Napi::CallbackInfo&);
+    Napi::Value next(const Napi::CallbackInfo&);
+    Napi::Value prev(const Napi::CallbackInfo&);
+    
+    // Поиск
+    Napi::Value seek(const Napi::CallbackInfo&);      // exact match
+    Napi::Value seek_ge(const Napi::CallbackInfo&);   // >= key (lower_bound)
+    
+    // Текущая позиция
+    Napi::Value current(const Napi::CallbackInfo&);
+    
+    // Модификация
+    Napi::Value put(const Napi::CallbackInfo&);
+    Napi::Value del(const Napi::CallbackInfo&);
+    
+    // Итерация
+    Napi::Value for_each(const Napi::CallbackInfo&);
+    
+    // Закрытие
+    Napi::Value close(const Napi::CallbackInfo&);
+    
+    void attach(txnmou& txn, dbimou& dbi, MDBX_cursor* cursor);
+};
+
+} // namespace mdbxmou

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/dbimou.hpp

@@ -33,9 +33,6 @@ public:
         , dbi{}
     {   }
 
-    //~dbimou() { fprintf(stderr, "dbimou::~dbimou %p key_cap=%zu val_cap=%zu\n",this, key_buf_.capacity(), val_buf_.capacity()); }
-    //void Finalize(Napi::Env env) { fprintf(stderr, "~dbimou %p key_cap=%zu val_cap=%zu\n",this, key_buf_.capacity(), val_buf_.capacity()); }
-
     Napi::Value get_id(const Napi::CallbackInfo& info) {
         return Napi::BigInt::New(info.Env(), static_cast<int64_t>(id_));
     }

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/modulemou.cpp

@@ -1,4 +1,5 @@
 #include "envmou.hpp"
+#include "cursormou.hpp"
 
 using namespace Napi;
 
@@ -106,6 +107,7 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
     mdbxmou::envmou::init("MDBX_Env", env, exports);
     mdbxmou::txnmou::init("MDBX_Txn", env);
     mdbxmou::dbimou::init("MDBX_Dbi", env);
+    mdbxmou::cursormou::init("MDBX_Cursor", env);
 
     return exports;
 }

package/src/txnmou.cpp

@@ -1,5 +1,6 @@
 #include "txnmou.hpp"
 #include "envmou.hpp"
+#include "cursormou.hpp"
 
 namespace mdbxmou {
 
@@ -11,6 +12,7 @@ void txnmou::init(const char *class_name, Napi::Env env) {
         InstanceMethod("abort", &txnmou::abort),
         InstanceMethod("openMap", &txnmou::open_map),
         InstanceMethod("createMap", &txnmou::create_map),
+        InstanceMethod("openCursor", &txnmou::open_cursor),
         InstanceMethod("isActive", &txnmou::is_active),
     });
 
@@ -21,18 +23,19 @@ 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");
+    }
+    
+    if (cursor_count_ > 0) {
+        throw Napi::Error::New(env, 
+            "txn commit: " + std::to_string(cursor_count_) + " cursor(s) still open");
+    }
+    
+    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 +44,19 @@ 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");
+    }
+    
+    if (cursor_count_ > 0) {
+        throw Napi::Error::New(env, 
+            "txn abort: " + std::to_string(cursor_count_) + " cursor(s) still open");
+    }
+    
+    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,73 +74,97 @@ 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() || arg0.IsBigInt()) {
-                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 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)");
-            }
+        } 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 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 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)");
         }
-        // arg_count == 0: используем значения по умолчанию (строковый ключ, default db)
+    }
+    // arg_count == 0: используем значения по умолчанию (строковый ключ, default db)
 
-        check();    
+    if (!txn_) {
+        throw Napi::Error::New(env, "txn already completed");
+    }
 
-        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));
-        }
-        // создаем новый объект 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;
+    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));
     }
-    catch(const std::exception& e)
-    {
-        throw Napi::Error::New(env, std::string("txn: get_dbi ") + e.what());
+    // создаем новый объект 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::open_cursor(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (!txn_) {
+        throw Napi::Error::New(env, "txn not active");
     }
     
-    return env.Undefined();
+    if (info.Length() < 1 || !info[0].IsObject()) {
+        throw Napi::Error::New(env, "dbi required");
+    }
+    
+    auto arg0 = info[0].As<Napi::Object>();
+    if (!arg0.InstanceOf(dbimou::ctor.Value())) {
+        throw Napi::TypeError::New(env, "openCursor: first argument must be MDBX_Dbi instance");
+    }
+    
+    auto* dbi = dbimou::Unwrap(arg0);
+    
+    MDBX_cursor* cursor{};
+    int 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));
+    }
+    
+    auto obj = cursormou::ctor.New({});
+    auto ptr = cursormou::Unwrap(obj);
+    ptr->attach(*this, *dbi, cursor);
+    return obj;
 }
 
 Napi::Value txnmou::is_active(const Napi::CallbackInfo& info) {

package/src/txnmou.hpp

@@ -10,17 +10,19 @@ class txnmou final
     : public Napi::ObjectWrap<txnmou>
 {
 private:
-    envmou* env_{nullptr};    
+    envmou* env_{nullptr};
+    
+    // свободу txn
+    struct free_txn
+    {
+        void operator()(MDBX_txn *txn) const noexcept {
+            mdbx_txn_abort(txn);
+        }
+    };
 
-    std::unique_ptr<MDBX_txn, 
-        txnmou_managed::free_txn> txn_{};
+    std::unique_ptr<MDBX_txn, free_txn> txn_{};
     txn_mode mode_{};
-
-    void check() const {
-        if (!txn_) {
-            throw std::runtime_error("txn: inactive");
-        }
-    }
+    std::size_t cursor_count_{};
     
     // Уменьшает счетчик транзакций
     void dec_counter() noexcept;
@@ -40,8 +42,6 @@ public:
         }
     }
 
-    //void Finalize(Napi::Env env) { fprintf(stderr, "txnmou::Finalize %p\n", this); }
-
     static void init(const char *class_name, Napi::Env env);
 
     Napi::Value commit(const Napi::CallbackInfo&);
@@ -52,11 +52,18 @@ public:
     Napi::Value create_map(const Napi::CallbackInfo& info) {
         return get_dbi(info, {db_mode::create});
     }
+    
+    Napi::Value open_cursor(const Napi::CallbackInfo&);
 
-    operator MDBX_txn*() const noexcept {
+    operator MDBX_txn*() noexcept {
         return txn_.get();
     }
 
+    // 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_; }
+
     Napi::Value is_active(const Napi::CallbackInfo&);
 
     void attach(envmou& env, MDBX_txn* txn, txn_mode mode);

package/src/typemou.hpp

@@ -4,6 +4,7 @@
 #include <mdbx.h++>
 #include <cstdint>
 #include <vector>
+#include <utility>
 
 namespace mdbxmou {
 
@@ -12,57 +13,39 @@ using buffer_type = std::vector<char>;
 struct txnmou_managed final
     : mdbx::txn
 {
-    // свободу txn
-    struct free_txn
-    {
-        void operator()(MDBX_txn *txn) const noexcept {
-            mdbx_txn_abort(txn);
-        }
-    };
-
-    std::unique_ptr<MDBX_txn, free_txn> guard_;
-
-    txnmou_managed(MDBX_txn* txn) noexcept
+    txnmou_managed(MDBX_txn *txn) noexcept
         : mdbx::txn(txn)
-        , guard_(txn)
     {   }
-    
-    // Move конструктор
-    txnmou_managed(txnmou_managed&& other) noexcept
-        : mdbx::txn(other.txn::handle_)
-        , guard_(std::move(other.guard_))
-    {
-        other.txn::handle_ = nullptr;
-    }
-    
-    // Запрет копирования
+
+    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 {
-        // guard_ автоматически откатит транзакцию
-        txn::handle_ = nullptr;
+    ~txnmou_managed() noexcept 
+    {
+        if (txn::handle_) {
+            ::mdbx_txn_abort(txn::handle_);
+        }
     }
     
-    // Commit транзакции
-    void commit() {
-        if (guard_) {
-            auto rc = ::mdbx_txn_commit(guard_.release());
-            txn::handle_ = nullptr;
-            if (rc != MDBX_SUCCESS) {
-                throw std::runtime_error(::mdbx_strerror(rc));
-            }
+    void commit() 
+    {
+        auto rc = ::mdbx_txn_commit(
+            std::exchange(txn::handle_, nullptr));
+        if (rc != MDBX_SUCCESS) {
+            throw std::runtime_error(::mdbx_strerror(rc));
         }
     }
     
-    // Abort транзакции
-    void abort() {
-        if (guard_) {
-            auto rc = ::mdbx_txn_abort(guard_.release());
-            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));
         }
     }
 };
@@ -70,36 +53,22 @@ struct txnmou_managed final
 struct cursormou_managed final
     : mdbx::cursor
 {
-    // свободу курсору
-    struct free_cursor
-    {
-        void operator()(MDBX_cursor* c) const noexcept {
-            if (c) ::mdbx_cursor_close(c);
-        }
-    };
-
-    std::unique_ptr<MDBX_cursor, free_cursor> guard_;
-
     explicit cursormou_managed(MDBX_cursor* cursor) noexcept
         : mdbx::cursor(cursor)
-        , guard_(cursor)
+    {   }
+
+    cursormou_managed(cursormou_managed &&other) noexcept
+        : mdbx::cursor(std::exchange(other.cursor::handle_, nullptr))
     {   }
     
-    // Move конструктор
-    cursormou_managed(cursormou_managed&& other) noexcept
-        : mdbx::cursor(other.cursor::handle_)
-        , guard_(std::move(other.guard_))
-    {
-        other.cursor::handle_ = nullptr;
-    }
-    
-    // Запрет копирования
     cursormou_managed(const cursormou_managed&) = delete;
     cursormou_managed& operator=(const cursormou_managed&) = delete;
     
-    ~cursormou_managed() noexcept {
-        // guard_ автоматически закроет курсор
-        cursor::handle_ = nullptr;
+    ~cursormou_managed() noexcept 
+    {
+        if (cursor::handle_) {
+            ::mdbx_cursor_close(cursor::handle_);
+        }
     }
 };
 

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}
@@ -39,10 +46,10 @@ public:
             throw Napi::Error::New(env, "napi_get_value_string_utf8 length");
         }
         
-        mem.reserve(length + 1);
+        mem.resize(length + 1);
 
         status = napi_get_value_string_utf8(
-            env, arg0, mem.data(), mem.capacity(), nullptr);
+            env, arg0, mem.data(), mem.size(), nullptr);
         if (status != napi_ok) {
             throw Napi::Error::New(env, "napi_get_value_string_utf8 copyout");
         }
@@ -76,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}