@nxtedition/rocksdb 15.2.3 → 15.2.6

package/.claude/settings.local.json

@@ -14,7 +14,21 @@
       "Bash(git submodule update:*)",
       "Bash(git submodule:*)",
       "Bash(yarn build:*)",
-      "Bash(yarn rebuild:*)"
+      "Bash(yarn rebuild:*)",
+      "Bash(npx tape:*)",
+      "Bash(echo \"=== In binding.gyp ===\" grep \"absl/base/internal\" binding.gyp echo \"\" echo \"=== Available \\(non-test\\) files ===\" ls deps/abseil-cpp/absl/base/internal/*.cc)",
+      "Bash(echo \"=== Checking for abseil source requirements ===\" echo \"\" echo \"profiling sources:\" ls /Users/ronagy/GitHub/nxtedition/rocks-level/deps/abseil-cpp/absl/profiling/internal/*.cc)",
+      "Bash(echo \"none found\" echo \"\" echo \"crc sources:\" ls /Users/ronagy/GitHub/nxtedition/rocks-level/deps/abseil-cpp/absl/crc/internal/*.cc)",
+      "Bash(echo \"NONE INCLUDED!\" echo \"\" echo \"=== Available log sources ===\" ls /Users/ronagy/GitHub/nxtedition/rocks-level/deps/abseil-cpp/absl/log/*.cc)",
+      "Bash(head -20 echo \"\" echo \"=== Log internal sources ===\" ls /Users/ronagy/GitHub/nxtedition/rocks-level/deps/abseil-cpp/absl/log/internal/*.cc)",
+      "Bash(echo \"=== Required log sources \\(non-test\\) ===\" ls /Users/ronagy/GitHub/nxtedition/rocks-level/deps/abseil-cpp/absl/log/*.cc)",
+      "Bash(CFLAGS=\"-g -O0\" CXXFLAGS=\"-g -O0\" npm run rebuild)",
+      "Bash(node-gyp rebuild:*)",
+      "Bash(npx node-gyp rebuild:*)",
+      "Bash(git rm:*)",
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "Bash(git log:*)",
+      "WebFetch(domain:github.com)"
     ]
   }
 }

package/binding.cc

@@ -31,6 +31,19 @@
 #include "max_rev_operator.h"
 #include "util.h"
 
