@nxtedition/rocksdb 5.2.3 → 5.2.10

package/binding.gyp

@@ -23,7 +23,8 @@
                 }
               }
           }, { # OS != 'win'
-              'cflags!': [ '-fno-rtti' ]
+              'cflags': [ '-std=c++20' ]
+            , 'cflags!': [ '-fno-rtti' ]
             , 'cflags_cc!': [ '-fno-rtti' ]
             , 'cflags_cc+': [ '-frtti' ]
           }]
@@ -38,7 +39,7 @@
                   , '-Wno-ignored-qualifiers'
                 ]
                 , 'OTHER_CPLUSPLUSFLAGS': [
-                    '-mmacosx-version-min=10.8'
+                    '-mmacosx-version-min=10.14'
                   , '-std=c++20'
                   , '-stdlib=libc++'
                   , '-arch x86_64'
@@ -51,7 +52,7 @@
                 ]
                 , 'GCC_ENABLE_CPP_RTTI': 'YES'
                 , 'GCC_ENABLE_CPP_EXCEPTIONS': 'YES'
-                , 'MACOSX_DEPLOYMENT_TARGET': '10.8'
+                , 'MACOSX_DEPLOYMENT_TARGET': '10.14'
             }
           }]
         , ['OS == "linux"', {

package/chained-batch.js

@@ -1,44 +1,39 @@
 'use strict'
 
-const { AbstractChainedBatch } = require('abstract-leveldown')
+const { AbstractChainedBatch } = require('abstract-level')
 const binding = require('./binding')
 
 const kDbContext = Symbol('db')
 const kBatchContext = Symbol('context')
-const kHasData = Symbol('hasData')
 
 class ChainedBatch extends AbstractChainedBatch {
-  constructor (db) {
+  constructor (db, context) {
     super(db)
-    this[kDbContext] = db.context
-    this[kBatchContext] = binding.batch_init(db.context)
-    this[kHasData] = false
+
+    this[kDbContext] = context
+    this[kBatchContext] = binding.batch_init(context)
   }
 
   _put (key, value) {
     binding.batch_put(this[kBatchContext], key, value)
-    this[kHasData] = true
   }
 
   _del (key) {
     binding.batch_del(this[kBatchContext], key)
-    this[kHasData] = true
   }
 
   _clear () {
-    if (this[kHasData]) {
-      binding.batch_clear(this[kBatchContext])
-      this[kHasData] = false
-    }
+    binding.batch_clear(this[kBatchContext])
   }
 
   _write (options, callback) {
-    if (this[kHasData]) {
-      binding.batch_write(this[kDbContext], this[kBatchContext], options, callback)
-    } else {
-      process.nextTick(callback)
-    }
+    binding.batch_write(this[kDbContext], this[kBatchContext], options, callback)
+  }
+
+  _close (callback) {
+    // TODO: close native batch (currently done on GC)
+    process.nextTick(callback)
   }
 }
 
-module.exports = ChainedBatch
+exports.ChainedBatch = ChainedBatch

package/deps/rocksdb/rocksdb.gyp

@@ -13,7 +13,10 @@
         ]
     }
   , 'defines': [
-        'SNAPPY=1'
+        'SNAPPY=1',
+        'ROCKSDB_BACKTRACE=1',
+        'ROCKSDB_SUPPORT_THREAD_LOCAL=1',
+        'USE_SSE=1'
     ]
   , 'include_dirs': [
         'rocksdb/'
@@ -73,16 +76,12 @@
           , 'defines': [
                 'ROCKSDB_PLATFORM_POSIX=1'
             ]
-          , 'ccflags': [
-                '-fno-builtin-memcmp'
-              , '-fPIC'
-            ]
-          , 'cflags': [ '-std=c++0x' ]
+          , 'ccflags': []
+          , 'cflags': [ '-std=c++20' ]
           , 'cflags!': [ '-fno-tree-vrp', '-fno-rtti' ]
           , 'cflags_cc!': [ '-fno-rtti' ]
-          # , 'cflags_cc+': [ '-frtti' ]
         }]
