@nxtedition/rocksdb 5.2.27 → 5.2.30

package/binding.cc

@@ -1,30 +1,27 @@
 #define NAPI_VERSION 8
 
+#include <assert.h>
 #include <napi-macros.h>
 #include <node_api.h>
-#include <assert.h>
 
-#include <rocksdb/db.h>
-#include <rocksdb/write_batch.h>
-#include <rocksdb/cache.h>
-#include <rocksdb/filter_policy.h>
 #include <rocksdb/cache.h>
 #include <rocksdb/comparator.h>
+#include <rocksdb/db.h>
 #include <rocksdb/env.h>
+#include <rocksdb/filter_policy.h>
 #include <rocksdb/options.h>
 #include <rocksdb/table.h>
-
-namespace leveldb = rocksdb;
+#include <rocksdb/write_batch.h>
 
 #include <array>
-#include <set>
 #include <memory>
+#include <optional>
+#include <set>
 #include <string>
 #include <vector>
-#include <optional>
 
 class NullLogger : public rocksdb::Logger {
-public:
+ public:
   using rocksdb::Logger::Logv;
   virtual void Logv(const char* format, va_list ap) override {}
   virtual size_t GetLogFileSize() const override { return 0; }
@@ -33,7 +30,7 @@ public:
 struct Database;
 struct Iterator;
 
-#define NAPI_DB_CONTEXT() \
+#define NAPI_DB_CONTEXT()       \
   Database* database = nullptr; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
 
@@ -41,29 +38,29 @@ struct Iterator;
   Iterator* iterator = nullptr; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
 
-#define NAPI_BATCH_CONTEXT() \
+#define NAPI_BATCH_CONTEXT()            \
   rocksdb::WriteBatch* batch = nullptr; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&batch));
 