+enum ResourceName {
+  ResourceIteratorNextv = 0,
+  ResourceLeveldownOpen,
+  ResourceLeveldownClose,
+  ResourceLeveldownGetMany,
+  ResourceLeveldownFlushWal,
+  ResourceLeveldownIteratorSeek,
+  ResourceLeveldownBatchWrite,
+  ResourceLeveldownUpdatesSince,
+  ResourceLeveldownCompactRange,
+  ResourceNameCount
+};
+
 class NullLogger : public rocksdb::Logger {
  public:
   using rocksdb::Logger::Logv;
@@ -98,6 +111,38 @@ struct Database final {
 
   std::unique_ptr<rocksdb::DB> db;
   std::map<int32_t, ColumnFamily> columns;
+  napi_ref resourceNamesRef = nullptr;
+
+  static napi_status InitResourceNames(napi_env env, Database* db) {
+    napi_value array;
+    NAPI_STATUS_RETURN(napi_create_array_with_length(env, ResourceNameCount, &array));
+
+    auto set = [&](uint32_t idx, const char* name) -> napi_status {
+      napi_value value;
+      NAPI_STATUS_RETURN(napi_create_string_utf8(env, name, NAPI_AUTO_LENGTH, &value));
+      NAPI_STATUS_RETURN(napi_set_element(env, array, idx, value));
+      return napi_ok;
+    };
+    NAPI_STATUS_RETURN(set(ResourceIteratorNextv, "iterator.nextv"));
+    NAPI_STATUS_RETURN(set(ResourceLeveldownOpen, "leveldown.open"));
+    NAPI_STATUS_RETURN(set(ResourceLeveldownClose, "leveldown.close"));
+    NAPI_STATUS_RETURN(set(ResourceLeveldownGetMany, "leveldown.get_many"));
+    NAPI_STATUS_RETURN(set(ResourceLeveldownFlushWal, "leveldown.flush_wal"));
+    NAPI_STATUS_RETURN(set(ResourceLeveldownIteratorSeek, "leveldown.iterator_seek"));
+    NAPI_STATUS_RETURN(set(ResourceLeveldownBatchWrite, "leveldown.batch_write"));
+    NAPI_STATUS_RETURN(set(ResourceLeveldownUpdatesSince, "leveldown.updates_since"));
+    NAPI_STATUS_RETURN(set(ResourceLeveldownCompactRange, "leveldown.compact_range"));
+
+    NAPI_STATUS_RETURN(napi_create_reference(env, array, 1, &db->resourceNamesRef));
+    return napi_ok;
+  }
+
+  napi_status GetResourceName(napi_env env, ResourceName name, napi_value& result) const {
+    napi_value array;
+    NAPI_STATUS_RETURN(napi_get_reference_value(env, resourceNamesRef, &array));
+    NAPI_STATUS_RETURN(napi_get_element(env, array, name, &result));
+    return napi_ok;
+  }
 
  private:
   mutable std::mutex mutex_;
@@ -546,8 +591,8 @@ class Iterator final : public BaseIterator {
     //   : std::chrono::microseconds::zero();
 
     return std::make_unique<Iterator>(database, column, reverse, keys, values, limit, lt, lte, gt, gte,
-                                      highWaterMarkBytes, keyFilter, valueFilter, keyEncoding, valueEncoding,
-                                      unsafe, readOptions);
+                                      highWaterMarkBytes, keyFilter, valueFilter, keyEncoding, valueEncoding, unsafe,
+                                      readOptions);
   }
 
   napi_value nextv(napi_env env, uint32_t count, uint32_t timeout, napi_value callback) {
@@ -558,8 +603,11 @@ class Iterator final : public BaseIterator {
       bool finished = false;
     };
 
-    runAsync<State>(
-        "iterator.nextv", env, callback,
+    napi_value resourceName;
+    NAPI_STATUS_THROWS(database_->GetResourceName(env, ResourceIteratorNextv, resourceName));
+
+    NAPI_STATUS_THROWS(runAsync<State>(
+        resourceName, env, callback,
         [=](auto& state) {
           state.keys.reserve(count);
           state.values.reserve(count);
@@ -623,9 +671,7 @@ class Iterator final : public BaseIterator {
 
           return rocksdb::Status::OK();
         },
-        [=](auto& state, auto env, auto& argv) {
-          argv.resize(2);
-
+        [=](auto& state, napi_env env, napi_value* result) {
           napi_value finished;
           NAPI_STATUS_RETURN(napi_get_boolean(env, state.finished, &finished));
 
@@ -653,12 +699,12 @@ class Iterator final : public BaseIterator {
             NAPI_STATUS_RETURN(napi_set_element(env, rows, n * 2 + 1, val));
           }
 
-          NAPI_STATUS_RETURN(napi_create_object(env, &argv[1]));
-          NAPI_STATUS_RETURN(napi_set_named_property(env, argv[1], "rows", rows));
-          NAPI_STATUS_RETURN(napi_set_named_property(env, argv[1], "finished", finished));
+          NAPI_STATUS_RETURN(napi_create_object(env, result));
+          NAPI_STATUS_RETURN(napi_set_named_property(env, *result, "rows", rows));
+          NAPI_STATUS_RETURN(napi_set_named_property(env, *result, "finished", finished));
 
           return napi_ok;
-        });
+        }));
 
     return 0;
   }
@@ -710,18 +756,14 @@ class Iterator final : public BaseIterator {
       napi_value val;
 
       if (keys_ && values_) {
-        const auto k = CurrentKey();
-        const auto v = CurrentValue();
-        NAPI_STATUS_THROWS(Convert(env, &k, keyEncoding_, key, unsafe_));
-        NAPI_STATUS_THROWS(Convert(env, &v, valueEncoding_, val, unsafe_));
+        NAPI_STATUS_THROWS(Convert(env, CurrentKey(), keyEncoding_, key, unsafe_));
+        NAPI_STATUS_THROWS(Convert(env, CurrentValue(), valueEncoding_, val, unsafe_));
       } else if (keys_) {
-        const auto k = CurrentKey();
-        NAPI_STATUS_THROWS(Convert(env, &k, keyEncoding_, key, unsafe_));
+        NAPI_STATUS_THROWS(Convert(env, CurrentKey(), keyEncoding_, key, unsafe_));
         NAPI_STATUS_THROWS(napi_get_undefined(env, &val));
       } else if (values_) {
-        const auto v = CurrentValue();
         NAPI_STATUS_THROWS(napi_get_undefined(env, &key));
-        NAPI_STATUS_THROWS(Convert(env, &v, valueEncoding_, val, unsafe_));
+        NAPI_STATUS_THROWS(Convert(env, CurrentValue(), valueEncoding_, val, unsafe_));
       } else {
         assert(false);
       }
@@ -761,6 +803,10 @@ static void FinalizeDatabase(napi_env env, void* data, void* hint) {
   auto database = reinterpret_cast<Database*>(data);
   if (database) {
     napi_remove_env_cleanup_hook(env, env_cleanup_hook, database);
+    if (database->resourceNamesRef) {
+      napi_delete_reference(env, database->resourceNamesRef);
+      database->resourceNamesRef = nullptr;
+    }
     database->Close();
   }
 }
@@ -783,6 +829,7 @@ NAPI_METHOD(db_init) {
     NAPI_STATUS_THROWS(napi_get_value_string_utf8(env, argv[0], &location[0], length + 1, &length));
 
     database = new Database(location);
+    NAPI_STATUS_THROWS(Database::InitResourceNames(env, database));
     napi_add_env_cleanup_hook(env, env_cleanup_hook, database);
     NAPI_STATUS_THROWS(napi_create_external(env, database, FinalizeDatabase, nullptr, &result));
   } else if (type == napi_bigint) {
@@ -820,7 +867,7 @@ NAPI_METHOD(db_get_location) {
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
   napi_value result;
-  NAPI_STATUS_THROWS(Convert(env, &database->location, Encoding::String, result));
+  NAPI_STATUS_THROWS(Convert(env, database->location, Encoding::String, result));
 
   return result;
 }
@@ -897,6 +944,11 @@ napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
     columnOptions.compression_opts.max_dict_bytes = 16 * 1024;
     columnOptions.compression_opts.zstd_max_train_bytes = 16 * 1024 * 100;
     // TODO (perf): compression_opts.parallel_threads
+  } else {
+    columnOptions.compression = rocksdb::kNoCompression;
+    for (auto& c : columnOptions.compression_per_level) {
+      c = rocksdb::kNoCompression;
+    }
   }
 
   std::string prefixExtractor;
@@ -1145,7 +1197,7 @@ NAPI_METHOD(db_get_identity) {
   ROCKS_STATUS_THROWS_NAPI(database->db->GetDbIdentity(identity));
 
   napi_value result;
-  NAPI_STATUS_THROWS(Convert(env, &identity, Encoding::String, result));
+  NAPI_STATUS_THROWS(Convert(env, identity, Encoding::String, result));
 
   return result;
 }
@@ -1304,8 +1356,11 @@ NAPI_METHOD(db_open) {
 
     auto callback = argv[2];
 
-    runAsync<std::vector<rocksdb::ColumnFamilyHandle*>>(
-        "leveldown.open", env, callback,
+    napi_value resourceName;
+    NAPI_STATUS_THROWS(database->GetResourceName(env, ResourceLeveldownOpen, resourceName));
+
+    NAPI_STATUS_THROWS(runAsync<std::vector<rocksdb::ColumnFamilyHandle*>>(
+        resourceName, env, callback,
         [=](auto& handles) {
           assert(!database->db);
 
@@ -1319,10 +1374,8 @@ NAPI_METHOD(db_open) {
 
           return status;
         },
-        [=](auto& handles, auto env, auto& argv) {
-          argv.resize(2);
-
-          NAPI_STATUS_RETURN(napi_create_object(env, &argv[1]));
+        [=](auto& handles, napi_env env, napi_value* result) {
+          NAPI_STATUS_RETURN(napi_create_object(env, result));
 
           for (size_t n = 0; n < handles.size(); ++n) {
             ColumnFamily column;
@@ -1331,7 +1384,7 @@ NAPI_METHOD(db_open) {
             database->columns[column.handle->GetID()] = column;
           }
 
-          napi_value columns = argv[1];
+          napi_value columns = *result;
           for (auto& [id, column] : database->columns) {
             napi_value val;
             NAPI_STATUS_RETURN(napi_create_external(env, column.handle, nullptr, nullptr, &val));
@@ -1339,7 +1392,7 @@ NAPI_METHOD(db_open) {
           }
 
           return napi_ok;
-        });
+        }));
   }
 
   return 0;
@@ -1357,10 +1410,10 @@ NAPI_METHOD(db_close) {
 
   auto callback = argv[1];
 
-  struct State {};
-  runAsync<State>(
-      "leveldown.close", env, callback, [=](auto& state) { return database->Close(); },
-      [](auto& state, auto env, auto& argv) { return napi_ok; });
+  napi_value resourceName;
+  NAPI_STATUS_THROWS(database->GetResourceName(env, ResourceLeveldownClose, resourceName));
+
+  NAPI_STATUS_THROWS(runAsync(resourceName, env, callback, [=](auto& state) { return database->Close(); }));
 
   return 0;
 }
@@ -1456,54 +1509,54 @@ NAPI_METHOD(db_get_many) {
 
   auto callback = argv[3];
 
-  struct State {
-    rocksdb::ReadOptions readOptions;
-    std::vector<rocksdb::Status> statuses;
-    std::vector<rocksdb::PinnableSlice> values;
-    std::vector<rocksdb::PinnableSlice> keys;
-  } state;
-
-  state.keys.resize(count);
+  std::vector<rocksdb::PinnableSlice> keys;
+  keys.resize(count);
 
   for (uint32_t n = 0; n < count; n++) {
     napi_value element;
     NAPI_STATUS_THROWS(napi_get_element(env, argv[1], n, &element));
-    NAPI_STATUS_THROWS(GetValue(env, element, state.keys[n]));
+    NAPI_STATUS_THROWS(GetValue(env, element, keys[n]));
   }
 
-  state.readOptions.fill_cache = false;
-  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "fillCache", state.readOptions.fill_cache));
+  rocksdb::ReadOptions readOptions;
+  readOptions.fill_cache = false;
+  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "fillCache", readOptions.fill_cache));
+
+  readOptions.async_io = true;
+  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "asyncIO", readOptions.async_io));
+
+  readOptions.optimize_multiget_for_io = true;
+  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "optimizeMultigetForIO", readOptions.optimize_multiget_for_io));
 
