rocksdb-native 3.9.1 → 3.9.3

package/CMakeLists.txt

@@ -9,7 +9,7 @@ project(rocksdb_native C CXX)
 
 bare_target(target)
 
-fetch_package("github:holepunchto/librocksdb#3aaa9dc")
+fetch_package("github:holepunchto/librocksdb#1fa9c8c")
 fetch_package("github:holepunchto/libjstl#098664c")
 
 add_bare_module(rocksdb_native_bare)

package/binding.cc

@@ -6,26 +6,20 @@
 #include <stdlib.h>
 #include <string.h>
 #include <utf.h>
-
-namespace {
-using cb_on_open_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
-using cb_on_close_t = js_function_t<void, js_receiver_t>;
-using cb_on_suspend_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
-using cb_on_resume_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
-using cb_on_flush_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
-using cb_on_write_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
-using cb_on_read_t = js_function_t<void, js_receiver_t, js_array_t, js_array_t>;
-using cb_on_iterator_open_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
-using cb_on_iterator_close_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
-using cb_on_iterator_read_t = js_function_t<
-  void,
-  js_receiver_t,
-  std::optional<js_string_t>,
-  std::vector<js_arraybuffer_t>,
-  std::vector<js_arraybuffer_t>>;
-using cb_on_compact_range_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
-using cb_on_approximate_size_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>, uint64_t>;
-}; // namespace
+#include <uv.h>
+
+using rocksdb_native_on_open_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
+using rocksdb_native_on_close_t = js_function_t<void, js_receiver_t>;
+using rocksdb_native_on_suspend_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
+using rocksdb_native_on_resume_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
+using rocksdb_native_on_flush_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
+using rocksdb_native_on_write_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
+using rocksdb_native_on_read_t = js_function_t<void, js_receiver_t, js_array_t, js_array_t>;
+using rocksdb_native_on_iterator_open_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
+using rocksdb_native_on_iterator_close_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
+using rocksdb_native_on_iterator_read_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>, std::vector<js_arraybuffer_t>, std::vector<js_arraybuffer_t>>;
+using rocksdb_native_on_compact_range_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
+using rocksdb_native_on_approximate_size_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>, uint64_t>;
 
 struct rocksdb_native_column_family_t {
   rocksdb_column_family_t *handle;
@@ -55,7 +49,7 @@ struct rocksdb_native_open_t {
 
   js_env_t *env;
   js_persistent_t<js_receiver_t> ctx;
-  js_persistent_t<cb_on_open_t> on_open;
+  js_persistent_t<rocksdb_native_on_open_t> on_open;
 
   js_persistent_t<js_array_t> column_families;
 };
@@ -65,7 +59,7 @@ struct rocksdb_native_close_t {
 
   js_env_t *env;
   js_persistent_t<js_receiver_t> ctx;
-  js_persistent_t<cb_on_close_t> on_close;
+  js_persistent_t<rocksdb_native_on_close_t> on_close;
 };
 
 struct rocksdb_native_suspend_t {
@@ -73,7 +67,7 @@ struct rocksdb_native_suspend_t {
 
   js_env_t *env;
   js_persistent_t<js_receiver_t> ctx;
-  js_persistent_t<cb_on_suspend_t> on_suspend;
+  js_persistent_t<rocksdb_native_on_suspend_t> on_suspend;
 };
 
 struct rocksdb_native_resume_t {
@@ -81,7 +75,7 @@ struct rocksdb_native_resume_t {
 
   js_env_t *env;
   js_persistent_t<js_receiver_t> ctx;
-  js_persistent_t<cb_on_resume_t> on_resume;
+  js_persistent_t<rocksdb_native_on_resume_t> on_resume;
 };
 
 struct rocksdb_native_iterator_t {
@@ -92,9 +86,9 @@ struct rocksdb_native_iterator_t {
 
   js_env_t *env;
   js_persistent_t<js_receiver_t> ctx;
-  js_persistent_t<cb_on_iterator_open_t> on_open;
-  js_persistent_t<cb_on_iterator_close_t> on_close;
-  js_persistent_t<cb_on_iterator_read_t> on_read;
+  js_persistent_t<rocksdb_native_on_iterator_open_t> on_open;
+  js_persistent_t<rocksdb_native_on_iterator_close_t> on_close;
+  js_persistent_t<rocksdb_native_on_iterator_read_t> on_read;
 
   bool active;
   bool exiting;
@@ -111,7 +105,7 @@ struct rocksdb_native_read_batch_t {
 
   js_env_t *env;
   js_persistent_t<js_receiver_t> ctx;
-  js_persistent_t<cb_on_read_t> on_read;
+  js_persistent_t<rocksdb_native_on_read_t> on_read;
 };
 
 struct rocksdb_native_write_batch_t {
@@ -123,7 +117,7 @@ struct rocksdb_native_write_batch_t {
 
   js_env_t *env;
   js_persistent_t<js_receiver_t> ctx;
-  js_persistent_t<cb_on_write_t> on_write;
+  js_persistent_t<rocksdb_native_on_write_t> on_write;
 };
 
 struct rocksdb_native_flush_t {
@@ -131,7 +125,7 @@ struct rocksdb_native_flush_t {
 
   js_env_t *env;
   js_persistent_t<js_receiver_t> ctx;
-  js_persistent_t<cb_on_flush_t> on_flush;
+  js_persistent_t<rocksdb_native_on_flush_t> on_flush;
 
   js_persistent_t<rocksdb_native_column_family_t> column_family;
 };
@@ -145,7 +139,7 @@ struct rocksdb_native_compact_range_t {
 
   js_env_t *env;
   js_persistent_t<js_receiver_t> ctx;
-  js_persistent_t<cb_on_compact_range_t> on_compact_range;
+  js_persistent_t<rocksdb_native_on_compact_range_t> on_compact_range;
 };
 
 struct rocksdb_native_approximate_size_t {
@@ -153,7 +147,7 @@ struct rocksdb_native_approximate_size_t {
 
   js_env_t *env;
   js_persistent_t<js_receiver_t> ctx;
-  js_persistent_t<cb_on_approximate_size_t> on_approximate_size;
+  js_persistent_t<rocksdb_native_on_approximate_size_t> on_approximate_size;
 };
 
 static void
@@ -161,6 +155,21 @@ rocksdb_native__on_free(js_env_t *env, char *data) {
   free(data);
 }
 
+static int
+rocksdb_native__try_create_external_arraybuffer(js_env_t *env, char *data, size_t len, js_arraybuffer_t &result) {
+  int err;
+
+  err = js_create_external_arraybuffer<rocksdb_native__on_free>(env, data, len, result);
+  if (err == 0) return 0;
+
+  err = js_create_arraybuffer(env, data, len, result);
+  assert(err == 0);
+
+  free(data);
+
+  return 0;
+}
+
 static void
 rocksdb_native__on_column_family_teardown(void *data);
 
@@ -174,11 +183,11 @@ rocksdb_native__on_open(rocksdb_open_t *handle, int status) {
 
   auto db = reinterpret_cast<rocksdb_native_t *>(req->handle.req.db);
 
-  js_env_t *env = req->env;
+  auto env = req->env;
 
-  const rocksdb_column_family_descriptor_t *descriptors = handle->column_families;
+  auto descriptors = handle->column_families;
 
-  rocksdb_column_family_t **handles = handle->handles;
+  auto handles = handle->handles;
 
   if (db->exiting) {
     req->on_open.reset();
@@ -192,7 +201,7 @@ rocksdb_native__on_open(rocksdb_open_t *handle, int status) {
     err = js_get_reference_value(env, req->ctx, ctx);
     assert(err == 0);
 
-    cb_on_open_t cb;
+    rocksdb_native_on_open_t cb;
     err = js_get_reference_value(env, req->on_open, cb);
     assert(err == 0);
 
@@ -213,9 +222,8 @@ rocksdb_native__on_open(rocksdb_open_t *handle, int status) {
 
     rocksdb_column_family_t **handles = handle->handles;
 
-    if (req->handle.error == NULL) {
+    if (req->handle.error == nullptr) {
       std::vector<js_arraybuffer_t> elements;
-
       err = js_get_array_elements(env, column_families, elements);
       assert(err == 0);
 
@@ -233,7 +241,7 @@ rocksdb_native__on_open(rocksdb_open_t *handle, int status) {
         err = js_create_reference(env, ctx, column_family->ctx);
         assert(err == 0);
 
-        err = js_add_teardown_callback(env, rocksdb_native__on_column_family_teardown, (void *) column_family);
+        err = js_add_teardown_callback(env, rocksdb_native__on_column_family_teardown, column_family);
         assert(err == 0);
       }
     }
@@ -254,13 +262,13 @@ rocksdb_native__on_close(rocksdb_close_t *handle, int status) {
 
   assert(status == 0);
 
-  rocksdb_native_close_t *req = (rocksdb_native_close_t *) handle->data;
+  auto req = reinterpret_cast<rocksdb_native_close_t *>(handle->data);
 
-  rocksdb_native_t *db = (rocksdb_native_t *) req->handle.req.db;
+  auto db = reinterpret_cast<rocksdb_native_t *>(req->handle.req.db);
 
-  js_env_t *env = req->env;
+  auto env = req->env;
 
-  js_deferred_teardown_t *teardown = db->teardown;
+  auto teardown = db->teardown;
 
   if (db->exiting) {
     db->ctx.reset();
@@ -280,7 +288,7 @@ rocksdb_native__on_close(rocksdb_close_t *handle, int status) {
     err = js_get_reference_value(env, req->ctx, ctx);
     assert(err == 0);
 
-    cb_on_close_t cb;
+    rocksdb_native_on_close_t cb;
     err = js_get_reference_value(env, req->on_close, cb);
     assert(err == 0);
 
@@ -302,9 +310,9 @@ static void
 rocksdb_native__on_teardown(js_deferred_teardown_t *handle, void *data) {
   int err;
 
-  rocksdb_native_t *db = (rocksdb_native_t *) data;
+  auto db = reinterpret_cast<rocksdb_native_t *>(data);
 
-  js_env_t *env = db->env;
+  auto env = db->env;
 
   db->exiting = true;
 
@@ -313,7 +321,7 @@ rocksdb_native__on_teardown(js_deferred_teardown_t *handle, void *data) {
   auto req = reinterpret_cast<rocksdb_native_close_t *>(malloc(sizeof(rocksdb_native_close_t)));
 
   req->env = env;
-  req->handle.data = (void *) req;
+  req->handle.data = req;
 
   err = rocksdb_close(&db->handle, &req->handle, rocksdb_native__on_close);
   assert(err == 0);
@@ -366,7 +374,13 @@ rocksdb_native_init(
   };
 
   err = rocksdb_init(loop, &db->handle);
-  assert(err == 0);
+
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
 
   return handle;
 }
@@ -379,12 +393,11 @@ rocksdb_native_open(
   char *path,
   js_array_t column_families_array,
   js_receiver_t ctx,
-  cb_on_open_t on_open
+  rocksdb_native_on_open_t on_open
 ) {
   int err;
 
   std::vector<js_arraybuffer_t> elements;
-
   err = js_get_array_elements(env, column_families_array, elements);
   assert(err == 0);
 
@@ -415,6 +428,15 @@ rocksdb_native_open(
   req->env = env;
   req->handle.data = req;
 
+  err = rocksdb_open(&db->handle, &req->handle, path, &db->options, column_families, handles, len, rocksdb_native__on_open);
+
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+
   err = js_create_reference(env, self, db->ctx);
   assert(err == 0);
 
@@ -427,10 +449,7 @@ rocksdb_native_open(
   err = js_create_reference(env, column_families_array, req->column_families);
   assert(err == 0);
 
-  err = rocksdb_open(&db->handle, &req->handle, path, &db->options, column_families, handles, len, rocksdb_native__on_open);
-  assert(err == 0);
-
-  err = js_add_deferred_teardown_callback(env, rocksdb_native__on_teardown, (void *) db, &db->teardown);
+  err = js_add_deferred_teardown_callback(env, rocksdb_native__on_teardown, db, &db->teardown);
   assert(err == 0);
 
   return handle;
@@ -441,7 +460,7 @@ rocksdb_native_close(
   js_env_t *env,
   js_arraybuffer_span_of_t<rocksdb_native_t, 1> db,
   js_receiver_t ctx,
-  cb_on_close_t on_close
+  rocksdb_native_on_close_t on_close
 ) {
   int err;
 
@@ -452,7 +471,16 @@ rocksdb_native_close(
   assert(err == 0);
 
   req->env = env;
-  req->handle.data = (void *) req;
+  req->handle.data = req;
+
+  err = rocksdb_close(&db->handle, &req->handle, rocksdb_native__on_close);
+
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
 
   err = js_create_reference(env, ctx, req->ctx);
   assert(err == 0);
@@ -462,9 +490,6 @@ rocksdb_native_close(
 
   db->closing = true;
 
-  err = rocksdb_close(&db->handle, &req->handle, rocksdb_native__on_close);
-  assert(err == 0);
-
   return handle;
 }
 
@@ -474,13 +499,13 @@ rocksdb_native__on_suspend(rocksdb_suspend_t *handle, int status) {
 
   assert(status == 0);
 
-  rocksdb_native_suspend_t *req = (rocksdb_native_suspend_t *) handle->data;
+  auto req = reinterpret_cast<rocksdb_native_suspend_t *>(handle->data);
 
-  rocksdb_native_t *db = (rocksdb_native_t *) req->handle.req.db;
+  auto db = reinterpret_cast<rocksdb_native_t *>(req->handle.req.db);
 
-  js_env_t *env = req->env;
+  auto env = req->env;
 
-  js_deferred_teardown_t *teardown = db->teardown;
+  auto teardown = db->teardown;
 
   if (db->exiting) {
     req->on_suspend.reset();
@@ -494,7 +519,7 @@ rocksdb_native__on_suspend(rocksdb_suspend_t *handle, int status) {
     err = js_get_reference_value(env, req->ctx, ctx);
     assert(err == 0);
 
-    cb_on_suspend_t cb;
+    rocksdb_native_on_suspend_t cb;
     err = js_get_reference_value(env, req->on_suspend, cb);
     assert(err == 0);
 
@@ -517,7 +542,7 @@ rocksdb_native_suspend(
   js_env_t *env,
   js_arraybuffer_span_of_t<rocksdb_native_t, 1> db,
   js_receiver_t ctx,
-  cb_on_suspend_t on_suspend
+  rocksdb_native_on_suspend_t on_suspend
 ) {
   int err;
 
@@ -528,7 +553,16 @@ rocksdb_native_suspend(
   assert(err == 0);
 
   req->env = env;
-  req->handle.data = (void *) req;
+  req->handle.data = req;
+
+  err = rocksdb_suspend(&db->handle, &req->handle, rocksdb_native__on_suspend);
+
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
 
   err = js_create_reference(env, ctx, req->ctx);
   assert(err == 0);
@@ -536,9 +570,6 @@ rocksdb_native_suspend(
   err = js_create_reference(env, on_suspend, req->on_suspend);
   assert(err == 0);
 
-  err = rocksdb_suspend(&db->handle, &req->handle, rocksdb_native__on_suspend);
-  assert(err == 0);
-
   return handle;
 }
 
@@ -548,13 +579,13 @@ rocksdb_native__on_resume(rocksdb_resume_t *handle, int status) {
 
   assert(status == 0);
 
-  rocksdb_native_resume_t *req = (rocksdb_native_resume_t *) handle->data;
+  auto req = reinterpret_cast<rocksdb_native_resume_t *>(handle->data);
 
-  rocksdb_native_t *db = (rocksdb_native_t *) req->handle.req.db;
+  auto db = reinterpret_cast<rocksdb_native_t *>(req->handle.req.db);
 
-  js_env_t *env = req->env;
+  auto env = req->env;
 
-  js_deferred_teardown_t *teardown = db->teardown;
+  auto teardown = db->teardown;
 
   if (db->exiting) {
     req->on_resume.reset();
@@ -568,7 +599,7 @@ rocksdb_native__on_resume(rocksdb_resume_t *handle, int status) {
     err = js_get_reference_value(env, req->ctx, ctx);
     assert(err == 0);
 
-    cb_on_resume_t cb;
+    rocksdb_native_on_resume_t cb;
     err = js_get_reference_value(env, req->on_resume, cb);
     assert(err == 0);
 
@@ -594,7 +625,7 @@ rocksdb_native_resume(
   js_env_t *env,
   js_arraybuffer_span_of_t<rocksdb_native_t, 1> db,
   js_receiver_t ctx,
-  cb_on_resume_t on_resume
+  rocksdb_native_on_resume_t on_resume
 ) {
   int err;
 
@@ -605,7 +636,16 @@ rocksdb_native_resume(
   assert(err == 0);
 
   req->env = env;
-  req->handle.data = (void *) req;
+  req->handle.data = req;
+
+  err = rocksdb_resume(&db->handle, &req->handle, rocksdb_native__on_resume);
+
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
 
   err = js_create_reference(env, ctx, req->ctx);
   assert(err == 0);
@@ -613,9 +653,6 @@ rocksdb_native_resume(
   err = js_create_reference(env, on_resume, req->on_resume);
   assert(err == 0);
 
-  err = rocksdb_resume(&db->handle, &req->handle, rocksdb_native__on_resume);
-  assert(err == 0);
-
   return handle;
 }
 
@@ -623,9 +660,9 @@ static void
 rocksdb_native__on_column_family_teardown(void *data) {
   int err;
 
-  rocksdb_native_column_family_t *column_family = (rocksdb_native_column_family_t *) data;
+  auto column_family = reinterpret_cast<rocksdb_native_column_family_t *>(data);
 
-  js_env_t *env = column_family->env;
+  auto env = column_family->env;
 
   err = rocksdb_column_family_destroy(column_family->db, column_family->handle);
   assert(err == 0);
@@ -688,8 +725,8 @@ rocksdb_native_column_family_init(
   assert(err == 0);
 
   column_family->env = env;
-  column_family->db = NULL;
-  column_family->handle = NULL;
+  column_family->db = nullptr;
+  column_family->handle = nullptr;
 
   column_family->descriptor = (rocksdb_column_family_descriptor_t) {
     name,
@@ -711,7 +748,7 @@ rocksdb_native_column_family_init(
       rocksdb_pinning_tier_t(unpartitioned_pinning_tier),
       optimize_filters_for_hits,
       num_levels,
-      max_write_buffer_number
+      max_write_buffer_number,
     }
   };
 
@@ -725,7 +762,7 @@ rocksdb_native_column_family_destroy(
 ) {
   int err;
 
-  if (column_family->handle == NULL) return;
+  if (column_family->handle == nullptr) return;
 
   err = rocksdb_column_family_destroy(column_family->db, column_family->handle);
   assert(err == 0);
@@ -735,7 +772,7 @@ rocksdb_native_column_family_destroy(
 
   column_family->ctx.reset();
 
-  column_family->handle = NULL;
+  column_family->handle = nullptr;
 }
 
 static js_arraybuffer_t
@@ -772,11 +809,11 @@ rocksdb_native_iterator_buffer(
 
   size_t offset = 0;
 
-  req->keys = (rocksdb_slice_t *) &data[offset];
+  req->keys = reinterpret_cast<rocksdb_slice_t *>(&data[offset]);
 
   offset += capacity * sizeof(rocksdb_slice_t);
 
-  req->values = (rocksdb_slice_t *) &data[offset];
+  req->values = reinterpret_cast<rocksdb_slice_t *>(&data[offset]);
 
   return handle;
 }
@@ -787,13 +824,13 @@ rocksdb_native__on_iterator_close(rocksdb_iterator_t *handle, int status) {
 
   assert(status == 0);
 
-  rocksdb_native_iterator_t *req = (rocksdb_native_iterator_t *) handle->data;
+  auto req = reinterpret_cast<rocksdb_native_iterator_t *>(handle->data);
 
   req->active = false;
 
-  js_env_t *env = req->env;
+  auto env = req->env;
 
-  js_deferred_teardown_t *teardown = req->teardown;
+  auto teardown = req->teardown;
 
   if (req->exiting) {
     req->on_open.reset();
@@ -809,7 +846,7 @@ rocksdb_native__on_iterator_close(rocksdb_iterator_t *handle, int status) {
     err = js_get_reference_value(env, req->ctx, ctx);
     assert(err == 0);
 
-    cb_on_iterator_close_t cb;
+    rocksdb_native_on_iterator_close_t cb;
     err = js_get_reference_value(env, req->on_close, cb);
     assert(err == 0);
 
@@ -841,7 +878,7 @@ rocksdb_native__on_iterator_open(rocksdb_iterator_t *handle, int status) {
 
   assert(status == 0);
 
-  rocksdb_native_iterator_t *req = (rocksdb_native_iterator_t *) handle->data;
+  auto req = reinterpret_cast<rocksdb_native_iterator_t *>(handle->data);
 
   req->active = false;
 
@@ -849,7 +886,7 @@ rocksdb_native__on_iterator_open(rocksdb_iterator_t *handle, int status) {
     err = rocksdb_iterator_close(&req->handle, rocksdb_native__on_iterator_close);
     assert(err == 0);
   } else {
-    js_env_t *env = req->env;
+    auto env = req->env;
 
     js_handle_scope_t *scope;
     err = js_open_handle_scope(env, &scope);
@@ -859,7 +896,7 @@ rocksdb_native__on_iterator_open(rocksdb_iterator_t *handle, int status) {
     err = js_get_reference_value(env, req->ctx, ctx);
     assert(err == 0);
 
-    cb_on_iterator_open_t cb;
+    rocksdb_native_on_iterator_open_t cb;
     err = js_get_reference_value(env, req->on_open, cb);
     assert(err == 0);
 
@@ -881,7 +918,7 @@ static void
 rocksdb_native__on_iterator_teardown(js_deferred_teardown_t *handle, void *data) {
   int err;
 
-  rocksdb_native_iterator_t *req = (rocksdb_native_iterator_t *) data;
+  auto req = reinterpret_cast<rocksdb_native_iterator_t *>(data);
 
   req->exiting = true;
 
@@ -905,14 +942,12 @@ rocksdb_native_iterator_open(
   bool keys_only,
   std::optional<js_arraybuffer_t> snapshot,
   js_receiver_t ctx,
-  cb_on_iterator_open_t on_open,
-  cb_on_iterator_close_t on_close,
-  cb_on_iterator_read_t on_read
+  rocksdb_native_on_iterator_open_t on_open,
+  rocksdb_native_on_iterator_close_t on_close,
+  rocksdb_native_on_iterator_read_t on_read
 ) {
   int err;
 
-  req->active = true;
-
   rocksdb_range_t range;
 
   err = js_get_typedarray_info(env, gt, range.gt.data, range.gt.len);
@@ -938,6 +973,17 @@ rocksdb_native_iterator_open(
     assert(err == 0);
   }
 
+  err = rocksdb_iterator_open(&db->handle, &req->handle, column_family->handle, range, &options, rocksdb_native__on_iterator_open);
+
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+
+  req->active = true;
+
   err = js_create_reference(env, ctx, req->ctx);
   assert(err == 0);
 
@@ -950,10 +996,7 @@ rocksdb_native_iterator_open(
   err = js_create_reference(env, on_read, req->on_read);
   assert(err == 0);
 
-  err = rocksdb_iterator_open(&db->handle, &req->handle, column_family->handle, range, &options, rocksdb_native__on_iterator_open);
-  assert(err == 0);
-
-  err = js_add_deferred_teardown_callback(env, rocksdb_native__on_iterator_teardown, (void *) req, &req->teardown);
+  err = js_add_deferred_teardown_callback(env, rocksdb_native__on_iterator_teardown, req, &req->teardown);
   assert(err == 0);
 }
 
@@ -961,20 +1004,16 @@ static void
 rocksdb_native_iterator_close(js_env_t *env, js_arraybuffer_span_of_t<rocksdb_native_iterator_t, 1> req) {
   int err;
 
-  req->active = true;
-
   err = rocksdb_iterator_close(&req->handle, rocksdb_native__on_iterator_close);
-  assert(err == 0);
-}
 
-static int
-rocksdb_native_try_create_external_arraybuffer(js_env_t *env, char *data, size_t len, js_arraybuffer_t &result) {
-  int err;
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
 
-  err = js_create_external_arraybuffer<rocksdb_native__on_free>(env, data, len, result);
-  if (err == 0) return 0;
+    throw js_pending_exception;
+  }
 
-  return js_create_arraybuffer(env, data, len, result);
+  req->active = true;
 }
 
 static void
@@ -983,16 +1022,16 @@ rocksdb_native__on_iterator_read(rocksdb_iterator_t *handle, int status) {
 
   assert(status == 0);
 
-  rocksdb_native_iterator_t *req = (rocksdb_native_iterator_t *) handle->data;
+  auto req = reinterpret_cast<rocksdb_native_iterator_t *>(handle->data);
 
   req->active = false;
 
-  rocksdb_native_t *db = (rocksdb_native_t *) req->handle.req.db;
+  auto db = reinterpret_cast<rocksdb_native_t *>(req->handle.req.db);
 
   size_t len = req->handle.len;
 
   if (db->exiting) {
-    if (status == 0 && req->handle.error == NULL) {
+    if (status == 0 && req->handle.error == nullptr) {
       for (size_t i = 0; i < len; i++) {
         js_value_t *result;
 
@@ -1005,7 +1044,7 @@ rocksdb_native__on_iterator_read(rocksdb_iterator_t *handle, int status) {
     err = rocksdb_iterator_close(&req->handle, rocksdb_native__on_iterator_close);
     assert(err == 0);
   } else {
-    js_env_t *env = req->env;
+    auto env = req->env;
 
     js_handle_scope_t *scope;
     err = js_open_handle_scope(env, &scope);
@@ -1015,7 +1054,7 @@ rocksdb_native__on_iterator_read(rocksdb_iterator_t *handle, int status) {
     err = js_get_reference_value(env, req->ctx, ctx);
     assert(err == 0);
 
-    cb_on_iterator_read_t cb;
+    rocksdb_native_on_iterator_read_t cb;
     err = js_get_reference_value(env, req->on_read, cb);
     assert(err == 0);
 
@@ -1036,14 +1075,14 @@ rocksdb_native__on_iterator_read(rocksdb_iterator_t *handle, int status) {
 
         rocksdb_slice_t *key = &req->keys[i];
 
-        err = rocksdb_native_try_create_external_arraybuffer(env, const_cast<char *>(key->data), key->len, result);
+        err = rocksdb_native__try_create_external_arraybuffer(env, const_cast<char *>(key->data), key->len, result);
         assert(err == 0);
 
         keys.push_back(result);
 
         rocksdb_slice_t *value = &req->values[i];
 
-        err = rocksdb_native_try_create_external_arraybuffer(env, const_cast<char *>(value->data), value->len, result);
+        err = rocksdb_native__try_create_external_arraybuffer(env, const_cast<char *>(value->data), value->len, result);
         assert(err == 0);
 
         values.push_back(result);
@@ -1065,10 +1104,16 @@ rocksdb_native_iterator_read(
 ) {
   int err;
 
-  req->active = true;
-
   err = rocksdb_iterator_read(&req->handle, req->keys, req->values, capacity, rocksdb_native__on_iterator_read);
-  assert(err == 0);
+
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+
+  req->active = true;
 }
 
 static js_arraybuffer_t
@@ -1113,11 +1158,11 @@ rocksdb_native__on_read(rocksdb_read_batch_t *handle, int status) {
 
   assert(status == 0);
 
-  rocksdb_native_read_batch_t *req = (rocksdb_native_read_batch_t *) handle->data;
+  auto req = reinterpret_cast<rocksdb_native_read_batch_t *>(handle->data);
 
-  rocksdb_native_t *db = (rocksdb_native_t *) req->handle.req.db;
+  auto db = reinterpret_cast<rocksdb_native_t *>(req->handle.req.db);
 
-  js_env_t *env = req->env;
+  auto env = req->env;
 
   size_t len = req->handle.len;
 
@@ -1163,11 +1208,11 @@ rocksdb_native__on_read(rocksdb_read_batch_t *handle, int status) {
 
         rocksdb_slice_t *slice = &req->reads[i].value;
 
-        if (slice->data == NULL && slice->len == (size_t) -1) {
-          err = js_get_null(env, (js_value_t **) result);
+        if (slice->data == nullptr && slice->len == size_t(-1)) {
+          err = js_get_null(env, static_cast<js_value_t **>(result));
           assert(err == 0);
         } else {
-          err = rocksdb_native_try_create_external_arraybuffer(env, const_cast<char *>(slice->data), slice->len, result);
+          err = rocksdb_native__try_create_external_arraybuffer(env, const_cast<char *>(slice->data), slice->len, result);
           assert(err == 0);
         }
 
@@ -1180,7 +1225,7 @@ rocksdb_native__on_read(rocksdb_read_batch_t *handle, int status) {
     err = js_get_reference_value(env, req->ctx, ctx);
     assert(err == 0);
 
-    cb_on_read_t cb;
+    rocksdb_native_on_read_t cb;
     err = js_get_reference_value(env, req->on_read, cb);
     assert(err == 0);
 
@@ -1204,18 +1249,11 @@ rocksdb_native_read(
   bool async_io,
   bool fill_cache,
   js_receiver_t ctx,
-  cb_on_read_t on_read
+  rocksdb_native_on_read_t on_read
 ) {
   int err;
 
-  err = js_create_reference(env, ctx, req->ctx);
-  assert(err == 0);
-
-  err = js_create_reference(env, on_read, req->on_read);
-  assert(err == 0);
-
   std::vector<js_object_t> elements;
-
   err = js_get_array_elements(env, operations, elements);
   assert(err == 0);
 
@@ -1268,6 +1306,18 @@ rocksdb_native_read(
   }
 
   err = rocksdb_read(&db->handle, &req->handle, req->reads, len, &options, rocksdb_native__on_read);
+
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+
+  err = js_create_reference(env, ctx, req->ctx);
+  assert(err == 0);
+
+  err = js_create_reference(env, on_read, req->on_read);
   assert(err == 0);
 }
 
@@ -1313,11 +1363,11 @@ rocksdb_native__on_write(rocksdb_write_batch_t *handle, int status) {
 
   assert(status == 0);
 
-  rocksdb_native_write_batch_t *req = (rocksdb_native_write_batch_t *) handle->data;
+  auto req = reinterpret_cast<rocksdb_native_write_batch_t *>(handle->data);
 
-  rocksdb_native_t *db = (rocksdb_native_t *) req->handle.req.db;
+  auto db = reinterpret_cast<rocksdb_native_t *>(req->handle.req.db);
 
-  js_env_t *env = req->env;
+  auto env = req->env;
 
   if (db->exiting) {
     req->on_write.reset();
@@ -1338,7 +1388,7 @@ rocksdb_native__on_write(rocksdb_write_batch_t *handle, int status) {
     err = js_get_reference_value(env, req->ctx, ctx);
     assert(err == 0);
 
-    cb_on_write_t cb;
+    rocksdb_native_on_write_t cb;
     err = js_get_reference_value(env, req->on_write, cb);
     assert(err == 0);
 
@@ -1359,18 +1409,11 @@ rocksdb_native_write(
   js_arraybuffer_span_of_t<rocksdb_native_write_batch_t, 1> req,
   js_array_t operations,
   js_receiver_t ctx,
-  cb_on_write_t on_write
+  rocksdb_native_on_write_t on_write
 ) {
   int err;
 
-  err = js_create_reference(env, ctx, req->ctx);
-  assert(err == 0);
-
-  err = js_create_reference(env, on_write, req->on_write);
-  assert(err == 0);
-
   std::vector<js_object_t> elements;
-
   err = js_get_array_elements(env, operations, elements);
   assert(err == 0);
 
@@ -1449,7 +1492,19 @@ rocksdb_native_write(
     }
   }
 
-  err = rocksdb_write(&db->handle, &req->handle, req->writes, len, NULL, rocksdb_native__on_write);
+  err = rocksdb_write(&db->handle, &req->handle, req->writes, len, nullptr, rocksdb_native__on_write);
+
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+
+  err = js_create_reference(env, ctx, req->ctx);
+  assert(err == 0);
+
+  err = js_create_reference(env, on_write, req->on_write);
   assert(err == 0);
 }
 
@@ -1459,11 +1514,11 @@ rocksdb_native__on_flush(rocksdb_flush_t *handle, int status) {
 
   assert(status == 0);
 
-  rocksdb_native_flush_t *req = (rocksdb_native_flush_t *) handle->data;
+  auto req = reinterpret_cast<rocksdb_native_flush_t *>(handle->data);
 
-  rocksdb_native_t *db = (rocksdb_native_t *) req->handle.req.db;
+  auto db = reinterpret_cast<rocksdb_native_t *>(req->handle.req.db);
 
-  js_env_t *env = req->env;
+  auto env = req->env;
 
   if (db->exiting) {
     req->on_flush.reset();
@@ -1484,7 +1539,7 @@ rocksdb_native__on_flush(rocksdb_flush_t *handle, int status) {
     err = js_get_reference_value(env, req->ctx, ctx);
     assert(err == 0);
 
-    cb_on_flush_t cb;
+    rocksdb_native_on_flush_t cb;
     err = js_get_reference_value(env, req->on_flush, cb);
     assert(err == 0);
 
@@ -1504,7 +1559,7 @@ rocksdb_native_flush(
   js_arraybuffer_span_of_t<rocksdb_native_t, 1> db,
   js_arraybuffer_span_of_t<rocksdb_native_column_family_t, 1> column_family,
   js_receiver_t ctx,
-  cb_on_flush_t on_flush
+  rocksdb_native_on_flush_t on_flush
 ) {
   int err;
 
@@ -1515,52 +1570,37 @@ rocksdb_native_flush(
   assert(err == 0);
 
   req->env = env;
-  req->handle.data = (void *) req;
-
-  err = js_create_reference(env, ctx, req->ctx);
-  assert(err == 0);
-
-  err = js_create_reference(env, on_flush, req->on_flush);
-  assert(err == 0);
-
-  err = rocksdb_flush(&db->handle, &req->handle, column_family->handle, NULL, rocksdb_native__on_flush);
-  assert(err == 0);
+  req->handle.data = req;
 
-  return handle;
-}
+  err = rocksdb_flush(&db->handle, &req->handle, column_family->handle, nullptr, rocksdb_native__on_flush);
 
-static js_arraybuffer_t
-rocksdb_native_snapshot_create(js_env_t *env, js_arraybuffer_span_of_t<rocksdb_native_t, 1> db) {
-  int err;
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
 
-  js_arraybuffer_t handle;
+    throw js_pending_exception;
+  }
 
-  rocksdb_native_snapshot_t *snapshot;
-  err = js_create_arraybuffer(env, snapshot, handle);
+  err = js_create_reference(env, ctx, req->ctx);
   assert(err == 0);
 
-  err = rocksdb_snapshot_create(&db->handle, &snapshot->handle);
+  err = js_create_reference(env, on_flush, req->on_flush);
   assert(err == 0);
 
   return handle;
 }
 
-static void
-rocksdb_native_snapshot_destroy(js_env_t *env, js_arraybuffer_span_of_t<rocksdb_native_snapshot_t, 1> snapshot) {
-  rocksdb_snapshot_destroy(&snapshot->handle);
-}
-
 static void
 rocksdb_native__on_compact_range(rocksdb_compact_range_t *handle, int status) {
   int err;
 
   assert(status == 0);
 
-  rocksdb_native_compact_range_t *req = (rocksdb_native_compact_range_t *) handle->data;
+  auto req = reinterpret_cast<rocksdb_native_compact_range_t *>(handle->data);
 
-  rocksdb_native_t *db = (rocksdb_native_t *) req->handle.req.db;
+  auto db = reinterpret_cast<rocksdb_native_t *>(req->handle.req.db);
 
-  js_env_t *env = req->env;
+  auto env = req->env;
 
   if (db->exiting) {
     req->on_compact_range.reset();
@@ -1581,7 +1621,7 @@ rocksdb_native__on_compact_range(rocksdb_compact_range_t *handle, int status) {
     err = js_get_reference_value(env, req->ctx, ctx);
     assert(err == 0);
 
-    cb_on_compact_range_t cb;
+    rocksdb_native_on_compact_range_t cb;
     err = js_get_reference_value(env, req->on_compact_range, cb);
     assert(err == 0);
 
@@ -1604,10 +1644,18 @@ rocksdb_native_compact_range(
   js_typedarray_t<> end,
   bool exclusive,
   js_receiver_t ctx,
-  cb_on_compact_range_t on_compact_range
+  rocksdb_native_on_compact_range_t on_compact_range
 ) {
   int err;
 
+  rocksdb_slice_t start_slice;
+  err = js_get_typedarray_info(env, start, start_slice.data, start_slice.len);
+  assert(err == 0);
+
+  rocksdb_slice_t end_slice;
+  err = js_get_typedarray_info(env, end, end_slice.data, end_slice.len);
+  assert(err == 0);
+
   js_arraybuffer_t handle;
 
   rocksdb_native_compact_range_t *req;
@@ -1615,28 +1663,26 @@ rocksdb_native_compact_range(
   assert(err == 0);
 
   req->env = env;
-  req->handle.data = (void *) req;
-
-  err = js_create_reference(env, ctx, req->ctx);
-  assert(err == 0);
-
-  err = js_create_reference(env, on_compact_range, req->on_compact_range);
-  assert(err == 0);
+  req->handle.data = req;
 
   rocksdb_compact_range_options_t options = {
     .version = 0,
     .exclusive_manual_compaction = exclusive
   };
 
-  rocksdb_slice_t start_slice;
-  err = js_get_typedarray_info(env, start, start_slice.data, start_slice.len);
-  assert(err == 0);
+  err = rocksdb_compact_range(&db->handle, &req->handle, column_family->handle, start_slice, end_slice, &options, rocksdb_native__on_compact_range);
 
-  rocksdb_slice_t end_slice;
-  err = js_get_typedarray_info(env, end, end_slice.data, end_slice.len);
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+
+  err = js_create_reference(env, ctx, req->ctx);
   assert(err == 0);
 
-  err = rocksdb_compact_range(&db->handle, &req->handle, column_family->handle, start_slice, end_slice, &options, rocksdb_native__on_compact_range);
+  err = js_create_reference(env, on_compact_range, req->on_compact_range);
   assert(err == 0);
 
   return handle;
@@ -1648,11 +1694,11 @@ rocksdb_native__on_approximate_size(rocksdb_approximate_size_t *handle, int stat
 
   assert(status == 0);
 
-  rocksdb_native_approximate_size_t *req = (rocksdb_native_approximate_size_t *) handle->data;
+  auto req = reinterpret_cast<rocksdb_native_approximate_size_t *>(handle->data);
 
-  rocksdb_native_t *db = (rocksdb_native_t *) req->handle.req.db;
+  auto db = reinterpret_cast<rocksdb_native_t *>(req->handle.req.db);
 
-  js_env_t *env = req->env;
+  auto env = req->env;
 
   if (db->exiting) {
     req->on_approximate_size.reset();
@@ -1673,7 +1719,7 @@ rocksdb_native__on_approximate_size(rocksdb_approximate_size_t *handle, int stat
     err = js_get_reference_value(env, req->ctx, ctx);
     assert(err == 0);
 
-    cb_on_approximate_size_t cb;
+    rocksdb_native_on_approximate_size_t cb;
     err = js_get_reference_value(env, req->on_approximate_size, cb);
     assert(err == 0);
 
@@ -1698,10 +1744,18 @@ rocksdb_native_approximate_size(
   bool include_files,
   double error_margin,
   js_receiver_t ctx,
-  cb_on_approximate_size_t on_approximate_size
+  rocksdb_native_on_approximate_size_t on_approximate_size
 ) {
   int err;
 
+  rocksdb_slice_t start_slice;
+  err = js_get_typedarray_info(env, start, start_slice.data, start_slice.len);
+  assert(err == 0);
+
+  rocksdb_slice_t end_slice;
+  err = js_get_typedarray_info(env, end, end_slice.data, end_slice.len);
+  assert(err == 0);
+
   js_arraybuffer_t handle;
 
   rocksdb_native_approximate_size_t *req;
@@ -1709,13 +1763,7 @@ rocksdb_native_approximate_size(
   assert(err == 0);
 
   req->env = env;
-  req->handle.data = (void *) req;
-
-  err = js_create_reference(env, ctx, req->ctx);
-  assert(err == 0);
-
-  err = js_create_reference(env, on_approximate_size, req->on_approximate_size);
-  assert(err == 0);
+  req->handle.data = req;
 
   rocksdb_approximate_size_options_t options = {
     .version = 0,
@@ -1724,20 +1772,51 @@ rocksdb_native_approximate_size(
     .files_size_error_margin = error_margin,
   };
 
-  rocksdb_slice_t start_slice;
-  err = js_get_typedarray_info(env, start, start_slice.data, start_slice.len);
+  err = rocksdb_approximate_size(&db->handle, &req->handle, column_family->handle, start_slice, end_slice, &options, rocksdb_native__on_approximate_size);
+
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+
+  err = js_create_reference(env, ctx, req->ctx);
   assert(err == 0);
 
-  rocksdb_slice_t end_slice;
-  err = js_get_typedarray_info(env, end, end_slice.data, end_slice.len);
+  err = js_create_reference(env, on_approximate_size, req->on_approximate_size);
   assert(err == 0);
 
-  err = rocksdb_approximate_size(&db->handle, &req->handle, column_family->handle, start_slice, end_slice, &options, rocksdb_native__on_approximate_size);
+  return handle;
+}
+
+static js_arraybuffer_t
+rocksdb_native_snapshot_create(js_env_t *env, js_arraybuffer_span_of_t<rocksdb_native_t, 1> db) {
+  int err;
+
+  js_arraybuffer_t handle;
+
+  rocksdb_native_snapshot_t *snapshot;
+  err = js_create_arraybuffer(env, snapshot, handle);
   assert(err == 0);
 
+  err = rocksdb_snapshot_create(&db->handle, &snapshot->handle);
+
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+
   return handle;
 }
 
+static void
+rocksdb_native_snapshot_destroy(js_env_t *env, js_arraybuffer_span_of_t<rocksdb_native_snapshot_t, 1> snapshot) {
+  rocksdb_snapshot_destroy(&snapshot->handle);
+}
+
 static js_value_t *
 rocksdb_native_exports(js_env_t *env, js_value_t *exports) {
   int err;
@@ -1770,12 +1849,11 @@ rocksdb_native_exports(js_env_t *env, js_value_t *exports) {
   V("iteratorRead", rocksdb_native_iterator_read)
 
   V("flush", rocksdb_native_flush)
+  V("compactRange", rocksdb_native_compact_range)
+  V("approximateSize", rocksdb_native_approximate_size)
 
   V("snapshotCreate", rocksdb_native_snapshot_create)
   V("snapshotDestroy", rocksdb_native_snapshot_destroy)
-
-  V("compactRange", rocksdb_native_compact_range)
-  V("approximateSize", rocksdb_native_approximate_size)
 #undef V
 
 #define V(name, n) \

package/lib/iterator.js

@@ -137,7 +137,8 @@ module.exports = class RocksDBIterator extends Readable {
       )
     } catch (err) {
       this._db._state.io.dec()
-      throw err
+
+      cb(err)
     }
   }
 
@@ -160,7 +161,8 @@ module.exports = class RocksDBIterator extends Readable {
       binding.iteratorRead(this._handle, Math.min(this._capacity, this._limit))
     } catch (err) {
       this._db._state.io.dec()
-      throw err
+
+      cb(err)
     }
   }
 
@@ -169,19 +171,22 @@ module.exports = class RocksDBIterator extends Readable {
 
     this._db._state.io.inc()
 
-    this._pendingDestroy = cb
-
     if (this._opened === false) {
       this._db._state.io.dec()
+      this._db._unref()
 
-      return this._onclose(null)
+      return cb(null)
     }
 
+    this._pendingDestroy = cb
+
     try {
       binding.iteratorClose(this._handle)
     } catch (err) {
       this._db._state.io.dec()
-      throw err
+      this._db._unref()
+
+      cb(err)
     }
   }
 

package/lib/state.js

@@ -83,6 +83,7 @@ module.exports = class RocksDBState extends ReadyResource {
   }
 
   freeBatch(batch, writable) {
+    if (batch._capacity > 16) return
     const queue = writable ? this._writeBatches : this._readBatches
     if (queue.length >= MAX_BATCH_REUSE) return
     queue.push(batch)
@@ -320,7 +321,10 @@ module.exports = class RocksDBState extends ReadyResource {
 
     const { exclusive = false } = opts
 
-    const req = { resolve: null, reject: null, handle: null }
+    start = this._encodeKey(start)
+    end = this._encodeKey(end)
+
+    const req = { resolve: null, reject: null, handle: null, start, end }
 
     const promise = new Promise((resolve, reject) => {
       req.resolve = resolve
@@ -331,8 +335,8 @@ module.exports = class RocksDBState extends ReadyResource {
       req.handle = binding.compactRange(
         this._handle,
         db._columnFamily._handle,
-        this._encodeKey(start),
-        this._encodeKey(end),
+        start,
+        end,
         exclusive,
         req,
         oncompactrange
@@ -356,7 +360,10 @@ module.exports = class RocksDBState extends ReadyResource {
 
     const { includeMemtables = false, includeFiles = true, filesSizeErrorMargin = -1 } = opts
 
-    const req = { resolve: null, reject: null, handle: null }
+    start = this._encodeKey(start)
+    end = this._encodeKey(end)
+
+    const req = { resolve: null, reject: null, handle: null, start, end }
 
     const promise = new Promise((resolve, reject) => {
       req.resolve = resolve
@@ -367,8 +374,8 @@ module.exports = class RocksDBState extends ReadyResource {
       req.handle = binding.approximateSize(
         this._handle,
         db._columnFamily._handle,
-        this._encodeKey(start),
-        this._encodeKey(end),
+        start,
+        end,
         includeMemtables,
         includeFiles,
         filesSizeErrorMargin,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rocksdb-native",
-  "version": "3.9.1",
+  "version": "3.9.3",
   "description": "librocksdb bindings for JavaScript",
   "exports": {
     ".": "./index.js",