@nxtedition/rocksdb 7.0.30 → 7.0.33

package/binding.cc

@@ -814,9 +814,8 @@ NAPI_METHOD(db_open) {
 
   rocksdb::Options dbOptions;
 
-  const auto parallelismValue = Uint32Property(env, argv[2], "parallelism")
-                                    .value_or(std::max<uint32_t>(1, std::thread::hardware_concurrency() / 2));
-  dbOptions.IncreaseParallelism(parallelismValue);
+  dbOptions.IncreaseParallelism(Uint32Property(env, argv[2], "parallelism")
+                                    .value_or(std::max<uint32_t>(1, std::thread::hardware_concurrency() / 2)));
 
   dbOptions.create_if_missing = BooleanProperty(env, argv[2], "createIfMissing").value_or(true);
   dbOptions.error_if_exists = BooleanProperty(env, argv[2], "errorIfExists").value_or(false);
@@ -824,8 +823,6 @@ NAPI_METHOD(db_open) {
   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.max_background_jobs = Uint32Property(env, argv[2], "maxBackgroundJobs")
-                                      .value_or(std::max<uint32_t>(2, std::thread::hardware_concurrency() / 8));
   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)
@@ -836,46 +833,6 @@ NAPI_METHOD(db_open) {
   dbOptions.fail_if_options_file_error = true;
   dbOptions.manual_wal_flush = BooleanProperty(env, argv[2], "manualWalFlush").value_or(false);
 
-  napi_value ret;
-  NAPI_STATUS_THROWS(napi_create_object(env, &ret));
-  {
-    napi_value parallelism;
-    NAPI_STATUS_THROWS(napi_create_int64(env, parallelismValue, &parallelism));
-    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "parallelism", parallelism));
-
-    napi_value createIfMissing;
-    NAPI_STATUS_THROWS(napi_get_boolean(env, dbOptions.create_if_missing, &createIfMissing));
-    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "createIfMissing", createIfMissing));
-
-    napi_value errorIfExists;
-    NAPI_STATUS_THROWS(napi_get_boolean(env, dbOptions.error_if_exists, &errorIfExists));
-    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "errorIfExists", errorIfExists));
-
-    napi_value maxBackgroundJobs;
-    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.max_background_jobs, &maxBackgroundJobs));
-    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "maxBackgroundJobs", maxBackgroundJobs));
-
-    napi_value walTTL;
-    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.WAL_ttl_seconds, &walTTL));
-    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "walTTL", walTTL));
-
-    napi_value walSizeLimit;
-    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.WAL_size_limit_MB, &walSizeLimit));
-    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "walSizeLimit", walSizeLimit));
-
-    napi_value walCompression;
-    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.wal_compression, &walCompression));
-    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "walCompression", walCompression));
-
-    napi_value unorderedWrite;
-    NAPI_STATUS_THROWS(napi_get_boolean(env, dbOptions.error_if_exists, &unorderedWrite));
-    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "unorderedWrite", unorderedWrite));
-
-    napi_value manualWalFlush;
-    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.manual_wal_flush, &manualWalFlush));
-    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "manualWalFlush", manualWalFlush));
-  }
-
   // TODO (feat): dbOptions.listeners
 
   const auto infoLogLevel = StringProperty(env, argv[2], "infoLogLevel").value_or("");
@@ -939,7 +896,7 @@ NAPI_METHOD(db_open) {
   auto worker = new OpenWorker(env, database, argv[3], location, dbOptions, columnsFamilies);
   worker->Queue(env);
 
-  return ret;
+  return 0;
 }
 
 struct CloseWorker final : public Worker {
@@ -1149,15 +1106,30 @@ NAPI_METHOD(updates_init) {
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  const auto seqNumber = Int64Property(env, argv[1], "since").value_or(database->db_->GetLatestSequenceNumber());
-  const auto keys = BooleanProperty(env, argv[1], "keys").value_or(true);
-  const auto values = BooleanProperty(env, argv[1], "values").value_or(true);
-  const auto data = BooleanProperty(env, argv[1], "data").value_or(true);
+  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));
+
+  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));
+
+  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));
+
+  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));
 
   rocksdb::ColumnFamilyHandle* column;
   NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[1], &column, false));
 