-  state.readOptions.async_io = true;
-  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "asyncIO", state.readOptions.async_io));
+  readOptions.value_size_soft_limit = std::numeric_limits<int32_t>::max();
+  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "highWaterMarkBytes", readOptions.value_size_soft_limit));
 
-  state.readOptions.optimize_multiget_for_io = true;
-  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "optimizeMultigetForIO", state.readOptions.optimize_multiget_for_io));
+  napi_value resourceName;
+  NAPI_STATUS_THROWS(database->GetResourceName(env, ResourceLeveldownGetMany, resourceName));
 
-  state.readOptions.value_size_soft_limit = std::numeric_limits<int32_t>::max();
-  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "highWaterMarkBytes", state.readOptions.value_size_soft_limit));
+  struct State {
+    std::vector<rocksdb::Status> statuses;
+    std::vector<rocksdb::PinnableSlice> values;
+  };
 
-  runAsync(
-      std::move(state), "leveldown.get_many", env, callback,
-      [=](auto& state) {
-        std::vector<rocksdb::Slice> keys;
-        keys.reserve(count);
+  NAPI_STATUS_THROWS(runAsync<State>(
+      resourceName, env, callback,
+      [=, keys = std::move(keys), readOptions = std::move(readOptions)](auto& state) {
+        std::vector<rocksdb::Slice> keys2;
+        keys2.reserve(count);
         for (uint32_t n = 0; n < count; n++) {
-          keys.emplace_back(state.keys[n]);
+          keys2.emplace_back(keys[n]);
         }
 
         state.statuses.resize(count);
         state.values.resize(count);
 
-        database->db->MultiGet(state.readOptions, column, count, keys.data(), state.values.data(),
-                               state.statuses.data());
+        database->db->MultiGet(readOptions, column, count, keys2.data(), state.values.data(), state.statuses.data());
 
         return rocksdb::Status::OK();
       },
-      [=](auto& state, auto env, auto& argv) {
-        argv.resize(2);
-
-        NAPI_STATUS_RETURN(napi_create_array_with_length(env, count, &argv[1]));
+      [=](auto& state, napi_env env, napi_value* result) {
+        NAPI_STATUS_RETURN(napi_create_array_with_length(env, count, result));
 
         for (auto n = 0; n < count; n++) {
           napi_value row;
@@ -1515,11 +1568,11 @@ NAPI_METHOD(db_get_many) {
             ROCKS_STATUS_RETURN_NAPI(state.statuses[n]);
             NAPI_STATUS_RETURN(Convert(env, std::move(state.values[n]), valueEncoding, row, unsafe));
           }
-          NAPI_STATUS_RETURN(napi_set_element(env, argv[1], n, row));
+          NAPI_STATUS_RETURN(napi_set_element(env, *result, n, row));
         }
 
         return napi_ok;
-      });
+      }));
 
   return 0;
 }
