@nxtedition/rocksdb 5.2.35 → 5.2.38

package/binding.cc

@@ -19,6 +19,7 @@
 #include <set>
 #include <string>
 #include <vector>
+#include <thread>
 
 class NullLogger : public rocksdb::Logger {
  public:
@@ -38,15 +39,6 @@ struct Iterator;
     }                            \
   }
 
-#define NAPI_PENDING_EXCEPTION()                                 \
-  {                                                              \
-    bool result;                                                 \
-    NAPI_STATUS_THROWS(napi_is_exception_pending(env, &result)); \
-    if (result) {                                                \
-      return nullptr;                                            \
-    }                                                            \
-  }
-
 #define NAPI_DB_CONTEXT()       \
   Database* database = nullptr; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
@@ -71,12 +63,6 @@ static bool IsBuffer(napi_env env, napi_value value) {
   return isBuffer;
 }
 
-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::optional<std::string_view>& code, const std::string_view& msg) {
   napi_value codeValue = nullptr;
   if (code) {
@@ -96,12 +82,12 @@ static bool HasProperty(napi_env env, napi_value obj, const std::string_view& ke
 }
 
 static napi_value GetProperty(napi_env env, napi_value obj, const std::string_view& key) {
-  napi_value value;
+  napi_value value = nullptr;
   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 std::optional<bool> BooleanProperty(napi_env env, napi_value obj, const std::string_view& key) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     bool result;
@@ -109,7 +95,7 @@ static bool BooleanProperty(napi_env env, napi_value obj, const std::string_view
     return result;
   }
 
-  return defaultValue;
+  return {};
 }
 
 static bool EncodingIsBuffer(napi_env env, napi_value obj, const std::string_view& option) {
@@ -125,7 +111,7 @@ static bool EncodingIsBuffer(napi_env env, napi_value obj, const std::string_vie
   return false;
 }
 
-static uint32_t Uint32Property(napi_env env, napi_value obj, const std::string_view& key, uint32_t defaultValue) {
+static std::optional<uint32_t> Uint32Property(napi_env env, napi_value obj, const std::string_view& key) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     uint32_t result;
@@ -133,10 +119,10 @@ static uint32_t Uint32Property(napi_env env, napi_value obj, const std::string_v
     return result;
   }
 
-  return defaultValue;
+  return {};
 }
 
-static int Int32Property(napi_env env, napi_value obj, const std::string_view& key, int defaultValue) {
+static std::optional<int> Int32Property(napi_env env, napi_value obj, const std::string_view& key) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     int result;
@@ -144,7 +130,7 @@ static int Int32Property(napi_env env, napi_value obj, const std::string_view& k
     return result;
   }
 
-  return defaultValue;
+  return {};
 }
 
 static std::string ToString(napi_env env, napi_value from, const std::string& defaultValue = "") {
@@ -164,26 +150,11 @@ static std::string ToString(napi_env env, napi_value from, const std::string& de
   return 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)) {
-      return ToString(env, value);
-    }
-  }
-
-  return defaultValue;
-}
-
-static std::optional<std::string> RangeOption(napi_env env, napi_value opts, const std::string_view& name) {
+static std::optional<std::string> StringProperty(napi_env env, napi_value opts, const std::string_view& name) {
   if (HasProperty(env, opts, name)) {
     const auto value = GetProperty(env, opts, name);
     return ToString(env, value);
   }
-
   return {};
 }
 
@@ -238,31 +209,42 @@ napi_status Convert(napi_env env, std::string s, bool asBuffer, napi_value& resu
   }
 }
 
-struct NapiSlice : public rocksdb::Slice {
-  NapiSlice(napi_env env, napi_value from) {
-    if (IsString(env, from)) {
-      NAPI_STATUS_THROWS_VOID(napi_get_value_string_utf8(env, from, nullptr, 0, &size_));
-      char* data;
-      if (size_ + 1 < stack_.size()) {
-        data = stack_.data();
-      } else {
-        heap_.reset(new char[size_ + 1]);
-        data = heap_.get();
-      }
-      data[size_] = 0;
-      NAPI_STATUS_THROWS_VOID(napi_get_value_string_utf8(env, from, data, size_ + 1, &size_));
-      data_ = data;
-    } else if (IsBuffer(env, from)) {
-      void* data;
-      NAPI_STATUS_THROWS_VOID(napi_get_buffer_info(env, from, &data, &size_));
-      data_ = static_cast<char*>(data);
-    }
+napi_status Convert(napi_env env, rocksdb::PinnableSlice s, bool asBuffer, napi_value& result) {
+  if (asBuffer) {
+    auto ptr = new rocksdb::PinnableSlice(std::move(s));
+    return napi_create_external_buffer(env, ptr->size(), const_cast<char*>(ptr->data()),
+                                       Finalize<rocksdb::PinnableSlice>, ptr, &result);
+  } else {
+    return napi_create_string_utf8(env, s.data(), s.size(), &result);
   }
+}
 
+struct NapiSlice : public rocksdb::Slice {
   std::unique_ptr<char[]> heap_;
   std::array<char, 1024> stack_;
 };
 
+napi_status ToNapiSlice(napi_env env, napi_value from, NapiSlice& slice) {
+  if (IsString(env, from)) {
+    NAPI_STATUS_RETURN(napi_get_value_string_utf8(env, from, nullptr, 0, &slice.size_));
+    char* data;
+    if (slice.size_ + 1 < slice.stack_.size()) {
+      data = slice.stack_.data();
+    } else {
+      slice.heap_.reset(new char[slice.size_ + 1]);
+      data = slice.heap_.get();
+    }
+    data[slice.size_] = 0;
+    NAPI_STATUS_RETURN(napi_get_value_string_utf8(env, from, data, slice.size_ + 1, &slice.size_));
+    slice.data_ = data;
+  } else if (IsBuffer(env, from)) {
+    void* data;
+    NAPI_STATUS_RETURN(napi_get_buffer_info(env, from, &data, &slice.size_));
+    slice.data_ = static_cast<char*>(data);
+  }
+  return napi_ok;
+}
+
 /**
  * Base worker class. Handles the async work. Derived classes can override the
  * following virtual methods (listed in the order in which they're called):
@@ -383,21 +365,21 @@ struct BaseIterator {
         limit_(limit),
         fillCache_(fillCache) {
     if (lte) {
-      upper_bound_ = std::make_unique<rocksdb::PinnableSlice>();
+      upper_bound_ = rocksdb::PinnableSlice();
       *upper_bound_->GetSelf() = std::move(*lte) + '\0';
       upper_bound_->PinSelf();
     } else if (lt) {
-      upper_bound_ = std::make_unique<rocksdb::PinnableSlice>();
+      upper_bound_ = rocksdb::PinnableSlice();
       *upper_bound_->GetSelf() = std::move(*lt);
       upper_bound_->PinSelf();
     }
 
     if (gte) {
-      lower_bound_ = std::make_unique<rocksdb::PinnableSlice>();
+      lower_bound_ = rocksdb::PinnableSlice();
       *lower_bound_->GetSelf() = std::move(*gte);
       lower_bound_->PinSelf();
     } else if (gt) {
-      lower_bound_ = std::make_unique<rocksdb::PinnableSlice>();
+      lower_bound_ = rocksdb::PinnableSlice();
       *lower_bound_->GetSelf() = std::move(*gt) + '\0';
       lower_bound_->PinSelf();
     }
@@ -477,8 +459,8 @@ struct BaseIterator {
     iterator_.reset(database_->db_->NewIterator(options));
   }
 
-  std::unique_ptr<rocksdb::PinnableSlice> lower_bound_;
-  std::unique_ptr<rocksdb::PinnableSlice> upper_bound_;
+  std::optional<rocksdb::PinnableSlice> lower_bound_;
+  std::optional<rocksdb::PinnableSlice> upper_bound_;
   std::shared_ptr<const rocksdb::Snapshot> snapshot_;
   std::unique_ptr<rocksdb::Iterator> iterator_;
   const bool reverse_;
@@ -506,9 +488,7 @@ struct Iterator final : public BaseIterator {
         values_(values),
         keyAsBuffer_(keyAsBuffer),
         valueAsBuffer_(valueAsBuffer),
-        highWaterMarkBytes_(highWaterMarkBytes),
-        first_(true),
-        ref_(nullptr) {}
+        highWaterMarkBytes_(highWaterMarkBytes) {}
 
   void Attach(napi_env env, napi_value context) {
     napi_create_reference(env, context, 1, &ref_);
@@ -527,10 +507,10 @@ struct Iterator final : public BaseIterator {
   const bool keyAsBuffer_;
   const bool valueAsBuffer_;
   const uint32_t highWaterMarkBytes_;
-  bool first_;
+  bool first_ = true;
 
  private:
-  napi_ref ref_;
+  napi_ref ref_ = nullptr;
 };
 
 /**
@@ -593,11 +573,10 @@ struct OpenWorker final : public Worker {
         readOnly_(readOnly),
         location_(location) {}
 
-  rocksdb::Status Execute(Database& database) override { 
-    rocksdb::DB* db;
-    const auto status = readOnly_
-      ? rocksdb::DB::OpenForReadOnly(options_, location_, &db)
-      : rocksdb::DB::Open(options_, location_, &db);
+  rocksdb::Status Execute(Database& database) override {
+    rocksdb::DB* db = nullptr;
+    const auto status = readOnly_ ? rocksdb::DB::OpenForReadOnly(options_, location_, &db)
+                                  : rocksdb::DB::Open(options_, location_, &db);
     database.db_.reset(db);
     return status;
   }
@@ -613,19 +592,21 @@ NAPI_METHOD(db_open) {
 
   rocksdb::Options options;
 
-  options.IncreaseParallelism(Uint32Property(env, argv[2], "parallelism", 4));
+  options.IncreaseParallelism(
+      Uint32Property(env, argv[2], "parallelism").value_or(std::thread::hardware_concurrency() / 2));
 
   const auto location = ToString(env, argv[1]);
-  options.create_if_missing = BooleanProperty(env, argv[2], "createIfMissing", true);
-  options.error_if_exists = BooleanProperty(env, argv[2], "errorIfExists", false);
-  options.compression =
-      BooleanProperty(env, argv[2], "compression", true) ? rocksdb::kSnappyCompression : rocksdb::kNoCompression;
-  options.max_open_files = Uint32Property(env, argv[2], "maxOpenFiles", 1000);
-  options.max_log_file_size = Uint32Property(env, argv[2], "maxFileSize", 2 << 20);
-  options.write_buffer_size = Uint32Property(env, argv[2], "writeBufferSize", 4 << 20);
+  options.create_if_missing = BooleanProperty(env, argv[2], "createIfMissing").value_or(true);
+  options.error_if_exists = BooleanProperty(env, argv[2], "errorIfExists").value_or(false);
+  options.compression = BooleanProperty(env, argv[2], "compression").value_or((true)) ? rocksdb::kSnappyCompression
+                                                                                      : rocksdb::kNoCompression;
   options.use_adaptive_mutex = true;
+  options.enable_pipelined_write = true;
 
-  const auto infoLogLevel = StringProperty(env, argv[2], "infoLogLevel");
+  // TODO: Consider direct IO (https://github.com/facebook/rocksdb/wiki/Direct-IO) once
+  // secondary compressed cache is stable.
+
+  const auto infoLogLevel = StringProperty(env, argv[2], "infoLogLevel").value_or("");
   if (infoLogLevel.size() > 0) {
     rocksdb::InfoLogLevel lvl = {};
 
@@ -652,8 +633,8 @@ NAPI_METHOD(db_open) {
     options.info_log.reset(new NullLogger());
   }
 
-  const auto readOnly = BooleanProperty(env, argv[2], "readOnly", false);
-  const auto cacheSize = Uint32Property(env, argv[2], "cacheSize", 8 << 20);
+  const auto readOnly = BooleanProperty(env, argv[2], "readOnly").value_or(false);
+  const auto cacheSize = Uint32Property(env, argv[2], "cacheSize").value_or(8 << 20);
 
   rocksdb::BlockBasedTableOptions tableOptions;
 
@@ -663,18 +644,18 @@ NAPI_METHOD(db_open) {
     tableOptions.no_block_cache = true;
   }
 
-  tableOptions.block_size = Uint32Property(env, argv[2], "blockSize", 4096);
-  tableOptions.block_restart_interval = Uint32Property(env, argv[2], "blockRestartInterval", 16);
-  tableOptions.filter_policy.reset(rocksdb::NewBloomFilterPolicy(10));
+  tableOptions.block_size = Uint32Property(env, argv[2], "blockSize").value_or(4096);
+  tableOptions.block_restart_interval = Uint32Property(env, argv[2], "blockRestartInterval").value_or(16);
+  tableOptions.filter_policy.reset(rocksdb::NewRibbonFilterPolicy(10));
   tableOptions.format_version = 5;
-  tableOptions.checksum = rocksdb::kxxHash64;
+  tableOptions.checksum = rocksdb::kXXH3;
+  tableOptions.optimize_filters_for_memory = BooleanProperty(env, argv[2], "optimizeFiltersForMemory").value_or(true);
+  tableOptions.cache_index_and_filter_blocks = BooleanProperty(env, argv[2], "cacheIndexAndFilterBlocks").value_or(true);
 
   options.table_factory.reset(rocksdb::NewBlockBasedTableFactory(tableOptions));
 
   const auto callback = argv[3];
 
-  NAPI_PENDING_EXCEPTION();
-
   auto worker = new OpenWorker(env, database, callback, location, options, readOnly);
   worker->Queue(env);
 
@@ -713,10 +694,11 @@ NAPI_METHOD(db_put) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
-  const auto key = NapiSlice(env, argv[1]);
-  const auto val = NapiSlice(env, argv[2]);
+  NapiSlice key;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], key));
 
-  NAPI_PENDING_EXCEPTION();
+  NapiSlice val;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[2], val));
 
   rocksdb::WriteOptions options;
   return ToError(env, database->db_->Put(options, key, val));
@@ -778,11 +760,9 @@ NAPI_METHOD(db_get) {
   const auto key = ToString(env, argv[1]);
   const auto options = argv[2];
   const auto asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
-  const auto fillCache = BooleanProperty(env, options, "fillCache", true);
+  const auto fillCache = BooleanProperty(env, options, "fillCache").value_or(true);
   const auto callback = argv[3];
 
-  NAPI_PENDING_EXCEPTION();
-
   auto worker = new GetWorker(env, database, callback, key, asBuffer, fillCache);
   worker->Queue(env);
 
@@ -792,12 +772,12 @@ NAPI_METHOD(db_get) {
 struct GetManyWorker final : public Worker {
   GetManyWorker(napi_env env,
                 Database* database,
-                const std::vector<std::string>& keys,
+                std::vector<std::string> keys,
                 napi_value callback,
                 const bool valueAsBuffer,
                 const bool fillCache)
       : Worker(env, database, callback, "leveldown.get.many"),
-        keys_(keys),
+        keys_(std::move(keys)),
         valueAsBuffer_(valueAsBuffer),
         fillCache_(fillCache),
         snapshot_(database_->db_->GetSnapshot(),
@@ -810,12 +790,24 @@ struct GetManyWorker final : public Worker {
     options.fill_cache = fillCache_;
     options.snapshot = snapshot_.get();
 
-    status_ = database.db_->MultiGet(options, std::vector<rocksdb::Slice>(keys_.begin(), keys_.end()), &values_);
+    const auto numKeys = keys_.size();
+
+    std::vector<rocksdb::Slice> keys;
+    keys.reserve(keys_.size());
+    for (const auto& key : keys_) {
+      keys.emplace_back(key);
+    }
+
+    statuses_.resize(numKeys);
+    values_.resize(numKeys);
+
+    database.db_->MultiGet(options, database.db_->DefaultColumnFamily(), numKeys, keys.data(), values_.data(),
+                           statuses_.data());
 
     keys_.clear();
     snapshot_ = nullptr;
 
-    for (auto status : status_) {
+    for (auto status : statuses_) {
       if (!status.ok() && !status.IsNotFound()) {
         return status;
       }
@@ -832,7 +824,7 @@ struct GetManyWorker final : public Worker {
 
     for (size_t idx = 0; idx < size; idx++) {
       napi_value element;
-      if (status_[idx].ok()) {
+      if (statuses_[idx].ok()) {
         NAPI_STATUS_RETURN(Convert(env, std::move(values_[idx]), valueAsBuffer_, element));
       } else {
         NAPI_STATUS_RETURN(napi_get_undefined(env, &element));
@@ -841,7 +833,7 @@ struct GetManyWorker final : public Worker {
     }
 
     values_.clear();
-    status_.clear();
+    statuses_.clear();
 
     napi_value argv[2];
     NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
@@ -856,8 +848,8 @@ struct GetManyWorker final : public Worker {
 
  private:
   std::vector<std::string> keys_;
-  std::vector<std::string> values_;
-  std::vector<rocksdb::Status> status_;
+  std::vector<rocksdb::PinnableSlice> values_;
+  std::vector<rocksdb::Status> statuses_;
   const bool valueAsBuffer_;
   const bool fillCache_;
   std::shared_ptr<const rocksdb::Snapshot> snapshot_;
@@ -884,12 +876,10 @@ NAPI_METHOD(db_get_many) {
 
   const auto options = argv[2];
   const bool asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
-  const bool fillCache = BooleanProperty(env, options, "fillCache", true);
+  const bool fillCache = BooleanProperty(env, options, "fillCache").value_or(true);
   const auto callback = argv[3];
 
-  NAPI_PENDING_EXCEPTION();
-
-  auto worker = new GetManyWorker(env, database, keys, callback, asBuffer, fillCache);
+  auto worker = new GetManyWorker(env, database, std::move(keys), callback, asBuffer, fillCache);
   worker->Queue(env);
 
   return 0;
@@ -899,9 +889,8 @@ NAPI_METHOD(db_del) {
   NAPI_ARGV(3);
   NAPI_DB_CONTEXT();
 
-  const auto key = NapiSlice(env, argv[1]);
-
-  NAPI_PENDING_EXCEPTION();
+  NapiSlice key;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], key));
 
   rocksdb::WriteOptions options;
   return ToError(env, database->db_->Delete(options, key));
@@ -911,15 +900,13 @@ NAPI_METHOD(db_clear) {
   NAPI_ARGV(2);
   NAPI_DB_CONTEXT();
 
-  const auto reverse = BooleanProperty(env, argv[1], "reverse", false);
-  const auto limit = Int32Property(env, argv[1], "limit", -1);
-
-  const auto lt = RangeOption(env, argv[1], "lt");
-  const auto lte = RangeOption(env, argv[1], "lte");
-  const auto gt = RangeOption(env, argv[1], "gt");
-  const auto gte = RangeOption(env, argv[1], "gte");
+  const auto reverse = BooleanProperty(env, argv[1], "reverse").value_or(false);
+  const auto limit = Int32Property(env, argv[1], "limit").value_or(-1);
 
-  NAPI_PENDING_EXCEPTION();
+  const auto lt = StringProperty(env, argv[1], "lt");
+  const auto lte = StringProperty(env, argv[1], "lte");
+  const auto gt = StringProperty(env, argv[1], "gt");
+  const auto gte = StringProperty(env, argv[1], "gte");
 
   // TODO (perf): Use DeleteRange.
 
@@ -966,9 +953,8 @@ NAPI_METHOD(db_get_property) {
   NAPI_ARGV(2);
   NAPI_DB_CONTEXT();
 
-  const auto property = NapiSlice(env, argv[1]);
-
-  NAPI_PENDING_EXCEPTION();
+  NapiSlice property;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], property));
 
   std::string value;
   database->db_->GetProperty(property, &value);
@@ -984,24 +970,22 @@ NAPI_METHOD(iterator_init) {
   NAPI_DB_CONTEXT();
 
   const auto options = argv[1];
-  const auto reverse = BooleanProperty(env, options, "reverse", false);
-  const auto keys = BooleanProperty(env, options, "keys", true);
-  const auto values = BooleanProperty(env, options, "values", true);
-  const auto fillCache = BooleanProperty(env, options, "fillCache", false);
+  const auto reverse = BooleanProperty(env, options, "reverse").value_or(false);
+  const auto keys = BooleanProperty(env, options, "keys").value_or(true);
+  const auto values = BooleanProperty(env, options, "values").value_or(true);
+  const auto fillCache = BooleanProperty(env, options, "fillCache").value_or(false);
   const bool keyAsBuffer = EncodingIsBuffer(env, options, "keyEncoding");
   const bool valueAsBuffer = EncodingIsBuffer(env, options, "valueEncoding");
-  const auto limit = Int32Property(env, options, "limit", -1);
-  const auto highWaterMarkBytes = Uint32Property(env, options, "highWaterMarkBytes", 16 * 1024);
-
-  const auto lt = RangeOption(env, options, "lt");
-  const auto lte = RangeOption(env, options, "lte");
-  const auto gt = RangeOption(env, options, "gt");
-  const auto gte = RangeOption(env, options, "gte");
+  const auto limit = Int32Property(env, options, "limit").value_or(-1);
+  const auto highWaterMarkBytes = Uint32Property(env, options, "highWaterMarkBytes").value_or(16 * 1024);
 
-  NAPI_PENDING_EXCEPTION();
+  const auto lt = StringProperty(env, options, "lt");
+  const auto lte = StringProperty(env, options, "lte");
+  const auto gt = StringProperty(env, options, "gt");
+  const auto gte = StringProperty(env, options, "gte");
 
-  auto iterator = std::make_unique<Iterator>(database, reverse, keys, values, limit, lt, lte, gt, gte, fillCache, keyAsBuffer,
-                               valueAsBuffer, highWaterMarkBytes);
+  auto iterator = std::make_unique<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.get(), Finalize<Iterator>, iterator.get(), &result));
@@ -1017,9 +1001,8 @@ NAPI_METHOD(iterator_seek) {
   NAPI_ARGV(2);
   NAPI_ITERATOR_CONTEXT();
 
-  const auto target = NapiSlice(env, argv[1]);
-
-  NAPI_PENDING_EXCEPTION();
+  NapiSlice target;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], target));
 
   iterator->first_ = true;
   iterator->Seek(target);
@@ -1147,33 +1130,22 @@ NAPI_METHOD(batch_do) {
     napi_value element;
     NAPI_STATUS_THROWS(napi_get_element(env, operations, i, &element));
 
-    if (!IsObject(env, element))
-      continue;
-
-    const auto type = StringProperty(env, element, "type");
+    NapiSlice type;
+    NAPI_STATUS_THROWS(ToNapiSlice(env, GetProperty(env, element, "type"), type));
 
     if (type == "del") {
-      if (!HasProperty(env, element, "key"))
-        continue;
-
-      const auto key = NapiSlice(env, GetProperty(env, element, "key"));
-
+      NapiSlice key;
+      NAPI_STATUS_THROWS(ToNapiSlice(env, GetProperty(env, element, "key"), key));
       batch.Delete(key);
     } else if (type == "put") {
-      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"));
-
+      NapiSlice key;
+      NAPI_STATUS_THROWS(ToNapiSlice(env, GetProperty(env, element, "key"), key));
+      NapiSlice value;
+      NAPI_STATUS_THROWS(ToNapiSlice(env, GetProperty(env, element, "value"), value));
       batch.Put(key, value);
     }
   }
 
-  NAPI_PENDING_EXCEPTION();
-
   rocksdb::WriteOptions options;
   return ToError(env, database->db_->Write(options, &batch));
 }
@@ -1193,10 +1165,11 @@ NAPI_METHOD(batch_put) {
   NAPI_ARGV(3);
   NAPI_BATCH_CONTEXT();
 
-  const auto key = NapiSlice(env, argv[1]);
-  const auto val = NapiSlice(env, argv[2]);
+  NapiSlice key;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], key));
 
-  NAPI_PENDING_EXCEPTION();
+  NapiSlice val;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[2], val));
 
   batch->Put(key, val);
 
@@ -1207,9 +1180,8 @@ NAPI_METHOD(batch_del) {
   NAPI_ARGV(2);
   NAPI_BATCH_CONTEXT();
 
-  const auto key = NapiSlice(env, argv[1]);
-
-  NAPI_PENDING_EXCEPTION();
+  NapiSlice key;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], key));
 
   batch->Delete(key);
 

package/binding.gyp

@@ -62,7 +62,7 @@
               ],
               "OTHER_CPLUSPLUSFLAGS": [
                 "-mmacosx-version-min=10.15",
-                "-std=c++17",
+                "-std=c++20",
                 "-fno-omit-frame-pointer",
                 "-momit-leaf-frame-pointer",
                 "-arch x86_64",