-  auto updates = std::make_unique<Updates>(database, seqNumber, keys, values, data, column);
+  auto updates = std::make_unique<Updates>(database, since, keys, values, data, column);
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, updates.get(), Finalize<Updates>, updates.get(), &result));

package/index.js

@@ -6,11 +6,11 @@ const fs = require('fs')
 const binding = require('./binding')
 const { ChainedBatch } = require('./chained-batch')
 const { Iterator } = require('./iterator')
+const os = require('os')
 
 const kContext = Symbol('context')
 const kColumns = Symbol('columns')
 const kLocation = Symbol('location')
-const kOptions = Symbol('options')
 
 class RocksLevel extends AbstractLevel {
   constructor (location, options, _) {
@@ -25,6 +25,21 @@ class RocksLevel extends AbstractLevel {
       throw new TypeError("The first argument 'location' must be a non-empty string")
     }
 
+    options = {
+      ...options, // TODO (fix): Other defaults...
+      parallelism: options?.parallelism ?? Math.max(1, os.cpus().length / 2),
+      createIfMissing: options?.createIfMissing ?? true,
+      errorIfExists: options?.errorIfExists ?? false,
+      walTTL: options?.walTTL ?? 0,
+      walSizeLimit: options?.walSizeLimit ?? 0,
+      walCompression: options?.walCompression ?? false,
+      unorderedWrite: options?.unorderedWrite ?? false,
+      manualWalFlush: options?.manualWalFlush ?? false,
+      infoLogLevel: options?.infoLogLevel ?? ''
+    }
+
+    // TODO (fix): Check options.
+
     super({
       encodings: {
         buffer: true,
@@ -44,10 +59,6 @@ class RocksLevel extends AbstractLevel {
     this[kColumns] = {}
   }
 
-  get options () {
-    return this[kOptions]
-  }
-
   get sequence () {
     return Number(binding.db_get_latest_sequence(this[kContext]))
   }
@@ -72,10 +83,10 @@ class RocksLevel extends AbstractLevel {
     if (options.createIfMissing) {
       fs.mkdir(this[kLocation], { recursive: true }, (err) => {
         if (err) return callback(err)
-        this[kOptions] = binding.db_open(this[kContext], this[kLocation], options, onOpen)
+        binding.db_open(this[kContext], this[kLocation], options, onOpen)
       })
     } else {
-      this[kOptions] = binding.db_open(this[kContext], this[kLocation], options, onOpen)
+      binding.db_open(this[kContext], this[kLocation], options, onOpen)
     }
   }
 
@@ -151,14 +162,32 @@ class RocksLevel extends AbstractLevel {
   }
 
   async getCurrentWALFile () {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
     return binding.db_get_current_wal_file(this[kContext])
   }
 
   async getSortedWALFiles () {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
     return binding.db_get_sorted_wal_files(this[kContext])
   }
 
   async flushWAL (options) {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
     binding.db_flush_wal(this[kContext], options)
   }
 
@@ -208,6 +237,34 @@ class RocksLevel extends AbstractLevel {
       })
     }
 
+    options = {
+      since: options?.since ?? 0,
+      keys: options?.keys ?? true,
+      values: options?.values ?? true,
+      data: options?.data ?? true,
+      column: options?.column ?? null
+    }
+
+    if (typeof options.since !== 'number') {
+      throw new TypeError("'since' must be nully or a number")
+    }
+
+    if (typeof options.keys !== 'boolean') {
+      throw new TypeError("'keys' must be nully or a boolean")
+    }
+
+    if (typeof options.values !== 'boolean') {
+      throw new TypeError("'values' must be nully or a boolean")
+    }
+
+    if (typeof options.data !== 'boolean') {
+      throw new TypeError("'data' must be nully or a boolean")
+    }
+
+    if (typeof options.column !== 'object') {
+      throw new TypeError("'column' must be nully or a object")
+    }
+
     class Updates {
       constructor (db, options) {
         this.context = binding.updates_init(db[kContext], options)

package/package.json

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