@@ -1666,10 +1719,10 @@ NAPI_METHOD(db_flush_wal) {
 
   auto callback = argv[2];
 
-  struct State {};
-  runAsync<State>(
-      "leveldown.flush_wal", env, callback, [=](auto& state) { return database->db->FlushWAL(sync); },
-      [](auto& state, auto env, auto& argv) { return napi_ok; });
+  napi_value resourceName;
+  NAPI_STATUS_THROWS(database->GetResourceName(env, ResourceLeveldownFlushWal, resourceName));
+
+  NAPI_STATUS_THROWS(runAsync(resourceName, env, callback, [=](auto& state) { return database->db->FlushWAL(sync); }));
 
   return 0;
 }
@@ -1698,21 +1751,18 @@ NAPI_METHOD(iterator_seek) {
     Iterator* iterator;
     NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&iterator)));
 
-    struct State {
-      rocksdb::PinnableSlice target;
-    } state;
-
-    NAPI_STATUS_THROWS(GetValue(env, argv[1], state.target));
+    rocksdb::PinnableSlice target;
+    NAPI_STATUS_THROWS(GetValue(env, argv[1], target));
 
     auto callback = argv[2];
 
-    runAsync<State>(
-        std::move(state), "leveldown.iterator_seek", env, callback,
-        [=](auto& state) {
-          iterator->Seek(state.target);
-          return iterator->Status();
-        },
-        [](auto& state, auto env, auto& argv) { return napi_ok; });
+    napi_value resourceName;
+    NAPI_STATUS_THROWS(iterator->database_->GetResourceName(env, ResourceLeveldownIteratorSeek, resourceName));
+
+    NAPI_STATUS_THROWS(runAsync(resourceName, env, callback, [iterator, target = std::move(target)](auto& state) {
+      iterator->Seek(target);
+      return iterator->Status();
+    }));
   } catch (const std::exception& e) {
     napi_throw_error(env, nullptr, e.what());
     return nullptr;
@@ -1919,15 +1969,15 @@ NAPI_METHOD(batch_write) {
 
   auto callback = argv[3];
 
-  runAsync<std::nullptr_t>(
-      "leveldown.batch_write", env, callback,
-      [=](auto& state) {
-        rocksdb::WriteOptions writeOptions;
-        writeOptions.sync = sync;
-        writeOptions.low_pri = lowPriority;
-        return database->db->Write(writeOptions, batch);
-      },
-      [](auto& state, auto env, auto& argv) { return napi_ok; });
+  napi_value resourceName;
+  NAPI_STATUS_THROWS(database->GetResourceName(env, ResourceLeveldownBatchWrite, resourceName));
+
+  NAPI_STATUS_THROWS(runAsync(resourceName, env, callback, [=](auto& state) {
+    rocksdb::WriteOptions writeOptions;
+    writeOptions.sync = sync;
+    writeOptions.low_pri = lowPriority;
+    return database->db->Write(writeOptions, batch);
+  }));
 
   return 0;
 }
@@ -2036,9 +2086,6 @@ struct Updates : public BatchIterator, public Closable {
   Database* database_;
   int64_t start_;
   std::unique_ptr<rocksdb::TransactionLogIterator> iterator_;
-
- private:
-  napi_ref ref_ = nullptr;
 };
 
 NAPI_METHOD(updates_init) {
@@ -2088,41 +2135,52 @@ NAPI_METHOD(updates_init) {
 NAPI_METHOD(updates_next) {
   NAPI_ARGV(2);
 
-  try {
-    Updates* updates;
-    NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&updates)));
+  Updates* updates;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&updates)));
 
