mdbxmou 0.1.34 → 0.2.0

package/CMakeLists.txt

@@ -7,6 +7,10 @@ add_definitions(-DNAPI_CPP_EXCEPTIONS)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
+if (MSVC)
+  add_compile_options(/Zc:__cplusplus)
+endif()
+
 add_subdirectory("deps/libmdbx")
 
 add_library(${PROJECT_NAME} SHARED
@@ -19,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.34",
+  "version": "0.2.0",
   "description": "Node bindings for mdbx",
   "repository": {
     "type": "git",

package/src/async/envmou_keys.cpp

@@ -35,16 +35,23 @@ static Napi::Value write_row(Napi::Env env, const keys_line& row)
     auto key_mode = row.key_mod;
     auto key_flag = row.key_flag;
     auto js_arr = Napi::Array::New(env, param.size());
-    for (std::size_t j = 0; j < param.size(); ++j) {
+    for (std::uint32_t j = 0; j < param.size(); ++j) {
         const auto& item = param[j];
+        Napi::Value key_value;
         if (key_mode.val & key_mode::ordinal) {
-            js_arr.Set(j, (key_flag.val & base_flag::number) ?
-                Napi::Number::New(env, item.id_buf) : Napi::BigInt::New(env, item.id_buf));
+            if (key_flag.val & base_flag::number) {
+                key_value = Napi::Number::New(env, static_cast<double>(item.id_buf));
+            } else {
+                key_value = Napi::BigInt::New(env, item.id_buf);
+            }
         } else {
-            js_arr.Set(j, (key_flag.val & base_flag::string) ?
-                Napi::String::New(env, item.key_buf.data(), item.key_buf.size()) :
-                Napi::Buffer<char>::Copy(env, item.key_buf.data(), item.key_buf.size()));
+            if (key_flag.val & base_flag::string) {
+                key_value = Napi::String::New(env, item.key_buf.data(), item.key_buf.size());
+            } else {
+                key_value = Napi::Buffer<char>::Copy(env, item.key_buf.data(), item.key_buf.size());
+            }
         }
+        js_arr.Set(j, key_value);
     }
     return js_arr;
 }
@@ -62,7 +69,7 @@ void async_keys::OnOK()
     }
 
     Napi::Array result = Napi::Array::New(env, query_.size());
-    for (std::size_t i = 0; i < query_.size(); ++i) {
+    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()) {

package/src/async/envmou_query.cpp

@@ -47,15 +47,22 @@ static Napi::Value write_row(Napi::Env env, const query_line& row)
     auto js_arr = Napi::Array::New(env, param.size());
     for (std::size_t j = 0; j < param.size(); ++j) {
         const auto& item = param[j];
+        Napi::Value key_value;
         Napi::Object js_item = Napi::Object::New(env);
         if (key_mode.val & key_mode::ordinal) {
-            js_item.Set("key", (key_flag.val & base_flag::number) ?
-                Napi::Number::New(env, item.id_buf) : Napi::BigInt::New(env, item.id_buf));
+            if (key_flag.val & base_flag::number) {
+                key_value = Napi::Number::New(env, static_cast<double>(item.id_buf));
+            } else {
+                key_value = Napi::BigInt::New(env, item.id_buf);
+            }
         } else {
-            js_item.Set("key", (key_flag.val & base_flag::string) ?
-                Napi::String::New(env, item.key_buf.data(), item.key_buf.size()) :
-                Napi::Buffer<char>::Copy(env, item.key_buf.data(), item.key_buf.size()));
+            if (key_flag.val & base_flag::string) {
+                key_value = Napi::String::New(env, item.key_buf.data(), item.key_buf.size());
+            } else {
+                key_value = Napi::Buffer<char>::Copy(env, item.key_buf.data(), item.key_buf.size());
+            }
         }
+        js_item.Set("key", key_value);
 
         // все методы которые должны показать value в результате
         const auto mask{query_mode::get|query_mode::upsert|
@@ -67,9 +74,13 @@ static Napi::Value write_row(Napi::Env env, const query_line& row)
                 js_item.Set("value", env.Null());
             } else {
                 auto value_flag = row.value_flag;
-                js_item.Set("value", (value_flag.val & base_flag::string) ?
-                    Napi::String::New(env, val_buf.data(), val_buf.size()) :
-                    Napi::Buffer<char>::Copy(env, val_buf.data(), val_buf.size()));
+                Napi::Value val_value;
+                if (value_flag.val & base_flag::string) {
+                    val_value = Napi::String::New(env, val_buf.data(), val_buf.size());
+                } else {
+                    val_value = Napi::Buffer<char>::Copy(env, val_buf.data(), val_buf.size());
+                }
+                js_item.Set("value", val_value);
             }
         }
 
@@ -77,7 +88,7 @@ static Napi::Value write_row(Napi::Env env, const query_line& row)
         if (mode.val & query_mode::del) {
             js_item.Set("found", Napi::Boolean::New(env, item.found));
         }
-        js_arr.Set(j, js_item);
+        js_arr.Set(static_cast<uint32_t>(j), js_item);
     }
     return js_arr;
 }
@@ -103,7 +114,7 @@ void async_query::OnOK()
         if (!row.db.empty()) {
             js_row.Set("db", Napi::String::New(env, row.db_name));
         }
-        result.Set(i, write_row(env, row));
+        result.Set(static_cast<uint32_t>(i), write_row(env, row));
     }
 
     deferred_.Resolve(result);

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