rocksdb-native 2.6.5 → 2.6.7

package/index.js

@@ -5,23 +5,26 @@ const { ReadBatch, WriteBatch } = require('./lib/batch')
 const Iterator = require('./lib/iterator')
 const Snapshot = require('./lib/snapshot')
 
-const RocksDB = module.exports = class RocksDB extends ReadyResource {
-  constructor (path, {
-    // default options, https://github.com/facebook/rocksdb/wiki/Setup-Options-and-Basic-Tuning
-    readOnly = false,
-    createIfMissing = true,
-    maxBackgroundJobs = 6,
-    bytesPerSync = 1048576,
-    // blob options, https://github.com/facebook/rocksdb/wiki/BlobDB
-    enableBlobFiles = false,
-    minBlobSize = 0,
-    blobFileSize = 0,
-    enableBlobGarbageCollection = true,
-    // (block) table options
-    tableBlockSize = 16384,
-    tableCacheIndexAndFilterBlocks = true,
-    tableFormatVersion = 4
-  } = {}) {
+module.exports = class RocksDB extends ReadyResource {
+  constructor(
+    path,
+    {
+      // default options, https://github.com/facebook/rocksdb/wiki/Setup-Options-and-Basic-Tuning
+      readOnly = false,
+      createIfMissing = true,
+      maxBackgroundJobs = 6,
+      bytesPerSync = 1048576,
+      // blob options, https://github.com/facebook/rocksdb/wiki/BlobDB
+      enableBlobFiles = false,
+      minBlobSize = 0,
+      blobFileSize = 0,
+      enableBlobGarbageCollection = true,
+      // (block) table options
+      tableBlockSize = 16384,
+      tableCacheIndexAndFilterBlocks = true,
+      tableFormatVersion = 4
+    } = {}
+  ) {
     super()
 
     this.path = path
@@ -49,7 +52,7 @@ const RocksDB = module.exports = class RocksDB extends ReadyResource {
     this._handle = binding.init()
   }
 
-  async _open () {
+  async _open() {
     const opts = new Uint32Array(16)
 
     opts[0] = this.readOnly ? 1 : 0
@@ -78,19 +81,17 @@ const RocksDB = module.exports = class RocksDB extends ReadyResource {
 
     req.handle = binding.open(this._handle, this.path, opts, req, onopen)
 
-    RocksDB._instances.add(this)
-
     await promise
 
     for (const snapshot of this._snapshots) snapshot._init()
 
-    function onopen (err) {
+    function onopen(err) {
       if (err) req.reject(new Error(err))
       else req.resolve()
     }
   }
 
-  async _close () {
+  async _close() {
     if (this._refs > 0) {
       await new Promise((resolve) => {
         this._resolvePreclose = resolve
@@ -108,17 +109,15 @@ const RocksDB = module.exports = class RocksDB extends ReadyResource {
 
     req.handle = binding.close(this._handle, req, onclose)
 
-    RocksDB._instances.delete(this)
-
     await promise
 
-    function onclose (err) {
+    function onclose(err) {
       if (err) req.reject(new Error(err))
       else req.resolve()
     }
   }
 
-  _incRef () {
+  _incRef() {
     if (this.closing !== null) {
       throw new Error('Database closed')
     }
@@ -126,7 +125,7 @@ const RocksDB = module.exports = class RocksDB extends ReadyResource {
     this._refs++
   }
 
-  _decRef () {
+  _decRef() {
     if (--this._refs !== 0) return
 
     if (this._resolveOnIdle !== null) {
@@ -143,76 +142,69 @@ const RocksDB = module.exports = class RocksDB extends ReadyResource {
     }
   }
 
-  isIdle () {
+  isIdle() {
     return this._refs === 0
   }
 
-  idle () {
+  idle() {
     if (this.isIdle()) return Promise.resolve()
 
     if (!this._idlePromise) {
-      this._idlePromise = new Promise(resolve => { this._resolveOnIdle = resolve })
+      this._idlePromise = new Promise((resolve) => {
+        this._resolveOnIdle = resolve
+      })
     }
 
     return this._idlePromise
   }
 
-  snapshot (opts) {
+  snapshot(opts) {
     return new Snapshot(this, opts)
   }
 
-  iterator (range, opts) {
+  iterator(range, opts) {
     return new Iterator(this, { ...range, ...opts })
   }
 
-  async peek (range, opts) {
-    for await (const value of this.iterator({ ...range, ...opts, limit: 1 })) { // eslint-disable-line no-unreachable-loop
+  async peek(range, opts) {
+    for await (const value of this.iterator({ ...range, ...opts, limit: 1 })) {
+      // eslint-disable-line no-unreachable-loop
       return value
     }
 
     return null
   }
 
-  read (opts) {
+  read(opts) {
     return new ReadBatch(this, opts)
   }
 
-  write (opts) {
+  write(opts) {
     return new WriteBatch(this, opts)
   }
 
-  async get (key, opts) {
+  async get(key, opts) {
     const batch = this.read(opts)
     const value = batch.get(key)
     await batch.flush()
     return value
   }
 
-  async put (key, value, opts) {
+  async put(key, value, opts) {
     const batch = this.write(opts)
     batch.put(key, value)
     await batch.flush()
   }
 
-  async delete (key, opts) {
+  async delete(key, opts) {
     const batch = this.write(opts)
     batch.delete(key)
     await batch.flush()
   }
 
-  async deleteRange (start, end, opts) {
+  async deleteRange(start, end, opts) {
     const batch = this.write(opts)
     batch.deleteRange(start, end)
     await batch.flush()
   }
-
-  static _instances = new Set()
-}
-
-if (typeof Bare !== 'undefined') {
-  Bare.on('exit', async () => {
-    for (const db of RocksDB._instances) {
-      await db.close()
-    }
-  })
 }

package/lib/batch.js

@@ -6,12 +6,13 @@ const empty = b4a.alloc(0)
 const emptyPromise = Promise.resolve()
 
 class RocksDBBatch {
-  constructor (db, opts = {}) {
+  constructor(db, opts = {}) {
     const {
       capacity = 8,
       encoding = null,
       keyEncoding = encoding,
-      valueEncoding = encoding
+      valueEncoding = encoding,
+      autoDestroy = true
     } = opts
 
     db._incRef()
@@ -24,6 +25,7 @@ class RocksDBBatch {
 
     this._keyEncoding = keyEncoding
     this._valueEncoding = valueEncoding
+    this._autoDestroy = autoDestroy !== false
 
     this._enqueuePromise = this._enqueuePromise.bind(this)
 
@@ -36,19 +38,19 @@ class RocksDBBatch {
     if (db.opened === true) this.ready()
   }
 
-  _onfinished () {
+  _onfinished() {
     const resolve = this._resolveRequest
 
     this._operations = []
     this._promises = []
     this._request = null
     this._resolveRequest = null
-    this.destroy()
+    if (this._autoDestroy) this.destroy()
 
     if (resolve !== null) resolve()
   }
 
-  _resize () {
+  _resize() {
     if (this._operations.length <= this._capacity) return false
 
     while (this._operations.length > this._capacity) {
@@ -58,7 +60,7 @@ class RocksDBBatch {
     return true
   }
 
-  async ready () {
+  async ready() {
     if (this._handle !== null) return
 
     if (this._db.opened === false) await this._db.ready()
@@ -66,85 +68,93 @@ class RocksDBBatch {
     this._init()
   }
 
-  destroy () {
+  destroy() {
     if (this._request) throw new Error('Batch already flushed')
     if (this._destroyed) return
     this._destroyed = true
     this._db._decRef()
   }
 
-  flush () {
+  flush() {
+    if (this._destroyed) throw new Error('Batch is destroyed')
     if (this._request) throw new Error('Request already in progress')
 
-    this._request = new Promise((resolve) => { this._resolveRequest = resolve })
+    this._request = new Promise((resolve) => {
+      this._resolveRequest = resolve
+    })
     this._flush()
 
     return this._request
   }
 
-  tryFlush () {
+  tryFlush() {
     if (this._request) throw new Error('Request already in progress')
 
     this._request = emptyPromise
     this._flush()
   }
 
-  async _flush () {
+  async _flush() {
     if (this._handle === null) await this.ready()
   }
 
-  _enqueuePromise (resolve, reject) {
+  _enqueuePromise(resolve, reject) {
     this._promises.push({ resolve, reject })
   }
 
-  _encodeKey (k) {
+  _encodeKey(k) {
     if (this._keyEncoding) return c.encode(this._keyEncoding, k)
     if (typeof k === 'string') return b4a.from(k)
     return k
   }
 
-  _encodeValue (v) {
+  _encodeValue(v) {
     if (this._valueEncoding) return c.encode(this._valueEncoding, v)
     if (v === null) return empty
     if (typeof v === 'string') return b4a.from(v)
     return v
   }
 
-  _decodeValue (b) {
+  _decodeValue(b) {
     if (this._valueEncoding) return c.decode(this._valueEncoding, b)
     return b
   }
 }
 
 exports.ReadBatch = class RocksDBReadBatch extends RocksDBBatch {
-  constructor (db, opts = {}) {
-    const {
-      snapshot = null
-    } = opts
+  constructor(db, opts = {}) {
+    const { snapshot = null } = opts
 
     super(db, opts)
 
     this._snapshot = snapshot
   }
 
-  _init () {
+  _init() {
     this._handle = binding.readInit()
     this._buffer = binding.readBuffer(this._handle, this._capacity)
   }
 
-  _resize () {
+  _resize() {
     if (super._resize() && this._handle !== null) {
       this._buffer = binding.readBuffer(this._handle, this._capacity)
     }
   }
 
-  async _flush () {
+  async _flush() {
     await super._flush()
 
-    binding.read(this._db._handle, this._handle, this._operations, this._snapshot ? this._snapshot._handle : null, this, this._onread)
+    binding.read(
+      this._db._handle,
+      this._handle,
+      this._operations,
+      this._snapshot ? this._snapshot._handle : null,
+      this,
+      this._onread
+    )
   }
 
-  _onread (errs, values) {
+  _onread(errs, values) {
     for (let i = 0, n = this._promises.length; i < n; i++) {
       const promise = this._promises[i]
       if (promise === null) continue
@@ -152,13 +162,18 @@ exports.ReadBatch = class RocksDBReadBatch extends RocksDBBatch {
       const err = errs[i]
 
       if (err) promise.reject(new Error(err))
-      else promise.resolve(values[i].byteLength === 0 ? null : this._decodeValue(b4a.from(values[i])))
+      else
+        promise.resolve(
+          values[i].byteLength === 0
+            ? null
+            : this._decodeValue(b4a.from(values[i]))
+        )
     }
 
     this._onfinished()
   }
 
-  get (key) {
+  get(key) {
     if (this._request) throw new Error('Request already in progress')
 
     const promise = new Promise(this._enqueuePromise)
@@ -171,24 +186,30 @@ exports.ReadBatch = class RocksDBReadBatch extends RocksDBBatch {
 }
 
 exports.WriteBatch = class RocksDBWriteBatch extends RocksDBBatch {
-  _init () {
+  _init() {
     this._handle = binding.writeInit()
     this._buffer = binding.writeBuffer(this._handle, this._capacity)
   }
 
-  _resize () {
+  _resize() {
     if (super._resize() && this._handle !== null) {
       this._buffer = binding.writeBuffer(this._handle, this._capacity)
     }
   }
 
-  async _flush () {
+  async _flush() {
     await super._flush()
 
-    binding.write(this._db._handle, this._handle, this._operations, this, this._onwrite)
+    binding.write(
+      this._db._handle,
+      this._handle,
+      this._operations,
+      this,
+      this._onwrite
+    )
   }
 
-  _onwrite (err) {
+  _onwrite(err) {
     for (let i = 0, n = this._promises.length; i < n; i++) {
       const promise = this._promises[i]
       if (promise === null) continue
@@ -200,26 +221,30 @@ exports.WriteBatch = class RocksDBWriteBatch extends RocksDBBatch {
     this._onfinished()
   }
 
-  put (key, value) {
+  put(key, value) {
     if (this._request) throw new Error('Request already in progress')
 
     const promise = new Promise(this._enqueuePromise)
 
-    this._operations.push(new RocksDBPut(this._encodeKey(key), this._encodeValue(value)))
+    this._operations.push(
+      new RocksDBPut(this._encodeKey(key), this._encodeValue(value))
+    )
     this._resize()
 
     return promise
   }
 
-  tryPut (key, value) {
+  tryPut(key, value) {
     if (this._request) throw new Error('Request already in progress')
 
-    this._operations.push(new RocksDBPut(this._encodeKey(key), this._encodeValue(value)))
+    this._operations.push(
+      new RocksDBPut(this._encodeKey(key), this._encodeValue(value))
+    )
     this._promises.push(null)
     this._resize()
   }
 
-  delete (key) {
+  delete(key) {
     if (this._request) throw new Error('Request already in progress')
 
     const promise = new Promise(this._enqueuePromise)
@@ -230,7 +255,7 @@ exports.WriteBatch = class RocksDBWriteBatch extends RocksDBBatch {
     return promise
   }
 
-  tryDelete (key) {
+  tryDelete(key) {
     if (this._request) throw new Error('Request already in progress')
 
     this._operations.push(new RocksDBDelete(this._encodeKey(key)))
@@ -238,64 +263,68 @@ exports.WriteBatch = class RocksDBWriteBatch extends RocksDBBatch {
     this._resize()
   }
 
-  deleteRange (start, end) {
+  deleteRange(start, end) {
     if (this._request) throw new Error('Request already in progress')
 
     const promise = new Promise(this._enqueuePromise)
 
-    this._operations.push(new RocksDBDeleteRange(this._encodeKey(start), this._encodeKey(end)))
+    this._operations.push(
+      new RocksDBDeleteRange(this._encodeKey(start), this._encodeKey(end))
+    )
     this._resize()
 
     return promise
   }
 
-  tryDeleteRange (start, end) {
+  tryDeleteRange(start, end) {
     if (this._request) throw new Error('Request already in progress')
 
-    this._operations.push(new RocksDBDeleteRange(this._encodeKey(start), this._encodeKey(end)))
+    this._operations.push(
+      new RocksDBDeleteRange(this._encodeKey(start), this._encodeKey(end))
+    )
     this._promises.push(null)
     this._resize()
   }
 }
 
 class RocksDBGet {
-  constructor (key) {
+  constructor(key) {
     this.key = key
   }
 
-  get type () {
+  get type() {
     return binding.GET
   }
 }
 
 class RocksDBPut {
-  constructor (key, value) {
+  constructor(key, value) {
     this.key = key
     this.value = value
   }
 
-  get type () {
+  get type() {
     return binding.PUT
   }
 }
 
 class RocksDBDelete {
-  constructor (key) {
+  constructor(key) {
     this.key = key
   }
 
-  get type () {
+  get type() {
     return binding.DELETE
   }
 }
 
 class RocksDBDeleteRange {
-  constructor (start, end) {
+  constructor(start, end) {
     this.start = start
     this.end = end
   }
 
-  get type () {
+  get type() {
     return binding.DELETE_RANGE
   }
 }

package/lib/iterator.js

@@ -6,7 +6,7 @@ const binding = require('../binding')
 const empty = b4a.alloc(0)
 
 module.exports = class RocksDBIterator extends Readable {
-  constructor (db, opts = {}) {
+  constructor(db, opts = {}) {
     const {
       gt = null,
       gte = null,
@@ -50,13 +50,13 @@ module.exports = class RocksDBIterator extends Readable {
     if (db.opened === true) this.ready()
   }
 
-  _onopen (err) {
+  _onopen(err) {
     const cb = this._pendingOpen
     this._pendingOpen = null
     cb(err)
   }
 
-  _onread (err, keys, values) {
+  _onread(err, keys, values) {
     const cb = this._pendingRead
     this._pendingRead = null
     if (err) return cb(err)
@@ -66,7 +66,10 @@ module.exports = class RocksDBIterator extends Readable {
     this._limit -= n
 
     for (let i = 0; i < n; i++) {
-      this.push({ key: this._decodeKey(b4a.from(keys[i])), value: this._decodeValue(b4a.from(values[i])) })
+      this.push({
+        key: this._decodeKey(b4a.from(keys[i])),
+        value: this._decodeValue(b4a.from(values[i]))
+      })
     }
 
     if (n < this._capacity) this.push(null)
@@ -74,20 +77,20 @@ module.exports = class RocksDBIterator extends Readable {
     cb(null)
   }
 
-  _onclose (err) {
+  _onclose(err) {
     const cb = this._pendingDestroy
     this._pendingDestroy = null
     this._db._decRef()
     cb(err)
   }
 
-  _resize () {
+  _resize() {
     if (this._handle !== null) {
       this._buffer = binding.iteratorBuffer(this._handle, this._capacity)
     }
   }
 
-  async ready () {
+  async ready() {
     if (this._handle !== null) return
 
     if (this._db.opened === false) await this._db.ready()
@@ -95,26 +98,40 @@ module.exports = class RocksDBIterator extends Readable {
     this._init()
   }
 
-  _init () {
-    this._handle = binding.iteratorInit(this, this._onopen, this._onclose, this._onread)
+  _init() {
+    this._handle = binding.iteratorInit(
+      this,
+      this._onopen,
+      this._onclose,
+      this._onread
+    )
     this._buffer = binding.iteratorBuffer(this._handle, this._capacity)
   }
 
-  async _open (cb) {
+  async _open(cb) {
     await this.ready()
 
     this._pendingOpen = cb
 
-    binding.iteratorOpen(this._db._handle, this._handle, this._gt, this._gte, this._lt, this._lte, this._reverse, this._snapshot ? this._snapshot._handle : null)
+    binding.iteratorOpen(
+      this._db._handle,
+      this._handle,
+      this._gt,
+      this._gte,
+      this._lt,
+      this._lte,
+      this._reverse,
+      this._snapshot ? this._snapshot._handle : null
+    )
   }
 
-  _read (cb) {
+  _read(cb) {
     this._pendingRead = cb
 
     binding.iteratorRead(this._handle, Math.min(this._capacity, this._limit))
   }
 
-  async _destroy (cb) {
+  async _destroy(cb) {
     await this.ready()
 
     this._pendingDestroy = cb
@@ -122,18 +139,18 @@ module.exports = class RocksDBIterator extends Readable {
     binding.iteratorClose(this._handle)
   }
 
-  _encodeKey (k) {
+  _encodeKey(k) {
     if (this._keyEncoding) return c.encode(this._keyEncoding, k)
     if (typeof k === 'string') return b4a.from(k)
     return k
   }
 
-  _decodeKey (b) {
+  _decodeKey(b) {
     if (this._keyEncoding) return c.decode(this._keyEncoding, b)
     return b
   }
 
-  _decodeValue (b) {
+  _decodeValue(b) {
     if (this._valueEncoding) return c.decode(this._valueEncoding, b)
     return b
   }

package/lib/snapshot.js

@@ -1,7 +1,7 @@
 const binding = require('../binding')
 
 module.exports = class RocksDBSnapshot {
-  constructor (db) {
+  constructor(db) {
     this._db = db
     this._db._snapshots.add(this)
 
@@ -10,11 +10,11 @@ module.exports = class RocksDBSnapshot {
     if (db.opened === true) this._init()
   }
 
-  _init () {
+  _init() {
     this._handle = binding.snapshotCreate(this._db._handle)
   }
 
-  destroy () {
+  destroy() {
     this._db._snapshots.delete(this)
 
     if (this._handle === null) return