@nxtedition/rocksdb 15.2.4 → 15.3.0

package/binding.cc

@@ -1960,7 +1960,6 @@ NAPI_METHOD(batch_write) {
 
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
-
   bool sync = false;
   NAPI_STATUS_THROWS(GetProperty(env, argv[2], "sync", sync));
 

package/chained-batch.js

@@ -1,12 +1,17 @@
 'use strict'
 
+const { fromCallback } = require('catering')
 const { AbstractChainedBatch } = require('abstract-level')
-const binding = require('./binding')
 const ModuleError = require('module-error')
 const assert = require('node:assert')
 
+const binding = require('./binding')
+
+const kPromise = Symbol('promise')
 const kBatchContext = Symbol('batchContext')
 const kDbContext = Symbol('dbContext')
+const kBusy = Symbol('busy')
+
 const EMPTY = {}
 
 class ChainedBatch extends AbstractChainedBatch {
@@ -15,10 +20,18 @@ class ChainedBatch extends AbstractChainedBatch {
 
     this[kDbContext] = context
     this[kBatchContext] = binding.batch_init()
+    this[kBusy] = false
+  }
+
+  get length () {
+    assert(this[kBatchContext])
+
+    return binding.batch_count(this[kBatchContext])
   }
 
   _put (key, value, options) {
     assert(this[kBatchContext])
+    assert(!this[kBusy])
 
     if (key === null || key === undefined) {
       throw new ModuleError('Key cannot be null or undefined', {
@@ -40,6 +53,7 @@ class ChainedBatch extends AbstractChainedBatch {
 
   _putLogData (blob) {
     assert(this[kBatchContext])
+    assert(!this[kBusy])
 
     if (blob === null || blob === undefined) {
       throw new ModuleError('Blob cannot be null or undefined', {
@@ -54,6 +68,7 @@ class ChainedBatch extends AbstractChainedBatch {
 
   _del (key, options) {
     assert(this[kBatchContext])
+    assert(!this[kBusy])
 
     if (key === null || key === undefined) {
       throw new ModuleError('Key cannot be null or undefined', {
@@ -68,24 +83,43 @@ class ChainedBatch extends AbstractChainedBatch {
 
   _clear () {
     assert(this[kBatchContext])
+    assert(!this[kBusy])
 
     binding.batch_clear(this[kBatchContext])
   }
 
   _write (options, callback) {
     assert(this[kBatchContext])
+    assert(!this[kBusy])
 
-    binding.batch_write(this[kDbContext], this[kBatchContext], options ?? EMPTY, callback)
+    return this._writeAsync(options, callback)
   }
 
   _writeSync (options) {
     assert(this[kBatchContext])
+    assert(!this[kBusy])
 
     binding.batch_write_sync(this[kDbContext], this[kBatchContext], options ?? EMPTY)
   }
 
+  _writeAsync (options, callback) {
+    assert(this[kBatchContext])
+    assert(!this[kBusy])
+
+    callback = fromCallback(callback, kPromise)
+
+    this[kBusy] = true
+    binding.batch_write(this[kDbContext], this[kBatchContext], options ?? EMPTY, (err) => {
+      this[kBusy] = false
+      callback(err)
+    })
+
+    return callback[kPromise]
+  }
+
   _close (callback) {
     assert(this[kBatchContext])
+    assert(!this[kBusy])
 
     try {
       this._closeSync()
@@ -96,20 +130,16 @@ class ChainedBatch extends AbstractChainedBatch {
   }
 
   _closeSync () {
-    if (this[kBatchContext]) {
-      binding.batch_clear(this[kBatchContext])
-      this[kBatchContext] = null
-    }
-  }
-
-  get length () {
     assert(this[kBatchContext])
+    assert(!this[kBusy])
 
-    return binding.batch_count(this[kBatchContext])
+    binding.batch_clear(this[kBatchContext])
+    this[kBatchContext] = null
   }
 
   _merge (key, value, options) {
     assert(this[kBatchContext])
+    assert(!this[kBusy])
 
     if (key === null || key === undefined) {
       throw new ModuleError('Key cannot be null or undefined', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/rocksdb",
-  "version": "15.2.4",
+  "version": "15.3.0",
   "description": "A low-level Node.js RocksDB binding",
   "license": "MIT",
   "main": "index.js",

package/util.h

@@ -452,21 +452,90 @@ napi_status Convert(napi_env env,
   }
 }
 
+class Reference {
+  Reference(napi_env env, napi_ref ref) : env_(env), ref_(ref) {}
+
+ public:
+  static napi_status Create(napi_env env, napi_value value, Reference& handle) {
+    napi_ref ref;
+    NAPI_STATUS_RETURN(napi_create_reference(env, value, 1, &ref));
+    handle = Reference(env, ref);
+    return napi_ok;
+  }
+
+  Reference() = default;
+
+  ~Reference() {
+    if (ref_) {
+      napi_delete_reference(env_, ref_);
+      ref_ = nullptr;
+    }
+  }
+  Reference(Reference&& other) noexcept : env_(other.env_), ref_(other.ref_) {
+    other.env_ = nullptr;
+    other.ref_ = nullptr;
+  }
+  Reference& operator=(Reference&& other) noexcept {
+    if (this != &other) {
+      if (ref_) {
+        napi_delete_reference(env_, ref_);
+      }
+      env_ = other.env_;
+      ref_ = other.ref_;
+      other.env_ = nullptr;
+      other.ref_ = nullptr;
+    }
+    return *this;
+  }
+  Reference(const Reference&) = delete;
+  Reference& operator=(const Reference&) = delete;
+
+ private:
+  napi_env env_ = nullptr;
+  napi_ref ref_ = nullptr;
+};
+
+
 class HandleScope {
+  HandleScope(napi_env env, napi_handle_scope scope) : env_(env), scope_(scope) {}
+
  public:
-  HandleScope(napi_env env) : env_(env) { status_ = napi_open_handle_scope(env_, &scope_); }
+  static napi_status Create(napi_env env, HandleScope& handleScope) {
+    napi_handle_scope scope;
+    NAPI_STATUS_RETURN(napi_open_handle_scope(env, &scope));
+    handleScope = HandleScope(env, scope);
+    return napi_ok;
+  }
+
+  HandleScope() = default;
+
   ~HandleScope() {
-    if (status_ == napi_ok && scope_) {
+    if (scope_) {
       napi_close_handle_scope(env_, scope_);
     }
   }
+  HandleScope(HandleScope&& other) noexcept : env_(other.env_), scope_(other.scope_) {
+    other.env_ = nullptr;
+    other.scope_ = nullptr;
+  }
+  HandleScope& operator=(HandleScope&& other) noexcept {
+    if (this != &other) {
+      if (scope_) {
+        napi_close_handle_scope(env_, scope_);
+      }
+      env_ = other.env_;
+      scope_ = other.scope_;
+      other.env_ = nullptr;
+      other.scope_ = nullptr;
+    }
+    return *this;
+  }
   HandleScope(const HandleScope&) = delete;
   HandleScope& operator=(const HandleScope&) = delete;
 
  private:
   napi_env env_ = nullptr;
   napi_handle_scope scope_ = nullptr;
-  napi_status status_ = napi_generic_failure;
 };
 
 template <typename State, typename T1, typename T2>
@@ -490,7 +559,8 @@ napi_status runAsync(napi_value asyncResourceName, napi_env env, napi_value call
         return;  // env is tearing down, just clean up
       }
 
-      HandleScope scope(env);
+      HandleScope scope;
+      NAPI_STATUS_THROWS_VOID(HandleScope::Create(env, scope));
 
       napi_value callback;
       NAPI_STATUS_THROWS_VOID(napi_get_reference_value(env, worker->ref, &callback));