-static bool IsString (napi_env env, napi_value value) {
+static bool IsString(napi_env env, napi_value value) {
   napi_valuetype type;
   napi_typeof(env, value, &type);
   return type == napi_string;
 }
 
-static bool IsBuffer (napi_env env, napi_value value) {
+static bool IsBuffer(napi_env env, napi_value value) {
   bool isBuffer;
   napi_is_buffer(env, value, &isBuffer);
   return isBuffer;
 }
 
-static bool IsObject (napi_env env, napi_value value) {
+static bool IsObject(napi_env env, napi_value value) {
   napi_valuetype type;
   napi_typeof(env, value, &type);
   return type == napi_object;
 }
 
-static napi_value CreateError (napi_env env, const std::string_view& str) {
+static napi_value CreateError(napi_env env, const std::string_view& str) {
   napi_value msg;
   napi_create_string_utf8(env, str.data(), str.size(), &msg);
   napi_value error;
@@ -71,7 +68,7 @@ static napi_value CreateError (napi_env env, const std::string_view& str) {
   return error;
 }
 
-static napi_value CreateCodeError (napi_env env, const std::string_view& code, const std::string_view& msg) {
+static napi_value CreateCodeError(napi_env env, const std::string_view& code, const std::string_view& msg) {
   napi_value codeValue;
   napi_create_string_utf8(env, code.data(), code.size(), &codeValue);
   napi_value msgValue;
@@ -81,19 +78,19 @@ static napi_value CreateCodeError (napi_env env, const std::string_view& code, c
   return error;
 }
 
-static bool HasProperty (napi_env env, napi_value obj, const std::string_view& key) {
+static bool HasProperty(napi_env env, napi_value obj, const std::string_view& key) {
   bool has = false;
   napi_has_named_property(env, obj, key.data(), &has);
   return has;
 }
 
-static napi_value GetProperty (napi_env env, napi_value obj, const std::string_view& key) {
+static napi_value GetProperty(napi_env env, napi_value obj, const std::string_view& key) {
   napi_value value;
   napi_get_named_property(env, obj, key.data(), &value);
   return value;
 }
 
-static bool BooleanProperty (napi_env env, napi_value obj, const std::string_view& key, bool defaultValue) {
+static bool BooleanProperty(napi_env env, napi_value obj, const std::string_view& key, bool defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     bool result;
@@ -104,12 +101,12 @@ static bool BooleanProperty (napi_env env, napi_value obj, const std::string_vie
   return defaultValue;
 }
 
-static bool EncodingIsBuffer (napi_env env, napi_value obj, const std::string_view& option) {
+static bool EncodingIsBuffer(napi_env env, napi_value obj, const std::string_view& option) {
   napi_value value;
   size_t size;
 
   if (napi_get_named_property(env, obj, option.data(), &value) == napi_ok &&
-    napi_get_value_string_utf8(env, value, nullptr, 0, &size) == napi_ok) {
+      napi_get_value_string_utf8(env, value, nullptr, 0, &size) == napi_ok) {
     // Value is either "buffer" or "utf8" so we can tell them apart just by size
     return size == 6;
   }
@@ -117,7 +114,7 @@ static bool EncodingIsBuffer (napi_env env, napi_value obj, const std::string_vi
   return false;
 }
 
-static uint32_t Uint32Property (napi_env env, napi_value obj, const std::string_view& key, uint32_t defaultValue) {
+static uint32_t Uint32Property(napi_env env, napi_value obj, const std::string_view& key, uint32_t defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     uint32_t result;
@@ -128,7 +125,7 @@ static uint32_t Uint32Property (napi_env env, napi_value obj, const std::string_
   return defaultValue;
 }
 
-static int Int32Property (napi_env env, napi_value obj, const std::string_view& key, int defaultValue) {
+static int Int32Property(napi_env env, napi_value obj, const std::string_view& key, int defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     int result;
@@ -139,7 +136,7 @@ static int Int32Property (napi_env env, napi_value obj, const std::string_view&
   return defaultValue;
 }
 
-static std::string ToString (napi_env env, napi_value from, const std::string& defaultValue = "") {
+static std::string ToString(napi_env env, napi_value from, const std::string& defaultValue = "") {
   if (IsString(env, from)) {
     size_t length = 0;
     napi_get_value_string_utf8(env, from, nullptr, 0, &length);
@@ -149,14 +146,17 @@ static std::string ToString (napi_env env, napi_value from, const std::string& d
   } else if (IsBuffer(env, from)) {
     char* buf = nullptr;
     size_t length = 0;
-    napi_get_buffer_info(env, from, reinterpret_cast<void **>(&buf), &length);
+    napi_get_buffer_info(env, from, reinterpret_cast<void**>(&buf), &length);
     return std::string(buf, length);
   }
 
   return defaultValue;
 }
 
-static std::string StringProperty (napi_env env, napi_value obj, const std::string_view& key, const std::string& defaultValue = "") {
+static std::string StringProperty(napi_env env,
+                                  napi_value obj,
+                                  const std::string_view& key,
+                                  const std::string& defaultValue = "") {
   if (HasProperty(env, obj, key)) {
     napi_value value = GetProperty(env, obj, key);
     if (IsString(env, value)) {
@@ -167,52 +167,30 @@ static std::string StringProperty (napi_env env, napi_value obj, const std::stri
   return defaultValue;
 }
 
-static size_t StringOrBufferLength (napi_env env, napi_value value) {
-  size_t size = 0;
-
-  if (IsString(env, value)) {
-    napi_get_value_string_utf8(env, value, nullptr, 0, &size);
-  } else if (IsBuffer(env, value)) {
-    char* buf = nullptr;
-    napi_get_buffer_info(env, value, (void **)&buf, &size);
-  }
-
-  return size;
-}
-
-static std::optional<std::string> RangeOption (napi_env env, napi_value opts, const std::string_view& name) {
+static std::optional<std::string> RangeOption(napi_env env, napi_value opts, const std::string_view& name) {
   if (HasProperty(env, opts, name)) {
     const auto value = GetProperty(env, opts, name);
-    return std::string(ToString(env, value));
+    return ToString(env, value);
   }
 
   return {};
 }
 
-static std::vector<std::string> KeyArray (napi_env env, napi_value arr) {
-  uint32_t length;
-  std::vector<std::string> result;
-
-  if (napi_get_array_length(env, arr, &length) == napi_ok) {
-    result.reserve(length);
-
-    for (uint32_t i = 0; i < length; i++) {
-      napi_value element;
+static napi_status CallFunction(napi_env env, napi_value callback, const int argc, napi_value* argv) {
+  napi_status status;
+  napi_value global;
 
-      if (napi_get_element(env, arr, i, &element) == napi_ok &&
-          StringOrBufferLength(env, element) > 0) {
-        result.push_back(ToString(env, element));
-      }
-    }
+  status = napi_get_global(env, &global);
+  if (status != napi_ok) {
+    return status;
   }
 
-  return result;
-}
+  status = napi_call_function(env, global, callback, argc, argv, nullptr);
+  if (status != napi_ok) {
+    return status;
+  }
 
-static napi_status CallFunction (napi_env env, napi_value callback, const int argc, napi_value* argv) {
-  napi_value global;
-  napi_get_global(env, &global);
-  return napi_call_function(env, global, callback, argc, argv, nullptr);
+  return napi_ok;
 }
 
 static napi_value ToError(napi_env env, const rocksdb::Status& status) {
@@ -227,11 +205,11 @@ static napi_value ToError(napi_env env, const rocksdb::Status& status) {
   } else if (status.IsCorruption()) {
     return CreateCodeError(env, "LEVEL_CORRUPTION", msg);
   } else if (status.IsIOError()) {
-    if (msg.find("IO error: lock ") != std::string::npos) { // env_posix.cc
+    if (msg.find("IO error: lock ") != std::string::npos) {  // env_posix.cc
       return CreateCodeError(env, "LEVEL_LOCKED", msg);
-    } else if (msg.find("IO error: LockFile ") != std::string::npos) { // env_win.cc
+    } else if (msg.find("IO error: LockFile ") != std::string::npos) {  // env_win.cc
       return CreateCodeError(env, "LEVEL_LOCKED", msg);
-    } else if (msg.find("IO error: While lock file") != std::string::npos) { // env_mac.cc
+    } else if (msg.find("IO error: While lock file") != std::string::npos) {  // env_mac.cc
       return CreateCodeError(env, "LEVEL_LOCKED", msg);
     } else {
       return CreateCodeError(env, "LEVEL_IO_ERROR", msg);
@@ -242,16 +220,16 @@ static napi_value ToError(napi_env env, const rocksdb::Status& status) {
 }
 
 template <typename T>
-void Convert (napi_env env, const T& s, bool asBuffer, napi_value& result) {
+napi_status Convert(napi_env env, const T& s, bool asBuffer, napi_value& result) {
   if (asBuffer) {
-    napi_create_buffer_copy(env, s.size(), s.data(), nullptr, &result);
+    return napi_create_buffer_copy(env, s.size(), s.data(), nullptr, &result);
   } else {
-    napi_create_string_utf8(env, s.data(), s.size(), &result);
+    return napi_create_string_utf8(env, s.data(), s.size(), &result);
   }
 }
 
 struct NapiSlice : public rocksdb::Slice {
-  NapiSlice (napi_env env, napi_value from) {
+  NapiSlice(napi_env env, napi_value from) {
     if (IsString(env, from)) {
       napi_get_value_string_utf8(env, from, nullptr, 0, &size_);
       char* data;
@@ -270,7 +248,7 @@ struct NapiSlice : public rocksdb::Slice {
       data_ = static_cast<char*>(data);
     }
   }
-  
+
   std::unique_ptr<char[]> heap_;
   std::array<char, 8192> stack_;
 };
@@ -284,33 +262,25 @@ struct NapiSlice : public rocksdb::Slice {
  * - OnError (main thread): call JS callback on error
  * - Destroy (main thread): do cleanup regardless of success
  */
-struct BaseWorker {
-  BaseWorker (napi_env env,
-              Database* database,
-              napi_value callback,
-              const std::string& resourceName)
-    : database_(database) {
+struct Worker {
+  Worker(napi_env env, Database* database, napi_value callback, const std::string& resourceName)
+      : database_(database) {
     NAPI_STATUS_THROWS_VOID(napi_create_reference(env, callback, 1, &callbackRef_));
     napi_value asyncResourceName;
-    NAPI_STATUS_THROWS_VOID(napi_create_string_utf8(env, resourceName.data(),
-                                                    NAPI_AUTO_LENGTH,
-                                                    &asyncResourceName));
-    NAPI_STATUS_THROWS_VOID(napi_create_async_work(env, callback,
-                                                   asyncResourceName,
-                                                   BaseWorker::Execute,
-                                                   BaseWorker::Complete,
-                                                   this, &asyncWork_));
+    NAPI_STATUS_THROWS_VOID(napi_create_string_utf8(env, resourceName.data(), resourceName.size(), &asyncResourceName));
+    NAPI_STATUS_THROWS_VOID(napi_create_async_work(env, callback, asyncResourceName, Worker::Execute,
+                                                   Worker::Complete, this, &asyncWork_));
   }
 
-  virtual ~BaseWorker () {}
+  virtual ~Worker() {}
 
-  static void Execute (napi_env env, void* data) {
-    auto self = reinterpret_cast<BaseWorker*>(data);
+  static void Execute(napi_env env, void* data) {
+    auto self = reinterpret_cast<Worker*>(data);
     self->status_ = self->Execute(*self->database_);
   }
 
-  static void Complete (napi_env env, napi_status status, void* data) {
-    auto self = reinterpret_cast<BaseWorker*>(data);
+  static void Complete(napi_env env, napi_status status, void* data) {
+    auto self = reinterpret_cast<Worker*>(data);
 
     napi_value callback;
     napi_get_reference_value(env, self->callbackRef_, &callback);
@@ -329,36 +299,30 @@ struct BaseWorker {
     delete self;
   }
 
-  virtual rocksdb::Status Execute (Database& database) = 0;
+  virtual rocksdb::Status Execute(Database& database) = 0;
 
-  virtual void OnOk (napi_env env, napi_value callback) {
+  virtual void OnOk(napi_env env, napi_value callback) {
     napi_value argv;
     napi_get_null(env, &argv);
     CallFunction(env, callback, 1, &argv);
   }
 
-  virtual void OnError (napi_env env, napi_value callback, napi_value err) {
-    CallFunction(env, callback, 1, &err);
-  }
+  virtual void OnError(napi_env env, napi_value callback, napi_value err) { CallFunction(env, callback, 1, &err); }
 
-  virtual void Destroy (napi_env env) {
-  }
+  virtual void Destroy(napi_env env) {}
 
-  void Queue (napi_env env) {
-    napi_queue_async_work(env, asyncWork_);
-  }
+  void Queue(napi_env env) { napi_queue_async_work(env, asyncWork_); }
 
   Database* database_;
-private:
+
+ private:
   napi_ref callbackRef_;
   napi_async_work asyncWork_;
   rocksdb::Status status_;
 };
 
 struct Database {
-  rocksdb::Status Open (const rocksdb::Options& options,
-                        const bool readOnly,
-                        const char* location) {
+  rocksdb::Status Open(const rocksdb::Options& options, const bool readOnly, const char* location) {
     if (readOnly) {
       rocksdb::DB* db = nullptr;
       const auto status = rocksdb::DB::OpenForReadOnly(options, location, &db);
@@ -372,25 +336,19 @@ struct Database {
     }
   }
 
-  void CloseDatabase () {
-    db_.reset();
-  }
-
-  void AttachIterator (napi_env env, Iterator* iterator) {
+  void AttachIterator(napi_env env, Iterator* iterator) {
     iterators_.insert(iterator);
     IncrementPriorityWork(env);
   }
 
-  void DetachIterator (napi_env env, Iterator* iterator) {
+  void DetachIterator(napi_env env, Iterator* iterator) {
     iterators_.erase(iterator);
     DecrementPriorityWork(env);
   }
 
-  void IncrementPriorityWork (napi_env env) {
-    napi_reference_ref(env, prioritRef_, &priorityWork_);
-  }
+  void IncrementPriorityWork(napi_env env) { napi_reference_ref(env, prioritRef_, &priorityWork_); }
 
-  void DecrementPriorityWork (napi_env env) {
+  void DecrementPriorityWork(napi_env env) {
     napi_reference_unref(env, prioritRef_, &priorityWork_);
 
     if (priorityWork_ == 0 && pendingCloseWorker_) {
@@ -399,36 +357,17 @@ struct Database {
     }
   }
 
-  bool HasPriorityWork () const {
-    return priorityWork_ > 0;
-  }
+  bool HasPriorityWork() const { return priorityWork_ > 0; }
 
   std::unique_ptr<rocksdb::DB> db_;
-  BaseWorker* pendingCloseWorker_;
+  Worker* pendingCloseWorker_;
   std::set<Iterator*> iterators_;
   napi_ref prioritRef_;
 
-private:
+ private:
   uint32_t priorityWork_ = 0;
 };
 
-/**
- * Base worker class for doing async work that defers closing the database.
- */
-struct PriorityWorker : public BaseWorker {
-  PriorityWorker (napi_env env, Database* database, napi_value callback, const char* resourceName)
-    : BaseWorker(env, database, callback, resourceName) {
-    database_->IncrementPriorityWork(env);
-  }
-
-  virtual ~PriorityWorker () {}
-
-  void Destroy (napi_env env) override {
-    database_->DecrementPriorityWork(env);
-    BaseWorker::Destroy(env);
-  }
-};
-
 struct BaseIterator {
   BaseIterator(Database* database,
                const bool reverse,
@@ -438,67 +377,52 @@ struct BaseIterator {
                const std::optional<std::string>& gte,
                const int limit,
                const bool fillCache)
-    : database_(database),
-      lt_(lt),
-      lte_(lte),
-      gt_(gt),
-      gte_(gte),
-      snapshot_(database_->db_->GetSnapshot(), [this](const rocksdb::Snapshot* ptr) {
-        database_->db_->ReleaseSnapshot(ptr);
-      }),
-      iterator_(database->db_->NewIterator([&]{
-        rocksdb::ReadOptions options;
-        if (lt_ && !lte_) {
-          upper_bound_ = rocksdb::Slice(lt_->data(), lt_->size());
-          options.iterate_upper_bound = &upper_bound_;
-        }
-        if (gte_) {
-          lower_bound_ = rocksdb::Slice(gte_->data(), gte_->size());
-          options.iterate_lower_bound = &lower_bound_;
-        }
-        options.fill_cache = fillCache;
-        options.snapshot = snapshot_.get();
-        return options;
-      }())),
-      reverse_(reverse),
-      limit_(limit) {
-  }
-
-  virtual ~BaseIterator () {
-    assert(!iterator_);
-  }
-
-  bool DidSeek () const {
-    return didSeek_;
-  }
-
-  void SeekToRange () {
+      : database_(database),
+        lt_(!lte ? lt : *lte + '\0'),
+        gte_(gte ? gte : (gt ? std::optional<std::string>(*gt + '\0') : std::nullopt)),
+        snapshot_(database_->db_->GetSnapshot(),
+                  [this](const rocksdb::Snapshot* ptr) { database_->db_->ReleaseSnapshot(ptr); }),
+        iterator_(database->db_->NewIterator([&] {
+          rocksdb::ReadOptions options;
+          if (lt_) {
+            upper_bound_ = rocksdb::Slice(lt_->data(), lt_->size());
+            options.iterate_upper_bound = &upper_bound_;
+          }
+          if (gte_) {
+            lower_bound_ = rocksdb::Slice(gte_->data(), gte_->size());
+            options.iterate_lower_bound = &lower_bound_;
+          }
+          options.fill_cache = fillCache;
+          options.snapshot = snapshot_.get();
+          return options;
+        }())),
+        reverse_(reverse),
+        limit_(limit) {}
+
+  virtual ~BaseIterator() { assert(!iterator_); }
+
+  bool DidSeek() const { return didSeek_; }
+
+  void SeekToRange() {
     didSeek_ = true;
 
-    if (!reverse_ && gt_ && !gte_) {
-      iterator_->Seek(*gt_);
-
-      if (iterator_->Valid() && iterator_->key().compare(*gt_) == 0) {
-        iterator_->Next();
-      }
-    } else if (reverse_ && lte_) {
-      iterator_->SeekForPrev(*lte_);
-    } else if (reverse_) {
+    if (reverse_) {
       iterator_->SeekToLast();
     } else {
       iterator_->SeekToFirst();
     }
   }
 
-  void Seek (const std::string& target) {
+  void Seek(const std::string& target) {
     didSeek_ = true;
 
-    // TODO (fix): Only check for (gt && !gte) and lte.
-    // See, https://github.com/facebook/rocksdb/issues/9904.
-
-    if (OutOfRange(target)) {
-      SeekToLast();
-      Next();
+    if ((lt_ && target.compare(*lt_) >= 0) || (gte_ && target.compare(*gte_) < 0)) {
+      // TODO (fix): Why is this required? Seek should handle it?
+      // https://github.com/facebook/rocksdb/issues/9904
+      iterator_->SeekToLast();
+      if (iterator_->Valid()) {
+        iterator_->Next();
+      }
     } else if (reverse_) {
       iterator_->SeekForPrev(target);
     } else {
@@ -506,80 +430,32 @@ struct BaseIterator {
     }
   }
 
-  void Close () {
+  void Close() {
     snapshot_.reset();
     iterator_.reset();
   }
 
-  bool Valid () const {
-    if (!iterator_->Valid()) {
-      return false;
-    }
-
-    if (lte_ && iterator_->key().compare(*lte_) > 0) {
-      return false;
-    }
-
-    if (!gte_ && gt_ && iterator_->key().compare(*gt_) <= 0) {
-      return false;
-    }
-
-    return true;
-  }
+  bool Valid() const { return iterator_->Valid(); }
 
-  bool Increment () {
-    return limit_ < 0 || ++count_ <= limit_;
-  }
+  bool Increment() { return limit_ < 0 || ++count_ <= limit_; }
 
-  void Next () {
-    if (reverse_) iterator_->Prev();
-    else iterator_->Next();
+  void Next() {
+    if (reverse_)
+      iterator_->Prev();
+    else
+      iterator_->Next();
   }
 
-  void SeekToFirst () {
-    if (reverse_) iterator_->SeekToLast();
-    else iterator_->SeekToFirst();
-  }
+  rocksdb::Slice CurrentKey() const { return iterator_->key(); }
 
-  void SeekToLast () {
-    if (reverse_) iterator_->SeekToFirst();
-    else iterator_->SeekToLast();
-  }
+  rocksdb::Slice CurrentValue() const { return iterator_->value(); }
 
-  rocksdb::Slice CurrentKey () const {
-    return iterator_->key();
-  }
-
-  rocksdb::Slice CurrentValue () const {
-    return iterator_->value();
-  }
-
-  rocksdb::Status Status () const {
-    return iterator_->status();
-  }
-
-  bool OutOfRange (const rocksdb::Slice& target) const {
-    if (lte_) {
-      if (target.compare(*lte_) > 0) return true;
-    } else if (lt_) {
-      if (target.compare(*lt_) >= 0) return true;
-    }
-
-    if (gte_) {
-      if (target.compare(*gte_) < 0) return true;
-    } else if (gt_) {
-      if (target.compare(*gt_) <= 0) return true;
-    }
-
-    return false;
-  }
+  rocksdb::Status Status() const { return iterator_->status(); }
 
   Database* database_;
 
-private:
+ private:
   const std::optional<std::string> lt_;
-  const std::optional<std::string> lte_;
-  const std::optional<std::string> gt_;
   const std::optional<std::string> gte_;
   rocksdb::Slice lower_bound_;
   rocksdb::Slice upper_bound_;
@@ -592,37 +468,38 @@ private:
 };
 
 struct Iterator final : public BaseIterator {
-  Iterator (Database* database,
-            const bool reverse,
-            const bool keys,
-            const bool values,
-            const int limit,
-            const std::optional<std::string>& lt,
-            const std::optional<std::string>& lte,
-            const std::optional<std::string>& gt,
-            const std::optional<std::string>& gte,
-            const bool fillCache,
-            const bool keyAsBuffer,
-            const bool valueAsBuffer,
-            const uint32_t highWaterMarkBytes)
-    : BaseIterator(database, reverse, lt, lte, gt, gte, limit, fillCache),
-      keys_(keys),
-      values_(values),
-      keyAsBuffer_(keyAsBuffer),
-      valueAsBuffer_(valueAsBuffer),
-      highWaterMarkBytes_(highWaterMarkBytes),
-      first_(true),
-      ref_(nullptr) {
-  }
-
-  void Attach (napi_env env, napi_value context) {
+  Iterator(Database* database,
+           const bool reverse,
+           const bool keys,
+           const bool values,
+           const int limit,
+           const std::optional<std::string>& lt,
+           const std::optional<std::string>& lte,
+           const std::optional<std::string>& gt,
+           const std::optional<std::string>& gte,
+           const bool fillCache,
+           const bool keyAsBuffer,
+           const bool valueAsBuffer,
+           const uint32_t highWaterMarkBytes)
+      : BaseIterator(database, reverse, lt, lte, gt, gte, limit, fillCache),
+        keys_(keys),
+        values_(values),
+        keyAsBuffer_(keyAsBuffer),
+        valueAsBuffer_(valueAsBuffer),
+        highWaterMarkBytes_(highWaterMarkBytes),
+        first_(true),
+        ref_(nullptr) {}
+
+  void Attach(napi_env env, napi_value context) {
     napi_create_reference(env, context, 1, &ref_);
     database_->AttachIterator(env, this);
   }
 
-  void Detach (napi_env env) {
+  void Detach(napi_env env) {
     database_->DetachIterator(env, this);
-    if (ref_) napi_delete_reference(env, ref_);
+    if (ref_) {
+      napi_delete_reference(env, ref_);
+    }
   }
 
   const bool keys_;
@@ -632,7 +509,7 @@ struct Iterator final : public BaseIterator {
   const uint32_t highWaterMarkBytes_;
   bool first_;
 
-private:
+ private:
   napi_ref ref_;
 };
 
@@ -641,15 +518,16 @@ private:
  * already-scheduled napi_async_work items have finished, which gives us
  * the guarantee that no db operations will be in-flight at this time.
  */
-static void env_cleanup_hook (void* arg) {
+static void env_cleanup_hook(void* arg) {
   auto database = reinterpret_cast<Database*>(arg);
 
-  // Do everything that db_close() does but synchronously. We're expecting that GC
-  // did not (yet) collect the database because that would be a user mistake (not
-  // closing their db) made during the lifetime of the environment. That's different
-  // from an environment being torn down (like the main process or a worker thread)
-  // where it's our responsibility to clean up. Note also, the following code must
-  // be a safe noop if called before db_open() or after db_close().
+  // Do everything that db_close() does but synchronously. We're expecting that
+  // GC did not (yet) collect the database because that would be a user mistake
+  // (not closing their db) made during the lifetime of the environment. That's
+  // different from an environment being torn down (like the main process or a
+  // worker thread) where it's our responsibility to clean up. Note also, the
+  // following code must be a safe noop if called before db_open() or after
+  // db_close().
   if (database && database->db_) {
     // TODO: does not do `napi_delete_reference(env, iterator->ref_)`. Problem?
     for (auto it : database->iterators_) {
@@ -657,15 +535,16 @@ static void env_cleanup_hook (void* arg) {
     }
 
     // Having closed the iterators (and released snapshots) we can safely close.
-    database->CloseDatabase();
+    database->db_->Close();
   }
 }
 
-static void FinalizeDatabase (napi_env env, void* data, void* hint) {
+static void FinalizeDatabase(napi_env env, void* data, void* hint) {
   if (data) {
     auto database = reinterpret_cast<Database*>(data);
     napi_remove_env_cleanup_hook(env, env_cleanup_hook, database);
-    if (database->prioritRef_) napi_delete_reference(env, database->prioritRef_);
+    if (database->prioritRef_)
+      napi_delete_reference(env, database->prioritRef_);
     delete database;
   }
 }
@@ -675,39 +554,33 @@ NAPI_METHOD(db_init) {
   napi_add_env_cleanup_hook(env, env_cleanup_hook, database);
 
   napi_value result;
-  NAPI_STATUS_THROWS(napi_create_external(env, database,
-                                          FinalizeDatabase,
-                                          nullptr, &result));
+  NAPI_STATUS_THROWS(napi_create_external(env, database, FinalizeDatabase, nullptr, &result));
 
   NAPI_STATUS_THROWS(napi_create_reference(env, result, 0, &database->prioritRef_));
 
   return result;
 }
 
-struct OpenWorker final : public PriorityWorker {
-  OpenWorker (napi_env env,
-              Database* database,
-              napi_value callback,
-              const std::string& location,
-              const bool createIfMissing,
-              const bool errorIfExists,
-              const bool compression,
-              const uint32_t writeBufferSize,
-              const uint32_t blockSize,
-              const uint32_t maxOpenFiles,
-              const uint32_t blockRestartInterval,
-              const uint32_t maxFileSize,
-              const uint32_t cacheSize,
-              const std::string& infoLogLevel,
-              const bool readOnly)
-    : PriorityWorker(env, database, callback, "leveldown.db.open"),
-      readOnly_(readOnly),
-      location_(location) {
+struct OpenWorker final : public Worker {
+  OpenWorker(napi_env env,
+             Database* database,
+             napi_value callback,
+             const std::string& location,
+             const bool createIfMissing,
+             const bool errorIfExists,
+             const bool compression,
+             const uint32_t writeBufferSize,
+             const uint32_t blockSize,
+             const uint32_t maxOpenFiles,
+             const uint32_t blockRestartInterval,
+             const uint32_t maxFileSize,
+             const uint32_t cacheSize,
+             const std::string& infoLogLevel,
+             const bool readOnly)
+      : Worker(env, database, callback, "leveldown.db.open"), readOnly_(readOnly), location_(location) {
     options_.create_if_missing = createIfMissing;
     options_.error_if_exists = errorIfExists;
-    options_.compression = compression
-      ? rocksdb::kSnappyCompression
-      : rocksdb::kNoCompression;
+    options_.compression = compression ? rocksdb::kSnappyCompression : rocksdb::kNoCompression;
     options_.write_buffer_size = writeBufferSize;
     options_.max_open_files = maxOpenFiles;
     options_.max_log_file_size = maxFileSize;
@@ -716,13 +589,20 @@ struct OpenWorker final : public PriorityWorker {
     if (infoLogLevel.size() > 0) {
       rocksdb::InfoLogLevel lvl = {};
 
-      if (infoLogLevel == "debug") lvl = rocksdb::InfoLogLevel::DEBUG_LEVEL;
-      else if (infoLogLevel == "info") lvl = rocksdb::InfoLogLevel::INFO_LEVEL;
-      else if (infoLogLevel == "warn") lvl = rocksdb::InfoLogLevel::WARN_LEVEL;
-      else if (infoLogLevel == "error") lvl = rocksdb::InfoLogLevel::ERROR_LEVEL;
-      else if (infoLogLevel == "fatal") lvl = rocksdb::InfoLogLevel::FATAL_LEVEL;
-      else if (infoLogLevel == "header") lvl = rocksdb::InfoLogLevel::HEADER_LEVEL;
-      else napi_throw_error(env, nullptr, "invalid log level");
+      if (infoLogLevel == "debug")
+        lvl = rocksdb::InfoLogLevel::DEBUG_LEVEL;
+      else if (infoLogLevel == "info")
+        lvl = rocksdb::InfoLogLevel::INFO_LEVEL;
+      else if (infoLogLevel == "warn")
+        lvl = rocksdb::InfoLogLevel::WARN_LEVEL;
+      else if (infoLogLevel == "error")
+        lvl = rocksdb::InfoLogLevel::ERROR_LEVEL;
+      else if (infoLogLevel == "fatal")
+        lvl = rocksdb::InfoLogLevel::FATAL_LEVEL;
+      else if (infoLogLevel == "header")
+        lvl = rocksdb::InfoLogLevel::HEADER_LEVEL;
+      else
+        napi_throw_error(env, nullptr, "invalid log level");
 
       options_.info_log_level = lvl;
     } else {
@@ -746,14 +626,10 @@ struct OpenWorker final : public PriorityWorker {
     tableOptions.format_version = 5;
     tableOptions.checksum = rocksdb::kxxHash64;
 
-    options_.table_factory.reset(
-      rocksdb::NewBlockBasedTableFactory(tableOptions)
-    );
+    options_.table_factory.reset(rocksdb::NewBlockBasedTableFactory(tableOptions));
   }
 
-  rocksdb::Status Execute (Database& database) override {
-    return database.Open(options_, readOnly_, location_.c_str());
-  }
+  rocksdb::Status Execute(Database& database) override { return database.Open(options_, readOnly_, location_.c_str()); }
 
   rocksdb::Options options_;
   const bool readOnly_;
@@ -774,38 +650,30 @@ NAPI_METHOD(db_open) {
   const auto infoLogLevel = StringProperty(env, options, "infoLogLevel");
 
   const auto cacheSize = Uint32Property(env, options, "cacheSize", 8 << 20);
-  const auto writeBufferSize = Uint32Property(env, options , "writeBufferSize" , 4 << 20);
+  const auto writeBufferSize = Uint32Property(env, options, "writeBufferSize", 4 << 20);
   const auto blockSize = Uint32Property(env, options, "blockSize", 4096);
   const auto maxOpenFiles = Uint32Property(env, options, "maxOpenFiles", 1000);
-  const auto blockRestartInterval = Uint32Property(env, options,
-                                                 "blockRestartInterval", 16);
+  const auto blockRestartInterval = Uint32Property(env, options, "blockRestartInterval", 16);
   const auto maxFileSize = Uint32Property(env, options, "maxFileSize", 2 << 20);
 
   const auto callback = argv[3];
 
-  auto worker = new OpenWorker(env, database, callback, location,
-                               createIfMissing, errorIfExists,
-                               compression, writeBufferSize, blockSize,
-                               maxOpenFiles, blockRestartInterval,
-                               maxFileSize, cacheSize,
-                               infoLogLevel, readOnly);
+  auto worker =
+      new OpenWorker(env, database, callback, location, createIfMissing, errorIfExists, compression, writeBufferSize,
+                     blockSize, maxOpenFiles, blockRestartInterval, maxFileSize, cacheSize, infoLogLevel, readOnly);
   worker->Queue(env);
 
   return 0;
 }
 
-struct CloseWorker final : public BaseWorker {
-  CloseWorker (napi_env env,
-               Database* database,
-               napi_value callback)
-    : BaseWorker(env, database, callback, "leveldown.db.close") {}
+struct CloseWorker final : public Worker {
+  CloseWorker(napi_env env, Database* database, napi_value callback)
+      : Worker(env, database, callback, "leveldown.db.close") {}
 
-  rocksdb::Status Execute (Database& database) override {
-    return database.db_->Close();
-  }
+  rocksdb::Status Execute(Database& database) override { return database.db_->Close(); }
 };
 
-napi_value noop_callback (napi_env env, napi_callback_info info) {
+napi_value noop_callback(napi_env env, napi_callback_info info) {
   return 0;
 }
 
@@ -837,37 +705,46 @@ NAPI_METHOD(db_put) {
   return ToError(env, database->db_->Put(options, key, value));
 }
 
-struct GetWorker final : public PriorityWorker {
-  GetWorker (napi_env env,
-             Database* database,
-             napi_value callback,
-             const std::string& key,
-             const bool asBuffer,
-             const bool fillCache)
-    : PriorityWorker(env, database, callback, "rocks_level.db.get"),
-      key_(key), asBuffer_(asBuffer), fillCache_(fillCache),
-      snapshot_(database_->db_->GetSnapshot(), [this](const rocksdb::Snapshot* ptr) {
-        database_->db_->ReleaseSnapshot(ptr);
-      }) {
+struct GetWorker final : public Worker {
+  GetWorker(napi_env env,
+            Database* database,
+            napi_value callback,
+            const std::string& key,
+            const bool asBuffer,
+            const bool fillCache)
+      : Worker(env, database, callback, "rocks_level.db.get"),
+        key_(key),
+        asBuffer_(asBuffer),
+        fillCache_(fillCache),
+        snapshot_(database_->db_->GetSnapshot(),
+                  [this](const rocksdb::Snapshot* ptr) { database_->db_->ReleaseSnapshot(ptr); }) {
+    database_->IncrementPriorityWork(env);
   }
 
-  rocksdb::Status Execute (Database& database) override {
+  rocksdb::Status Execute(Database& database) override {
     rocksdb::ReadOptions options;
     options.fill_cache = fillCache_;
     options.snapshot = snapshot_.get();
+
     auto status = database.db_->Get(options, database.db_->DefaultColumnFamily(), key_, &value_);
-    snapshot_.reset();
+    snapshot_ = nullptr;
+
     return status;
   }
 
-  void OnOk (napi_env env, napi_value callback) override {
+  void OnOk(napi_env env, napi_value callback) override {
     napi_value argv[2];
     napi_get_null(env, &argv[0]);
     Convert(env, std::move(value_), asBuffer_, argv[1]);
     CallFunction(env, callback, 2, argv);
   }
 
-private:
+  void Destroy(napi_env env) override {
+    database_->DecrementPriorityWork(env);
+    Worker::Destroy(env);
+  }
+
+ private:
   const std::string key_;
   rocksdb::PinnableSlice value_;
   const bool asBuffer_;
@@ -891,30 +768,28 @@ NAPI_METHOD(db_get) {
   return 0;
 }
 
-struct GetManyWorker final : public PriorityWorker {
-  GetManyWorker (napi_env env,
-                 Database* database,
-                 const std::vector<std::string>& keys,
-                 napi_value callback,
-                 const bool valueAsBuffer,
-                 const bool fillCache)
-    : PriorityWorker(env, database, callback, "leveldown.get.many"),
-      keys_(keys), valueAsBuffer_(valueAsBuffer), fillCache_(fillCache),
-      snapshot_(database_->db_->GetSnapshot(), [this](const rocksdb::Snapshot* ptr) {
-        database_->db_->ReleaseSnapshot(ptr);
-      }) {
+struct GetManyWorker final : public Worker {
+  GetManyWorker(napi_env env,
+                Database* database,
+                const std::vector<std::string>& keys,
+                napi_value callback,
+                const bool valueAsBuffer,
+                const bool fillCache)
+      : Worker(env, database, callback, "leveldown.get.many"),
+        keys_(keys),
+        valueAsBuffer_(valueAsBuffer),
+        fillCache_(fillCache),
+        snapshot_(database_->db_->GetSnapshot(),
+                  [this](const rocksdb::Snapshot* ptr) { database_->db_->ReleaseSnapshot(ptr); }) {
+    database_->IncrementPriorityWork(env);
   }
 
-  rocksdb::Status Execute (Database& database) override {
+  rocksdb::Status Execute(Database& database) override {
     rocksdb::ReadOptions options;
     options.fill_cache = fillCache_;
     options.snapshot = snapshot_.get();
-  
-    status_ = database.db_->MultiGet(
-      options,
-      std::vector<rocksdb::Slice>(keys_.begin(), keys_.end()),
-      &values_
-    );
+
+    status_ = database.db_->MultiGet(options, std::vector<rocksdb::Slice>(keys_.begin(), keys_.end()), &values_);
     snapshot_ = nullptr;
 
     for (auto status : status_) {
@@ -926,7 +801,7 @@ struct GetManyWorker final : public PriorityWorker {
     return rocksdb::Status::OK();
   }
 
-  void OnOk (napi_env env, napi_value callback) override {
+  void OnOk(napi_env env, napi_value callback) override {
     const auto size = values_.size();
 
     napi_value array;
@@ -948,7 +823,12 @@ struct GetManyWorker final : public PriorityWorker {
     CallFunction(env, callback, 2, argv);
   }
 
-private:
+  void Destroy(napi_env env) override {
+    database_->DecrementPriorityWork(env);
+    Worker::Destroy(env);
+  }
+
+ private:
   const std::vector<std::string> keys_;
   std::vector<std::string> values_;
   std::vector<rocksdb::Status> status_;
@@ -961,7 +841,21 @@ NAPI_METHOD(db_get_many) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
-  const auto keys = KeyArray(env, argv[1]);
+  std::vector<std::string> keys;
+  {
+    uint32_t length;
+    NAPI_STATUS_THROWS(napi_get_array_length(env, argv[1], &length));
+
+    keys.reserve(length);
+
+    for (uint32_t i = 0; i < length; i++) {
+      napi_value element;
+
+      NAPI_STATUS_THROWS(napi_get_element(env, argv[1], i, &element));
+      keys.push_back(ToString(env, element));
+    }
+  }
+
   const auto options = argv[2];
   const bool asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
   const bool fillCache = BooleanProperty(env, options, "fillCache", true);
@@ -995,6 +889,8 @@ NAPI_METHOD(db_clear) {
   const auto gt = RangeOption(env, argv[1], "gt");
   const auto gte = RangeOption(env, argv[1], "gte");
 
+  // TODO (perf): Use DeleteRange.
+
   BaseIterator it(database, reverse, lt, lte, gt, gte, limit, false);
 
   it.SeekToRange();
@@ -1005,7 +901,7 @@ NAPI_METHOD(db_clear) {
   rocksdb::WriteBatch batch;
   rocksdb::WriteOptions options;
   rocksdb::Status status;
-  
+
   while (true) {
     size_t bytesRead = 0;
 
@@ -1030,7 +926,7 @@ NAPI_METHOD(db_clear) {
   }
 
   it.Close();
-  
+
   return ToError(env, status);
 }
 
@@ -1049,7 +945,7 @@ NAPI_METHOD(db_get_property) {
   return result;
 }
 
-static void FinalizeIterator (napi_env env, void* data, void* hint) {
+static void FinalizeIterator(napi_env env, void* data, void* hint) {
   if (data) {
     delete reinterpret_cast<Iterator*>(data);
   }
@@ -1074,9 +970,8 @@ NAPI_METHOD(iterator_init) {
   const auto gt = RangeOption(env, options, "gt");
   const auto gte = RangeOption(env, options, "gte");
 
-  auto iterator = new Iterator(database, reverse, keys,
-                               values, limit, lt, lte, gt, gte, fillCache,
-                               keyAsBuffer, valueAsBuffer, highWaterMarkBytes);
+  auto iterator = new Iterator(database, reverse, keys, values, limit, lt, lte, gt, gte, fillCache, keyAsBuffer,
+                               valueAsBuffer, highWaterMarkBytes);
   napi_value result;
 
   NAPI_STATUS_THROWS(napi_create_external(env, iterator, FinalizeIterator, nullptr, &result));
@@ -1099,24 +994,21 @@ NAPI_METHOD(iterator_seek) {
   return 0;
 }
 
-struct CloseIteratorWorker final : public BaseWorker {
-  CloseIteratorWorker (napi_env env,
-                       Iterator* iterator,
-                       napi_value callback)
-    : BaseWorker(env, iterator->database_, callback, "leveldown.iterator.end"),
-      iterator_(iterator) {}
+struct CloseIteratorWorker final : public Worker {
+  CloseIteratorWorker(napi_env env, Iterator* iterator, napi_value callback)
+      : Worker(env, iterator->database_, callback, "leveldown.iterator.end"), iterator_(iterator) {}
 
-  rocksdb::Status Execute (Database& database) override {
+  rocksdb::Status Execute(Database& database) override {
     iterator_->Close();
     return rocksdb::Status::OK();
   }
 
-  void Destroy (napi_env env) override {
+  void Destroy(napi_env env) override {
     iterator_->Detach(env);
-    BaseWorker::Destroy(env);
+    Worker::Destroy(env);
   }
 
-private:
+ private:
   Iterator* iterator_;
 };
 
@@ -1132,16 +1024,11 @@ NAPI_METHOD(iterator_close) {
   return 0;
 }
 
-struct NextWorker final : public BaseWorker {
-  NextWorker (napi_env env,
-              Iterator* iterator,
-              uint32_t size,
-              napi_value callback)
-    : BaseWorker(env, iterator->database_, callback,
-                 "leveldown.iterator.next"),
-      iterator_(iterator), size_(size) {}
+struct NextWorker final : public Worker {
+  NextWorker(napi_env env, Iterator* iterator, uint32_t size, napi_value callback)
+      : Worker(env, iterator->database_, callback, "leveldown.iterator.next"), iterator_(iterator), size_(size) {}
 
-  rocksdb::Status Execute (Database& database) override {
+  rocksdb::Status Execute(Database& database) override {
     if (!iterator_->DidSeek()) {
       iterator_->SeekToRange();
     }
@@ -1153,11 +1040,14 @@ struct NextWorker final : public BaseWorker {
     size_t bytesRead = 0;
 
     while (true) {
-      if (!iterator_->first_) iterator_->Next();
-      else iterator_->first_ = false;
+      if (!iterator_->first_)
+        iterator_->Next();
+      else
+        iterator_->first_ = false;
+
+      if (!iterator_->Valid() || !iterator_->Increment())
+        break;
 
-      if (!iterator_->Valid() || !iterator_->Increment()) break;
-    
       if (iterator_->keys_ && iterator_->values_) {
         auto k = iterator_->CurrentKey();
         auto v = iterator_->CurrentValue();
@@ -1185,7 +1075,7 @@ struct NextWorker final : public BaseWorker {
     return iterator_->Status();
   }
 
-  void OnOk (napi_env env, napi_value callback) override {
+  void OnOk(napi_env env, napi_value callback) override {
     const auto size = cache_.size();
     napi_value result;
     napi_create_array_with_length(env, size, &result);
@@ -1210,7 +1100,7 @@ struct NextWorker final : public BaseWorker {
     CallFunction(env, callback, 3, argv);
   }
 
-private:
+ private:
   std::vector<std::string> cache_;
   Iterator* iterator_ = nullptr;
   uint32_t size_ = 0;
@@ -1223,7 +1113,8 @@ NAPI_METHOD(iterator_nextv) {
 
   uint32_t size;
   NAPI_STATUS_THROWS(napi_get_value_uint32(env, argv[1], &size));
-  if (size == 0) size = 1;
+  if (size == 0)
+    size = 1;
 
   const auto callback = argv[2];
 
@@ -1248,19 +1139,23 @@ NAPI_METHOD(batch_do) {
     napi_value element;
     NAPI_STATUS_THROWS(napi_get_element(env, operations, i, &element));
 
-    if (!IsObject(env, element)) continue;
+    if (!IsObject(env, element))
+      continue;
 
     const auto type = StringProperty(env, element, "type");
 
     if (type == "del") {
-      if (!HasProperty(env, element, "key")) continue;
+      if (!HasProperty(env, element, "key"))
+        continue;
 
       const auto key = NapiSlice(env, GetProperty(env, element, "key"));
 
       batch.Delete(key);
     } else if (type == "put") {
-      if (!HasProperty(env, element, "key")) continue;
-      if (!HasProperty(env, element, "value")) continue;
+      if (!HasProperty(env, element, "key"))
+        continue;
+      if (!HasProperty(env, element, "value"))
+        continue;
 
       const auto key = NapiSlice(env, GetProperty(env, element, "key"));
       const auto value = NapiSlice(env, GetProperty(env, element, "value"));
@@ -1273,7 +1168,7 @@ NAPI_METHOD(batch_do) {
   return ToError(env, database->db_->Write(options, &batch));
 }
 
-static void FinalizeBatch (napi_env env, void* data, void* hint) {
+static void FinalizeBatch(napi_env env, void* data, void* hint) {
   if (data) {
     delete reinterpret_cast<rocksdb::WriteBatch*>(data);
   }
@@ -1323,7 +1218,7 @@ NAPI_METHOD(batch_clear) {
 }
 
 NAPI_METHOD(batch_write) {
-  NAPI_ARGV(4);
+  NAPI_ARGV(3);
   NAPI_DB_CONTEXT();
 
   rocksdb::WriteBatch* batch;

package/package.json

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