-      , ['OS != "win"' and 'OS != "freebsd"', {
+      , ['OS != "win"', {
             'cflags': [
                 '-Wno-sign-compare'
               , '-Wno-unused-but-set-variable'
@@ -91,66 +90,50 @@
       , ['OS == "linux"', {
             'defines': [
                 'OS_LINUX=1',
-                'ROCKSDB_LIB_IO_POSIX=1'
-            ]
-          , 'libraries': [
-                '-lpthread'
+                'ROCKSDB_LIB_IO_POSIX=1',
+                'ROCKSDB_FALLOCATE_PRESENT=1',
+                'ROCKSDB_MALLOC_USABLE_SIZE=1',
+                'ROCKSDB_PTHREAD_ADAPTIVE_MUTEX=1',
+                'ROCKSDB_RANGESYNC_PRESENT=1',
+                'ROCKSDB_SCHED_GETCPU_PRESENT=1',
+                # 'ROCKSDB_IOURING_PRESENT=1',
+                # 'HAVE_SSE42=1',
+                'HAVE_BMI=1',
+                'HAVE_LZCNT=1'
+                'HAVE_AVX2=1',
+                'HAVE_PCLMUL=1',
+                'HAVE_UINT128_EXTENSION=1',
+                'HAVE_ALIGNED_NEW=1',
+                # 'LIBURING=1'
+                # 'NUMA=1'
+                'ROCKSDB_PLATFORM_POSIX=1',
+                'ROCKSDB_LIB_IO_POSIX=1',
+                # "-TBB=1",
             ]
           , 'ccflags': [
-                '-pthread'
-                '-fexceptions'
+                '-flto'
+              , '-pthread'
+              , '-msse4.2'
+              , '-mpclmul'
+              , '-mavx2'
+              , '-mbmi'
+              , '-mlzcnt'
+              , '-fexceptions'
+              , '-faligned-new'
+              , '-latomic'
             ]
           , 'cflags!': [ '-fno-exceptions' ]
           , 'cflags_cc!': [ '-fno-exceptions' ]
-        }]
-      , ['OS == "freebsd"', {
-            'defines': [
-                'OS_FREEBSD=1'
-              , '_REENTRANT=1'
-            ]
-          , 'libraries': [
-                '-lpthread'
-            ]
-          , 'ccflags': [
-                '-pthread'
-            ]
-          , 'cflags': [
-                '-Wno-sign-compare'
-            ]
-        }]
-      , ['OS == "openbsd"', {
-            'defines': [
-                'OS_OPENBSD=1'
-              , '_REENTRANT=1'
-            ]
-          , 'libraries': [
-                '-lpthread'
-            ]
-          , 'ccflags': [
-                '-pthread'
-            ]
-          , 'cflags': [
-                '-Wno-sign-compare'
-            ]
-        }]
-      , ['OS == "solaris"', {
-            'defines': [
-                'OS_SOLARIS=1'
-              , '_REENTRANT=1'
-            ]
-          , 'libraries': [
-                '-lrt'
-              , '-lpthread'
-            ]
-          , 'ccflags': [
-                '-pthread'
+          , 'ldflags': [ 
+                '-flto'
+              , '-fuse-linker-plugin'
             ]
         }]
       , ['OS == "mac"', {
             'defines': [
                 'OS_MACOSX=1',
-                'ROCKSDB_LIB_IO_POSIX=1',
-                'ROCKSDB_BACKTRACE=1'
+                'DROCKSDB_PLATFORM_POSIX=1',
+                'ROCKSDB_LIB_IO_POSIX=1'
             ]
           , 'libraries': []
           , 'ccflags': []
@@ -161,18 +144,17 @@
                   , '-Wno-unused-function'
                 ]
                 , 'OTHER_CPLUSPLUSFLAGS': [
-                    '-mmacosx-version-min=10.8'
-                  , '-std=c++11'
+                    '-mmacosx-version-min=10.14'
+                  , '-std=c++20'
                   , '-stdlib=libc++'
                   , '-fno-omit-frame-pointer'
                   , '-momit-leaf-frame-pointer'
                   , '-arch x86_64'
                   , '-arch arm64'
                 ]
-# , 'OTHER_LDFLAGS': ['-stdlib=libc++']
                 , 'GCC_ENABLE_CPP_RTTI': 'YES'
                 , 'GCC_ENABLE_CPP_EXCEPTIONS': 'YES'
-                , 'MACOSX_DEPLOYMENT_TARGET': '10.8'
+                , 'MACOSX_DEPLOYMENT_TARGET': '10.14'
             }
         }]
     ]

package/index.js

@@ -0,0 +1,92 @@
+'use strict'
+
+const { AbstractLevel } = require('abstract-level')
+const ModuleError = require('module-error')
+const fs = require('fs')
+const binding = require('./binding')
+const { ChainedBatch } = require('./chained-batch')
+const { Iterator } = require('./iterator')
+
+const kContext = Symbol('context')
+const kLocation = Symbol('location')
+
+class ClassicLevel extends AbstractLevel {
+  constructor (location, options, _) {
+    // To help migrating to abstract-level
+    if (typeof options === 'function' || typeof _ === 'function') {
+      throw new ModuleError('The levelup-style callback argument has been removed', {
+        code: 'LEVEL_LEGACY'
+      })
+    }
+
+    if (typeof location !== 'string' || location === '') {
+      throw new TypeError("The first argument 'location' must be a non-empty string")
+    }
+
+    super({
+      encodings: {
+        buffer: true,
+        utf8: true
+      },
+      seek: true,
+      createIfMissing: true,
+      errorIfExists: true
+    }, options)
+
+    this[kLocation] = location
+    this[kContext] = binding.db_init()
+  }
+
+  get location () {
+    return this[kLocation]
+  }
+
+  _open (options, callback) {
+    if (options.createIfMissing) {
+      fs.mkdir(this[kLocation], { recursive: true }, (err) => {
+        if (err) return callback(err)
+        binding.db_open(this[kContext], this[kLocation], options, callback)
+      })
+    } else {
+      binding.db_open(this[kContext], this[kLocation], options, callback)
+    }
+  }
+
+  _close (callback) {
+    binding.db_close(this[kContext], callback)
+  }
+
+  _put (key, value, options, callback) {
+    binding.db_put(this[kContext], key, value, options, callback)
+  }
+
+  _get (key, options, callback) {
+    binding.db_get(this[kContext], key, options, callback)
+  }
+
+  _getMany (keys, options, callback) {
+    binding.db_get_many(this[kContext], keys, options, callback)
+  }
+
+  _del (key, options, callback) {
+    binding.db_del(this[kContext], key, options, callback)
+  }
+
+  _clear (options, callback) {
+    binding.db_clear(this[kContext], options, callback)
+  }
+
+  _chainedBatch () {
+    return new ChainedBatch(this, this[kContext])
+  }
+
+  _batch (operations, options, callback) {
+    binding.batch_do(this[kContext], operations, options, callback)
+  }
+
+  _iterator (options) {
+    return new Iterator(this, this[kContext], options)
+  }
+}
+
+exports.ClassicLevel = ClassicLevel

package/iterator.js

@@ -1,19 +1,31 @@
 'use strict'
 
-const { AbstractIterator } = require('abstract-leveldown')
+const { AbstractIterator } = require('abstract-level')
 const binding = require('./binding')
 
 const kContext = Symbol('context')
-const kFinalized = Symbol('finalized')
+const kCache = Symbol('cache')
+const kFinished = Symbol('finished')
+const kFirst = Symbol('first')
+const kPosition = Symbol('position')
+const kHandleNext = Symbol('handleNext')
+const kHandleNextv = Symbol('handleNextv')
+const kCallback = Symbol('callback')
+const empty = []
 
 class Iterator extends AbstractIterator {
-  constructor (db, options) {
-    super(db)
+  constructor (db, context, options) {
+    super(db, options)
 
-    this[kContext] = binding.iterator_init(db.context, options)
-    this[kFinalized] = false
+    this[kContext] = binding.iterator_init(context, options)
 
-    this.cache = null
+    this[kHandleNext] = this[kHandleNext].bind(this)
+    this[kHandleNextv] = this[kHandleNextv].bind(this)
+    this[kCallback] = null
+    this[kFirst] = true
+    this[kCache] = empty
+    this[kFinished] = false
+    this[kPosition] = 0
   }
 
   _seek (target) {
@@ -21,35 +33,87 @@ class Iterator extends AbstractIterator {
       throw new Error('cannot seek() to an empty target')
     }
 
-    this.cache = null
+    this[kFirst] = true
+    this[kCache] = empty
+    this[kFinished] = false
+    this[kPosition] = 0
+
     binding.iterator_seek(this[kContext], target)
-    this[kFinalized] = false
   }
 
   _next (callback) {
-    if (this.cache && this.cache.length) {
-      process.nextTick(callback, null, this.cache.pop(), this.cache.pop())
-    } else if (this[kFinalized]) {
+    if (this[kPosition] < this[kCache].length) {
+      const key = this[kCache][this[kPosition]++]
+      const val = this[kCache][this[kPosition]++]
+      process.nextTick(callback, null, key, val)
+    } else if (this[kFinished]) {
       process.nextTick(callback)
     } else {
-      binding.iterator_nextv(this[kContext], 1000, (err, array, finished) => {
-        if (err) {
-          callback(err)
-        } else {
-          this.cache = array
-          this[kFinalized] = finished
-          this._next(callback)
-        }
-      })
+      this[kCallback] = callback
+
+      if (this[kFirst]) {
+        // It's common to only want one entry initially or after a seek()
+        this[kFirst] = false
+        binding.iterator_nextv(this[kContext], 1, this[kHandleNext])
+      } else {
+        // Limit the size of the cache to prevent starving the event loop
+        // while we're recursively calling process.nextTick().
+        binding.iterator_nextv(this[kContext], 1000, this[kHandleNext])
+      }
     }
 
     return this
   }
 
-  _end (callback) {
-    this.cache = null
+  [kHandleNext] (err, items, finished) {
+    const callback = this[kCallback]
+    if (err) return callback(err)
+
+    this[kCache] = items
+    this[kFinished] = finished
+    this[kPosition] = 0
+
+    this._next(callback)
+  }
+
+  _nextv (size, options, callback) {
+    if (this[kFinished]) {
+      process.nextTick(callback, null, [])
+    } else {
+      this[kCallback] = callback
+      this[kFirst] = false
+      binding.iterator_nextv(this[kContext], size, this[kHandleNextv])
+    }
+  }
+
+  [kHandleNextv] (err, items, finished) {
+    const callback = this[kCallback]
+    if (err) return callback(err)
+    this[kFinished] = finished
+
+    const entries = []
+    for (let n = 0; n < items.length; n += 2) {
+      entries.push([items[n + 0], items[n + 1]])
+    }
+
+    callback(null, entries)
+  }
+
+  _close (callback) {
+    this[kCache] = empty
+    this[kCallback] = null
+
     binding.iterator_close(this[kContext], callback)
   }
+
+  _end (callback) {
+    this._close(callback)
+  }
+
+  // Undocumented, exposed for tests only
+  get cached () {
+    return (this[kCache].length - this[kPosition]) / 2
+  }
 }
 
-module.exports = Iterator
+exports.Iterator = Iterator

package/package.json

@@ -1,32 +1,38 @@
 {
   "name": "@nxtedition/rocksdb",
-  "version": "5.2.3",
+  "version": "5.2.10",
   "description": "A low-level Node.js RocksDB binding",
   "license": "MIT",
-  "main": "leveldown.js",
+  "main": "index.js",
   "scripts": {
     "install": "node-gyp-build",
-    "test": "npx standard && npx hallmark && (nyc -s tape test/*-test.js | faucet) && nyc report",
+    "test": "standard && (nyc -s tape test/*-test.js | faucet) && nyc report",
     "test-gc": "node --expose-gc test/gc.js",
     "test-electron": "electron test/electron.js",
     "test-prebuild": "cross-env PREBUILDS_ONLY=1 npm t",
     "coverage": "nyc report -r lcovonly",
     "rebuild": "npm run install --build-from-source",
     "prebuild": "prebuildify -t 8.14.0 --napi --strip",
+    "download-prebuilds": "prebuildify-ci download",
+    "hallmark": "hallmark --fix",
+    "dependency-check": "dependency-check --no-dev -i napi-macros . test/*.js",
+    "prepublishOnly": "npm run dependency-check",
+    "prebuild-linux-arm": "prebuildify-cross -i linux-armv6 -i linux-armv7 -i linux-arm64 -t 8.14.0 --napi --strip",
+    "prebuild-android-arm": "prebuildify-cross -i android-armv7 -i android-arm64 -t 8.14.0 --napi --strip",
     "prebuild-linux-x64": "prebuildify-cross -i centos7-devtoolset7 -i alpine -t 8.14.0 --napi --strip",
     "prebuild-darwin-x64+arm64": "prebuildify -t 8.14.0 --napi --strip --arch x64+arm64",
-    "prebuild-win32-x64": "prebuildify -t 8.14.0 --napi --strip",
-    "download-prebuilds": "prebuildify-ci download",
-    "hallmark": "hallmark fix",
-    "dependency-check": "npx dependency-check --no-dev -i napi-macros . test/*.js",
-    "prepublishOnly": "npm run dependency-check"
+    "prebuild-win32-x86": "prebuildify -t 8.14.0 --napi --strip",
+    "prebuild-win32-x64": "prebuildify -t 8.14.0 --napi --strip"
   },
   "dependencies": {
-    "abstract-leveldown": "^7.2.0",
-    "napi-macros": "^2.0.0",
+    "abstract-level": "^1.0.2",
+    "module-error": "^1.0.1",
+    "napi-macros": "~2.0.0",
     "node-gyp-build": "^4.3.0"
   },
   "devDependencies": {
+    "@types/node": "^17.0.16",
+    "@voxpelli/tsconfig": "^3.1.0",
     "async-each": "^1.0.3",
     "cross-env": "^7.0.3",
     "delayed": "^2.0.0",
@@ -34,9 +40,8 @@
     "du": "^1.0.0",
     "electron": "^18.0.1",
     "faucet": "^0.0.1",
-    "glob": "^8.0.1",
-    "hallmark": "^4.0.0",
-    "level-concat-iterator": "^3.0.0",
+    "glob": "^7.2.0",
+    "hallmark": "^4.1.0",
     "mkfiletree": "^2.0.0",
     "node-gyp": "^9.0.0",
     "nyc": "^15.0.0",
@@ -45,9 +50,9 @@
     "prebuildify-cross": "^5.0.0",
     "readfiletree": "^1.0.0",
     "rimraf": "^3.0.0",
-    "standard": "^16.0.3",
-    "tape": "^5.0.1",
-    "tempy": "^3.0.0"
+    "standard": "^16.0.4",
+    "tape": "^5.5.0",
+    "tempy": "^1.0.1"
   },
   "standard": {
     "ignore": [

package/leveldown.js

@@ -1,113 +0,0 @@
-'use strict'
-
-const util = require('util')
-const { AbstractLevelDOWN } = require('abstract-leveldown')
-const binding = require('./binding')
-const ChainedBatch = require('./chained-batch')
-const Iterator = require('./iterator')
-
-function LevelDOWN (location) {
-  if (!(this instanceof LevelDOWN)) {
-    return new LevelDOWN(location)
-  }
-
-  if (typeof location !== 'string') {
-    throw new Error('constructor requires a location string argument')
-  }
-
-  AbstractLevelDOWN.call(this, {
-    bufferKeys: true,
-    snapshots: true,
-    permanence: true,
-    seek: true,
-    clear: true,
-    getMany: true,
-    createIfMissing: true,
-    errorIfExists: true
-  })
-
-  this.location = location
-  this.context = binding.db_init()
-}
-
-util.inherits(LevelDOWN, AbstractLevelDOWN)
-
-LevelDOWN.prototype._open = function (options, callback) {
-  binding.db_open(this.context, this.location, options, callback)
-}
-
-LevelDOWN.prototype._close = function (callback) {
-  binding.db_close(this.context, callback)
-}
-
-LevelDOWN.prototype._serializeKey = function (key) {
-  return Buffer.isBuffer(key) ? key : String(key)
-}
-
-LevelDOWN.prototype._serializeValue = function (value) {
-  return Buffer.isBuffer(value) ? value : String(value)
-}
-
-LevelDOWN.prototype._put = function (key, value, options, callback) {
-  const batch = new ChainedBatch(this)
-  batch.put(key, value)
-  batch.write(options, callback)
-}
-
-LevelDOWN.prototype._get = function (key, options, callback) {
-  binding.db_get_many(this.context, [key], options, (err, val) => {
-    if (err) {
-      callback(err)
-    } else if (!val[0]) {
-      callback(new Error('NotFound'))
-    } else {
-      callback(null, val[0])
-    }
-  })
-}
-
-LevelDOWN.prototype._getMany = function (keys, options, callback) {
-  binding.db_get_many(this.context, keys, options, callback)
-}
-
-LevelDOWN.prototype._del = function (key, options, callback) {
-  const batch = new ChainedBatch(this)
-  batch.del(key)
-  batch.write(options, callback)
-}
-
-LevelDOWN.prototype._chainedBatch = function () {
-  return new ChainedBatch(this)
-}
-
-LevelDOWN.prototype._batch = function (operations, options, callback) {
-  let batch = null
-  for (const op of operations) {
-    if (op.type === 'del') {
-      if (!('key' in op)) continue
-      batch = batch || this.batch()
-      batch.del(op.key)
-    } else if (op.type === 'put') {
-      if (!('key' in op)) continue
-      if (!('value' in op)) continue
-      batch = batch || this.batch()
-      batch.put(op.key, op.value)
-    }
-  }
-  if (batch) {
-    batch.write(options, callback)
-  } else {
-    process.nextTick(callback)
-  }
-}
-
-LevelDOWN.prototype._iterator = function (options) {
-  if (this.status !== 'open') {
-    // Prevent segfault
-    throw new Error('cannot call iterator() before open()')
-  }
-
-  return new Iterator(this, options)
-}
-
-module.exports = LevelDOWN