mdbxmou 0.2.5 → 0.2.6

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

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

package/src/dbimou.hpp

@@ -33,6 +33,9 @@ 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/txnmou.cpp

@@ -97,7 +97,7 @@ Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
             if (arg0.IsString()) {
                 db_name = arg0.As<Napi::String>().Utf8Value();
                 key_mode = parse_key_mode(env, arg1, key_flag);
-            } else if (arg0.IsNumber()) {
+            } else if (arg0.IsNumber() || arg0.IsBigInt()) {
                 key_mode = parse_key_mode(env, arg0, key_flag);
                 value_mode = value_mode::parse(arg1);
             } else {
@@ -108,12 +108,13 @@ Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
             auto arg0 = info[0];
             if (arg0.IsString()) {
                 db_name = arg0.As<Napi::String>().Utf8Value();
-            } else {
+            } 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 {
-            throw Napi::Error::New(env, "Invalid number of arguments for get_dbi");
         }
+        // arg_count == 0: используем значения по умолчанию (строковый ключ, default db)
 
         check();    
 

package/src/txnmou.hpp

@@ -10,16 +10,10 @@ class txnmou final
     : public Napi::ObjectWrap<txnmou>
 {
 private:
-    envmou* env_{nullptr};
-    
-    // Простой deleter
-    struct free_txn {
-        void operator()(MDBX_txn* txn) const noexcept {
-            mdbx_txn_abort(txn);
-        }
-    };
-    
-    std::unique_ptr<MDBX_txn, free_txn> txn_{};
+    envmou* env_{nullptr};    
+
+    std::unique_ptr<MDBX_txn, 
+        txnmou_managed::free_txn> txn_{};
     txn_mode mode_{};
 
     void check() const {
@@ -46,6 +40,8 @@ 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&);

package/src/typemou.hpp

@@ -10,21 +10,97 @@ 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; 
+    // свободу 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
+        : 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(const txnmou_managed&) = delete;
+    txnmou_managed& operator=(const txnmou_managed&) = delete;
+    
+    ~txnmou_managed() noexcept {
+        // guard_ автоматически откатит транзакцию
+        txn::handle_ = nullptr;
+    }
+    
+    // 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));
+            }
+        }
+    }
+    
+    // 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));
+            }
+        }
     }
 };
 
 struct cursormou_managed final
-    : mdbx::cursor_managed
+    : mdbx::cursor
 {
-    cursormou_managed(MDBX_cursor* cursor) noexcept
-    {  
-        cursor::handle_ = 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)
+    {   }
+    
+    // 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;
+    }
 };
 
 struct env_flag {

package/src/valuemou.hpp

@@ -38,9 +38,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 +47,8 @@ public:
             throw Napi::Error::New(env, "napi_get_value_string_utf8 copyout");
         }
 
+        mem.resize(length);
+
         assign(mem.data(), mem.size());
     }