@nxtedition/rocksdb 7.0.62 → 7.0.65

package/binding.cc

@@ -12,11 +12,12 @@
 #include <rocksdb/filter_policy.h>
 #include <rocksdb/merge_operator.h>
 #include <rocksdb/options.h>
+#include <rocksdb/slice.h>
 #include <rocksdb/slice_transform.h>
+#include <rocksdb/status.h>
 #include <rocksdb/table.h>
 #include <rocksdb/write_batch.h>
 
-#include <array>
 #include <memory>
 #include <optional>
 #include <set>
@@ -25,6 +26,7 @@
 #include <vector>
 
 #include "max_rev_operator.h"
+#include "util.h"
 
 class NullLogger : public rocksdb::Logger {
  public:
@@ -37,298 +39,6 @@ struct Database;
 struct Iterator;
 struct Updates;
 
-#define NAPI_STATUS_RETURN(call) \
-  {                              \
-    auto _status = (call);       \
-    if (_status != napi_ok) {    \
-      return _status;            \
-    }                            \
-  }
-
-#define ROCKS_STATUS_RETURN(call) \
-  {                               \
-    auto _status = (call);        \
-    if (!_status.ok()) {          \
-      return _status;             \
-    }                             \
-  }
-
-#define ROCKS_STATUS_THROWS(call)             \
-  {                                           \
-    auto _status = (call);                    \
-    if (!_status.ok()) {                      \
-      napi_throw(env, ToError(env, _status)); \
-      return NULL;                            \
-    }                                         \
-  }
-
-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) {
-    NAPI_STATUS_THROWS(napi_create_string_utf8(env, code->data(), code->size(), &codeValue));
-  }
-  napi_value msgValue;
-  NAPI_STATUS_THROWS(napi_create_string_utf8(env, msg.data(), msg.size(), &msgValue));
-  napi_value error;
-  NAPI_STATUS_THROWS(napi_create_error(env, codeValue, msgValue, &error));
-  return error;
-}
-
-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) {
-  napi_value value = nullptr;
-  napi_get_named_property(env, obj, key.data(), &value);
-  return value;
-}
-
-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;
-    napi_get_value_bool(env, value, &result);
-    return result;
-  }
-
-  return {};
-}
-
-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) {
-    // Value is either "buffer" or "utf8" so we can tell them apart just by size
-    return size == 6;
-  }
-
-  return false;
-}
-
-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;
-    napi_get_value_uint32(env, value, &result);
-    return result;
-  }
-
-  return {};
-}
-
-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;
-    napi_get_value_int32(env, value, &result);
-    return result;
-  }
-
-  return {};
-}
-
-static napi_status ToString(napi_env env, napi_value from, std::string& to) {
-  napi_valuetype type;
-  NAPI_STATUS_RETURN(napi_typeof(env, from, &type));
-
-  if (type == napi_string) {
-    size_t length = 0;
-    NAPI_STATUS_RETURN(napi_get_value_string_utf8(env, from, nullptr, 0, &length));
-    to.resize(length, '\0');
-    NAPI_STATUS_RETURN(napi_get_value_string_utf8(env, from, &to[0], length + 1, &length));
-  } else {
-    bool isBuffer;
-    NAPI_STATUS_RETURN(napi_is_buffer(env, from, &isBuffer));
-
-    if (isBuffer) {
-      char* buf = nullptr;
-      size_t length = 0;
-      NAPI_STATUS_RETURN(napi_get_buffer_info(env, from, reinterpret_cast<void**>(&buf), &length));
-      to.assign(buf, length);
-    } else {
-      return napi_invalid_arg;
-    }
-  }
-
-  return napi_ok;
-}
-
-void noop(void* arg1, void* arg2) {}
-
-// TODO (fix): Should use rocksdb::Slice since "to" cannot outlive "from".
-static napi_status ToString(napi_env env, napi_value from, rocksdb::PinnableSlice& to) {
-  napi_valuetype type;
-  NAPI_STATUS_RETURN(napi_typeof(env, from, &type));
-
-  if (type == napi_string) {
-    size_t length = 0;
-    NAPI_STATUS_RETURN(napi_get_value_string_utf8(env, from, nullptr, 0, &length));
-    to.GetSelf()->resize(length, '\0');
-    NAPI_STATUS_RETURN(napi_get_value_string_utf8(env, from, &(*to.GetSelf())[0], length + 1, &length));
-    to.PinSelf();
-  } else {
-    bool isBuffer;
-    NAPI_STATUS_RETURN(napi_is_buffer(env, from, &isBuffer));
-
-    if (isBuffer) {
-      char* buf = nullptr;
-      size_t length = 0;
-      NAPI_STATUS_RETURN(napi_get_buffer_info(env, from, reinterpret_cast<void**>(&buf), &length));
-
-      // TODO (fix): Should extend life of "from". Or "to" should be a non-pinnable slice.
-      to.PinSlice(rocksdb::Slice(buf, length), noop, nullptr, nullptr);
-    } else {
-      return napi_invalid_arg;
-    }
-  }
-
-  return napi_ok;
-}
-
-static std::optional<std::string> StringProperty(napi_env env, napi_value opts, const std::string_view& name) {
-  if (HasProperty(env, opts, name)) {
-    const auto property = GetProperty(env, opts, name);
-    std::string value;
-    ToString(env, property, value);
-    return value;
-  }
-  return {};
-}
-
-static napi_status CallFunction(napi_env env, napi_value callback, const int argc, napi_value* argv) {
-  napi_value global;
-
-  NAPI_STATUS_RETURN(napi_get_global(env, &global));
-  NAPI_STATUS_RETURN(napi_call_function(env, global, callback, argc, argv, nullptr));
-
-  return napi_ok;
-}
-
-static napi_value ToError(napi_env env, const rocksdb::Status& status) {
-  if (status.ok()) {
-    return 0;
-  }
-
-  const auto msg = status.ToString();
-
-  if (status.IsNotFound()) {
-    return CreateError(env, "LEVEL_NOT_FOUND", msg);
-  } else if (status.IsCorruption()) {
-    return CreateError(env, "LEVEL_CORRUPTION", msg);
-  } else if (status.IsTryAgain()) {
-    return CreateError(env, "LEVEL_TRYAGAIN", msg);
-  } else if (status.IsIOError()) {
-    if (msg.find("IO error: lock ") != std::string::npos) {  // env_posix.cc
-      return CreateError(env, "LEVEL_LOCKED", msg);
-    } else if (msg.find("IO error: LockFile ") != std::string::npos) {  // env_win.cc
-      return CreateError(env, "LEVEL_LOCKED", msg);
-    } else if (msg.find("IO error: While lock file") != std::string::npos) {  // env_mac.cc
-      return CreateError(env, "LEVEL_LOCKED", msg);
-    } else {
-      return CreateError(env, "LEVEL_IO_ERROR", msg);
-    }
-  }
-
-  return CreateError(env, {}, msg);
-}
-
-template <typename T>
-static void Finalize(napi_env env, void* data, void* hint) {
-  if (hint) {
-    delete reinterpret_cast<T*>(hint);
-  }
-}
-
-template <typename T>
-napi_status Convert(napi_env env, T&& s, bool asBuffer, napi_value& result) {
-  if (!s) {
-    return napi_get_null(env, &result);
-  } else if (asBuffer) {
-    using Y = typename std::decay<decltype(*s)>::type;
-    auto ptr = new Y(std::move(*s));
-    return napi_create_external_buffer(env, ptr->size(), const_cast<char*>(ptr->data()), Finalize<Y>, ptr, &result);
-  } else {
-    return napi_create_string_utf8(env, s->data(), s->size(), &result);
-  }
-}
-
-/**
- * Base worker class. Handles the async work. Derived classes can override the
- * following virtual methods (listed in the order in which they're called):
- *
- * - Execute (abstract, worker pool thread): main work
- * - OnOk (main thread): call JS callback on success
- * - OnError (main thread): call JS callback on error
- * - Destroy (main thread): do cleanup regardless of success
- */
-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(), resourceName.size(), &asyncResourceName));
-    NAPI_STATUS_THROWS_VOID(
-        napi_create_async_work(env, callback, asyncResourceName, Worker::Execute, Worker::Complete, this, &asyncWork_));
-  }
-
-  virtual ~Worker() {}
-
-  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<Worker*>(data);
-
-    // TODO (fix): napi status handling...
-
-    napi_value callback;
-    napi_get_reference_value(env, self->callbackRef_, &callback);
-
-    if (self->status_.ok()) {
-      self->OnOk(env, callback);
-    } else {
-      self->OnError(env, callback, ToError(env, self->status_));
-    }
-
-    self->Destroy(env);
-
-    napi_delete_reference(env, self->callbackRef_);
-    napi_delete_async_work(env, self->asyncWork_);
-
-    delete self;
-  }
-
-  virtual rocksdb::Status Execute(Database& database) = 0;
-
-  virtual napi_status OnOk(napi_env env, napi_value callback) {
-    napi_value argv[1];
-    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
-
-    return CallFunction(env, callback, 1, &argv[0]);
-  }
-
-  virtual napi_status OnError(napi_env env, napi_value callback, napi_value err) {
-    return CallFunction(env, callback, 1, &err);
-  }
-
-  virtual void Destroy(napi_env env) {}
-
-  void Queue(napi_env env) { napi_queue_async_work(env, asyncWork_); }
-
-  Database* database_;
-
- private:
-  napi_ref callbackRef_;
-  napi_async_work asyncWork_;
-  rocksdb::Status status_;
-};
-
 struct ColumnFamily {
   napi_ref ref;
   napi_value val;
@@ -336,81 +46,69 @@ struct ColumnFamily {
   rocksdb::ColumnFamilyDescriptor descriptor;
 };
 
-struct Database {
-  void AttachIterator(napi_env env, Iterator* iterator) {
-    iterators_.insert(iterator);
-    IncrementPriorityWork(env);
-  }
-
-  void DetachIterator(napi_env env, Iterator* iterator) {
-    iterators_.erase(iterator);
-    DecrementPriorityWork(env);
-  }
-
-  void AttachUpdates(napi_env env, Updates* update) {
-    updates_.insert(update);
-    IncrementPriorityWork(env);
-  }
+struct Closable {
+  virtual ~Closable() {}
+  virtual rocksdb::Status Close() = 0;
+};
 
-  void DetachUpdates(napi_env env, Updates* update) {
-    updates_.erase(update);
-    DecrementPriorityWork(env);
-  }
+struct Database final {
+  ~Database() { assert(!db); }
 
-  void IncrementPriorityWork(napi_env env) { napi_reference_ref(env, priorityRef_, &priorityWork_); }
+  rocksdb::Status Close() {
+    if (!db) {
+      return rocksdb::Status::OK();
+    }
 
-  void DecrementPriorityWork(napi_env env) {
-    napi_reference_unref(env, priorityRef_, &priorityWork_);
+    for (auto closable : closables) {
+      closable->Close();
+    }
+    closables.clear();
 
-    if (priorityWork_ == 0 && pendingCloseWorker_) {
-      pendingCloseWorker_->Queue(env);
-      pendingCloseWorker_ = nullptr;
+    for (auto& [id, column] : columns) {
+      db->DestroyColumnFamilyHandle(column.handle);
     }
-  }
+    columns.clear();
 
-  bool HasPriorityWork() const { return priorityWork_ > 0; }
+    db->FlushWAL(true);
 
-  std::unique_ptr<rocksdb::DB> db_;
-  Worker* pendingCloseWorker_;
-  std::set<Iterator*> iterators_;
-  std::set<Updates*> updates_;
-  std::map<int32_t, ColumnFamily> columns_;
-  napi_ref priorityRef_;
+    auto db2 = std::move(db);
+    return db2->Close();
+  }
 
- private:
-  uint32_t priorityWork_ = 0;
+  std::unique_ptr<rocksdb::DB> db;
+  std::set<Closable*> closables;
+  std::map<int32_t, ColumnFamily> columns;
 };
 
 enum BatchOp { Empty, Put, Delete, Merge, Data };
 
 struct BatchEntry {
   BatchOp op = BatchOp::Empty;
-  std::optional<std::string> key;
-  std::optional<std::string> val;
-  std::optional<ColumnFamily> column;
+  std::optional<std::string> key = std::nullopt;
+  std::optional<std::string> val = std::nullopt;
+  std::optional<ColumnFamily> column = std::nullopt;
 };
 
 struct BatchIterator : public rocksdb::WriteBatch::Handler {
   BatchIterator(Database* database,
-                bool keys = true,
-                bool values = true,
-                bool data = true,
-                const rocksdb::ColumnFamilyHandle* column = nullptr,
-                bool keyAsBuffer = false,
-                bool valueAsBuffer = false)
+                const bool keys,
+                const bool values,
+                const bool data,
+                const rocksdb::ColumnFamilyHandle* column,
+                const Encoding keyEncoding,
+                const Encoding valueEncoding)
       : database_(database),
         keys_(keys),
         values_(values),
         data_(data),
         column_(column),
-        keyAsBuffer_(keyAsBuffer),
-        valueAsBuffer_(valueAsBuffer) {}
+        keyEncoding_(keyEncoding),
+        valueEncoding_(valueEncoding) {}
 
   napi_status Iterate(napi_env env, const rocksdb::WriteBatch& batch, napi_value* result) {
-    cache_.clear();
     cache_.reserve(batch.Count());
 
-    batch.Iterate(this);  // TODO (fix): Handle error?
+    ROCKS_STATUS_RETURN_NAPI(batch.Iterate(this));
 
     napi_value putStr;
     NAPI_STATUS_RETURN(napi_create_string_utf8(env, "put", NAPI_AUTO_LENGTH, &putStr));
@@ -445,11 +143,11 @@ struct BatchIterator : public rocksdb::WriteBatch::Handler {
       NAPI_STATUS_RETURN(napi_set_element(env, *result, n * 4 + 0, op));
 
       napi_value key;
-      NAPI_STATUS_RETURN(Convert(env, cache_[n].key, keyAsBuffer_, key));
+      NAPI_STATUS_RETURN(Convert(env, cache_[n].key, keyEncoding_, key));
       NAPI_STATUS_RETURN(napi_set_element(env, *result, n * 4 + 1, key));
 
       napi_value val;
-      NAPI_STATUS_RETURN(Convert(env, cache_[n].val, valueAsBuffer_, val));
+      NAPI_STATUS_RETURN(Convert(env, cache_[n].val, valueEncoding_, val));
       NAPI_STATUS_RETURN(napi_set_element(env, *result, n * 4 + 2, val));
 
       // TODO (fix)
@@ -457,6 +155,8 @@ struct BatchIterator : public rocksdb::WriteBatch::Handler {
       NAPI_STATUS_RETURN(napi_set_element(env, *result, n * 4 + 3, nullVal));
     }
 
+    cache_.clear();
+
     return napi_ok;
   }
 
@@ -465,9 +165,7 @@ struct BatchIterator : public rocksdb::WriteBatch::Handler {
       return rocksdb::Status::OK();
     }
 
-    BatchEntry entry;
-
-    entry.op = BatchOp::Put;
+    BatchEntry entry = {BatchOp::Put};
 
     if (keys_) {
       entry.key = key.ToStringView();
@@ -477,8 +175,8 @@ struct BatchIterator : public rocksdb::WriteBatch::Handler {
       entry.val = value.ToStringView();
     }
 
-    // if (database_ && database_->columns_.find(column_family_id) != database_->columns_.end()) {
-    //   entry.column = database_->columns_[column_family_id];
+    // if (database_ && database_->columns.find(column_family_id) != database_->columns.end()) {
+    //   entry.column = database_->columns[column_family_id];
     // }
 
     cache_.push_back(entry);
@@ -491,16 +189,14 @@ struct BatchIterator : public rocksdb::WriteBatch::Handler {
       return rocksdb::Status::OK();
     }
 
-    BatchEntry entry;
-
-    entry.op = BatchOp::Delete;
+    BatchEntry entry = {BatchOp::Delete};
 
     if (keys_) {
       entry.key = key.ToStringView();
     }
 
-    // if (database_ && database_->columns_.find(column_family_id) != database_->columns_.end()) {
-    //   entry.column = database_->columns_[column_family_id];
+    // if (database_ && database_->columns.find(column_family_id) != database_->columns.end()) {
+    //   entry.column = database_->columns[column_family_id];
     // }
 
     cache_.push_back(entry);
@@ -513,9 +209,7 @@ struct BatchIterator : public rocksdb::WriteBatch::Handler {
       return rocksdb::Status::OK();
     }
 
-    BatchEntry entry;
-
-    entry.op = BatchOp::Merge;
+    BatchEntry entry = {BatchOp::Merge};
 
     if (keys_) {
       entry.key = key.ToStringView();
@@ -525,8 +219,8 @@ struct BatchIterator : public rocksdb::WriteBatch::Handler {
       entry.val = value.ToStringView();
     }
 
-    // if (database_ && database_->columns_.find(column_family_id) != database_->columns_.end()) {
-    //   entry.column = database_->columns_[column_family_id];
+    // if (database_ && database_->columns.find(column_family_id) != database_->columns.end()) {
+    //   entry.column = database_->columns[column_family_id];
     // }
 
     cache_.push_back(entry);
@@ -539,9 +233,7 @@ struct BatchIterator : public rocksdb::WriteBatch::Handler {
       return;
     }
 
-    BatchEntry entry;
-
-    entry.op = BatchOp::Data;
+    BatchEntry entry = {BatchOp::Data};
 
     entry.val = data.ToStringView();
 
@@ -552,40 +244,47 @@ struct BatchIterator : public rocksdb::WriteBatch::Handler {
 
  private:
   Database* database_;
-  bool keys_;
-  bool values_;
-  bool data_;
+  const bool keys_;
+  const bool values_;
+  const bool data_;
   const rocksdb::ColumnFamilyHandle* column_;
-  bool keyAsBuffer_;
-  bool valueAsBuffer_;
+  const Encoding keyEncoding_;
+  const Encoding valueEncoding_;
   std::vector<BatchEntry> cache_;
 };
 
-struct Updates : public BatchIterator {
+struct Updates : public BatchIterator, public Closable {
   Updates(Database* database,
-          int64_t seqNumber,
-          bool keys,
-          bool values,
-          bool data,
+          const int64_t seqNumber,
+          const bool keys,
+          const bool values,
+          const bool data,
           const rocksdb::ColumnFamilyHandle* column,
-          bool keyAsBuffer,
-          bool valueAsBuffer)
-      : BatchIterator(database, keys, values, data, column, keyAsBuffer, valueAsBuffer),
+          const Encoding keyEncoding,
+          const Encoding valueEncoding)
+      : BatchIterator(database, keys, values, data, column, keyEncoding, valueEncoding),
         database_(database),
         start_(seqNumber) {}
 
-  void Close() { iterator_.reset(); }
+  virtual ~Updates() { assert(!iterator_); }
 
-  void Attach(napi_env env, napi_value context) {
-    napi_create_reference(env, context, 1, &ref_);
-    database_->AttachUpdates(env, this);
+  rocksdb::Status Close() override {
+    iterator_.reset();
+    return rocksdb::Status::OK();
+  }
+
+  napi_status Attach(napi_env env, napi_value context) {
+    NAPI_STATUS_RETURN(napi_create_reference(env, context, 1, &ref_));
+    database_->closables.insert(this);
+    return napi_ok;
   }
 
-  void Detach(napi_env env) {
-    database_->DetachUpdates(env, this);
+  napi_status Detach(napi_env env) {
+    database_->closables.erase(this);
     if (ref_) {
-      napi_delete_reference(env, ref_);
+      NAPI_STATUS_RETURN(napi_delete_reference(env, ref_));
     }
+    return napi_ok;
   }
 
   Database* database_;
@@ -596,7 +295,7 @@ struct Updates : public BatchIterator {
   napi_ref ref_ = nullptr;
 };
 
-struct BaseIterator {
+struct BaseIterator : public Closable {
   BaseIterator(Database* database,
                rocksdb::ColumnFamilyHandle* column,
                const bool reverse,
@@ -669,9 +368,10 @@ struct BaseIterator {
     }
   }
 
-  void Close() {
+  rocksdb::Status Close() override {
     snapshot_.reset();
     iterator_.reset();
+    return rocksdb::Status::OK();
   }
 
   bool Valid() const {
@@ -726,7 +426,7 @@ struct BaseIterator {
     readOptions.async_io = true;
     readOptions.adaptive_readahead = true;
 
-    iterator_.reset(database_->db_->NewIterator(readOptions, column_));
+    iterator_.reset(database_->db->NewIterator(readOptions, column_));
   }
 
   int count_ = 0;
@@ -750,33 +450,35 @@ struct Iterator final : public BaseIterator {
            const std::optional<std::string>& gt,
            const std::optional<std::string>& gte,
            const bool fillCache,
-           const bool keyAsBuffer,
-           const bool valueAsBuffer,
+           const Encoding keyEncoding,
+           const Encoding valueEncoding,
            const size_t highWaterMarkBytes,
            std::shared_ptr<const rocksdb::Snapshot> snapshot)
       : BaseIterator(database, column, reverse, lt, lte, gt, gte, limit, fillCache, snapshot),
         keys_(keys),
         values_(values),
-        keyAsBuffer_(keyAsBuffer),
-        valueAsBuffer_(valueAsBuffer),
+        keyEncoding_(keyEncoding),
+        valueEncoding_(valueEncoding),
         highWaterMarkBytes_(highWaterMarkBytes) {}
 
-  void Attach(napi_env env, napi_value context) {
-    napi_create_reference(env, context, 1, &ref_);
-    database_->AttachIterator(env, this);
+  napi_status Attach(napi_env env, napi_value context) {
+    NAPI_STATUS_RETURN(napi_create_reference(env, context, 1, &ref_));
+    database_->closables.insert(this);
+    return napi_ok;
   }
 
-  void Detach(napi_env env) {
-    database_->DetachIterator(env, this);
+  napi_status Detach(napi_env env) {
+    database_->closables.erase(this);
     if (ref_) {
-      napi_delete_reference(env, ref_);
+      NAPI_STATUS_RETURN(napi_delete_reference(env, ref_));
     }
+    return napi_ok;
   }
 
   const bool keys_;
   const bool values_;
-  const bool keyAsBuffer_;
-  const bool valueAsBuffer_;
+  const Encoding keyEncoding_;
+  const Encoding valueEncoding_;
   const size_t highWaterMarkBytes_;
   bool first_ = true;
 
@@ -784,152 +486,20 @@ struct Iterator final : public BaseIterator {
   napi_ref ref_ = nullptr;
 };
 
-static napi_status GetColumnFamily(Database* database,
-                                   napi_env env,
-                                   napi_value options,
-                                   rocksdb::ColumnFamilyHandle** column) {
-  bool hasColumn = false;
-  NAPI_STATUS_RETURN(napi_has_named_property(env, options, "column", &hasColumn));
-
-  if (hasColumn) {
-    napi_value value = nullptr;
-    NAPI_STATUS_RETURN(napi_get_named_property(env, options, "column", &value));
-
-    bool nully = false;
-
-    napi_value nullVal;
-    NAPI_STATUS_RETURN(napi_get_null(env, &nullVal));
-    NAPI_STATUS_RETURN(napi_strict_equals(env, nullVal, value, &nully));
-    if (nully) {
-      *column = nullptr;
-      return napi_ok;
-    }
-
-    napi_value undefinedVal;
-    NAPI_STATUS_RETURN(napi_get_undefined(env, &undefinedVal));
-    NAPI_STATUS_RETURN(napi_strict_equals(env, undefinedVal, value, &nully));
-    if (nully) {
-      *column = nullptr;
-      return napi_ok;
-    }
-
-    NAPI_STATUS_RETURN(napi_get_value_external(env, value, reinterpret_cast<void**>(column)));
-  } else if (database) {
-    *column = database->db_->DefaultColumnFamily();
-  } else {
-    *column = nullptr;
-  }
-
-  return napi_ok;
-}
-
-template <typename State,
-          typename ExecuteType = std::function<rocksdb::Status(State& state, Database& database)>,
-          typename OnOkType = std::function<napi_status(State& state, napi_env env, napi_value callback)>>
-struct GenericWorker final : public Worker {
-  template <typename T1, typename T2>
-  GenericWorker(const std::string& name,
-                napi_env env,
-                napi_value callback,
-                Database* database,
-                bool priority,
-                T1&& execute,
-                T2&& onOK)
-      : Worker(env, database, callback, name),
-        priority_(priority),
-        execute_(std::forward<T1>(execute)),
-        onOk_(std::forward<T2>(onOK)) {
-    if (priority_) {
-      database_->IncrementPriorityWork(env);
-    }
-  }
-
-  rocksdb::Status Execute(Database& database) override { return execute_(state_, database); }
-
-  napi_status OnOk(napi_env env, napi_value callback) override { return onOk_(state_, env, callback); }
-
-  void Destroy(napi_env env) override {
-    if (priority_) {
-      database_->DecrementPriorityWork(env);
-    }
-    Worker::Destroy(env);
-  }
-
- private:
-  State state_;
-  bool priority_ = false;
-  ExecuteType execute_;
-  OnOkType onOk_;
-};
-
-template <typename State, typename T1, typename T2>
-Worker* createWorker(const std::string& name,
-                     napi_env env,
-                     napi_value callback,
-                     Database* database,
-                     bool priority,
-                     T1&& execute,
-                     T2&& onOk) {
-  return new GenericWorker<State, typename std::decay<T1>::type, typename std::decay<T2>::type>(
-      name, env, callback, database, priority, std::forward<T1>(execute), std::forward<T2>(onOk));
-}
-
-template <typename State, typename T1, typename T2>
-void runWorker(const std::string& name,
-               napi_env env,
-               napi_value callback,
-               Database* database,
-               bool priority,
-               T1&& execute,
-               T2&& onOk) {
-  auto worker = new GenericWorker<State, typename std::decay<T1>::type, typename std::decay<T2>::type>(
-      name, env, callback, database, priority, std::forward<T1>(execute), std::forward<T2>(onOk));
-  worker->Queue(env);
-}
-
-/**
- * Hook for when the environment exits. This hook will be called after
- * 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) {
   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().
-  if (database && database->db_) {
-    for (auto& it : database->iterators_) {
-      // TODO: does not do `napi_delete_reference`. Problem?
-      it->Close();
-    }
-
-    for (auto& it : database->updates_) {
-      // TODO: does not do `napi_delete_reference`. Problem?
-      it->Close();
-    }
-
-    for (auto& it : database->columns_) {
-      database->db_->DestroyColumnFamilyHandle(it.second.handle);
-    }
-
-    // Having closed the iterators (and released snapshots) we can safely close.
-    database->db_->Close();
+  if (database) {
+    database->Close();
   }
 }
 
 static void FinalizeDatabase(napi_env env, void* data, void* hint) {
   if (data) {
     auto database = reinterpret_cast<Database*>(data);
+    database->Close();
     napi_remove_env_cleanup_hook(env, env_cleanup_hook, database);
-    if (database->priorityRef_)
-      napi_delete_reference(env, database->priorityRef_);
-    for (auto& it : database->columns_) {
-      napi_delete_reference(env, it.second.ref);
+    for (auto& [id, column] : database->columns) {
+      napi_delete_reference(env, column.ref);
     }
     delete database;
   }
@@ -942,94 +512,109 @@ NAPI_METHOD(db_init) {
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, database, FinalizeDatabase, nullptr, &result));
 
-  NAPI_STATUS_THROWS(napi_create_reference(env, result, 0, &database->priorityRef_));
-
   return result;
 }
 
 template <typename T, typename U>
-rocksdb::Status InitOptions(napi_env env, T& columnOptions, const U& options) {
+napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
   rocksdb::ConfigOptions configOptions;
 
-  const auto memtable_memory_budget = Uint32Property(env, options, "memtableMemoryBudget").value_or(256 * 1024 * 1024);
-
-  const auto compaction = StringProperty(env, options, "compaction").value_or("level");
-
-  if (compaction == "universal") {
-    columnOptions.write_buffer_size = static_cast<size_t>(memtable_memory_budget / 4);
-    // merge two memtables when flushing to L0
-    columnOptions.min_write_buffer_number_to_merge = 2;
-    // this means we'll use 50% extra memory in the worst case, but will reduce
-    // write stalls.
-    columnOptions.max_write_buffer_number = 6;
-    // universal style compaction
-    columnOptions.compaction_style = rocksdb::kCompactionStyleUniversal;
-    columnOptions.compaction_options_universal.compression_size_percent = 80;
-  } else {
-    // merge two memtables when flushing to L0
-    columnOptions.min_write_buffer_number_to_merge = 2;
-    // this means we'll use 50% extra memory in the worst case, but will reduce
-    // write stalls.
-    columnOptions.max_write_buffer_number = 6;
-    // start flushing L0->L1 as soon as possible. each file on level0 is
-    // (memtable_memory_budget / 2). This will flush level 0 when it's bigger than
-    // memtable_memory_budget.
-    columnOptions.level0_file_num_compaction_trigger = 2;
-    // doesn't really matter much, but we don't want to create too many files
-    columnOptions.target_file_size_base = memtable_memory_budget / 8;
-    // make Level1 size equal to Level0 size, so that L0->L1 compactions are fast
-    columnOptions.max_bytes_for_level_base = memtable_memory_budget;
-
-    // level style compaction
-    columnOptions.compaction_style = rocksdb::kCompactionStyleLevel;
-
-    // TODO (perf): only compress levels >= 2
+  uint64_t memtable_memory_budget = 256 * 1024 * 1024;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "memtableMemoryBudget", memtable_memory_budget));
+
+  std::optional<std::string> compactionOpt;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "compaction", compactionOpt));
+  if (compactionOpt) {
+    if (*compactionOpt == "universal") {
+      columnOptions.write_buffer_size = memtable_memory_budget / 4;
+      // merge two memtables when flushing to L0
+      columnOptions.min_write_buffer_number_to_merge = 2;
+      // this means we'll use 50% extra memory in the worst case, but will reduce
+      // write stalls.
+      columnOptions.max_write_buffer_number = 6;
+      // universal style compaction
+      columnOptions.compaction_style = rocksdb::kCompactionStyleUniversal;
+      columnOptions.compaction_options_universal.compression_size_percent = 80;
+    } else if (*compactionOpt == "level") {
+      // merge two memtables when flushing to L0
+      columnOptions.min_write_buffer_number_to_merge = 2;
+      // this means we'll use 50% extra memory in the worst case, but will reduce
+      // write stalls.
+      columnOptions.max_write_buffer_number = 6;
+      // start flushing L0->L1 as soon as possible. each file on level0 is
+      // (memtable_memory_budget / 2). This will flush level 0 when it's bigger than
+      // memtable_memory_budget.
+      columnOptions.level0_file_num_compaction_trigger = 2;
+      // doesn't really matter much, but we don't want to create too many files
+      columnOptions.target_file_size_base = memtable_memory_budget / 8;
+      // make Level1 size equal to Level0 size, so that L0->L1 compactions are fast
+      columnOptions.max_bytes_for_level_base = memtable_memory_budget;
+
+      // level style compaction
+      columnOptions.compaction_style = rocksdb::kCompactionStyleLevel;
+
+      // only compress levels >= 2
+      columnOptions.compression_per_level.resize(columnOptions.num_levels);
+      for (int i = 0; i < columnOptions.num_levels; ++i) {
+        if (i < 2) {
+          columnOptions.compression_per_level[i] = rocksdb::kNoCompression;
+        } else {
+          columnOptions.compression_per_level[i] = rocksdb::kZSTD;
+        }
+      }
+    } else {
+      return napi_invalid_arg;
+    }
   }
 
-  columnOptions.compression =
-      BooleanProperty(env, options, "compression").value_or((true)) ? rocksdb::kZSTD : rocksdb::kNoCompression;
-  if (columnOptions.compression == rocksdb::kZSTD) {
+  bool compression = true;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "compression", compression));
+
+  if (compression) {
+    columnOptions.compression = rocksdb::kZSTD;
     columnOptions.compression_opts.max_dict_bytes = 16 * 1024;
     columnOptions.compression_opts.zstd_max_train_bytes = 16 * 1024 * 100;
     // TODO (perf): compression_opts.parallel_threads
   }
 
-  const auto prefixExtractorOpt = StringProperty(env, options, "prefixExtractor");
+  std::optional<std::string> prefixExtractorOpt;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "prefixExtractor", prefixExtractorOpt));
   if (prefixExtractorOpt) {
-    ROCKS_STATUS_RETURN(
+    ROCKS_STATUS_RETURN_NAPI(
         rocksdb::SliceTransform::CreateFromString(configOptions, *prefixExtractorOpt, &columnOptions.prefix_extractor));
   }
 
-  const auto comparatorOpt = StringProperty(env, options, "comparator");
+  std::optional<std::string> comparatorOpt;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "comparator", comparatorOpt));
   if (comparatorOpt) {
-    ROCKS_STATUS_RETURN(
+    ROCKS_STATUS_RETURN_NAPI(
         rocksdb::Comparator::CreateFromString(configOptions, *comparatorOpt, &columnOptions.comparator));
   }
 
-  const auto mergeOperatorOpt = StringProperty(env, options, "mergeOperator");
+  std::optional<std::string> mergeOperatorOpt;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "mergeOperator", mergeOperatorOpt));
   if (mergeOperatorOpt) {
-    if (*mergeOperatorOpt == "maxRev") {
-      columnOptions.merge_operator = std::make_shared<MaxRevOperator>();
-    } else {
-      ROCKS_STATUS_RETURN(
-          rocksdb::MergeOperator::CreateFromString(configOptions, *mergeOperatorOpt, &columnOptions.merge_operator));
-    }
+    ROCKS_STATUS_RETURN_NAPI(
+        rocksdb::MergeOperator::CreateFromString(configOptions, *mergeOperatorOpt, &columnOptions.merge_operator));
   }
 
-  const auto cacheSize = Uint32Property(env, options, "cacheSize").value_or(8 << 20);
+  uint32_t cacheSize = 8 << 20;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "cacheSize", cacheSize));
 
   rocksdb::BlockBasedTableOptions tableOptions;
 
   if (cacheSize) {
     tableOptions.block_cache = rocksdb::NewLRUCache(cacheSize);
-    tableOptions.cache_index_and_filter_blocks =
-        BooleanProperty(env, options, "cacheIndexAndFilterBlocks").value_or(true);
+    tableOptions.cache_index_and_filter_blocks = true;
+    NAPI_STATUS_RETURN(
+        GetProperty(env, options, "cacheIndexAndFilterBlocks", tableOptions.cache_index_and_filter_blocks));
   } else {
     tableOptions.no_block_cache = true;
     tableOptions.cache_index_and_filter_blocks = false;
   }
 
-  const auto optimize = StringProperty(env, options, "optimize").value_or("");
+  std::string optimize = "";
+  NAPI_STATUS_RETURN(GetProperty(env, options, "optimize", optimize));
 
   if (optimize == "point-lookup") {
     tableOptions.data_block_index_type = rocksdb::BlockBasedTableOptions::kDataBlockBinaryAndHash;
@@ -1041,25 +626,29 @@ rocksdb::Status InitOptions(napi_env env, T& columnOptions, const U& options) {
   } else if (optimize == "range-lookup") {
     // TODO?
   } else {
-    tableOptions.filter_policy.reset(rocksdb::NewRibbonFilterPolicy(10));
+    tableOptions.filter_policy.reset(rocksdb::NewBloomFilterPolicy(10));
   }
 
-  const auto filterPolicyOpt = StringProperty(env, options, "filterPolicy");
+  std::optional<std::string> filterPolicyOpt;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "filterPolicy", filterPolicyOpt));
   if (filterPolicyOpt) {
-    rocksdb::ConfigOptions configOptions;
-    ROCKS_STATUS_RETURN(
+    ROCKS_STATUS_RETURN_NAPI(
         rocksdb::FilterPolicy::CreateFromString(configOptions, *filterPolicyOpt, &tableOptions.filter_policy));
   }
 
-  tableOptions.block_size = Uint32Property(env, options, "blockSize").value_or(4096);
-  tableOptions.block_restart_interval = Uint32Property(env, options, "blockRestartInterval").value_or(16);
+  NAPI_STATUS_RETURN(GetProperty(env, options, "blockSize", tableOptions.block_size));
+
+  NAPI_STATUS_RETURN(GetProperty(env, options, "blockRestartInterval", tableOptions.block_restart_interval));
+
   tableOptions.format_version = 5;
   tableOptions.checksum = rocksdb::kXXH3;
-  tableOptions.optimize_filters_for_memory = BooleanProperty(env, options, "optimizeFiltersForMemory").value_or(true);
+
+  tableOptions.optimize_filters_for_memory = true;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "optimizeFiltersForMemory", tableOptions.optimize_filters_for_memory));
 
   columnOptions.table_factory.reset(rocksdb::NewBlockBasedTableFactory(tableOptions));
 
-  return rocksdb::Status::OK();
+  return napi_ok;
 }
 
 NAPI_METHOD(db_open) {
@@ -1069,32 +658,44 @@ NAPI_METHOD(db_open) {
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
   std::string location;
-  NAPI_STATUS_THROWS(ToString(env, argv[1], location));
+  NAPI_STATUS_THROWS(GetValue(env, argv[1], location));
 
   rocksdb::Options dbOptions;
 
-  dbOptions.IncreaseParallelism(Uint32Property(env, argv[2], "parallelism")
-                                    .value_or(std::max<uint32_t>(1, std::thread::hardware_concurrency() / 2)));
+  const auto options = argv[2];
+
+  int parallelism = std::max<int>(1, std::thread::hardware_concurrency() / 2);
+  NAPI_STATUS_THROWS(GetProperty(env, options, "parallelism", parallelism));
+  dbOptions.IncreaseParallelism(parallelism);
+
+  uint32_t walTTL = 0;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "walTTL", walTTL));
+  dbOptions.WAL_ttl_seconds = walTTL / 1e3;
+
+  uint32_t walSizeLimit = 0;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "walSizeLimit", walSizeLimit));
+  dbOptions.WAL_size_limit_MB = walSizeLimit / 1e6;
+
+  bool walCompression = false;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "walCompression", walCompression));
+  dbOptions.wal_compression =
+      walCompression ? rocksdb::CompressionType::kZSTD : rocksdb::CompressionType::kNoCompression;
 
-  dbOptions.create_if_missing = BooleanProperty(env, argv[2], "createIfMissing").value_or(true);
-  dbOptions.error_if_exists = BooleanProperty(env, argv[2], "errorIfExists").value_or(false);
   dbOptions.avoid_unnecessary_blocking_io = true;
   dbOptions.write_dbid_to_manifest = true;
   dbOptions.use_adaptive_mutex = true;       // We don't have soo many threads in the libuv thread pool...
   dbOptions.enable_pipelined_write = false;  // We only write in the main thread...
-  dbOptions.WAL_ttl_seconds = Uint32Property(env, argv[2], "walTTL").value_or(0) / 1e3;
-  dbOptions.WAL_size_limit_MB = Uint32Property(env, argv[2], "walSizeLimit").value_or(0) / 1e6;
-  dbOptions.wal_compression = BooleanProperty(env, argv[2], "walCompression").value_or(false)
-                                  ? rocksdb::CompressionType::kZSTD
-                                  : rocksdb::CompressionType::kNoCompression;
   dbOptions.create_missing_column_families = true;
-  dbOptions.unordered_write = BooleanProperty(env, argv[2], "unorderedWrite").value_or(false);
   dbOptions.fail_if_options_file_error = true;
-  dbOptions.manual_wal_flush = BooleanProperty(env, argv[2], "manualWalFlush").value_or(false);
+
+  NAPI_STATUS_THROWS(GetProperty(env, options, "createIfMissing", dbOptions.create_if_missing));
+  NAPI_STATUS_THROWS(GetProperty(env, options, "errorIfExists", dbOptions.error_if_exists));
+  NAPI_STATUS_THROWS(GetProperty(env, options, "unorderedWrite", dbOptions.unordered_write));
 
   // TODO (feat): dbOptions.listeners
 
-  const auto infoLogLevel = StringProperty(env, argv[2], "infoLogLevel").value_or("");
+  std::string infoLogLevel;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "infoLogLevel", infoLogLevel));
   if (infoLogLevel.size() > 0) {
     rocksdb::InfoLogLevel lvl = {};
 
@@ -1121,16 +722,16 @@ NAPI_METHOD(db_open) {
     dbOptions.info_log.reset(new NullLogger());
   }
 
-  ROCKS_STATUS_THROWS(InitOptions(env, dbOptions, argv[2]));
+  NAPI_STATUS_THROWS(InitOptions(env, dbOptions, options));
 
   std::vector<rocksdb::ColumnFamilyDescriptor> descriptors;
 
   bool hasColumns;
-  NAPI_STATUS_THROWS(napi_has_named_property(env, argv[2], "columns", &hasColumns));
+  NAPI_STATUS_THROWS(napi_has_named_property(env, options, "columns", &hasColumns));
 
   if (hasColumns) {
     napi_value columns;
-    NAPI_STATUS_THROWS(napi_get_named_property(env, argv[2], "columns", &columns));
+    NAPI_STATUS_THROWS(napi_get_named_property(env, options, "columns", &columns));
 
     napi_value keys;
     NAPI_STATUS_THROWS(napi_get_property_names(env, columns, &keys));
@@ -1146,26 +747,25 @@ NAPI_METHOD(db_open) {
       napi_value column;
       NAPI_STATUS_THROWS(napi_get_property(env, columns, key, &column));
 
-      ROCKS_STATUS_THROWS(InitOptions(env, descriptors[n].options, column));
+      NAPI_STATUS_THROWS(InitOptions(env, descriptors[n].options, column));
 
-      NAPI_STATUS_THROWS(ToString(env, key, descriptors[n].name));
+      NAPI_STATUS_THROWS(GetValue(env, key, descriptors[n].name));
     }
   }
 
   auto callback = argv[3];
 
-  runWorker<std::vector<rocksdb::ColumnFamilyHandle*>>(
-      "leveldown.open", env, callback, database, false,
-      [=](auto& handles, auto& database) -> rocksdb::Status {
+  runAsync<std::vector<rocksdb::ColumnFamilyHandle*>>(
+      "leveldown.open", env, callback,
+      [=](auto& handles) {
         rocksdb::DB* db = nullptr;
         const auto status = descriptors.empty() ? rocksdb::DB::Open(dbOptions, location, &db)
                                                 : rocksdb::DB::Open(dbOptions, location, descriptors, &handles, &db);
-        database.db_.reset(db);
+        database->db.reset(db);
         return status;
       },
-      [=](auto& handles, napi_env env, napi_value callback) -> napi_status {
-        napi_value argv[2];
-        NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
+      [=](auto& handles, auto env, auto& argv) {
+        argv.resize(2);
 
         const auto size = handles.size();
         NAPI_STATUS_RETURN(napi_create_object(env, &argv[1]));
@@ -1176,13 +776,11 @@ NAPI_METHOD(db_open) {
           column.descriptor = descriptors[n];
           NAPI_STATUS_RETURN(napi_create_external(env, column.handle, nullptr, nullptr, &column.val));
           NAPI_STATUS_RETURN(napi_create_reference(env, column.val, 1, &column.ref));
-
           NAPI_STATUS_RETURN(napi_set_named_property(env, argv[1], descriptors[n].name.c_str(), column.val));
-
-          database->columns_[column.handle->GetID()] = column;
+          database->columns[column.handle->GetID()] = column;
         }
 
-        return CallFunction(env, callback, 2, argv);
+        return napi_ok;
       });
 
   return 0;
@@ -1201,28 +799,9 @@ NAPI_METHOD(db_close) {
   auto callback = argv[1];
 
   struct State {};
-  auto worker = createWorker<State>(
-      "leveldown.close", env, callback, database, false,
-      [=](auto& state, auto& database) -> rocksdb::Status {
-        for (auto& it : database.columns_) {
-          database.db_->DestroyColumnFamilyHandle(it.second.handle);
-        }
-        database.columns_.clear();
-
-        return database.db_->Close();
-      },
-      [](auto& state, napi_env env, napi_value callback) -> napi_status {
-        napi_value argv[1];
-        NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
-
-        return CallFunction(env, callback, 1, &argv[0]);
-      });
-
-  if (!database->HasPriorityWork()) {
-    worker->Queue(env);
-  } else {
-    database->pendingCloseWorker_ = worker;
-  }
+  runAsync<State>(
+      "leveldown.close", env, callback, [=](auto& state) { return database->Close(); },
+      [](auto& state, auto env, auto& argv) { return napi_ok; });
 
   return 0;
 }
@@ -1233,40 +812,38 @@ NAPI_METHOD(updates_init) {
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  napi_value sinceProperty;
-  int64_t since;
-  NAPI_STATUS_THROWS(napi_get_named_property(env, argv[1], "since", &sinceProperty));
-  NAPI_STATUS_THROWS(napi_get_value_int64(env, sinceProperty, &since));
+  const auto options = argv[1];
 
-  napi_value keysProperty;
-  bool keys;
-  NAPI_STATUS_THROWS(napi_get_named_property(env, argv[1], "keys", &keysProperty));
-  NAPI_STATUS_THROWS(napi_get_value_bool(env, keysProperty, &keys));
+  int64_t since = 0;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "since", since));
 
-  napi_value valuesProperty;
-  bool values;
-  NAPI_STATUS_THROWS(napi_get_named_property(env, argv[1], "values", &valuesProperty));
-  NAPI_STATUS_THROWS(napi_get_value_bool(env, valuesProperty, &values));
+  bool keys = true;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "keys", keys));
 
-  napi_value dataProperty;
-  bool data;
-  NAPI_STATUS_THROWS(napi_get_named_property(env, argv[1], "data", &dataProperty));
-  NAPI_STATUS_THROWS(napi_get_value_bool(env, dataProperty, &data));
+  bool values = true;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "values", values));
 
-  const bool keyAsBuffer = EncodingIsBuffer(env, argv[1], "keyEncoding");
-  const bool valueAsBuffer = EncodingIsBuffer(env, argv[1], "valueEncoding");
+  bool data = true;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "data", data));
+
+  Encoding keyEncoding = Encoding::String;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "keyEncoding", keyEncoding));
+
+  Encoding valueEncoding = Encoding::String;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "valueEncoding", valueEncoding));
 
   rocksdb::ColumnFamilyHandle* column = nullptr;
-  NAPI_STATUS_THROWS(GetColumnFamily(nullptr, env, argv[1], &column));
+  NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
 
-  auto updates = std::make_unique<Updates>(database, since, keys, values, data, column, keyAsBuffer, valueAsBuffer);
+  auto updates =
+      std::unique_ptr<Updates>(new Updates(database, since, keys, values, data, column, keyEncoding, valueEncoding));
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, updates.get(), Finalize<Updates>, updates.get(), &result));
 
   // Prevent GC of JS object before the iterator is closed (explicitly or on
   // db close) and keep track of non-closed iterators to end them on db close.
-  updates.release()->Attach(env, result);
+  NAPI_STATUS_THROWS(updates.release()->Attach(env, result));
 
   return result;
 }
@@ -1279,12 +856,12 @@ NAPI_METHOD(updates_next) {
 
   auto callback = argv[1];
 
-  runWorker<rocksdb::BatchResult>(
-      "leveldown.updates.next", env, callback, updates->database_, true,
-      [=](auto& batchResult, auto& database) -> rocksdb::Status {
+  runAsync<rocksdb::BatchResult>(
+      "leveldown.updates.next", env, callback,
+      [=](auto& batchResult) {
         if (!updates->iterator_) {
           rocksdb::TransactionLogIterator::ReadOptions options;
-          const auto status = database.db_->GetUpdatesSince(updates->start_, &updates->iterator_, options);
+          const auto status = updates->database_->db->GetUpdatesSince(updates->start_, &updates->iterator_, options);
           if (!status.ok()) {
             return status;
           }
@@ -1300,22 +877,18 @@ NAPI_METHOD(updates_next) {
 
         return rocksdb::Status::OK();
       },
-      [=](auto& batchResult, napi_env env, napi_value callback) -> napi_status {
-        napi_value argv[5];
-
-        NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
-
+      [=](auto& batchResult, auto env, auto& argv) {
         if (!batchResult.writeBatchPtr) {
-          return CallFunction(env, callback, 1, argv);
+          return napi_ok;
         }
 
+        argv.resize(5);
         NAPI_STATUS_RETURN(updates->Iterate(env, *batchResult.writeBatchPtr, &argv[1]));
-
         NAPI_STATUS_RETURN(napi_create_int64(env, batchResult.sequence, &argv[2]));
         NAPI_STATUS_RETURN(napi_create_int64(env, batchResult.writeBatchPtr->Count(), &argv[3]));
         NAPI_STATUS_RETURN(napi_create_int64(env, updates->start_, &argv[4]));
 
-        return CallFunction(env, callback, 5, argv);
+        return napi_ok;
       });
 
   return 0;
@@ -1327,8 +900,8 @@ NAPI_METHOD(updates_close) {
   Updates* updates;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&updates)));
 
-  updates->Detach(env);
-  updates->Close();
+  ROCKS_STATUS_THROWS_NAPI(updates->Close());
+  NAPI_STATUS_THROWS(updates->Detach(env));
 
   return 0;
 }
@@ -1348,44 +921,53 @@ NAPI_METHOD(db_get_many) {
     for (uint32_t n = 0; n < length; n++) {
       napi_value element;
       NAPI_STATUS_THROWS(napi_get_element(env, argv[1], n, &element));
-      NAPI_STATUS_THROWS(ToString(env, element, keys[n]));
+      NAPI_STATUS_THROWS(GetValue(env, element, keys[n]));
     }
   }
 
-  const bool valueAsBuffer = EncodingIsBuffer(env, argv[2], "valueEncoding");
-  const bool fillCache = BooleanProperty(env, argv[2], "fillCache").value_or(true);
-  const bool ignoreRangeDeletions = BooleanProperty(env, argv[2], "ignoreRangeDeletions").value_or(false);
+  const auto options = argv[2];
+
+  Encoding valueEncoding = Encoding::String;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "valueEncoding", valueEncoding));
+
+  bool fillCache = true;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "fillCache", fillCache));
 
-  rocksdb::ColumnFamilyHandle* column;
-  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[2], &column));
+  bool ignoreRangeDeletions = false;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "ignoreRangeDeletions", ignoreRangeDeletions));
+
+  rocksdb::ColumnFamilyHandle* column = database->db->DefaultColumnFamily();
+  NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
 
   auto callback = argv[3];
 
   auto snapshot = std::shared_ptr<const rocksdb::Snapshot>(
-      database->db_->GetSnapshot(), [database](auto ptr) { database->db_->ReleaseSnapshot(ptr); });
+      database->db->GetSnapshot(), [database](auto ptr) { database->db->ReleaseSnapshot(ptr); });
 
-  runWorker<std::vector<rocksdb::PinnableSlice>>(
-      "leveldown.get.many", env, callback, database, true,
-      [=, keys = std::move(keys)](auto& values, Database& db) -> rocksdb::Status {
+  runAsync<std::vector<rocksdb::PinnableSlice>>(
+      "leveldown.get.many", env, callback,
+      [=, keys = std::move(keys), snapshot = std::move(snapshot)](auto& values) {
         rocksdb::ReadOptions readOptions;
         readOptions.fill_cache = fillCache;
         readOptions.snapshot = snapshot.get();
         readOptions.async_io = true;
         readOptions.ignore_range_deletions = ignoreRangeDeletions;
 
+        const auto size = keys.size();
+
         std::vector<rocksdb::Slice> keys2;
-        keys2.reserve(keys.size());
+        keys2.reserve(size);
         for (const auto& key : keys) {
           keys2.emplace_back(key);
         }
         std::vector<rocksdb::Status> statuses;
 
-        statuses.resize(keys2.size());
-        values.resize(keys2.size());
+        statuses.resize(size);
+        values.resize(size);
 
-        db.db_->MultiGet(readOptions, column, keys2.size(), keys2.data(), values.data(), statuses.data());
+        database->db->MultiGet(readOptions, column, size, keys2.data(), values.data(), statuses.data());
 
-        for (size_t idx = 0; idx < keys2.size(); idx++) {
+        for (size_t idx = 0; idx < size; idx++) {
           if (statuses[idx].IsNotFound()) {
             values[idx] = rocksdb::PinnableSlice(nullptr);
           } else if (!statuses[idx].ok()) {
@@ -1395,23 +977,22 @@ NAPI_METHOD(db_get_many) {
 
         return rocksdb::Status::OK();
       },
-      [=](auto& values, napi_env env, napi_value callback) -> napi_status {
-        napi_value argv[2];
-        NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
+      [=](auto& values, auto env, auto& argv) {
+        argv.resize(2);
 
         NAPI_STATUS_RETURN(napi_create_array_with_length(env, values.size(), &argv[1]));
 
         for (size_t idx = 0; idx < values.size(); idx++) {
           napi_value element;
           if (values[idx].GetSelf()) {
-            NAPI_STATUS_RETURN(Convert(env, &values[idx], valueAsBuffer, element));
+            NAPI_STATUS_RETURN(Convert(env, &values[idx], valueEncoding, element));
           } else {
             NAPI_STATUS_RETURN(napi_get_undefined(env, &element));
           }
           NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<uint32_t>(idx), element));
         }
 
-        return CallFunction(env, callback, 2, argv);
+        return napi_ok;
       });
 
   return 0;
@@ -1423,16 +1004,28 @@ NAPI_METHOD(db_clear) {
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  const auto reverse = BooleanProperty(env, argv[1], "reverse").value_or(false);
-  const auto limit = Int32Property(env, argv[1], "limit").value_or(-1);
+  const auto options = argv[1];
+
+  bool reverse = false;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "reverse", reverse));
+
+  int32_t limit = -1;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "limit", limit));
+
+  rocksdb::ColumnFamilyHandle* column = database->db->DefaultColumnFamily();
+  NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
 
-  rocksdb::ColumnFamilyHandle* column;
-  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[1], &column));
+  std::optional<std::string> lt;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "lt", lt));
 
-  auto lt = StringProperty(env, argv[1], "lt");
-  auto lte = StringProperty(env, argv[1], "lte");
-  auto gt = StringProperty(env, argv[1], "gt");
-  auto gte = StringProperty(env, argv[1], "gte");
+  std::optional<std::string> lte;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "lte", lte));
+
+  std::optional<std::string> gt;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "gt", gt));
+
+  std::optional<std::string> gte;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "gte", gte));
 
   if (limit == -1) {
     rocksdb::PinnableSlice begin;
@@ -1457,7 +1050,7 @@ NAPI_METHOD(db_clear) {
 
     if (begin.compare(end) < 0) {
       rocksdb::WriteOptions writeOptions;
-      ROCKS_STATUS_THROWS(database->db_->DeleteRange(writeOptions, column, begin, end));
+      ROCKS_STATUS_THROWS_NAPI(database->db->DeleteRange(writeOptions, column, begin, end));
     }
 
     return 0;
@@ -1465,8 +1058,8 @@ NAPI_METHOD(db_clear) {
     // TODO (fix): Error handling.
     // TODO (fix): This should be async...
 
-    std::shared_ptr<const rocksdb::Snapshot> snapshot(database->db_->GetSnapshot(),
-                                                      [=](const auto ptr) { database->db_->ReleaseSnapshot(ptr); });
+    std::shared_ptr<const rocksdb::Snapshot> snapshot(database->db->GetSnapshot(),
+                                                      [=](const auto ptr) { database->db->ReleaseSnapshot(ptr); });
     BaseIterator it(database, column, reverse, lt, lte, gt, gte, limit, false, snapshot);
 
     it.SeekToRange();
@@ -1490,7 +1083,7 @@ NAPI_METHOD(db_clear) {
         break;
       }
 
-      status = database->db_->Write(writeOptions, &batch);
+      status = database->db->Write(writeOptions, &batch);
       if (!status.ok()) {
         break;
       }
@@ -1501,7 +1094,7 @@ NAPI_METHOD(db_clear) {
     it.Close();
 
     if (!status.ok()) {
-      ROCKS_STATUS_THROWS(status);
+      ROCKS_STATUS_THROWS_NAPI(status);
     }
 
     return 0;
@@ -1514,11 +1107,11 @@ NAPI_METHOD(db_get_property) {
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  rocksdb::PinnableSlice property;
-  NAPI_STATUS_THROWS(ToString(env, argv[1], property));
+  NapiSlice property;
+  NAPI_STATUS_THROWS(GetValue(env, argv[1], property));
 
   std::string value;
-  database->db_->GetProperty(property, &value);
+  database->db->GetProperty(property, &value);
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_string_utf8(env, value.data(), value.size(), &result));
@@ -1532,7 +1125,7 @@ NAPI_METHOD(db_get_latest_sequence) {
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  const auto seq = database->db_->GetLatestSequenceNumber();
+  const auto seq = database->db->GetLatestSequenceNumber();
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_int64(env, seq, &result));
@@ -1547,35 +1140,59 @@ NAPI_METHOD(iterator_init) {
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
   const auto options = argv[1];
-  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").value_or(-1);
-  const auto highWaterMarkBytes = Uint32Property(env, options, "highWaterMarkBytes").value_or(64 * 1024);
 
-  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");
+  bool reverse = false;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "reverse", reverse));
+
+  bool keys = true;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "keys", keys));
+
+  bool values = true;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "values", values));
+
+  bool fillCache = false;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "fillCache", fillCache));
+
+  Encoding keyEncoding = Encoding::String;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "keyEncoding", keyEncoding));
+
+  Encoding valueEncoding = Encoding::String;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "valueEncoding", valueEncoding));
+
+  int32_t limit = -1;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "limit", limit));
+
+  int32_t highWaterMarkBytes = 64 * 1024;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "highWaterMarkBytes", highWaterMarkBytes));
 
-  rocksdb::ColumnFamilyHandle* column;
-  NAPI_STATUS_THROWS(GetColumnFamily(database, env, options, &column));
+  std::optional<std::string> lt;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "lt", lt));
 
-  std::shared_ptr<const rocksdb::Snapshot> snapshot(database->db_->GetSnapshot(),
-                                                    [=](const auto ptr) { database->db_->ReleaseSnapshot(ptr); });
+  std::optional<std::string> lte;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "lte", lte));
 
-  auto iterator = std::make_unique<Iterator>(database, column, reverse, keys, values, limit, lt, lte, gt, gte,
-                                             fillCache, keyAsBuffer, valueAsBuffer, highWaterMarkBytes, snapshot);
+  std::optional<std::string> gt;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "gt", gt));
+
+  std::optional<std::string> gte;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "gte", gte));
+
+  rocksdb::ColumnFamilyHandle* column = database->db->DefaultColumnFamily();
+  NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
+
+  std::shared_ptr<const rocksdb::Snapshot> snapshot(database->db->GetSnapshot(),
+                                                    [=](const auto ptr) { database->db->ReleaseSnapshot(ptr); });
+
+  auto iterator =
+      std::unique_ptr<Iterator>(new Iterator(database, column, reverse, keys, values, limit, lt, lte, gt, gte,
+                                             fillCache, keyEncoding, valueEncoding, highWaterMarkBytes, snapshot));
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, iterator.get(), Finalize<Iterator>, iterator.get(), &result));
 
   // Prevent GC of JS object before the iterator is closed (explicitly or on
   // db close) and keep track of non-closed iterators to end them on db close.
-  iterator.release()->Attach(env, result);
+  NAPI_STATUS_THROWS(iterator.release()->Attach(env, result));
 
   return result;
 }
@@ -1586,8 +1203,8 @@ NAPI_METHOD(iterator_seek) {
   Iterator* iterator;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&iterator)));
 
-  rocksdb::PinnableSlice target;
-  NAPI_STATUS_THROWS(ToString(env, argv[1], target));
+  NapiSlice target;
+  NAPI_STATUS_THROWS(GetValue(env, argv[1], target));
 
   iterator->first_ = true;
   iterator->Seek(target);  // TODO: Does seek causing blocking IO?
@@ -1601,8 +1218,8 @@ NAPI_METHOD(iterator_close) {
   Iterator* iterator;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&iterator)));
 
-  iterator->Detach(env);
-  iterator->Close();
+  ROCKS_STATUS_THROWS_NAPI(iterator->Close());
+  NAPI_STATUS_THROWS(iterator->Detach(env));
 
   return 0;
 }
@@ -1637,9 +1254,9 @@ NAPI_METHOD(iterator_nextv) {
     bool finished = false;
   };
 
-  runWorker<State>(
-      std::string("leveldown.iterator.next"), env, callback, iterator->database_, true,
-      [=](auto& state, Database& db) -> rocksdb::Status {
+  runAsync<State>(
+      std::string("leveldown.iterator.next"), env, callback,
+      [=](auto& state) {
         if (!iterator->DidSeek()) {
           iterator->SeekToRange();
         }
@@ -1684,9 +1301,8 @@ NAPI_METHOD(iterator_nextv) {
 
         return iterator->Status();
       },
-      [=](auto& state, napi_env env, napi_value callback) -> napi_status {
-        napi_value argv[3];
-        NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
+      [=](auto& state, auto env, auto& argv) {
+        argv.resize(3);
 
         NAPI_STATUS_RETURN(napi_create_array_with_length(env, state.cache.size(), &argv[1]));
 
@@ -1694,8 +1310,8 @@ NAPI_METHOD(iterator_nextv) {
           napi_value key;
           napi_value val;
 
-          NAPI_STATUS_RETURN(Convert(env, state.cache[n + 0], iterator->keyAsBuffer_, key));
-          NAPI_STATUS_RETURN(Convert(env, state.cache[n + 1], iterator->valueAsBuffer_, val));
+          NAPI_STATUS_RETURN(Convert(env, state.cache[n + 0], iterator->keyEncoding_, key));
+          NAPI_STATUS_RETURN(Convert(env, state.cache[n + 1], iterator->valueEncoding_, val));
 
           NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<int>(n + 0), key));
           NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<int>(n + 1), val));
@@ -1703,7 +1319,7 @@ NAPI_METHOD(iterator_nextv) {
 
         NAPI_STATUS_RETURN(napi_get_boolean(env, state.finished, &argv[2]));
 
-        return CallFunction(env, callback, 3, argv);
+        return napi_ok;
       });
 
   return 0;
@@ -1717,63 +1333,45 @@ NAPI_METHOD(batch_do) {
 
   rocksdb::WriteBatch batch;
 
+  auto elements = argv[1];
+
   uint32_t length;
-  NAPI_STATUS_THROWS(napi_get_array_length(env, argv[1], &length));
+  NAPI_STATUS_THROWS(napi_get_array_length(env, elements, &length));
 
   for (uint32_t i = 0; i < length; i++) {
-    rocksdb::PinnableSlice type;
-    rocksdb::PinnableSlice key;
-    rocksdb::PinnableSlice value;
+    NapiSlice type;
+    NapiSlice key;
+    NapiSlice value;
 
     napi_value element;
-    NAPI_STATUS_THROWS(napi_get_element(env, argv[1], i, &element));
+    NAPI_STATUS_THROWS(napi_get_element(env, elements, i, &element));
 
-    napi_value typeProperty;
-    NAPI_STATUS_THROWS(napi_get_named_property(env, element, "type", &typeProperty));
-    NAPI_STATUS_THROWS(ToString(env, typeProperty, type));
+    NAPI_STATUS_THROWS(GetProperty(env, element, "type", type, true));
 
-    rocksdb::ColumnFamilyHandle* column;
-    NAPI_STATUS_THROWS(GetColumnFamily(database, env, element, &column));
+    rocksdb::ColumnFamilyHandle* column = database->db->DefaultColumnFamily();
+    NAPI_STATUS_THROWS(GetProperty(env, element, "column", column));
 
     if (type == "del") {
-      napi_value keyProperty;
-      NAPI_STATUS_THROWS(napi_get_named_property(env, element, "key", &keyProperty));
-      NAPI_STATUS_THROWS(ToString(env, keyProperty, key));
-
-      ROCKS_STATUS_THROWS(batch.Delete(column, key));
+      NAPI_STATUS_THROWS(GetProperty(env, element, "key", key, true));
+      ROCKS_STATUS_THROWS_NAPI(batch.Delete(column, key));
     } else if (type == "put") {
-      napi_value keyProperty;
-      NAPI_STATUS_THROWS(napi_get_named_property(env, element, "key", &keyProperty));
-      NAPI_STATUS_THROWS(ToString(env, keyProperty, key));
-
-      napi_value valueProperty;
-      NAPI_STATUS_THROWS(napi_get_named_property(env, element, "value", &valueProperty));
-      NAPI_STATUS_THROWS(ToString(env, valueProperty, value));
-
-      ROCKS_STATUS_THROWS(batch.Put(column, key, value));
+      NAPI_STATUS_THROWS(GetProperty(env, element, "key", key, true));
+      NAPI_STATUS_THROWS(GetProperty(env, element, "value", value, true));
+      ROCKS_STATUS_THROWS_NAPI(batch.Put(column, key, value));
     } else if (type == "data") {
-      napi_value valueProperty;
-      NAPI_STATUS_THROWS(napi_get_named_property(env, element, "value", &valueProperty));
-      NAPI_STATUS_THROWS(ToString(env, valueProperty, value));
-
-      ROCKS_STATUS_THROWS(batch.PutLogData(value));
+      NAPI_STATUS_THROWS(GetProperty(env, element, "value", value, true));
+      ROCKS_STATUS_THROWS_NAPI(batch.PutLogData(value));
     } else if (type == "merge") {
-      napi_value keyProperty;
-      NAPI_STATUS_THROWS(napi_get_named_property(env, element, "key", &keyProperty));
-      NAPI_STATUS_THROWS(ToString(env, keyProperty, key));
-
-      napi_value valueProperty;
-      NAPI_STATUS_THROWS(napi_get_named_property(env, element, "value", &valueProperty));
-      NAPI_STATUS_THROWS(ToString(env, valueProperty, value));
-
-      ROCKS_STATUS_THROWS(batch.Merge(column, key, value));
+      NAPI_STATUS_THROWS(GetProperty(env, element, "key", key, true));
+      NAPI_STATUS_THROWS(GetProperty(env, element, "value", value, true));
+      ROCKS_STATUS_THROWS_NAPI(batch.Merge(column, key, value));
     } else {
-      ROCKS_STATUS_THROWS(rocksdb::Status::InvalidArgument());
+      NAPI_STATUS_THROWS(napi_invalid_arg);
     }
   }
 
   rocksdb::WriteOptions writeOptions;
-  ROCKS_STATUS_THROWS(database->db_->Write(writeOptions, &batch));
+  ROCKS_STATUS_THROWS_NAPI(database->db->Write(writeOptions, &batch));
 
   return 0;
 }
@@ -1791,21 +1389,23 @@ NAPI_METHOD(batch_put) {
   NAPI_ARGV(4);
 
   rocksdb::WriteBatch* batch;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)(&batch)));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&batch)));
 
-  rocksdb::PinnableSlice key;
-  NAPI_STATUS_THROWS(ToString(env, argv[1], key));
+  NapiSlice key;
+  NAPI_STATUS_THROWS(GetValue(env, argv[1], key));
 
-  rocksdb::PinnableSlice val;
-  NAPI_STATUS_THROWS(ToString(env, argv[2], val));
+  NapiSlice val;
+  NAPI_STATUS_THROWS(GetValue(env, argv[2], val));
 
-  rocksdb::ColumnFamilyHandle* column;
-  NAPI_STATUS_THROWS(GetColumnFamily(nullptr, env, argv[3], &column));
+  const auto options = argv[3];
+
+  rocksdb::ColumnFamilyHandle* column = nullptr;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
 
   if (column) {
-    ROCKS_STATUS_THROWS(batch->Put(column, key, val));
+    ROCKS_STATUS_THROWS_NAPI(batch->Put(column, key, val));
   } else {
-    ROCKS_STATUS_THROWS(batch->Put(key, val));
+    ROCKS_STATUS_THROWS_NAPI(batch->Put(key, val));
   }
 
   return 0;
@@ -1817,16 +1417,18 @@ NAPI_METHOD(batch_del) {
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&batch)));
 
-  rocksdb::PinnableSlice key;
-  NAPI_STATUS_THROWS(ToString(env, argv[1], key));
+  NapiSlice key;
+  NAPI_STATUS_THROWS(GetValue(env, argv[1], key));
+
+  const auto options = argv[2];
 
-  rocksdb::ColumnFamilyHandle* column;
-  NAPI_STATUS_THROWS(GetColumnFamily(nullptr, env, argv[2], &column));
+  rocksdb::ColumnFamilyHandle* column = nullptr;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
 
   if (column) {
-    ROCKS_STATUS_THROWS(batch->Delete(column, key));
+    ROCKS_STATUS_THROWS_NAPI(batch->Delete(column, key));
   } else {
-    ROCKS_STATUS_THROWS(batch->Delete(key));
+    ROCKS_STATUS_THROWS_NAPI(batch->Delete(key));
   }
 
   return 0;
@@ -1838,19 +1440,21 @@ NAPI_METHOD(batch_merge) {
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)(&batch)));
 
-  rocksdb::PinnableSlice key;
-  NAPI_STATUS_THROWS(ToString(env, argv[1], key));
+  NapiSlice key;
+  NAPI_STATUS_THROWS(GetValue(env, argv[1], key));
+
+  NapiSlice val;
+  NAPI_STATUS_THROWS(GetValue(env, argv[2], val));
 
-  rocksdb::PinnableSlice val;
-  NAPI_STATUS_THROWS(ToString(env, argv[2], val));
+  const auto options = argv[3];
 
-  rocksdb::ColumnFamilyHandle* column;
-  NAPI_STATUS_THROWS(GetColumnFamily(nullptr, env, argv[3], &column));
+  rocksdb::ColumnFamilyHandle* column = nullptr;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
 
   if (column) {
-    ROCKS_STATUS_THROWS(batch->Merge(column, key, val));
+    ROCKS_STATUS_THROWS_NAPI(batch->Merge(column, key, val));
   } else {
-    ROCKS_STATUS_THROWS(batch->Merge(key, val));
+    ROCKS_STATUS_THROWS_NAPI(batch->Merge(key, val));
   }
 
   return 0;
@@ -1877,7 +1481,7 @@ NAPI_METHOD(batch_write) {
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
 
   rocksdb::WriteOptions writeOptions;
-  ROCKS_STATUS_THROWS(database->db_->Write(writeOptions, batch));
+  ROCKS_STATUS_THROWS_NAPI(database->db->Write(writeOptions, batch));
 
   return 0;
 }
@@ -1888,10 +1492,10 @@ NAPI_METHOD(batch_put_log_data) {
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&batch)));
 
-  rocksdb::PinnableSlice logData;
-  NAPI_STATUS_THROWS(ToString(env, argv[1], logData));
+  NapiSlice logData;
+  NAPI_STATUS_THROWS(GetValue(env, argv[1], logData));
 
-  ROCKS_STATUS_THROWS(batch->PutLogData(logData));
+  ROCKS_STATUS_THROWS_NAPI(batch->PutLogData(logData));
 
   return 0;
 }
@@ -1917,111 +1521,34 @@ NAPI_METHOD(batch_iterate) {
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
 
-  napi_value keysProperty;
-  bool keys;
-  NAPI_STATUS_THROWS(napi_get_named_property(env, argv[2], "keys", &keysProperty));
-  NAPI_STATUS_THROWS(napi_get_value_bool(env, keysProperty, &keys));
+  const auto options = argv[2];
+
+  bool keys = true;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "keys", keys));
+
+  bool values = true;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "values", values));
 
-  napi_value valuesProperty;
-  bool values;
-  NAPI_STATUS_THROWS(napi_get_named_property(env, argv[2], "values", &valuesProperty));
-  NAPI_STATUS_THROWS(napi_get_value_bool(env, valuesProperty, &values));
+  bool data = true;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "data", data));
 
-  napi_value dataProperty;
-  bool data;
-  NAPI_STATUS_THROWS(napi_get_named_property(env, argv[2], "data", &dataProperty));
-  NAPI_STATUS_THROWS(napi_get_value_bool(env, dataProperty, &data));
+  Encoding keyEncoding = Encoding::String;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "keyEncoding", keyEncoding));
 
-  const bool keyAsBuffer = EncodingIsBuffer(env, argv[1], "keyEncoding");
-  const bool valueAsBuffer = EncodingIsBuffer(env, argv[1], "valueEncoding");
+  Encoding valueEncoding = Encoding::String;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "valueEncoding", valueEncoding));
 
   rocksdb::ColumnFamilyHandle* column = nullptr;
-  NAPI_STATUS_THROWS(GetColumnFamily(nullptr, env, argv[2], &column));
+  NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
 
-  napi_value result;
-  BatchIterator iterator(nullptr, keys, values, data, column, keyAsBuffer, valueAsBuffer);
+  BatchIterator iterator(nullptr, keys, values, data, column, keyEncoding, valueEncoding);
 
+  napi_value result;
   NAPI_STATUS_THROWS(iterator.Iterate(env, *batch, &result));
 
   return result;
 }
 
-NAPI_METHOD(db_flush_wal) {
-  NAPI_ARGV(2);
-
-  Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
-
-  const auto flush = BooleanProperty(env, argv[1], "flush").value_or(false);
-
-  ROCKS_STATUS_THROWS(database->db_->FlushWAL(flush));
-
-  return 0;
-}
-
-template <typename T>
-napi_status FromLogFile(napi_env env, const T& file, napi_value* obj) {
-  NAPI_STATUS_RETURN(napi_create_object(env, obj));
-
-  napi_value pathName;
-  NAPI_STATUS_RETURN(napi_create_string_utf8(env, file->PathName().c_str(), NAPI_AUTO_LENGTH, &pathName));
-  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "pathName", pathName));
-
-  napi_value logNumber;
-  NAPI_STATUS_RETURN(napi_create_int64(env, file->LogNumber(), &logNumber));
-  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "logNumber", logNumber));
-
-  napi_value type;
-  NAPI_STATUS_RETURN(napi_create_int64(env, file->Type(), &type));
-  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "type", type));
-
-  napi_value startSequence;
-  NAPI_STATUS_RETURN(napi_create_int64(env, file->StartSequence(), &startSequence));
-  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "startSequence", startSequence));
-
-  napi_value sizeFileBytes;
-  NAPI_STATUS_RETURN(napi_create_int64(env, file->SizeFileBytes(), &sizeFileBytes));
-  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "sizeFileBytes", sizeFileBytes));
-
-  return napi_ok;
-}
-
-NAPI_METHOD(db_get_sorted_wal_files) {
-  NAPI_ARGV(1);
-
-  Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
-
-  rocksdb::VectorLogPtr files;
-  ROCKS_STATUS_THROWS(database->db_->GetSortedWalFiles(files));
-
-  napi_value ret;
-  NAPI_STATUS_THROWS(napi_create_array_with_length(env, files.size(), &ret));
-
-  for (size_t n = 0; n < files.size(); ++n) {
-    napi_value obj;
-    NAPI_STATUS_THROWS(FromLogFile(env, files[n], &obj));
-    NAPI_STATUS_THROWS(napi_set_element(env, ret, n, obj));
-  }
-
-  return ret;
-}
-
-NAPI_METHOD(db_get_current_wal_file) {
-  NAPI_ARGV(1);
-
-  Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
-
-  std::unique_ptr<rocksdb::LogFile> file;
-  ROCKS_STATUS_THROWS(database->db_->GetCurrentWalFile(&file));
-
-  napi_value ret;
-  NAPI_STATUS_THROWS(FromLogFile(env, file, &ret));
-
-  return ret;
-}
-
 NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_init);
   NAPI_EXPORT_FUNCTION(db_open);
@@ -2041,10 +1568,6 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(updates_close);
   NAPI_EXPORT_FUNCTION(updates_next);
 
-  NAPI_EXPORT_FUNCTION(db_flush_wal);
-  NAPI_EXPORT_FUNCTION(db_get_sorted_wal_files);
-  NAPI_EXPORT_FUNCTION(db_get_current_wal_file);
-
   NAPI_EXPORT_FUNCTION(batch_do);
   NAPI_EXPORT_FUNCTION(batch_init);
   NAPI_EXPORT_FUNCTION(batch_put);