mdbxmou 0.2.1 → 0.2.4

package/CMakeLists.txt

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

package/README.md

@@ -19,6 +19,8 @@ npm install mdbxmou
 
 ## Quick Start
 
+CommonJS:
+
 ```javascript
 const { MDBX_Env, MDBX_Param } = require('mdbxmou');
 
@@ -47,6 +49,12 @@ readTxn.commit();
 await env.close();
 ```
 
+ESM:
+
+```javascript
+import { MDBX_Env, MDBX_Param } from "mdbxmou";
+```
+
 ## API Reference
 
 ### Environment (MDBX_Env)
@@ -64,19 +72,19 @@ await env.open({
   path: './database',           // Database directory
   keyFlag: MDBX_Param.keyFlag.string,    // Default key encoding (optional)
   valueFlag: MDBX_Param.valueFlag.string, // Default value encoding (optional)
-  envFlag: MDBX_Param.envFlag.nostickythreads
+  flags: MDBX_Param.envFlag.nostickythreads
 });
 ```
 
 Options:
 - `path` - Database directory path
+- `flags` - Environment flags (optional, defaults to `0`)
 - `keyFlag` - Default key encoding for all operations (optional, defaults to Buffer)
   - Only `string` can be set (ordinal mode uses `number`/`bigint` separately)
 - `valueFlag` - Default value encoding for all operations (optional, defaults to Buffer)
-- `envFlag` - Environment flags
-- `mapSize` - Maximum database size
-- `maxReaders` - Maximum number of readers
-- `maxDbs` - Maximum number of databases
+- `maxDbi` - Maximum number of databases (optional, default `32`)
+- `mode` - Filesystem permissions mode (optional, default `0664`)
+- `geometry` - Map size/geometry options (optional)
 
 Note: When `keyFlag` or `valueFlag` are set at environment level, they become defaults for all subsequent operations unless explicitly overridden.
 
@@ -124,14 +132,14 @@ const result = await env.query([
 
 #### Methods
 
-**createMap(keyMode, [valueMode], [flags], [name]) → DBI**
+**createMap(db_name | keyMode, [keyMode | valueMode], [valueMode]) → DBI**
 ```javascript
-// No arguments - default keyMode (0) and valueMode (0)
-const dbi = txn.createMap();
-
 // One argument - keyMode only
 const dbi = txn.createMap(MDBX_Param.keyMode.ordinal);
 
+// One argument - db_name only (uses default keyMode)
+const namedDbi = txn.createMap("my-table");
+
 // Two arguments - keyMode + valueMode
 const dbi = txn.createMap(MDBX_Param.keyMode.ordinal, MDBX_Param.valueMode.multi);
 
@@ -144,17 +152,17 @@ 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(keyMode, [name]) → DBI**
+**openMap(db_name | keyMode, [keyMode]) → DBI**
 ```javascript
-// No arguments - default keyMode (0) 
-const dbi = txn.openMap();
-
 // One argument - keyMode only
 // Number keyMode - keys returned as numbers
 const dbi = txn.openMap(MDBX_Param.keyMode.ordinal);
 // BigInt keyMode - keys returned as BigInts
 const dbi = txn.openMap(BigInt(MDBX_Param.keyMode.ordinal));
 
+// One argument - db_name only (uses default keyMode)
+const namedDbi = txn.openMap("my-table");
+
 // Two arguments - db_name + keyMode
 const namedDbi = txn.openMap("my-table", MDBX_Param.keyMode.ordinal);
 const namedDbiBigInt = txn.openMap("my-table", BigInt(MDBX_Param.keyMode.ordinal));
@@ -454,24 +462,27 @@ async function queryExample() {
   const env = new MDBX_Env();
   await env.open({ path: './query-data' });
 
-  // Async query with multiple databases
+  // Create DBI first in synchronous transaction
+  const writeTxn = env.startWrite();
+  const dbi = writeTxn.createMap(MDBX_Param.keyMode.ordinal);
+  writeTxn.commit();
+
+  // Async query with DBI object (not database name)
   const results = await env.query([
     {
-      db: "users",
-      dbMode: MDBX_Param.dbMode.create | MDBX_Param.dbMode.accede,
-      mode: MDBX_Param.queryMode.put,
+      dbi: dbi,
+      mode: MDBX_Param.queryMode.insertUnique,
       item: [
-        { key: "user1", value: JSON.stringify({ name: "Alice" }) },
-        { key: "user2", value: JSON.stringify({ name: "Bob" }) }
+        { key: 1, value: JSON.stringify({ name: "Alice" }) },
+        { key: 2, value: JSON.stringify({ name: "Bob" }) }
       ]
     },
     {
-      db: "users", 
-      dbMode: MDBX_Param.dbMode.accede,
+      dbi: dbi,
       mode: MDBX_Param.queryMode.get,
       item: [
-        { key: "user1" },
-        { key: "user2" }
+        { key: 1 },
+        { key: 2 }
       ]
     }
   ]);
@@ -481,6 +492,47 @@ async function queryExample() {
 }
 ```
 
