mdbxmou 0.1.35 → 0.2.0

package/CMakeLists.txt

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

package/README.md

@@ -5,7 +5,7 @@ High-performance Node.js binding for libmdbx — a fast, lightweight, embedded k
 ## Features
 
 - **Synchronous API** — Direct MDBX operations in main thread
-- **Asynchronous API** — Background operations via single Worker Thread
+- **Asynchronous API** — Background operations with async/await
 - **Transactions** — ACID transactions with read/write modes
 - **Multiple key/value types** — String, binary, ordinal (integer) keys
 - **Batch operations** — Efficient multi-key read/write
@@ -33,14 +33,14 @@ await env.open({
 // Write data
 const txn = env.startWrite();
 const dbi = txn.createMap(MDBX_Param.keyMode.ordinal);
-dbi.put(1, "hello");
-dbi.put(2, "world");
+dbi.put(txn, 1, "hello");
+dbi.put(txn, 2, "world");
 txn.commit();
 
 // Read data
 const readTxn = env.startRead();
 const readDbi = readTxn.openMap(BigInt(MDBX_Param.keyMode.ordinal));
-const value = readDbi.get(1);
+const value = readDbi.get(readTxn, 1);
 console.log(value); // "hello"
 readTxn.commit();
 
@@ -180,32 +180,37 @@ txn.abort();
 
 #### Methods
 
-**put(key, value, [flags])**
+**put(txn, key, value)**
 ```javascript
-dbi.put(123, "value");
-dbi.put("key", Buffer.from("binary data"));
+dbi.put(txn, 123, "value");
+dbi.put(txn, "key", Buffer.from("binary data"));
 ```
 
-**get(key) → value**
+**get(txn, key) → value**
 ```javascript
-const value = dbi.get(123);
-const binary = dbi.get("key");
+const value = dbi.get(txn, 123);
+const binary = dbi.get(txn, "key");
 ```
 
-**del(key) → boolean**
+**del(txn, key) → boolean**
 ```javascript
-const deleted = dbi.del(123);
+const deleted = dbi.del(txn, 123);
 ```
 
-**stat() → Object**
+**has(txn, key) → boolean**
 ```javascript
-const stats = dbi.stat();
+const exists = dbi.has(txn, 123);
+```
+
+**stat(txn) → Object**
+```javascript
+const stats = dbi.stat(txn);
 // { pageSize: 4096, depth: 1, entries: 10, ... }
 ```
 
-**forEach(callback)**
+**forEach(txn, callback)**
 ```javascript
-dbi.forEach((key, value, index) => {
+dbi.forEach(txn, (key, value, index) => {
   console.log(`${key}: ${value}`);
   return false; // continue iteration (or undefined)
   // return true; // stop iteration
@@ -214,34 +219,37 @@ dbi.forEach((key, value, index) => {
 
 > **Note**: forEach continues scanning while callback returns `undefined` or `false`, and stops when callback returns `true`.
 
-**keys() → Array**
+**keys(txn) → Array**
 ```javascript
 // Get all keys
-const allKeys = dbi.keys();
+const allKeys = dbi.keys(txn);
 ```
 
-**keysFrom(startKey, [limit], [cursorMode]) → Array**
+**keysFrom(txn, startKey, [limit], [cursorMode]) → Array**
 ```javascript
 // Get keys starting from specific key
-const keys = dbi.keysFrom(42, 50); // 50 keys starting from 42
+const keys = dbi.keysFrom(txn, 42, 50); // 50 keys starting from 42
 
 // With cursor mode
-const keys = dbi.keysFrom(42, 50, 'keyGreaterOrEqual');
+const keys = dbi.keysFrom(txn, 42, 50, 'keyGreaterOrEqual');
 
 // BigInt keys
-const bigIntKeys = dbi.keysFrom(42n, 50);
+const bigIntKeys = dbi.keysFrom(txn, 42n, 50);
 
 // Key equal mode (for multi-value databases)
-const equalKeys = dbi.keysFrom(5, 10, 'keyEqual');
+const equalKeys = dbi.keysFrom(txn, 5, 10, 'keyEqual');
 ```
 
-**query(requests) → Promise<Array>** (Async batch operations)
+**drop(txn, [delete_db]) → void**
 ```javascript
-dbi.forEach((key, value, index) => {
-  console.log(`${key}: ${value}`);
-  // return false; // continue iteration (or undefined)
-  // return true; // stop iteration
-});
+// Clear database contents (keep structure)
+dbi.drop(txn, false);
+
+// Delete database completely
+dbi.drop(txn, true);
+
+// Default behavior (clear contents)
+dbi.drop(txn);
 ```
 
 ## Key and Value Types
@@ -280,7 +288,7 @@ function syncExample() {
   const dbi = writeTxn.createMap(MDBX_Param.keyMode.ordinal);
   
   for (let i = 0; i < 1000; i++) {
-    dbi.put(i, `value_${i}`);
+    dbi.put(writeTxn, i, `value_${i}`);
   }
   writeTxn.commit();
 
@@ -288,17 +296,17 @@ function syncExample() {
   const readTxn = env.startRead();
   const readDbi = readTxn.openMap(MDBX_Param.keyMode.ordinal); // keys as numbers
   
-  const value = readDbi.get(42);
+  const value = readDbi.get(readTxn, 42);
   console.log(value); // "value_42"
   
   // Iterate with cursor
-  readDbi.forEach((key, value, index) => {
+  readDbi.forEach(readTxn, (key, value, index) => {
     console.log(`Key ${key} (type: ${typeof key}): ${value}`); // key is number
     return index >= 9; // stop after 10 items (indices 0-9)
   });
   
   // Get specific keys
-  const someKeys = readDbi.keysFrom(100, { limit: 50 });
+  const someKeys = readDbi.keysFrom(readTxn, 100, 50);
   console.log(`Keys 100-149:`, someKeys); // array of numbers
   
   readTxn.commit();
@@ -316,7 +324,7 @@ async function asyncExample() {
   const dbi = writeTxn.createMap(MDBX_Param.keyMode.ordinal);
   
   for (let i = 0; i < 1000; i++) {
-    dbi.put(i, `value_${i}`);
+    dbi.put(writeTxn, i, `value_${i}`);
   }
   writeTxn.commit();
 
@@ -324,17 +332,17 @@ async function asyncExample() {
   const readTxn = env.startRead();
   const readDbi = readTxn.openMap(BigInt(MDBX_Param.keyMode.ordinal)); // keys as BigInts
   
-  const value = readDbi.get(42);
+  const value = readDbi.get(readTxn, 42);
   console.log(value); // "value_42"
   
   // Iterate with BigInt keys
-  readDbi.forEach((key, value, index) => {
+  readDbi.forEach(readTxn, (key, value, index) => {
     console.log(`Key ${key} (type: ${typeof key}): ${value}`); // key is bigint
     return index >= 9; // stop after 10 items (indices 0-9)
   });
   
   // Get BigInt keys
-  const bigIntKeys = readDbi.keysFrom(100n, { limit: 50 });
+  const bigIntKeys = readDbi.keysFrom(readTxn, 100n, 50);
   console.log(`Keys 100n-149n:`, bigIntKeys); // array of BigInts
   
   readTxn.commit();
@@ -355,16 +363,16 @@ function keyTypesExample() {
   const dbi = txn.createMap(MDBX_Param.keyMode.ordinal);
   
   // Store some data
-  dbi.put(1, "one");
-  dbi.put(2, "two");
-  dbi.put(3, "three");
+  dbi.put(txn, 1, "one");
+  dbi.put(txn, 2, "two");
+  dbi.put(txn, 3, "three");
   txn.commit();
 
   // Read with number keyMode
   const readTxn1 = env.startRead();
   const numberDbi = readTxn1.openMap(MDBX_Param.keyMode.ordinal);
   
-  numberDbi.forEach((key, value) => {
+  numberDbi.forEach(readTxn1, (key, value) => {
     console.log(`Number key: ${key} (${typeof key})`); // number
     // return undefined; // continue iteration (default)
   });
@@ -374,7 +382,7 @@ function keyTypesExample() {
   const readTxn2 = env.startRead();
   const bigintDbi = readTxn2.openMap(BigInt(MDBX_Param.keyMode.ordinal));
   
-  bigintDbi.forEach((key, value) => {
+  bigintDbi.forEach(readTxn2, (key, value) => {
     console.log(`BigInt key: ${key} (${typeof key})`); // bigint
     // return false; // continue iteration
   });
@@ -398,7 +406,7 @@ function cursorExample() {
   
   // Store test data
   for (let i = 0; i < 100; i++) {
-    dbi.put(i, `value_${i}`);
+    dbi.put(txn, i, `value_${i}`);
   }
   txn.commit();
 
@@ -406,25 +414,25 @@ function cursorExample() {
   const readDbi = readTxn.openMap(MDBX_Param.keyMode.ordinal);
   
   // Get all keys
-  const allKeys = readDbi.keys();
+  const allKeys = readDbi.keys(readTxn);
   console.log(`Total keys: ${allKeys.length}`);
   
   // Get limited keys - use keysFrom with limit
-  const firstTen = readDbi.keysFrom(0, 10);
+  const firstTen = readDbi.keysFrom(readTxn, 0, 10);
   console.log(`First 10 keys:`, firstTen);
   
   // Get keys from specific position
-  const fromFifty = readDbi.keysFrom(50, 20);
+  const fromFifty = readDbi.keysFrom(readTxn, 50, 20);
   console.log(`Keys 50-69:`, fromFifty);
   
   // Reverse iteration - need manual logic or forEach
-  const allKeysForReverse = readDbi.keys();
+  const allKeysForReverse = readDbi.keys(readTxn);
   const lastTen = allKeysForReverse.slice(-10).reverse();
   console.log(`Last 10 keys:`, lastTen);
   
   // Manual iteration with forEach
   let count = 0;
-  readDbi.forEach((key, value, index) => {
+  readDbi.forEach(readTxn, (key, value, index) => {
     if (key >= 80) {
       console.log(`Key ${key}: ${value}`);
       count++;
@@ -437,52 +445,6 @@ function cursorExample() {
 }
 ```
 
-### Batch Operations (Asynchronous)
-
-```javascript
-const { MDBX_Async_Env } = require('mdbxmou/lib/mdbx_evn_async');
-const { MDBX_Param } = require('mdbxmou');
-
-async function batchExample() {
-  const env = new MDBX_Async_Env();
-  await env.open({ path: './async-data' });
-
-  // Write transaction in worker thread
-  const writeTxn = await env.startWrite();
-  const dbi = await writeTxn.openMap({ 
-    keyMode: MDBX_Param.keyMode.ordinal, 
-    create: true 
-  });
-
-  // Batch write
-  await dbi.putBatch([
-    { key: 1n, value: "one" },
-    { key: 2n, value: "two" },
-    { key: 3n, value: "three" }
-  ]);
-  
-  await writeTxn.commit();
-
-  // Read transaction in worker thread
-  const readTxn = await env.startRead();
-  const readDbi = await readTxn.openMap({ 
-    keyMode: MDBX_Param.keyMode.ordinal 
-  });
-
-  // Batch read
-  const results = await readDbi.getBatch([1n, 2n, 3n]);
-  results.forEach((result, i) => {
-    if (result.found) {
-      console.log(`Key ${result.key}: ${result.value}`);
-    }
-  });
-
-  await readTxn.commit();
-  await env.close();
-  await env.terminate();
-}
-```
-
 ### Query API (Advanced Async)
 
 ```javascript
@@ -519,54 +481,6 @@ async function queryExample() {
 }
 ```
 
-### Worker Thread Example
-
-```javascript
-const { MDBX_Async_Env } = require('mdbxmou/lib/mdbx_evn_async');
-
-async function workerExample() {
-  // Single worker thread for all async operations
-  const env = new MDBX_Async_Env();
-  await env.open({ path: './worker-data' });
-
-  // Each transaction runs in the same worker thread
-  const txn1 = await env.startWrite();
-  const dbi1 = await txn1.openMap({ 
-    keyMode: MDBX_Param.keyMode.ordinal, 
-    create: true 
-  });
-  await dbi1.put(1n, "worker-value-1");
-  await txn1.commit();
-
-  // Another transaction in the same worker
-  const txn2 = await env.startWrite();
-  const dbi2 = await txn2.openMap({ 
-    keyMode: MDBX_Param.keyMode.ordinal,
-    create: true 
-  });
-  await dbi2.put(2n, "worker-value-2");
-  await txn2.commit();
-
-  // Read transaction
-  const readTxn = await env.startRead();
-  const readDbi = await readTxn.openMap({ 
-    keyMode: MDBX_Param.keyMode.ordinal 
-  });
-  
-  const results = await readDbi.getBatch([1n, 2n]);
-  results.forEach(r => {
-    if (r.found) {
-      console.log(`Key ${r.key}: ${r.value}`);
-    }
-  });
-  
-  await readTxn.commit();
-
-  await env.close();
-  await env.terminate(); // Terminate the worker thread
-}
-```
-
 ## Error Handling
 
 ```javascript
@@ -578,7 +492,7 @@ try {
   const dbi = txn.createMap(MDBX_Param.keyMode.ordinal);
   
   // This might throw if key already exists with MDBX_NOOVERWRITE
-  dbi.put(123, "value", MDBX_Param.putFlag.nooverwrite);
+  dbi.put(txn, 123, "value", MDBX_Param.putFlag.nooverwrite);
   
   txn.commit();
 } catch (error) {
@@ -624,10 +538,10 @@ Note: For ordinal (integer) keys, use keyFlag.number or keyFlag.bigint to specif
 ## Performance Tips
 
 1. **Use ordinal keys** for integer data - much faster than string keys
-2. **Batch operations** - Use query API or async worker thread for bulk operations
+2. **Batch operations** - Use query API for bulk operations
 3. **Reuse transactions** - Keep read transactions open for multiple operations
-4. **Worker thread** - Use async API for CPU-intensive or I/O operations
-5. **Memory mapping** - MDBX uses memory-mapped files for zero-copy access
+4. **Memory mapping** - MDBX uses memory-mapped files for zero-copy access
+5. **Transaction scope** - Always pass transaction object to DBI methods
 
 ## License
 

package/package.json

@@ -16,17 +16,16 @@
   },
   "scripts": {
     "e3": "node ./test/e3.js",
+    "e33": "node ./test/e33.js",
     "e4": "node ./test/e4.js",
     "e5": "node ./test/e5.js",
-    "test": "node ./test/e3.js && node ./test/e4.js && node ./test/e5.js",
     "build": "node build.js",
-    "install-1": "git submodule update --init --recursive 2>/dev/null || true && node build.js",
-    "install": "node build.js",
-    "!prepublishOnly": "./prepare-npm.sh"
+    "build-dev": "node build-dev.js",
+    "install": "node build.js"
   },
   "gypfile": true,
   "name": "mdbxmou",
-  "version": "0.1.35",
+  "version": "0.2.0",
   "description": "Node bindings for mdbx",
   "repository": {
     "type": "git",

package/src/dbi.cpp

@@ -0,0 +1,66 @@
+#include "dbi.hpp"
+
+namespace mdbxmou {
+
+MDBX_stat dbi::get_stat(const MDBX_txn* txn, MDBX_dbi dbi)
+{
+    MDBX_stat stat;
+    auto rc = mdbx_dbi_stat(txn, dbi, &stat, sizeof(stat));
+    if (rc != MDBX_SUCCESS) {
+        throw std::runtime_error(mdbx_strerror(rc));
+    }
+    return stat;
+}
+
+valuemou dbi::get(const MDBX_txn* txn, const keymou& key) const
+{
+    valuemou val{};
+    auto rc = mdbx_get(txn, id_, key, val);
+    if (rc == MDBX_NOTFOUND)
+        return {};
+    if (rc != MDBX_SUCCESS) {
+        throw std::runtime_error(mdbx_strerror(rc));
+    }
+    return val;
+}
+
+void dbi::put(MDBX_txn* txn, const keymou& key, valuemou& value, MDBX_put_flags_t flags)
+{
+    auto rc = mdbx_put(txn, id_, key, value, flags);
+    if (rc != MDBX_SUCCESS) {
+        throw std::runtime_error(mdbx_strerror(rc));
+    }
+}
+
+bool dbi::del(MDBX_txn* txn, const keymou& key)
+{
+    auto rc = mdbx_del(txn, id_, key, nullptr);
+    if (rc == MDBX_NOTFOUND) {
+        return false;
+    }
+    if (rc != MDBX_SUCCESS) {
+        throw std::runtime_error(mdbx_strerror(rc));
+    }
+    return true;
+}
+
+
+cursormou_managed dbi::open_cursor(MDBX_txn* txn) const
+{
+    MDBX_cursor* cursor_ptr;
+    auto rc = mdbx_cursor_open(txn, id_, &cursor_ptr);
+    if (rc != MDBX_SUCCESS) {
+        throw std::runtime_error(mdbx_strerror(rc));
+    }
+    return cursormou_managed{ cursor_ptr };
+}
+
+void dbi::drop(MDBX_txn* txn, bool delete_db)
+{
+    auto rc = mdbx_drop(txn, id_, delete_db);
+    if (rc != MDBX_SUCCESS) {
+        throw std::runtime_error(mdbx_strerror(rc));
+    }
+}
+
+} // namespace mdbxmou

package/src/dbi.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "valuemou.hpp"
+#include <memory>
+
+namespace mdbxmou {
+
+class dbi
+{
+protected:
+    MDBX_dbi id_{};
+    
+public:
+    dbi() = default;
+
+    void attach(MDBX_dbi id) noexcept {
+        id_ = id;
+    }
+
+    static MDBX_stat get_stat(const MDBX_txn* txn, MDBX_dbi dbi);
+
+    MDBX_stat get_stat(const MDBX_txn* txn) const
+    {
+        return get_stat(txn, id_);
+    }
+
+    valuemou get(const MDBX_txn* txn, const keymou& key) const;
+
+    bool has(const MDBX_txn* txn, const keymou& key) const
+    {
+        return !get(txn, key).is_null();
+    }
+
+    void put(MDBX_txn* txn, const keymou& key, valuemou& value, 
+        MDBX_put_flags_t flags = MDBX_UPSERT);
+
+    bool del(MDBX_txn* txn, const keymou& key);
+
+    cursormou_managed open_cursor(MDBX_txn* txn) const;
+
+    // Drop database or delete it
+    void drop(MDBX_txn* txn, bool delete_db = false);
+};
+
+} // namespace mdbxmou

package/src/dbimou.cpp

@@ -18,30 +18,41 @@ void dbimou::init(const char *class_name, Napi::Env env)
         InstanceMethod("stat", &dbimou::stat),
         InstanceMethod("keys", &dbimou::keys),
         InstanceMethod("keysFrom", &dbimou::keys_from),
+        InstanceMethod("drop", &dbimou::drop),
+        
+        // Свойства только для чтения
+        InstanceAccessor("id", &dbimou::get_id, nullptr),
+        InstanceAccessor("dbMode", &dbimou::get_mode, nullptr),
+        InstanceAccessor("keyMode", &dbimou::get_key_mode, nullptr),
+        InstanceAccessor("valueMode", &dbimou::get_value_mode, nullptr),
+        InstanceAccessor("keyFlag", &dbimou::get_key_flag, nullptr),
+        InstanceAccessor("valueFlag", &dbimou::get_value_flag, nullptr),
     });
 
     ctor = Napi::Persistent(func);
     ctor.SuppressDestruct();
 }
 
-Napi::Value dbimou::put(const Napi::CallbackInfo& info) {
+Napi::Value dbimou::put(const Napi::CallbackInfo& info) 
+{
     Napi::Env env = info.Env();
-    
     auto arg_len = info.Length();
-    if (arg_len < 2) {
-        throw Napi::Error::New(env, "put: key and value required");
+    if (arg_len < 3) {
+        throw Napi::Error::New(env, "put: txnmou, key and value required");
     }
-
+    auto arg0 = info[0].As<Napi::Object>();
+    // Дополнительная проверка - есть ли у объекта нужный constructor
+    if (!arg0.InstanceOf(txnmou::ctor.Value())) {
+        throw Napi::TypeError::New(env, "put: first argument must be MDBX_Txn instance");
+    }    
+    auto txn = Napi::ObjectWrap<txnmou>::Unwrap(arg0);
     try {
+        std::uint64_t t;
         auto key = (key_mode_.val & key_mode::ordinal) ?
-            keymou::from(info[0], env, id_buf_) : 
-            keymou::from(info[0], env, key_buf_);
-        auto val = valuemou::from(info[1], env, val_buf_);
-        auto flag = static_cast<MDBX_put_flags_t>(key_mode_.val & value_mode_.val);
-        auto rc = mdbx_put(*txn_, dbi_, key, val, flag);
-        if (rc != MDBX_SUCCESS) {
-            throw Napi::Error::New(env, mdbx_strerror(rc));
-        }
+            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) {
         throw Napi::Error::New(env, std::string("put: ") + e.what());
     }
@@ -51,22 +62,28 @@ Napi::Value dbimou::put(const Napi::CallbackInfo& info) {
 
 Napi::Value dbimou::get(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
-
-    if (info.Length() < 1) {
-        throw Napi::Error::New(env, "get: key required");
+    auto arg_len = info.Length();
+    if (arg_len < 2) {
+        throw Napi::Error::New(env, "get: txnmou and key required");
     }
+    auto arg0 = info[0].As<Napi::Object>();
+    // Дополнительная проверка - есть ли у объекта нужный constructor
+    if (!arg0.InstanceOf(txnmou::ctor.Value())) {
+        throw Napi::TypeError::New(env, "get: first argument must be MDBX_Txn instance");
+    }    
+    auto txn = Napi::ObjectWrap<txnmou>::Unwrap(arg0);
 
     try {
-        valuemou val{};
+        std::uint64_t t;
         auto key = (key_mode_.val & key_mode::ordinal) ?
-            keymou::from(info[0], env, id_buf_) : 
-            keymou::from(info[0], env, key_buf_);
-        auto rc = mdbx_get(*txn_, dbi_, key, val);
-        if (rc == MDBX_NOTFOUND)
+            keymou::from(info[1], env, t) : 
+            keymou::from(info[1], env, key_buf_);
+        
+        auto val = dbi::get(*txn, key);
+        if (val.is_null()) {
             return env.Undefined();
-        if (rc != MDBX_SUCCESS) {
-            throw Napi::Error::New(env, mdbx_strerror(rc));
         }
+        
         return (value_flag_.val & base_flag::string) ? 
             val.to_string(env) : val.to_buffer(env);
     } catch (const std::exception& e) {
@@ -78,23 +95,25 @@ Napi::Value dbimou::get(const Napi::CallbackInfo& info) {
 
 Napi::Value dbimou::del(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
-
-    if (info.Length() < 1) {
-        throw Napi::Error::New(env, "del: key required");
+    auto arg_len = info.Length();
+    if (arg_len < 2) {
+        throw Napi::Error::New(env, "del: txnmou and key required");
     }
+    auto arg0 = info[0].As<Napi::Object>();
+    // Дополнительная проверка - есть ли у объекта нужный constructor
+    if (!arg0.InstanceOf(txnmou::ctor.Value())) {
+        throw Napi::TypeError::New(env, "del: first argument must be MDBX_Txn instance");
+    }    
+    auto txn = Napi::ObjectWrap<txnmou>::Unwrap(arg0);
 
     try {
+        std::uint64_t t;
         auto key = (key_mode_.val & key_mode::ordinal) ?
-            keymou::from(info[0], env, id_buf_) : 
-            keymou::from(info[0], env, key_buf_);
-        auto rc = mdbx_del(*txn_, dbi_, key, nullptr);
-        if (rc == MDBX_NOTFOUND) {
-            return Napi::Value::From(env, false);
-        }
-        if (rc != MDBX_SUCCESS) {
-            throw Napi::Error::New(env, mdbx_strerror(rc));
-        }
-        return Napi::Value::From(env, true);
+            keymou::from(info[1], env, t) : 
+            keymou::from(info[1], env, key_buf_);
+        
+        bool result = dbi::del(*txn, key);
+        return Napi::Value::From(env, result);
     } catch (const std::exception& e) {
         throw Napi::Error::New(env, std::string("del: ") + e.what());
     }
@@ -104,23 +123,25 @@ Napi::Value dbimou::del(const Napi::CallbackInfo& info) {
 
 Napi::Value dbimou::has(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
-    
-    if (info.Length() < 1) {
-        throw Napi::Error::New(env, "Key is required");
+    auto arg_len = info.Length();
+    if (arg_len < 2) {
+        throw Napi::Error::New(env, "has: txnmou and key required");
     }
+    auto arg0 = info[0].As<Napi::Object>();
+    // Дополнительная проверка - есть ли у объекта нужный constructor
+    if (!arg0.InstanceOf(txnmou::ctor.Value())) {
+        throw Napi::TypeError::New(env, "has: first argument must be MDBX_Txn instance");
+    }    
+    auto txn = Napi::ObjectWrap<txnmou>::Unwrap(arg0);
 
     try {
+        std::uint64_t t;
         auto key = (key_mode_.val & key_mode::ordinal) ?
-            keymou::from(info[0], env, id_buf_) : 
-            keymou::from(info[0], env, key_buf_);
-        auto rc = mdbx_get(*txn_, dbi_, key, nullptr);
-        if (rc == MDBX_NOTFOUND) {
-            return Napi::Value::From(env, false);
-        }
-        if (rc != MDBX_SUCCESS) {
-            throw Napi::Error::New(env, mdbx_strerror(rc));
-        }
-        return Napi::Value::From(env, true);
+            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) {
         throw Napi::Error::New(env, std::string("has: ") + e.what());
     }
@@ -130,26 +151,26 @@ Napi::Value dbimou::has(const Napi::CallbackInfo& info) {
 
 Napi::Value dbimou::for_each(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
-    
-    if (info.Length() < 1) {
-        throw Napi::TypeError::New(env, "Expected at least one argument");
+    auto arg_len = info.Length();
+    if (arg_len < 2) {
+        throw Napi::Error::New(env, "for_each: txnmou and function required");
     }
-
-    // Проверяем тип вызова: forEach(fn), forEach(fromKey, fn) или forEach(fromKey, cursorMode, fn)
-    if (info.Length() == 1 && info[0].IsFunction()) {
-        // Обычный forEach(fn)
-        auto fn = info[0].As<Napi::Function>();
-        
-        MDBX_cursor* cursor_ptr;
-        auto rc = mdbx_cursor_open(*txn_, dbi_, &cursor_ptr);
-        if (rc != MDBX_SUCCESS) {
-            throw Napi::Error::New(env, mdbx_strerror(rc));
-        }
+    auto arg0 = info[0].As<Napi::Object>();
+    // Дополнительная проверка - есть ли у объекта нужный constructor
+    if (!arg0.InstanceOf(txnmou::ctor.Value())) {
+        throw Napi::TypeError::New(env, "for_each: first argument must be MDBX_Txn instance");
+    }    
+    auto txn = Napi::ObjectWrap<txnmou>::Unwrap(arg0);
+
+    // Проверяем тип вызова: forEach(txn, fn), forEach(txn, fromKey, fn) или forEach(txn, fromKey, cursorMode, fn)
+    if (info.Length() == 2 && info[1].IsFunction()) {
+        // Обычный forEach(txn, fn)
+        auto fn = info[1].As<Napi::Function>();
         
-        uint32_t index{};
-
         try {
-            cursormou_managed cursor{ cursor_ptr };
+            auto cursor = dbi::open_cursor(*txn);
+            uint32_t index{};
+
             if (key_mode_.val & key_mode::ordinal) {
                 cursor.scan([&](const mdbx::pair& f) {
                     keymou key{f.key};
@@ -190,56 +211,63 @@ Napi::Value dbimou::for_each(const Napi::CallbackInfo& info) {
                     return result.IsBoolean() ? result.ToBoolean() : false;
                 });
             }
+
+            return Napi::Number::New(env, static_cast<double>(index));
         } catch (const std::exception& e) {
             throw Napi::Error::New(env, std::string("forEach: ") + e.what());
         }
 
-        return Napi::Number::New(env, static_cast<double>(index));
-
-    } else if ((info.Length() == 2 && info[1].IsFunction()) || 
-               (info.Length() == 3 && info[2].IsFunction())) {
-        // forEach(fromKey, fn) или forEach(fromKey, cursorMode, fn) - делегируем внутреннему методу
+    } else if ((info.Length() == 3 && info[2].IsFunction()) || 
+               (info.Length() == 4 && info[3].IsFunction())) {
+        // forEach(txn, fromKey, fn) или forEach(txn, fromKey, cursorMode, fn) - делегируем внутреннему методу
         return for_each_from(info);
         
     } else {
-        throw Napi::TypeError::New(env, "Expected function, (key, function) or (key, cursorMode, function)");
+        throw Napi::TypeError::New(env, "Expected (txn, function), (txn, key, function) or (txn, key, cursorMode, function)");
     }
 }
 
 Napi::Value dbimou::for_each_from(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
+    auto arg_len = info.Length();
+    
+    if (arg_len < 3) {
+        throw Napi::Error::New(env, "for_each_from: txnmou, fromKey and function required");
+    }
+    
+    auto arg0 = info[0].As<Napi::Object>();
+    // Дополнительная проверка - есть ли у объекта нужный constructor
+    if (!arg0.InstanceOf(txnmou::ctor.Value())) {
+        throw Napi::TypeError::New(env, "for_each_from: first argument must be MDBX_Txn instance");
+    }    
+    auto txn = Napi::ObjectWrap<txnmou>::Unwrap(arg0);
     
-    // Определяем позицию функции: info[1] или info[2]
+    // Определяем позицию функции: info[2] или info[3]
     Napi::Function fn;
-    if (info.Length() == 2 && info[1].IsFunction()) {
-        fn = info[1].As<Napi::Function>();
-    } else if (info.Length() == 3 && info[2].IsFunction()) {
+    if (info.Length() == 3 && info[2].IsFunction()) {
         fn = info[2].As<Napi::Function>();
+    } else if (info.Length() == 4 && info[3].IsFunction()) {
+        fn = info[3].As<Napi::Function>();
     } else {
         throw Napi::TypeError::New(env, "Function argument required");
     }
     
-    MDBX_cursor* cursor_ptr;
-    auto rc = mdbx_cursor_open(*txn_, dbi_, &cursor_ptr);
-    if (rc != MDBX_SUCCESS) {
-        throw Napi::Error::New(env, mdbx_strerror(rc));
-    }
-    
     try {
-        cursormou_managed cursor{ cursor_ptr };
+        auto cursor = dbi::open_cursor(*txn);
         
         // Парсим начальный ключ
-        keymou from_key = mdbx::is_ordinal(key_mode_) ?
-            keymou::from(info[0], env, id_buf_) : 
-            keymou::from(info[0], env, key_buf_);
+        std::uint64_t t;
+        keymou from_key = (key_mode_.val & key_mode::ordinal) ?
+            keymou::from(info[1], env, t) : 
+            keymou::from(info[1], env, key_buf_);
         
         // Парсим cursor mode (если передан)
         using move_operation = mdbx::cursor::move_operation;
         auto cursor_mode = move_operation::key_greater_or_equal;
         auto turn_mode = move_operation::next;
 
-        if (info.Length() == 3 && !info[1].IsUndefined()) {
-            cursor_mode = parse_cursor_mode(info[1]);
+        if (info.Length() == 4 && !info[2].IsUndefined()) {
+            cursor_mode = parse_cursor_mode(info[2]);
             
             // Определяем направление сканирования на основе операции
             switch (cursor_mode) {
@@ -268,7 +296,7 @@ Napi::Value dbimou::for_each_from(const Napi::CallbackInfo& info) {
                 keymou key{f.key};
                 valuemou val{f.value};
                 if (is_key_equal_mode) {
-                    if (id_buf_ != key.as_int64()) {
+                    if (t != key.as_int64()) {
                         return true; // останавливаем сканирование
                     }
                 }
@@ -318,15 +346,25 @@ Napi::Value dbimou::for_each_from(const Napi::CallbackInfo& info) {
 
         return Napi::Number::New(env, static_cast<double>(index));
     } catch (const std::exception& e) {
-        throw Napi::Error::New(env, std::string("forEach: ") + e.what());
+        throw Napi::Error::New(env, std::string("forEach_from: ") + e.what());
     }
 }
 
 Napi::Value dbimou::stat(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
+    auto arg_len = info.Length();
+    if (arg_len < 1) {
+        throw Napi::Error::New(env, "stat: txnmou required");
+    }
+    auto arg0 = info[0].As<Napi::Object>();
+    // Дополнительная проверка - есть ли у объекта нужный constructor
+    if (!arg0.InstanceOf(txnmou::ctor.Value())) {
+        throw Napi::TypeError::New(env, "stat: first argument must be MDBX_Txn instance");
+    }    
+    auto txn = Napi::ObjectWrap<txnmou>::Unwrap(arg0);
     
     try {
-        auto stat = get_stat(*txn_, dbi_);
+        auto stat = dbi::get_stat(*txn);
         
         Napi::Object result = Napi::Object::New(env);
         
@@ -352,16 +390,20 @@ Napi::Value dbimou::stat(const Napi::CallbackInfo& info) {
 
 Napi::Value dbimou::keys(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
-    
-    MDBX_cursor* cursor_ptr;
-    auto rc = mdbx_cursor_open(*txn_, dbi_, &cursor_ptr);
-    if (rc != MDBX_SUCCESS) {
-        throw Napi::Error::New(env, mdbx_strerror(rc));
+    auto arg_len = info.Length();
+    if (arg_len < 1) {
+        throw Napi::Error::New(env, "keys: txnmou required");
     }
-
+    auto arg0 = info[0].As<Napi::Object>();
+    // Дополнительная проверка - есть ли у объекта нужный constructor
+    if (!arg0.InstanceOf(txnmou::ctor.Value())) {
+        throw Napi::TypeError::New(env, "keys: first argument must be MDBX_Txn instance");
+    }    
+    auto txn = Napi::ObjectWrap<txnmou>::Unwrap(arg0);
+    
     try {
-        cursormou_managed cursor{ cursor_ptr };
-        auto stat = get_stat(*txn_, dbi_);
+        auto cursor = dbi::open_cursor(*txn);
+        auto stat = dbi::get_stat(*txn);
         
         // Создаем массив для ключей
         Napi::Array keys = Napi::Array::New(env, stat.ms_entries);
@@ -402,36 +444,37 @@ Napi::Value dbimou::keys(const Napi::CallbackInfo& info) {
 
 Napi::Value dbimou::keys_from(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
-    
-    if (info.Length() < 1) {
-        throw Napi::Error::New(env, "keysFrom: 'from' key required");
-    }
-    
-    MDBX_cursor* cursor_ptr;
-    auto rc = mdbx_cursor_open(*txn_, dbi_, &cursor_ptr);
-    if (rc != MDBX_SUCCESS) {
-        throw Napi::Error::New(env, mdbx_strerror(rc));
+    auto arg_len = info.Length();
+    if (arg_len < 2) {
+        throw Napi::Error::New(env, "keysFrom: txnmou and 'from' key required");
     }
+    auto arg0 = info[0].As<Napi::Object>();
+    // Дополнительная проверка - есть ли у объекта нужный constructor
+    if (!arg0.InstanceOf(txnmou::ctor.Value())) {
+        throw Napi::TypeError::New(env, "keysFrom: first argument must be MDBX_Txn instance");
+    }    
+    auto txn = Napi::ObjectWrap<txnmou>::Unwrap(arg0);
 
     try {
-        cursormou_managed cursor{ cursor_ptr };
+        auto cursor = dbi::open_cursor(*txn);
         
-        // Парсим аргументы: from, limit, cursorMode
-        keymou from_key = mdbx::is_ordinal(key_mode_) ?
-            keymou::from(info[0], env, id_buf_) : 
-            keymou::from(info[0], env, key_buf_);
+        // Парсим аргументы: txn, from, limit, cursorMode
+        std::uint64_t t;
+        keymou from_key = (key_mode_.val & key_mode::ordinal) ?
+            keymou::from(info[1], env, t) : 
+            keymou::from(info[1], env, key_buf_);
         
         std::size_t count = SIZE_MAX;
-        if (info.Length() > 1 && !info[1].IsUndefined()) {
-            count = info[1].As<Napi::Number>().Uint32Value();
+        if (info.Length() > 2 && !info[2].IsUndefined()) {
+            count = info[2].As<Napi::Number>().Uint32Value();
         }
         
         using move_operation = mdbx::cursor::move_operation;
         auto cursor_mode = move_operation::key_greater_or_equal;
         auto turn_mode = move_operation::next;
 
-        if (info.Length() > 2 && !info[2].IsUndefined()) {
-            cursor_mode = parse_cursor_mode(info[2]);
+        if (info.Length() > 3 && !info[3].IsUndefined()) {
+            cursor_mode = parse_cursor_mode(info[3]);
             
             // Определяем направление сканирования на основе операции
             switch (cursor_mode) {
@@ -466,7 +509,7 @@ Napi::Value dbimou::keys_from(const Napi::CallbackInfo& info) {
                 
                 keymou key{f.key};
                 if (is_key_equal_mode) {
-                    if (id_buf_ != key.as_int64()) {
+                    if (t != key.as_int64()) {
                         return true; // останавливаем сканирование
                     }
                 }
@@ -510,13 +553,28 @@ Napi::Value dbimou::keys_from(const Napi::CallbackInfo& info) {
     return env.Undefined();
 }
 
-const env_arg0* dbimou::get_env_userctx(MDBX_env* e) 
-{
-    assert(e);
-    auto rc = static_cast<env_arg0*>(mdbx_env_get_userctx(e));
-    if (!rc)
-        throw std::runtime_error("env: userctx not set");
-    return rc;
-} 
+Napi::Value dbimou::drop(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "First argument must be a transaction").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    auto arg0 = info[0].As<Napi::Object>();
+    if (!arg0.InstanceOf(txnmou::ctor.Value())) {
+        Napi::TypeError::New(env, "First argument must be a txnmou instance").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    auto txn = Napi::ObjectWrap<txnmou>::Unwrap(arg0);
+    bool delete_db = false;
+    if (info.Length() > 1 && info[1].IsBoolean()) {
+        delete_db = info[1].As<Napi::Boolean>().Value();
+    }
+    try {
+        dbi::drop(*txn, delete_db);
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, std::string("drop: ") + e.what());
+    }
+    return env.Undefined();
+}
 
 } // namespace mdbxmou

package/src/dbimou.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "valuemou.hpp"
+#include "dbi.hpp"
 #include "querymou.hpp"
 #include "env_arg0.hpp"
 #include <memory>
@@ -13,36 +13,50 @@ struct env_arg0;
 
 class dbimou final
     : public Napi::ObjectWrap<dbimou>
+    , public dbi
 {
-    // мы должны отслеживать время жизни evn
-    envmou* env_{nullptr};
-    txnmou* txn_{nullptr};
-    MDBX_dbi dbi_{};
     db_mode mode_{};
     key_mode key_mode_{};
     value_mode value_mode_{};
+
     base_flag key_flag_{};
     base_flag value_flag_{};
+
     buffer_type key_buf_{};
     buffer_type val_buf_{};
     std::uint64_t id_buf_{};
     
-public:
-    static inline MDBX_stat get_stat(MDBX_txn* txn, MDBX_dbi dbi) 
-    {
-        MDBX_stat stat;
-        auto rc = mdbx_dbi_stat(txn, dbi, &stat, sizeof(stat));
-        if (rc != MDBX_SUCCESS) {
-            throw std::runtime_error(mdbx_strerror(rc));
-        }
-        return stat;
-    }    
-    
+public:   
     static Napi::FunctionReference ctor;
 
     dbimou(const Napi::CallbackInfo& info)
-        : Napi::ObjectWrap<dbimou>(info) 
-    {  }
+        : Napi::ObjectWrap<dbimou>{info}
+        , dbi{}
+    {   }
+
+    Napi::Value get_id(const Napi::CallbackInfo& info) {
+        return Napi::BigInt::New(info.Env(), static_cast<int64_t>(id_));
+    }
+
+    Napi::Value get_mode(const Napi::CallbackInfo& info) {
+        return Napi::Number::New(info.Env(), static_cast<double>(mode_.val));
+    }
+    
+    Napi::Value get_key_mode(const Napi::CallbackInfo& info) {
+        return Napi::Number::New(info.Env(), static_cast<double>(key_mode_.val));
+    }
+    
+    Napi::Value get_value_mode(const Napi::CallbackInfo& info) {
+        return Napi::Number::New(info.Env(), static_cast<double>(value_mode_.val));
+    }
+    
+    Napi::Value get_key_flag(const Napi::CallbackInfo& info) {
+        return Napi::Number::New(info.Env(), static_cast<double>(key_flag_.val));
+    }
+    
+    Napi::Value get_value_flag(const Napi::CallbackInfo& info) {
+        return Napi::Number::New(info.Env(), static_cast<double>(value_flag_.val));
+    }    
 
     static void init(const char *class_name, Napi::Env env);
 
@@ -55,6 +69,7 @@ public:
     Napi::Value stat(const Napi::CallbackInfo&);
     Napi::Value keys(const Napi::CallbackInfo&);
     Napi::Value keys_from(const Napi::CallbackInfo&);
+    Napi::Value drop(const Napi::CallbackInfo& info);
 
 private:
     // Внутренний метод для forEach с начальным ключом
@@ -62,13 +77,11 @@ private:
 
 public:
 
-    void attach(envmou* env, txnmou* txn, MDBX_dbi dbi, 
-        db_mode mode, key_mode key_mode, value_mode value_mode, 
+    void attach(MDBX_dbi id, db_mode mode, 
+        key_mode key_mode, value_mode value_mode, 
         base_flag key_flag, base_flag value_flag)
     {
-        env_ = env;
-        txn_ = txn;
-        dbi_ = dbi;
+        dbi::attach(id);
         mode_ = mode;
         key_mode_ = key_mode;
         value_mode_ = value_mode;
@@ -76,7 +89,9 @@ public:
         value_flag_ = value_flag;
     }
 
-    static const env_arg0* get_env_userctx(MDBX_env* env_ptr);
+    operator MDBX_put_flags_t() const noexcept {
+        return static_cast<MDBX_put_flags_t>(key_mode_.val & value_mode_.val);
+    }
 };
 
 } // namespace mdbxmou

package/src/env_arg0.hpp

@@ -18,4 +18,13 @@ struct env_arg0 {
     base_flag value_flag{};
 };
 
+static inline const env_arg0* get_env_userctx(MDBX_env* env_ptr)
+{
+    assert(env_ptr);
+    auto rc = static_cast<env_arg0*>(mdbx_env_get_userctx(env_ptr));
+    if (!rc)
+        throw std::runtime_error("env: userctx not set");
+    return rc;
+}
+
 } // namespace mdbxmou

package/src/envmou.cpp

@@ -386,7 +386,7 @@ Napi::Value envmou::query(const Napi::CallbackInfo& info)
 
         check();
 
-        auto conf = dbimou::get_env_userctx(*this);
+        auto conf = get_env_userctx(*this);
 
         auto arg0 = info[0];
         query_request query = parse_query(mode, 
@@ -429,7 +429,7 @@ Napi::Value envmou::keys(const Napi::CallbackInfo& info)
 
         check();
 
-        auto conf = dbimou::get_env_userctx(*this);
+        auto conf = get_env_userctx(*this);
 
         auto arg0 = info[0];
         keys_request query = parse_keys(mode, 

package/src/txnmou.cpp

@@ -97,7 +97,7 @@ Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
         key_mode key_mode{};
         value_mode value_mode{};
         std::string db_name{};
-        auto conf = dbimou::get_env_userctx(*env_);
+        auto conf = get_env_userctx(*env_);
         auto key_flag = conf->key_flag;
         auto value_flag = conf->value_flag;
         auto arg_count = info.Length();
@@ -145,7 +145,7 @@ Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
         if (rc != MDBX_SUCCESS) {
             throw std::runtime_error(std::string("mdbx_dbi_open ") + mdbx_strerror(rc));
         }
-        ptr->attach(env_, this, dbi, db_mode, key_mode, 
+        ptr->attach(dbi, db_mode, key_mode, 
             value_mode, key_flag, value_flag);
         return obj;
     }
@@ -251,4 +251,12 @@ void txnmou::free_txn::operator()(MDBX_txn* txn) const noexcept {
     }
 }
 
+void txnmou::drop(MDBX_dbi id, bool del)
+{
+    auto rc = mdbx_drop(*this, id, del);
+    if (rc != MDBX_SUCCESS) {
+        throw std::runtime_error(mdbx_strerror(rc));
+    }
+}
+
 } // namespace mdbxmou

package/src/txnmou.hpp

@@ -117,6 +117,8 @@ public:
 
     void attach(envmou& env, MDBX_txn* txn, 
         txn_mode mode, txnmou* parent = nullptr);
+
+    void drop(MDBX_dbi id, bool del);
 };
 
 } // namespace mdbxmou