@nxtedition/rocksdb 15.5.0 → 16.0.1

package/binding.cc

@@ -551,10 +551,10 @@ class Iterator final : public BaseIterator {
     rocksdb::ColumnFamilyHandle* column = database->db->DefaultColumnFamily();
     NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
 
-    Encoding keyEncoding;
+    Encoding keyEncoding = Encoding::Buffer;
     NAPI_STATUS_THROWS(GetProperty(env, options, "keyEncoding", keyEncoding));
 
-    Encoding valueEncoding;
+    Encoding valueEncoding = Encoding::Buffer;
     NAPI_STATUS_THROWS(GetProperty(env, options, "valueEncoding", valueEncoding));
 
     rocksdb::ReadOptions readOptions;
@@ -601,6 +601,7 @@ class Iterator final : public BaseIterator {
       std::vector<rocksdb::PinnableSlice> keys;
       std::vector<rocksdb::PinnableSlice> values;
       size_t count = 0;
+      size_t bytes = 0;
       bool finished = false;
       bool limited = false;
     };
@@ -616,14 +617,16 @@ class Iterator final : public BaseIterator {
 
           const auto deadline = timeout ? database_->db->GetEnv()->NowMicros() + timeout * 1000 : 0;
 
-          size_t bytesRead = 0;
           while (true) {
-            if (state.count >= count || bytesRead > highWaterMarkBytes_) {
+            if (state.count >= count || state.bytes > highWaterMarkBytes_) {
+              // Batch cap (size/bytes) reached: more data may exist, so this is
+              // "limited", not "finished".
               state.limited = true;
               break;
             }
 
             if (deadline > 0 && database_->db->GetEnv()->NowMicros() > deadline) {
+              // Timed out: neither finished nor limited; the caller may retry.
               break;
             }
 
@@ -635,12 +638,19 @@ class Iterator final : public BaseIterator {
 
             ROCKS_STATUS_RETURN(Status());
 
-            if (!Valid() || !Increment()) {
+            if (!Valid()) {
+              // Iterator naturally exhausted.
               state.finished = true;
               break;
             }
 
-            bytesRead += CurrentKey().size() + CurrentValue().size();
+            if (!Increment()) {
+              // Hit the user's `limit` option: terminal, and flag that it was a
+              // limit rather than natural exhaustion.
+              state.finished = true;
+              state.limited = true;
+              break;
+            }
 
             if (keyFilter_ && !re2::RE2::PartialMatch(CurrentKey().ToStringView(), *keyFilter_)) {
               continue;
@@ -653,18 +663,22 @@ class Iterator final : public BaseIterator {
             if (keys_ && values_) {
               rocksdb::PinnableSlice k;
               k.PinSelf(CurrentKey());
+              state.bytes += k.size();
               state.keys.push_back(std::move(k));
 
               rocksdb::PinnableSlice v;
               v.PinSelf(CurrentValue());
+              state.bytes += v.size();
               state.values.push_back(std::move(v));
             } else if (keys_) {
               rocksdb::PinnableSlice k;
               k.PinSelf(CurrentKey());
+              state.bytes += k.size();
               state.keys.push_back(std::move(k));
             } else if (values_) {
               rocksdb::PinnableSlice v;
               v.PinSelf(CurrentValue());
+              state.bytes += v.size();
               state.values.push_back(std::move(v));
             } else {
               assert(false);
@@ -729,14 +743,18 @@ class Iterator final : public BaseIterator {
     const auto deadline = timeout ? database_->db->GetEnv()->NowMicros() + timeout * 1000 : 0;
 
     size_t idx = 0;
-    size_t bytesRead = 0;
+    size_t bytes = 0;
     while (true) {
-      if (idx >= count * 2 || bytesRead > highWaterMarkBytes_) {
+      if (idx >= static_cast<size_t>(count) * 2 || bytes > highWaterMarkBytes_) {
+        // Batch cap (size/bytes) reached: more data may exist, so this is
+        // "limited", not "finished". (count is uint32_t; widen before *2 so
+        // query()'s UINT32_MAX count doesn't overflow to a small cap.)
         NAPI_STATUS_THROWS(napi_get_boolean(env, true, &limited));
         break;
       }
 
       if (deadline > 0 && database_->db->GetEnv()->NowMicros() > deadline) {
+        // Timed out: neither finished nor limited; the caller may retry.
         break;
       }
 
@@ -748,12 +766,19 @@ class Iterator final : public BaseIterator {
 
       ROCKS_STATUS_THROWS_NAPI(Status());
 
-      if (!Valid() || !Increment()) {
+      if (!Valid()) {
+        // Iterator naturally exhausted.
         NAPI_STATUS_THROWS(napi_get_boolean(env, true, &finished));
         break;
       }
 
-      bytesRead += CurrentKey().size() + CurrentValue().size();
+      if (!Increment()) {
+        // Hit the user's `limit` option: terminal, and flag that it was a limit
+        // rather than natural exhaustion.
+        NAPI_STATUS_THROWS(napi_get_boolean(env, true, &finished));
+        NAPI_STATUS_THROWS(napi_get_boolean(env, true, &limited));
+        break;
+      }
 
       if (keyFilter_ && !re2::RE2::PartialMatch(CurrentKey().ToStringView(), *keyFilter_)) {
         continue;
@@ -767,12 +792,15 @@ class Iterator final : public BaseIterator {
       napi_value val;
 
       if (keys_ && values_) {
+        bytes += CurrentKey().size() + CurrentValue().size();
         NAPI_STATUS_THROWS(Convert(env, CurrentKey(), keyEncoding_, key, unsafe_));
         NAPI_STATUS_THROWS(Convert(env, CurrentValue(), valueEncoding_, val, unsafe_));
       } else if (keys_) {
+        bytes += CurrentKey().size();
         NAPI_STATUS_THROWS(Convert(env, CurrentKey(), keyEncoding_, key, unsafe_));
         NAPI_STATUS_THROWS(napi_get_undefined(env, &val));
       } else if (values_) {
+        bytes += CurrentValue().size();
         NAPI_STATUS_THROWS(napi_get_undefined(env, &key));
         NAPI_STATUS_THROWS(Convert(env, CurrentValue(), valueEncoding_, val, unsafe_));
       } else {
@@ -1233,6 +1261,11 @@ NAPI_METHOD(db_get_identity) {
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
+  if (!database->db) {
+    napi_throw_error(env, "LEVEL_DATABASE_NOT_OPEN", "Database is not open");
+    return NULL;
+  }
+
   std::string identity;
   ROCKS_STATUS_THROWS_NAPI(database->db->GetDbIdentity(identity));
 
@@ -1733,6 +1766,11 @@ NAPI_METHOD(db_get_latest_sequence) {
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
+  if (!database->db) {
+    napi_throw_error(env, "LEVEL_DATABASE_NOT_OPEN", "Database is not open");
+    return NULL;
+  }
+
   const auto seq = database->db->GetLatestSequenceNumber();
 
   napi_value result;

package/index.js

@@ -52,6 +52,12 @@ class RocksLevel extends AbstractLevel {
   }
 
   get sequence () {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
     return binding.db_get_latest_sequence(this[kContext])
   }
 
@@ -112,7 +118,14 @@ class RocksLevel extends AbstractLevel {
   [kUnref] () {
     this[kRefs]--
     if (this[kRefs] === 0 && this[kPendingClose]) {
-      process.nextTick(this[kPendingClose])
+      // Perform the deferred native close now that all in-flight ops have
+      // drained. Note: kPendingClose holds the abstract-level _close callback,
+      // so we must call binding.db_close here (not just the callback) or the
+      // native DB and its directory lock would leak. nextTick avoids reentering
+      // the native layer from within the completing op's own callback.
+      const callback = this[kPendingClose]
+      this[kPendingClose] = null
+      process.nextTick(() => binding.db_close(this[kContext], callback))
     }
   }
 
@@ -243,10 +256,22 @@ class RocksLevel extends AbstractLevel {
       }
     }
 
-    binding.batch_write(this[kContext], batch, options ?? {}, (err, val) => {
+    // Hold a db ref for the duration of the write so close() defers db_close
+    // (which frees the native db on a worker thread) until it completes. The
+    // array-form batch uses a transient WriteBatch that is not an abstract-level
+    // resource, so it is not otherwise tracked across close.
+    this[kRef]()
+    try {
+      binding.batch_write(this[kContext], batch, options ?? {}, (err, val) => {
+        this[kUnref]()
+        binding.batch_clear(batch)
+        callback(err, val)
+      })
+    } catch (err) {
+      this[kUnref]()
       binding.batch_clear(batch)
-      callback(err, val)
-    })
+      process.nextTick(callback, err)
+    }
 
     return callback[kPromise]
   }
@@ -256,6 +281,12 @@ class RocksLevel extends AbstractLevel {
   }
 
   get identity () {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
     return binding.db_get_identity(this[kContext])
   }
 
@@ -305,10 +336,21 @@ class RocksLevel extends AbstractLevel {
 
     const handle = binding.updates_init(this[kContext], options)
     try {
-      while (true) {
-        const value = await new Promise((resolve, reject) => {
-          binding.updates_next(handle, (err, val) => err ? reject(err) : resolve(val))
-        })
+      // Stop if the db is closed between yields, so we never call updates_next
+      // on a freed db.
+      while (this.status === 'open') {
+        // Hold a db ref for the duration of each updates_next so close() defers
+        // db_close (and the Database::Close() that resets this log iterator on a
+        // worker thread) until the in-flight read completes.
+        this[kRef]()
+        let value
+        try {
+          value = await new Promise((resolve, reject) => {
+            binding.updates_next(handle, (err, val) => err ? reject(err) : resolve(val))
+          })
+        } finally {
+          this[kUnref]()
+        }
         if (!value) {
           break
         }
@@ -328,7 +370,16 @@ class RocksLevel extends AbstractLevel {
       })
     }
 
-    binding.db_compact_range(this[kContext], options, callback)
+    this[kRef]()
+    try {
+      binding.db_compact_range(this[kContext], options, (err, val) => {
+        this[kUnref]()
+        callback(err, val)
+      })
+    } catch (err) {
+      this[kUnref]()
+      process.nextTick(callback, err)
+    }
 
     return callback[kPromise]
   }
@@ -342,7 +393,16 @@ class RocksLevel extends AbstractLevel {
       })
     }
 
-    binding.db_flush_wal(this[kContext], options?.sync ?? false, callback)
+    this[kRef]()
+    try {
+      binding.db_flush_wal(this[kContext], options?.sync ?? false, (err, val) => {
+        this[kUnref]()
+        callback(err, val)
+      })
+    } catch (err) {
+      this[kUnref]()
+      process.nextTick(callback, err)
+    }
 
     return callback[kPromise]
   }

package/iterator.js

@@ -15,6 +15,7 @@ const kFinished = Symbol('finished')
 const kFirst = Symbol('first')
 const kPosition = Symbol('position')
 const kBusy = Symbol('busy')
+const kPendingClose = Symbol('pendingClose')
 
 const kEmpty = Object.freeze([])
 
@@ -30,6 +31,7 @@ class Iterator extends AbstractIterator {
     this[kPosition] = 0
     this[kDB] = db
     this[kBusy] = false
+    this[kPendingClose] = null
   }
 
   [Symbol.asyncDispose] () {
@@ -41,7 +43,23 @@ class Iterator extends AbstractIterator {
   }
 
   _close (callback) {
-    return this._closeAsync(callback)
+    // If an async nextv/seek is in flight on a worker thread, defer the close
+    // until it completes so we never free the native rocksdb iterator while the
+    // worker is still reading it. The pending close is flushed from the async
+    // op's completion callback (see _flushPendingClose).
+    if (this[kBusy]) {
+      this[kPendingClose] = callback
+    } else {
+      this._closeAsync(callback)
+    }
+  }
+
+  _flushPendingClose () {
+    if (!this[kBusy] && this[kPendingClose]) {
+      const callback = this[kPendingClose]
+      this[kPendingClose] = null
+      this._closeAsync(callback)
+    }
   }
 
   _end (callback) {
@@ -147,6 +165,8 @@ class Iterator extends AbstractIterator {
         } else {
           callback(null)
         }
+
+        this._flushPendingClose()
       })
     } catch (err) {
       this[kBusy] = false
@@ -193,6 +213,8 @@ class Iterator extends AbstractIterator {
             this[kFinished] = result.finished
             callback(null, result)
           }
+
+          this._flushPendingClose()
         })
       }
     } catch (err) {

package/max_rev_operator.h

@@ -13,10 +13,14 @@ int compareRev(const rocksdb::Slice& a, const rocksdb::Slice& b) {
     return 1;
   }
 
-  std::size_t indexA = 0;
-  std::size_t indexB = 0;
-  const std::size_t endA = std::min<std::size_t>(a[indexA++], a.size());
-  const std::size_t endB = std::min<std::size_t>(b[indexB++], b.size());
+  // The first byte is a length prefix declaring the content length. Clamp it to
+  // the bytes actually available (size - 1) so malformed/truncated operands can
+  // never over-read, and cast through unsigned char so a prefix >= 0x80 is not
+  // sign-extended. endA/endB are exclusive end offsets: content is at [1, endX).
+  std::size_t indexA = 1;
+  std::size_t indexB = 1;
+  const std::size_t endA = 1 + std::min<std::size_t>(static_cast<unsigned char>(a[0]), a.size() - 1);
+  const std::size_t endB = 1 + std::min<std::size_t>(static_cast<unsigned char>(b[0]), b.size() - 1);
 
   // Compare the revision number
   auto result = 0;
@@ -52,7 +56,7 @@ int compareRev(const rocksdb::Slice& a, const rocksdb::Slice& b) {
     }
   }
 
-  return endA - endB;
+  return static_cast<int>(endA) - static_cast<int>(endB);
 }
 
 class MaxRevOperator : public rocksdb::MergeOperator {

package/package.json

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