-    if (!updates->iterator_) {
-      rocksdb::TransactionLogIterator::ReadOptions options;
-      ROCKS_STATUS_THROWS_NAPI(updates->database_->db->GetUpdatesSince(updates->start_, &updates->iterator_, options));
-    }
+  auto callback = argv[1];
 
-    ROCKS_STATUS_THROWS_NAPI(updates->iterator_->status());
+  napi_value resourceName;
+  NAPI_STATUS_THROWS(updates->database_->GetResourceName(env, ResourceLeveldownUpdatesSince, resourceName));
 
-    if (!updates->iterator_->Valid()) {
-      return 0;
-    }
+  struct State {
+    rocksdb::BatchResult batchResult;
+  };
+
+  NAPI_STATUS_THROWS(runAsync<State>(
+      resourceName, env, callback,
+      [updates](auto& state) {
+        if (!updates->iterator_) {
+          rocksdb::TransactionLogIterator::ReadOptions options;
+          ROCKS_STATUS_RETURN(updates->database_->db->GetUpdatesSince(updates->start_, &updates->iterator_, options));
+        } else {
+          updates->iterator_->Next();
+          ROCKS_STATUS_RETURN(updates->iterator_->status());
+        }
 
-    auto batchResult = updates->iterator_->GetBatch();
+        if (updates->iterator_->Valid()) {
+          state.batchResult = updates->iterator_->GetBatch();
+        }
 
-    napi_value rows;
-    napi_value sequence;
+        return rocksdb::Status::OK();
+      },
+      [updates](auto& state, napi_env env, napi_value* result) {
+        if (state.batchResult.writeBatchPtr != nullptr) {
+          napi_value rows;
+          napi_value sequence;
 
-    NAPI_STATUS_THROWS(updates->Iterate(env, *batchResult.writeBatchPtr, &rows));
-    NAPI_STATUS_THROWS(napi_create_int64(env, batchResult.sequence, &sequence));
+          NAPI_STATUS_RETURN(updates->Iterate(env, *state.batchResult.writeBatchPtr, &rows));
+          NAPI_STATUS_RETURN(napi_create_int64(env, state.batchResult.sequence, &sequence));
 
-    ROCKS_STATUS_THROWS_NAPI(updates->iterator_->status());
-    updates->iterator_->Next();
+          NAPI_STATUS_RETURN(napi_create_object(env, result));
+          NAPI_STATUS_RETURN(napi_set_named_property(env, *result, "rows", rows));
+          NAPI_STATUS_RETURN(napi_set_named_property(env, *result, "seq", sequence));
+        }
 
-    napi_value ret;
-    NAPI_STATUS_THROWS(napi_create_object(env, &ret));
-    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "rows", rows));
-    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "seq", sequence));
-    return ret;
-  } catch (const std::exception& e) {
-    napi_throw_error(env, nullptr, e.what());
-    return nullptr;
-  }
+        return napi_ok;
+      }));
+
+  return 0;
 }
 
 NAPI_METHOD(updates_close) {
@@ -2176,17 +2234,17 @@ NAPI_METHOD(db_compact_range) {
 
   auto callback = argv[2];
 
-  runAsync<std::nullptr_t>(
-      "leveldown.compact_range", env, callback,
-      [=](auto& state) {
-        rocksdb::CompactRangeOptions options;
+  napi_value resourceName;
+  NAPI_STATUS_THROWS(database->GetResourceName(env, ResourceLeveldownCompactRange, resourceName));
 
-        auto begin = start ? std::make_unique<rocksdb::Slice>(*start) : nullptr;
-        auto finish = end ? std::make_unique<rocksdb::Slice>(*end) : nullptr;
+  NAPI_STATUS_THROWS(runAsync(resourceName, env, callback, [=](auto& state) {
+    rocksdb::CompactRangeOptions options;
 
-        return database->db->CompactRange(options, begin.get(), finish.get());
-      },
-      [](auto& state, auto env, auto& argv) { return napi_ok; });
+    auto begin = start ? std::make_unique<rocksdb::Slice>(*start) : nullptr;
+    auto finish = end ? std::make_unique<rocksdb::Slice>(*end) : nullptr;
+
+    return database->db->CompactRange(options, begin.get(), finish.get());
+  }));
 
   return 0;
 }