rocksdb-native 1.2.0 → 2.1.0

package/index.js

@@ -1,12 +1,9 @@
 /* global Bare */
 const ReadyResource = require('ready-resource')
-const b4a = require('b4a')
 const binding = require('./binding')
-const Batch = require('./lib/batch')
+const { ReadBatch, WriteBatch } = require('./lib/batch')
 const Iterator = require('./lib/iterator')
 
-const empty = b4a.alloc(0)
-
 const RocksDB = module.exports = class RocksDB extends ReadyResource {
   constructor (path, {
     // default options, https://github.com/facebook/rocksdb/wiki/Setup-Options-and-Basic-Tuning
@@ -104,48 +101,24 @@ const RocksDB = module.exports = class RocksDB extends ReadyResource {
     }
   }
 
-  async deleteRange (start, end, opts = {}) {
-    if (typeof start === 'string') start = b4a.from(start)
-    if (typeof end === 'string') end = b4a.from(end)
+  iterator (opts) {
+    return new Iterator(this, opts)
+  }
 
-    if (start && !b4a.isBuffer(start)) {
-      opts = start
-      start = empty
-    } else if (end && !b4a.isBuffer(end)) {
-      opts = end
-      end = empty
+  async peek (opts) {
+    for await (const value of this.iterator({ ...opts, limit: 1 })) { // eslint-disable-line no-unreachable-loop
+      return value
     }
 
-    const {
-      gt = empty,
-      gte = start,
-      lt = end,
-      lte = empty
-    } = opts
-
-    const req = { resolve: null, reject: null, handle: null }
-
-    const promise = new Promise((resolve, reject) => {
-      req.resolve = resolve
-      req.reject = reject
-    })
-
-    req.handle = binding.deleteRange(this._handle, gt, gte, lt, lte, req, onstatus)
-
-    return promise
-
-    function onstatus (err) {
-      if (err) req.reject(new Error(err))
-      else req.resolve()
-    }
+    return null
   }
 
-  batch (opts) {
-    return new Batch(this, opts)
+  read (opts) {
+    return new ReadBatch(this, opts)
   }
 
-  iterator (start, end, opts) {
-    return new Iterator(this, start, end, opts)
+  write (opts) {
+    return new WriteBatch(this, opts)
   }
 
   static _instances = new Set()

package/lib/batch.js

@@ -1,20 +1,26 @@
+const c = require('compact-encoding')
 const b4a = require('b4a')
 const binding = require('../binding')
 
 const empty = b4a.alloc(0)
 
-module.exports = class RocksDBBatch {
+class RocksDBBatch {
   constructor (db, opts = {}) {
     const {
-      capacity = 8
+      capacity = 8,
+      encoding = null,
+      keyEncoding = encoding,
+      valueEncoding = encoding
     } = opts
 
     this._db = db
     this._capacity = capacity
-    this._keys = []
-    this._values = []
+    this._operations = []
     this._promises = []
 
+    this._keyEncoding = keyEncoding
+    this._valueEncoding = valueEncoding
+
     this._enqueuePromise = this._enqueuePromise.bind(this)
 
     this._request = null
@@ -31,8 +37,7 @@ module.exports = class RocksDBBatch {
   _onfinished () {
     const resolve = this._resolveRequest
 
-    this._keys = []
-    this._values = []
+    this._operations = []
     this._promises = []
     this._request = null
     this._resolveRequest = null
@@ -40,6 +45,85 @@ module.exports = class RocksDBBatch {
     if (resolve !== null) resolve()
   }
 
+  _resize () {
+    if (this._operations.length <= this._capacity) return false
+
+    while (this._operations.length > this._capacity) {
+      this._capacity *= 2
+    }
+
+    return true
+  }
+
+  async ready () {
+    if (this._handle !== null) return
+
+    if (this._db.opened === false) await this._db.ready()
+
+    this._init()
+  }
+
+  flush () {
+    if (this._request) throw new Error('Request already in progress')
+
+    this._request = new Promise((resolve) => { this._resolveRequest = resolve })
+    this._flush()
+
+    return this._request
+  }
+
+  tryFlush () {
+    if (this._request) throw new Error('Request already in progress')
+
+    this._request = true
+    this._flush()
+  }
+
+  async _flush () {
+    if (this._handle === null) await this.ready()
+  }
+
+  _enqueuePromise (resolve, reject) {
+    this._promises.push({ resolve, reject })
+  }
+
+  _encodeKey (k) {
+    if (this._keyEncoding) return c.encode(this._keyEncoding, k)
+    if (typeof k === 'string') return b4a.from(k)
+    return k
+  }
+
+  _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) {
+    if (this._valueEncoding) return c.decode(this._valueEncoding, b)
+    return b
+  }
+}
+
+exports.ReadBatch = class RocksDBReadBatch extends RocksDBBatch {
+  async _init () {
+    this._handle = binding.readInit(this)
+    this._buffer = binding.readBuffer(this._handle, this._capacity)
+  }
+
+  _resize () {
+    if (super._resize() && this._handle !== null) {
+      this._buffer = binding.readBuffer(this._handle, this._capacity)
+    }
+  }
+
+  async _flush () {
+    await super._flush()
+
+    binding.read(this._db._handle, this._handle, this._operations, this._onread)
+  }
+
   _onread (errs, values) {
     for (let i = 0, n = this._promises.length; i < n; i++) {
       const promise = this._promises[i]
@@ -48,123 +132,158 @@ module.exports = class RocksDBBatch {
       const err = errs[i]
 
       if (err) promise.reject(new Error(err))
-      else promise.resolve(values[i].byteLength === 0 ? null : b4a.from(values[i]))
+      else promise.resolve(values[i].byteLength === 0 ? null : this._decodeValue(b4a.from(values[i])))
     }
 
     this._onfinished()
   }
 
-  _onwrite (err) {
-    for (let i = 0, n = this._promises.length; i < n; i++) {
-      const promise = this._promises[i]
-      if (promise === null) continue
+  get (key) {
+    if (this._request) throw new Error('Request already in progress')
 
-      if (err) promise.reject(new Error(err))
-      else promise.resolve(this._values[i].byteLength === 0 ? null : this._values[i])
-    }
+    const promise = new Promise(this._enqueuePromise)
 
-    this._onfinished()
+    this._operations.push(new RocksDBGet(this._encodeKey(key)))
+    this._resize()
+
+    return promise
   }
 
-  _resize () {
-    if (this._keys.length <= this._capacity) return
+  tryPut (key, value) {
+    if (this._request) throw new Error('Request already in progress')
 
-    while (this._keys.length > this._capacity) {
-      this._capacity *= 2
-    }
+    this._operations.push(new RocksDBPut(this._encodeKey(key), this._encodeValue(value)))
+    this._promises.push(null)
+    this._resize()
+  }
+}
+
+exports.WriteBatch = class RocksDBWriteBatch extends RocksDBBatch {
+  async _init () {
+    this._handle = binding.writeInit(this)
+    this._buffer = binding.writeBuffer(this._handle, this._capacity)
+  }
 
-    if (this._handle !== null) {
-      this._buffer = binding.batchBuffer(this._handle, this._capacity)
+  _resize () {
+    if (super._resize() && this._handle !== null) {
+      this._buffer = binding.writeBuffer(this._handle, this._capacity)
     }
   }
 
-  async ready () {
-    if (this._handle !== null) return
+  async _flush () {
+    await super._flush()
 
-    if (this._db.opened === false) await this._db.ready()
+    binding.write(this._db._handle, this._handle, this._operations, this._onwrite)
+  }
+
+  _onwrite (err) {
+    for (let i = 0, n = this._promises.length; i < n; i++) {
+      const promise = this._promises[i]
+      if (promise === null) continue
 
-    this._handle = binding.batchInit(this._db._handle, this)
+      if (err) promise.reject(new Error(err))
+      else promise.resolve()
+    }
 
-    this._buffer = binding.batchBuffer(this._handle, this._capacity)
+    this._onfinished()
   }
 
-  add (key, value = empty) {
+  put (key, value) {
     if (this._request) throw new Error('Request already in progress')
 
     const promise = new Promise(this._enqueuePromise)
 
-    this._keys.push(this._encodeKey(key))
-    this._values.push(this._encodeValue(value))
+    this._operations.push(new RocksDBPut(this._encodeKey(key), this._encodeValue(value)))
     this._resize()
 
     return promise
   }
 
-  tryAdd (key, value = empty) {
+  tryPut (key, value) {
     if (this._request) throw new Error('Request already in progress')
 
-    this._keys.push(this._encodeKey(key))
-    this._values.push(this._encodeValue(value))
+    this._operations.push(new RocksDBPut(this._encodeKey(key), this._encodeValue(value)))
     this._promises.push(null)
     this._resize()
   }
 
-  read () {
+  delete (key) {
     if (this._request) throw new Error('Request already in progress')
 
-    this._request = new Promise((resolve) => { this._resolveRequest = resolve })
-    this._read()
+    const promise = new Promise(this._enqueuePromise)
 
-    return this._request
+    this._operations.push(new RocksDBDelete(this._encodeKey(key)))
+    this._resize()
+
+    return promise
   }
 
-  tryRead () {
+  tryDelete (key) {
     if (this._request) throw new Error('Request already in progress')
 
-    this._request = true
-    this._read()
+    this._operations.push(new RocksDBDelete(this._encodeKey(key)))
+    this._promises.push(null)
+    this._resize()
   }
 
-  async _read () {
-    if (this._handle === null) await this.ready()
+  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._resize()
 
-    binding.batchRead(this._handle, this._keys, this._onread)
+    return promise
   }
 
-  write () {
+  tryDeleteRange (start, end) {
     if (this._request) throw new Error('Request already in progress')
 
-    this._request = new Promise((resolve) => { this._resolveRequest = resolve })
-    this._write()
+    this._operations.push(new RocksDBDeleteRange(this._encodeKey(start), this._encodeKey(end)))
+    this._promises.push(null)
+    this._resize()
+  }
+}
 
-    return this._request
+class RocksDBGet {
+  constructor (key) {
+    this.key = key
   }
 
-  tryWrite () {
-    if (this._request) throw new Error('Request already in progress')
+  get type () {
+    return binding.GET
+  }
+}
 
-    this._request = true
-    this._write()
+class RocksDBPut {
+  constructor (key, value) {
+    this.key = key
+    this.value = value
   }
 
-  async _write () {
-    if (this._handle === null) await this.ready()
+  get type () {
+    return binding.PUT
+  }
+}
 
-    binding.batchWrite(this._handle, this._keys, this._values, this._onwrite)
+class RocksDBDelete {
+  constructor (key) {
+    this.key = key
   }
 
-  _enqueuePromise (resolve, reject) {
-    this._promises.push({ resolve, reject })
+  get type () {
+    return binding.DELETE
   }
+}
 
-  _encodeKey (k) {
-    if (typeof k === 'string') return Buffer.from(k)
-    return k
+class RocksDBDeleteRange {
+  constructor (start, end) {
+    this.start = start
+    this.end = end
   }
 
-  _encodeValue (v) {
-    if (v === null) return empty
-    if (typeof v === 'string') return Buffer.from(v)
-    return v
+  get type () {
+    return binding.DELETE_RANGE
   }
 }

package/lib/iterator.js

@@ -1,40 +1,36 @@
 const { Readable } = require('streamx')
+const c = require('compact-encoding')
 const b4a = require('b4a')
 const binding = require('../binding')
 
 const empty = b4a.alloc(0)
 
 module.exports = class RocksDBIterator extends Readable {
-  constructor (db, start, end, opts = {}) {
-    if (typeof start === 'string') start = b4a.from(start)
-    if (typeof end === 'string') end = b4a.from(end)
-
-    if (start && !b4a.isBuffer(start)) {
-      opts = start
-      start = empty
-    } else if (end && !b4a.isBuffer(end)) {
-      opts = end
-      end = empty
-    }
-
+  constructor (db, opts = {}) {
     const {
-      gt = empty,
-      gte = start,
-      lt = end,
-      lte = empty,
+      gt = null,
+      gte = null,
+      lt = null,
+      lte = null,
       reverse = false,
       limit = Infinity,
-      capacity = 8
+      capacity = 8,
+      encoding = null,
+      keyEncoding = encoding,
+      valueEncoding = encoding
     } = opts
 
     super()
 
     this._db = db
 
-    this._gt = toBuffer(gt) || empty
-    this._gte = toBuffer(gte) || empty
-    this._lt = toBuffer(lt) || empty
-    this._lte = toBuffer(lte) || empty
+    this._keyEncoding = keyEncoding
+    this._valueEncoding = valueEncoding
+
+    this._gt = gt ? this._encodeKey(gt) : empty
+    this._gte = gte ? this._encodeKey(gte) : empty
+    this._lt = lt ? this._encodeKey(lt) : empty
+    this._lte = lte ? this._encodeKey(lte) : empty
 
     this._reverse = reverse
     this._limit = limit
@@ -66,7 +62,7 @@ module.exports = class RocksDBIterator extends Readable {
     this._limit -= n
 
     for (let i = 0; i < n; i++) {
-      this.push({ key: b4a.from(keys[i]), value: 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)
@@ -91,12 +87,11 @@ module.exports = class RocksDBIterator extends Readable {
 
     if (this._db.opened === false) await this._db.ready()
 
-    this._handle = binding.iteratorInit(this._db._handle, this,
-      this._onopen,
-      this._onclose,
-      this._onread
-    )
+    this._init()
+  }
 
+  _init () {
+    this._handle = binding.iteratorInit(this, this._onopen, this._onclose, this._onread)
     this._buffer = binding.iteratorBuffer(this._handle, this._capacity)
   }
 
@@ -105,7 +100,7 @@ module.exports = class RocksDBIterator extends Readable {
 
     this._pendingOpen = cb
 
-    binding.iteratorOpen(this._handle, this._gt, this._gte, this._lt, this._lte, this._reverse)
+    binding.iteratorOpen(this._db._handle, this._handle, this._gt, this._gte, this._lt, this._lte, this._reverse)
   }
 
   _read (cb) {
@@ -121,8 +116,20 @@ module.exports = class RocksDBIterator extends Readable {
 
     binding.iteratorClose(this._handle)
   }
-}
 
-function toBuffer (data) {
-  return typeof data === 'string' ? b4a.from(data) : data
+  _encodeKey (k) {
+    if (this._keyEncoding) return c.encode(this._keyEncoding, k)
+    if (typeof k === 'string') return b4a.from(k)
+    return k
+  }
+
+  _decodeKey (b) {
+    if (this._keyEncoding) return c.decode(this._keyEncoding, b)
+    return b
+  }
+
+  _decodeValue (b) {
+    if (this._valueEncoding) return c.decode(this._valueEncoding, b)
+    return b
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rocksdb-native",
-  "version": "1.2.0",
+  "version": "2.1.0",
   "description": "librocksdb bindings for JavaScript",
   "exports": {
     ".": "./index.js",
@@ -34,6 +34,7 @@
   "homepage": "https://github.com/holepunchto/rocksdb-native",
   "dependencies": {
     "b4a": "^1.6.6",
+    "compact-encoding": "^2.15.0",
     "load-addon": "^1.0.0",
     "ready-resource": "^1.0.0",
     "streamx": "^2.16.1"