+### Async Keys API
+
+```javascript
+const { MDBX_Env, MDBX_Param } = require('mdbxmou');
+
+async function keysExample() {
+  const env = new MDBX_Env();
+  await env.open({ path: './keys-data' });
+
+  // Create DBI first
+  const writeTxn = env.startWrite();
+  const dbi = writeTxn.createMap(MDBX_Param.keyMode.ordinal);
+  
+  // Add some test data
+  for (let i = 1; i <= 10; i++) {
+    dbi.put(writeTxn, i, `value-${i}`);
+  }
+  writeTxn.commit();
+
+  // Get all keys from DBI
+  const allKeys = await env.keys(dbi);
+  console.log("All keys:", allKeys);
+
+  // Get keys with DBI object parameter  
+  const allKeys2 = await env.keys({ dbi: dbi });
+  console.log("All keys (object):", allKeys2);
+
+  // Get keys from multiple DBIs
+  const multiKeys = await env.keys([dbi, dbi]);
+  console.log("Multi DBI keys:", multiKeys);
+
+  // Get limited keys from specific position
+  const limitedKeys = await env.keys([
+    { dbi: dbi, limit: 3, from: 5 }
+  ]);
+  console.log("Limited keys:", limitedKeys);
+
+  await env.close();
+}
+```
+
 ## Error Handling
 
 ```javascript
@@ -492,7 +544,7 @@ try {
   const dbi = txn.createMap(MDBX_Param.keyMode.ordinal);
   
   // This might throw if key already exists with MDBX_NOOVERWRITE
-  dbi.put(txn, 123, "value", MDBX_Param.putFlag.nooverwrite);
+  dbi.put(txn, 123, "value");
   
   txn.commit();
 } catch (error) {
@@ -524,7 +576,17 @@ Note: For ordinal (integer) keys, use keyFlag.number or keyFlag.bigint to specif
 
 ### Environment Flags
 - `MDBX_Param.envFlag.nostickythreads` - Don't stick reader transactions to threads
-- `MDBX_Param.envFlag.readonly` - Open database in read-only mode
+- `MDBX_Param.envFlag.rdonly` - Open database in read-only mode
+- `MDBX_Param.envFlag.validation` - Enable page validation
+- `MDBX_Param.envFlag.exclusive` - Exclusive mode
+- `MDBX_Param.envFlag.accede` - Open existing environment
+- `MDBX_Param.envFlag.writemap` - Use writable memory map
+- `MDBX_Param.envFlag.nordahead` - Disable OS readahead
+- `MDBX_Param.envFlag.nomeminit` - Disable memory initialization
+- `MDBX_Param.envFlag.liforeclaim` - LIFO reclaim
+- `MDBX_Param.envFlag.nometasync` - Disable metadata flushes
+- `MDBX_Param.envFlag.safeNosync` - Safe nosync mode
+- `MDBX_Param.envFlag.utterlyNosync` - Utterly nosync mode
 
 ### Database Modes  
 - `MDBX_Param.dbMode.create` - Create database if it doesn't exist
@@ -532,9 +594,24 @@ Note: For ordinal (integer) keys, use keyFlag.number or keyFlag.bigint to specif
 
 ### Query Modes
 - `MDBX_Param.queryMode.get` - Read operations
-- `MDBX_Param.queryMode.put` - Write operations  
+- `MDBX_Param.queryMode.upsert` - Write operations (insert or update)
+- `MDBX_Param.queryMode.update` - Update existing (MDBX_CURRENT)
+- `MDBX_Param.queryMode.insertUnique` - Insert unique (MDBX_NOOVERWRITE)
 - `MDBX_Param.queryMode.del` - Delete operations
 
+### Cursor Modes
+- `MDBX_Param.cursorMode.first` - First key
+- `MDBX_Param.cursorMode.last` - Last key  
+- `MDBX_Param.cursorMode.next` - Next key
+- `MDBX_Param.cursorMode.prev` - Previous key
+- `MDBX_Param.cursorMode.keyLesserThan` - Keys less than target
+- `MDBX_Param.cursorMode.keyLesserOrEqual` - Keys less than or equal to target
+- `MDBX_Param.cursorMode.keyEqual` - Keys exactly equal to target
+- `MDBX_Param.cursorMode.keyGreaterOrEqual` - Keys greater than or equal to target  
+- `MDBX_Param.cursorMode.keyGreaterThan` - Keys greater than target
+
+> **Note**: Cursor modes can be used with `keysFrom()` and `forEach()` methods to control iteration direction and filtering.
+
 ## Performance Tips
 
 1. **Use ordinal keys** for integer data - much faster than string keys
@@ -549,5 +626,5 @@ Apache License 2.0
 
 ---
 
-**Documentation generated by GitHub Copilot (Claude 3.5 Sonnet) on August 13, 2025**  
+**Documentation generated by GitHub Copilot (Claude 3.5 Sonnet) on August 27, 2025**  
 **Reviewed and approved by the library author**

package/build.js

@@ -1,6 +1,7 @@
 
 var spawnSync = require('child_process').spawnSync;
 var fs = require('fs');
+var path = require('path');
 
 function exec(cmd) {
     const { status } = spawnSync(cmd, {
@@ -14,6 +15,7 @@ function exec(cmd) {
 
 // Create VERSION.json for libmdbx (needed for npm package)
 const versionFile = 'deps/libmdbx/VERSION.json';
+const libmdbxGitMarker = 'deps/libmdbx/.git';
 if (!fs.existsSync(versionFile)) {
     console.log('Creating VERSION.json for libmdbx...');
     const versionJson = {
@@ -27,14 +29,20 @@ if (!fs.existsSync(versionFile)) {
     console.log('VERSION.json created successfully!');
 }
 
-// Patch CMakeLists.txt line 56: if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git" -> if(NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git"
+// Workaround for npm package: npm does not ship git metadata, while libmdbx
+// may rely on it to determine version info during CMake configure.
+// Apply this patch only when git metadata is missing.
 const cmakeFile = 'deps/libmdbx/CMakeLists.txt';
-if (fs.existsSync(cmakeFile)) {
-    let cmakeContent = fs.readFileSync(cmakeFile, 'utf8').split('\n');
-    if (cmakeContent[55] && cmakeContent[55].trim().startsWith('if(EXISTS')) {
-        cmakeContent[55] = cmakeContent[55].replace('if(EXISTS', 'if(NOT EXISTS');
-        fs.writeFileSync(cmakeFile, cmakeContent.join('\n'));
-        console.log('Patched CMakeLists.txt line 56: if(NOT EXISTS ...');
+if (!fs.existsSync(libmdbxGitMarker) && fs.existsSync(cmakeFile)) {
+    const cmakeText = fs.readFileSync(cmakeFile, 'utf8');
+    const from = 'if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git"';
+    const to = 'if(NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git"';
+    if (cmakeText.includes(from)) {
+        const patched = cmakeText.replace(from, to);
+        if (patched !== cmakeText) {
+            fs.writeFileSync(cmakeFile, patched);
+            console.log('Patched libmdbx CMakeLists.txt for npm package (no .git).');
+        }
     }
 }
 

package/lib/async.mjs

@@ -0,0 +1,7 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const { MDBX_Async_Env } = require("./mdbx_evn_async.js");
+
+export { MDBX_Async_Env };
+export default MDBX_Async_Env;

package/lib/index.mjs

@@ -0,0 +1,12 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+
+const native = require("./nativemou.js");
+const { MDBX_Async_Env } = require("./mdbx_evn_async.js");
+
+export const MDBX_Env = native.MDBX_Env;
+export const MDBX_Param = native.MDBX_Param;
+export { MDBX_Async_Env };
+
+export default native;

package/lib/mdbx_worker.js

@@ -82,17 +82,21 @@ async function handler(msg) {
 
       case "dbi_put": {
         const { txnId, dbiId, key, value, flags = 0 } = params;
+        const t = txns.get(txnId);
+        if (!t) throw new Error("no txn");
         const d = dbis.get(dbiId);
         if (!d || d.txnId !== txnId) throw new Error("no dbi");
-        d.dbi.put(key, value, flags);
+        d.dbi.put(t.txn, key, value, flags);
         return ok(id, true);
       }
 
       case "dbi_get": {
         const { txnId, dbiId, key } = params;
+        const t = txns.get(txnId);
+        if (!t) throw new Error("no txn");
         const d = dbis.get(dbiId);
         if (!d || d.txnId !== txnId) throw new Error("no dbi");
-        const val = d.dbi.get(key);
+        const val = d.dbi.get(t.txn, key);
         // Если val это Buffer, преобразуем в строку для удобства
         const result = (val && Buffer.isBuffer(val)) ? val.toString() : val;
         return ok(id, result);
@@ -100,25 +104,31 @@ async function handler(msg) {
 
       case "dbi_del": {
         const { txnId, dbiId, key } = params;
+        const t = txns.get(txnId);
+        if (!t) throw new Error("no txn");
         const d = dbis.get(dbiId);
         if (!d || d.txnId !== txnId) throw new Error("no dbi");
-        const r = d.dbi.del(key);
+        const r = d.dbi.del(t.txn, key);
         return ok(id, r);
       }
 
       case "dbi_stat": {
         const { txnId, dbiId } = params;
+        const t = txns.get(txnId);
+        if (!t) throw new Error("no txn");
         const d = dbis.get(dbiId);
         if (!d || d.txnId !== txnId) throw new Error("no dbi");
-        return ok(id, d.dbi.stat());
+        return ok(id, d.dbi.stat(t.txn));
       }
 
       case "dbi_iter_all": {
         const { txnId, dbiId } = params;
+        const t = txns.get(txnId);
+        if (!t) throw new Error("no txn");
         const d = dbis.get(dbiId);
         if (!d || d.txnId !== txnId) throw new Error("no dbi");
         const out = [];
-        d.dbi.forEach((k, v) => {
+        d.dbi.forEach(t.txn, (k, v) => {
           out.push({ key: k, value: v });
           return true;
         });
@@ -128,13 +138,15 @@ async function handler(msg) {
       case "dbi_get_batch": {
         // Групповое чтение множества ключей
         const { txnId, dbiId, keys } = params;
+        const t = txns.get(txnId);
+        if (!t) throw new Error("no txn");
         const d = dbis.get(dbiId);
         if (!d || d.txnId !== txnId) throw new Error("no dbi");
         
         const results = [];
         for (const key of keys) {
           try {
-            const val = d.dbi.get(key);
+            const val = d.dbi.get(t.txn, key);
             if (val !== undefined && val !== null) {
               const result = (val && Buffer.isBuffer(val)) ? val.toString() : val;
               results.push({ key, value: result, found: true });
@@ -151,13 +163,15 @@ async function handler(msg) {
       case "dbi_put_batch": {
         // Групповая запись множества пар ключ-значение
         const { txnId, dbiId, items, flags = 0 } = params;
+        const t = txns.get(txnId);
+        if (!t) throw new Error("no txn");
         const d = dbis.get(dbiId);
         if (!d || d.txnId !== txnId) throw new Error("no dbi");
         
         const results = [];
         for (const item of items) {
           try {
-            d.dbi.put(item.key, item.value, flags);
+            d.dbi.put(t.txn, item.key, item.value, flags);
             results.push({ key: item.key, success: true });
           } catch (e) {
             results.push({ key: item.key, success: false, error: e.message });
@@ -169,13 +183,15 @@ async function handler(msg) {
       case "dbi_del_batch": {
         // Групповое удаление множества ключей
         const { txnId, dbiId, keys } = params;
+        const t = txns.get(txnId);
+        if (!t) throw new Error("no txn");
         const d = dbis.get(dbiId);
         if (!d || d.txnId !== txnId) throw new Error("no dbi");
         
         const results = [];
         for (const key of keys) {
           try {
-            const r = d.dbi.del(key);
+            const r = d.dbi.del(t.txn, key);
             results.push({ key, deleted: r });
           } catch (e) {
             results.push({ key, deleted: false, error: e.message });

package/package.json

@@ -1,5 +1,17 @@
 {
   "main": "lib/nativemou.js",
+  "exports": {
+    ".": {
+      "import": "./lib/index.mjs",
+      "require": "./lib/nativemou.js"
+    },
+    "./async": {
+      "import": "./lib/async.mjs",
+      "require": "./lib/mdbx_evn_async.js"
+    },
+    "./nativemou": "./lib/nativemou.js",
+    "./package.json": "./package.json"
+  },
   "files": [
     "lib/**/*",
     "src/**/*",
@@ -18,6 +30,7 @@
     "e3": "node ./test/e3.js",
     "e33": "node ./test/e33.js",
     "e4": "node ./test/e4.js",
+    "e4async": "node ./test/e4async.mjs",
     "e5": "node ./test/e5.js",
     "build": "node build.js",
     "build-dev": "node build-dev.js",
@@ -25,7 +38,7 @@
   },
   "gypfile": true,
   "name": "mdbxmou",
-  "version": "0.2.1",
+  "version": "0.2.4",
   "description": "Node bindings for mdbx",
   "repository": {
     "type": "git",

package/src/async/envmou_keys.cpp

@@ -10,16 +10,7 @@ void async_keys::Execute()
         // стартуем транзакцию
         auto txn = start_transaction();
         for (auto& req : query_) 
-        {
-            mdbx::map_handle dbi{};
-            auto db_mode = req.db_mod;
-            if (db_mode.val & db_mode::accede) {
-                dbi = txn.open_map_accede(req.db);
-            } else {
-                dbi = txn.open_map(req.db, req.key_mod, req.val_mod);
-            }
-            do_keys(txn, dbi, req);
-        }
+            do_keys(txn, {req.id}, req);
 
         txn.commit();
     } catch (const std::exception& e) {
@@ -72,9 +63,6 @@ void async_keys::OnOK()
     for (std::uint32_t i = 0; i < query_.size(); ++i) {
         Napi::Object js_row = Napi::Object::New(env);
         const auto& row = query_[i];
-        if (!row.db.empty()) {
-            js_row.Set("db", Napi::String::New(env, row.db_name));
-        }
         result.Set(i, write_row(env, row));
     }
 

package/src/async/envmou_query.cpp

@@ -10,16 +10,7 @@ void async_query::Execute()
         auto txn = start_transaction();
         for (auto& req : query_) 
         {
-            mdbx::map_handle dbi{};
-            auto db_mode = req.db_mod;
-            if (db_mode.val & db_mode::accede) {
-                dbi = txn.open_map_accede(req.db);
-            } else if (db_mode.val & db_mode::create) {
-                dbi = txn.create_map(req.db, req.key_mod, req.val_mod);
-            } else {
-                dbi = txn.open_map(req.db, req.key_mod, req.val_mod);
-            }
-
+            mdbx::map_handle dbi{req.id};
             auto mode = req.mode;
             if (mode.val & query_mode::get) {
                 do_get(txn, dbi, req);
@@ -29,7 +20,6 @@ void async_query::Execute()
                 do_put(txn, dbi, req);
             }
         }
-
         txn.commit();
     } catch (const std::exception& e) {
         SetError(e.what());
@@ -111,9 +101,6 @@ void async_query::OnOK()
     for (std::size_t i = 0; i < query_.size(); ++i) {
         Napi::Object js_row = Napi::Object::New(env);
         const auto& row = query_[i];
-        if (!row.db.empty()) {
-            js_row.Set("db", Napi::String::New(env, row.db_name));
-        }
         result.Set(static_cast<uint32_t>(i), write_row(env, row));
     }
 

package/src/dbimou.cpp

@@ -569,13 +569,11 @@ Napi::Value dbimou::keys_from(const Napi::CallbackInfo& info) {
 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();
+        throw Napi::TypeError::New(env, "First argument must be a transaction");
     }
     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();
+        throw Napi::TypeError::New(env, "First argument must be a txnmou instance");
     }
     auto txn = Napi::ObjectWrap<txnmou>::Unwrap(arg0);
     bool delete_db = false;

package/src/dbimou.hpp

@@ -24,7 +24,6 @@ class dbimou final
 
     buffer_type key_buf_{};
     buffer_type val_buf_{};
-    std::uint64_t id_buf_{};
     
 public:   
     static Napi::FunctionReference ctor;
@@ -60,6 +59,9 @@ public:
 
     static void init(const char *class_name, Napi::Env env);
 
+    // valuemou read(const MDBX_txn* txn);
+    // valuemou read(const MDBX_txn* txn, const keymou& key);
+
     // Основные операции (только синхронные)
     Napi::Value put(const Napi::CallbackInfo&);
     Napi::Value get(const Napi::CallbackInfo&);
@@ -69,7 +71,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);
+    Napi::Value drop(const Napi::CallbackInfo&);
 
 private:
     // Внутренний метод для forEach с начальным ключом
@@ -92,6 +94,30 @@ public:
     operator MDBX_put_flags_t() const noexcept {
         return static_cast<MDBX_put_flags_t>(key_mode_.val & value_mode_.val);
     }
+
+    MDBX_dbi get_id() const noexcept {
+        return id_;
+    }
+
+    db_mode get_mode() const noexcept {
+        return mode_;
+    }
+
+    key_mode get_key_mode() const noexcept {
+        return key_mode_;
+    }
+
+    value_mode get_value_mode() const noexcept {
+        return value_mode_;
+    }
+
+    base_flag get_key_flag() const noexcept {
+        return key_flag_;
+    }
+
+    base_flag get_value_flag() const noexcept {
+        return value_flag_;
+    }
 };
 
 } // namespace mdbxmou

package/src/envmou.cpp

@@ -372,8 +372,7 @@ Napi::Value envmou::query(const Napi::CallbackInfo& info)
     txn_mode mode{};
 
     if (info.Length() < 1) {
-        throw Napi::TypeError::New(env, 
-            "expected array of requests: [{ db: String, db_mode: Number, key_mode: Number, key_flag: Number, value_mode: Number, value_flag: Number, mode: Number, item: [] }, ...]");
+        throw Napi::TypeError::New(env, "expected array of requests");
     }
 
     if (info.Length() > 1 || info[1].IsNumber()) {
@@ -389,8 +388,7 @@ Napi::Value envmou::query(const Napi::CallbackInfo& info)
         auto conf = get_env_userctx(*this);
 
         auto arg0 = info[0];
-        query_request query = parse_query(mode, 
-            conf->key_flag, conf->value_flag, arg0);
+        query_request query = parse_query(mode, arg0);
         auto* worker = new async_query(env, *this, mode, 
             std::move(query), arg0.IsObject());
         auto promise = worker->GetPromise();
@@ -429,11 +427,8 @@ Napi::Value envmou::keys(const Napi::CallbackInfo& info)
 
         check();
 
-        auto conf = get_env_userctx(*this);
-
         auto arg0 = info[0];
-        keys_request query = parse_keys(mode, 
-            conf->key_flag, conf->value_flag, arg0);
+        keys_request query = parse_keys(arg0);
 
         auto* worker = new async_keys(env, *this, mode, 
             std::move(query), arg0.IsObject());

package/src/modulemou.cpp

@@ -78,24 +78,24 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
     MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "last", move_operation::last);
     MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "next", move_operation::next);
     MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "prev", move_operation::previous);
-    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "key_lesser_than", 
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "keyLesserThan", 
         move_operation::key_lesser_than);
-    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "key_lesser_or_equal", 
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "keyLesserOrEqual", 
         move_operation::key_lesser_or_equal);
-    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "key_equal", move_operation::key_equal);
-    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "key_greater_or_equal", 
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "keyEqual", move_operation::key_equal);
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "keyGreaterOrEqual", 
         move_operation::key_greater_or_equal);
-    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "key_greater_than", 
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "keyGreaterThan", 
         move_operation::key_greater_than);
-    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multi_exactkey_value_lesser_than", 
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multiExactKeyValueLesserThan", 
         move_operation::multi_exactkey_value_lesser_than);
-    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multi_exactkey_value_lesser_or_equal", 
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multiExactKeyValueLesserOrEqual", 
         move_operation::multi_exactkey_value_lesser_or_equal);
-    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multi_exactkey_value_equal", 
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multiExactKeyValueEqual", 
         move_operation::multi_exactkey_value_equal);
-    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multi_exactkey_value_greater_or_equal", 
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multiExactKeyValueGreaterOrEqual", 
         move_operation::multi_exactkey_value_greater_or_equal);
-    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multi_exactkey_value_greater", 
+    MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "multiExactKeyValueGreater", 
         move_operation::multi_exactkey_value_greater);
     mdbx_mou.Set("cursorMode", cursor_mode);
 

package/src/querymou.cpp

@@ -1,30 +1,24 @@
 #include "querymou.hpp"
+#include "dbimou.hpp"
 
 namespace mdbxmou {
 
-void async_common::parse(txn_mode txn, const Napi::Object& obj)
+dbimou* async_common::parse(const Napi::Object& arg0)
 {
-    if (obj.Has("db")) {
-        db_name = obj.Get("db").As<Napi::String>().Utf8Value();
-        db = mdbx::slice{db_name};
-    }
-
-    if (obj.Has("dbMode")) {
-        db_mod = db_mode::parse(txn, obj.Get("dbMode").As<Napi::Number>());
-    }
-
-    if (obj.Has("keyFlag")) {
-        key_flag = base_flag::parse_key(obj.Get("keyFlag").As<Napi::Number>());
-    }
-
-    if (obj.Has("keyMode")) {
-        key_mod = parse_key_mode(obj.Env(), obj.Get("keyMode").As<Napi::Number>(), key_flag);
+    dbimou* dbi = nullptr;
+    // если просто передали dbi
+    if (arg0.InstanceOf(dbimou::ctor.Value())) {
+        dbi = Napi::ObjectWrap<dbimou>::Unwrap(arg0);
+    } else {
+        auto t = arg0.Get("dbi").As<Napi::Object>();
+        dbi = Napi::ObjectWrap<dbimou>::Unwrap(t);
     }
 
-    // парсим value
-    if (obj.Has("valueMode")) {
-        val_mod = value_mode::parse(obj.Get("valueMode").As<Napi::Number>());
-    }    
+    id = dbi->get_id();
+    key_mod = dbi->get_key_mode();
+    val_mod = dbi->get_value_mode();
+    key_flag = dbi->get_key_flag();
+    return dbi;
 }
 
 void async_key::parse(const async_common& common, const Napi::Value& item)
@@ -59,101 +53,75 @@ void async_keyval::parse(const query_line& common, const Napi::Object& item)
     }
 }
 
-void query_line::parse(txn_mode txn, const Napi::Object& obj)
+void query_line::parse(txn_mode txn, const Napi::Object& arg0)
 {
     //  парсим общие параметры
-    async_common::parse(txn, obj);
-
-    if (obj.Has("valueFlag")) {
-        value_flag = base_flag::parse_value(val_mod, 
-            obj.Get("valueFlag").As<Napi::Number>());
-    }    
-
-    if (obj.Has("mode")) {
-        mode = query_mode::parse(txn, obj.Get("mode").As<Napi::Number>());
-    } else if (obj.Has("queryMode")) {
-        mode = query_mode::parse(txn, obj.Get("queryMode").As<Napi::Number>());
-    }    
-}
-
-void query_line::parse(txn_mode txn, base_flag kf, 
-        base_flag vf, const Napi::Object& obj)
-{
-    // утснавлиаем общие параметры
-    this->key_flag = kf;
-    this->value_flag = vf;
-
-    // парсим общие параметры
-    parse(txn, obj);
-
-    // Парсим элементы
-    if (obj.Has("item")) {
-        auto items_array = obj.Get("item").As<Napi::Array>();
-        auto length = items_array.Length();
-        item.reserve(length);
-        for (uint32_t i = 0; i < length; ++i) {
+    auto dbi = async_common::parse(arg0);
+    value_flag = dbi->get_value_flag();
+    if (arg0.Has("mode")) {
+        mode = query_mode::parse(txn, arg0.Get("mode").As<Napi::Number>());
+    } else if (arg0.Has("queryMode")) {
+        mode = query_mode::parse(txn, arg0.Get("queryMode").As<Napi::Number>());
+    }
+    auto items_array = arg0.Get("item").As<Napi::Array>();
+    auto item_len = items_array.Length();
+    if (item_len > 0) {
+        item.reserve(item_len);
+        for (uint32_t i = 0; i < item_len; ++i) {
             auto item_obj = items_array.Get(i).As<Napi::Object>();
             async_keyval keyval{};
             keyval.parse(*this, item_obj);
             item.emplace_back(std::move(keyval));
         }
-    } else {
-        throw std::runtime_error("query: no item");
     }
 }
 
-query_request parse_query(txn_mode mode, base_flag key_flag, 
-        base_flag value_flag, const Napi::Value& obj)
+query_request parse_query(txn_mode txn, const Napi::Value& arg0)
 {
     query_request rc{};
-    if (obj.IsArray()) {
-        auto arr = obj.As<Napi::Array>();
+    if (arg0.IsArray()) {
+        auto arr = arg0.As<Napi::Array>();
         rc.reserve(arr.Length());
         for (uint32_t i = 0; i < arr.Length(); ++i) {
             query_line row{};
-            row.parse(mode, key_flag, value_flag, arr.Get(i).As<Napi::Object>());
+            row.parse(txn, arr.Get(i).As<Napi::Object>());
             rc.push_back(std::move(row));
         }
-    } else if (obj.IsObject()) {
+    } else if (arg0.IsObject()) {
         query_line row{};
-        row.parse(mode, key_flag, value_flag, obj.As<Napi::Object>());
+        row.parse(txn, arg0.As<Napi::Object>());
         rc.push_back(std::move(row));
     } else {
-        throw Napi::TypeError::New(obj.Env(), "Expected array or object for query");
+        throw Napi::TypeError::New(arg0.Env(), "Expected array or object for query");
     }
     return rc;
 }
 
-void keys_line::parse(txn_mode txn, 
-    base_flag kf, const Napi::Object& obj)
+void keys_line::parse(const Napi::Object& arg0)
 {
-    // утснавлиаем общие параметры
-    this->key_flag = kf;
-
     // парсим общие параметры
-    async_common::parse(txn, obj);
+    async_common::parse(arg0);
 
     // парсим параметры scan_from
-    if (obj.Has("from")) {
+    if (arg0.Has("from")) {
         keymou key{};
         has_from_key = true;
-        async_key::parse(*this, obj.Get("from"));
+        async_key::parse(*this, arg0.Get("from"));
     }
     
-    if (obj.Has("limit")) {
-        auto limit_val = obj.Get("limit");
+    if (arg0.Has("limit")) {
+        auto limit_val = arg0.Get("limit");
         if (limit_val.IsNumber()) {
             limit = limit_val.As<Napi::Number>().Uint32Value();
         }
     }
     
-    if (obj.Has("cursorMode")) {
-        cursor_mode = parse_cursor_mode(obj.Get("cursorMode"));
+    if (arg0.Has("cursorMode")) {
+        cursor_mode = parse_cursor_mode(arg0.Get("cursorMode"));
     }    
 }
 
-keys_request parse_keys(txn_mode txn, base_flag key_flag, 
-    base_flag value_flag, const Napi::Value& obj)
+keys_request parse_keys(const Napi::Value& obj)
 {
     keys_request rc{};
     if (obj.IsArray()) {
@@ -161,12 +129,12 @@ keys_request parse_keys(txn_mode txn, base_flag key_flag,
         rc.reserve(arr.Length());
         for (uint32_t i = 0; i < arr.Length(); ++i) {
             keys_line row{};
-            row.parse(txn, key_flag, arr.Get(i).As<Napi::Object>());
+            row.parse(arr.Get(i).As<Napi::Object>());
             rc.push_back(std::move(row));
         }
     } else if (obj.IsObject()) {
         keys_line row{};
-        row.parse(txn, key_flag, obj.As<Napi::Object>());
+        row.parse(obj.As<Napi::Object>());
         rc.push_back(std::move(row));
     } else {
         throw Napi::TypeError::New(obj.Env(), "Expected array or object for query");

package/src/querymou.hpp

@@ -5,28 +5,28 @@
 
 namespace mdbxmou {
 
+class dbimou;
 struct keys_line;
 struct query_line;
 
 struct async_common 
 {
     // чтобы уметь открыть базу по умолчанию
-    mdbx::slice db{};
-    std::string db_name{};
-    db_mode db_mod{};
+    MDBX_dbi id{};
     // тут важен для нас ordinal он влияет на option_mask
     key_mode key_mod{};
     base_flag key_flag{};
     // общий используется для открытия db
     value_mode val_mod{};
 
-    void parse(txn_mode mode, const Napi::Object& obj);
+    dbimou* parse(const Napi::Object& arg0);
 };
 
 struct async_key 
 {
-    buffer_type key_buf{};
     std::uint64_t id_buf{};
+    buffer_type key_buf{};
+
     void parse(const async_common& common, const Napi::Value& item);
     
     void parse(const async_common& common, const Napi::Object& item)
@@ -57,18 +57,13 @@ struct query_line
 {
     base_flag value_flag{};
     query_mode mode{};
-
-    void parse(txn_mode mode, const Napi::Object& obj);
-
     // буффер для запроса / ответа
     std::vector<async_keyval> item{};
-    void parse(txn_mode txn, base_flag key_flag, 
-        base_flag value_flag, const Napi::Object& obj);
+    void parse(txn_mode txn, const Napi::Object& arg0);
 };
 
 using query_request = std::vector<query_line>;
-query_request parse_query(txn_mode txn, base_flag key_flag, 
-        base_flag value_flag, const Napi::Value& obj);
+query_request parse_query(txn_mode txn, const Napi::Value& arg0);
 
 
 struct keys_line 
@@ -82,12 +77,10 @@ struct keys_line
     // буффер для ответов
     std::vector<async_key> item{};
 
-    void parse(txn_mode txn, base_flag key_flag,
-        const Napi::Object& obj);
+    void parse(const Napi::Object& arg0);
 };
 
 using keys_request = std::vector<keys_line>;
-keys_request parse_keys(txn_mode txn, base_flag key_flag, 
-        base_flag value_flag, const Napi::Value& obj);
+keys_request parse_keys(const Napi::Value& obj);
 
 } // namespace mdbxmou

package/src/txnmou.cpp

@@ -251,12 +251,4 @@ 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,8 +117,6 @@ public:
 
     void attach(envmou& env, MDBX_txn* txn, 
         txn_mode mode, txnmou* parent = nullptr);
-
-    void drop(MDBX_dbi id, bool del);
 };
 
 } // namespace mdbxmou

package/src/typemou.hpp

@@ -10,7 +10,7 @@ namespace mdbxmou {
 using buffer_type = std::vector<char>;
 
 struct txnmou_managed final
-    : public mdbx::txn_managed
+    : mdbx::txn_managed
 {
     txnmou_managed(MDBX_txn* txn)
     {  
@@ -19,7 +19,7 @@ struct txnmou_managed final
 };
 
 struct cursormou_managed final
-    : public mdbx::cursor_managed
+    : mdbx::cursor_managed
 {
     cursormou_managed(MDBX_cursor* cursor) noexcept
     {