Use reachdown package (Level/community#82) (#75)

leveldown.js

@@ -1,6 +1,8 @@
 var inherits = require('inherits')
 var abstract = require('abstract-leveldown')
 var wrap = require('level-option-wrap')
+var reachdown = require('reachdown')
+var matchdown = require('./matchdown')
 
 var rangeOptions = 'start end gt gte lt lte'.split(' ')
 var defaultClear = abstract.AbstractLevelDOWN.prototype._clear
@@ -83,13 +85,13 @@ SubDown.prototype._open = function (opts, cb) {
  this.db.open(function (err) {
  if (err) return cb(err)
 
- var subdb = down(self.db, 'subleveldown')
+ var subdb = reachdown(self.db, 'subleveldown')
 
  if (subdb && subdb.prefix) {
  self.prefix = subdb.prefix + self.prefix
- self.leveldown = down(subdb.db)
+ self.leveldown = reachdown(subdb.db, matchdown, false)
  } else {
- self.leveldown = down(self.db)
+ self.leveldown = reachdown(self.db, matchdown, false)
  }
 
  if (self._beforeOpen) self._beforeOpen(cb)
@@ -179,16 +181,3 @@ SubDown.prototype._iterator = function (opts) {
 }
 
 module.exports = SubDown
-
-function down (db, type) {
- if (typeof db.down === 'function') return db.down(type)
- if (type && db.type === type) return db
- if (isLooseAbstract(db.db)) return down(db.db, type)
- if (isLooseAbstract(db._db)) return down(db._db, type)
- return type ? null : db
-}
-
-function isLooseAbstract (db) {
- if (!db || typeof db !== 'object') { return false }
- return typeof db._batch === 'function' && typeof db._iterator === 'function'
-}

matchdown.js

@@ -0,0 +1,8 @@
+module.exports = function matchdown (db, type) {
+ // Skip layers that we handle ourselves
+ if (type === 'levelup') return false
+ if (type === 'encoding-down') return false
+ if (type === 'deferred-leveldown') return false
+
+ return true
+}

package.json

@@ -20,7 +20,8 @@
  "encoding-down": "^6.2.0",
  "inherits": "^2.0.3",
  "level-option-wrap": "^1.1.0",
- "levelup": "^4.2.0"
+ "levelup": "^4.2.0",
+ "reachdown": "^1.0.0"
  },
  "devDependencies": {
  "after": "^0.8.2",
@@ -30,6 +31,7 @@
  "hallmark": "^2.0.0",
  "level-community": "^3.0.0",
  "level-concat-iterator": "^2.0.1",
+ "memdb": "^1.3.1",
  "memdown": "^5.0.0",
  "nyc": "^14.0.0",
  "standard": "^14.0.0",

test/index.js

@@ -7,6 +7,10 @@ var after = require('after')
 var subdown = require('../leveldown')
 var subdb = require('..')
 var levelup = require('levelup')
+var reachdown = require('reachdown')
+var memdb = require('memdb')
+var abstract = require('abstract-leveldown')
+var inherits = require('util').inherits
 
 // Test abstract-leveldown compliance
 suite({
@@ -359,6 +363,78 @@ test('SubDb main function', function (t) {
  }
 })
 
+// Test that we peel off the levelup, deferred-leveldown and encoding-down
+// layers from db, but stop at any other intermediate layer like encrypt-down,
+// cachedown, etc.
+test('subleveldown on intermediate layer', function (t) {
+ t.plan(7)
+
+ function Intermediate (db) {
+ abstract.AbstractLevelDOWN.call(this)
+ this.db = db
+ }
+
+ inherits(Intermediate, abstract.AbstractLevelDOWN)
+
+ Intermediate.prototype._put = function (key, value, options, callback) {
+ t.pass('got _put call')
+ this.db._put('mitm' + key, value, options, callback)
+ }
+
+ Intermediate.prototype._get = function (key, options, callback) {
+ t.pass('got _get call')
+ this.db._get('mitm' + key, options, callback)
+ }
+
+ var db = levelup(encoding(new Intermediate(memdown())))
+ var sub = subdb(db, 'test')
+
+ sub.put('key', 'value', function (err) {
+ t.error(err, 'no err')
+
+ db.get('!test!key', function (err, value) {
+ t.ifError(err, 'no levelup get error')
+ t.is(value, 'value')
+ })
+
+ reachdown(db).get('mitm!test!key', { asBuffer: false }, function (err, value) {
+ t.ifError(err, 'no memdown get error')
+ t.is(value, 'value')
+ })
+ })
+})
+
+test('legacy memdb (old levelup)', function (t) {
+ t.plan(7)
+
+ // Should not result in double json encoding
+ var db = memdb({ valueEncoding: 'json' })
+ var sub = subdb(db, 'test', { valueEncoding: 'json' })
+
+ // Integration with memdb still works because subleveldown waits to reachdown
+ // until the (old levelup) db is open. Reaching down then correctly lands on
+ // the memdown db. If subleveldown were to reachdown immediately it'd land on
+ // the old deferred-leveldown (which when unopened doesn't have a reference to
+ // the memdown db yet) so we'd be unable to persist anything.
+ t.is(Object.getPrototypeOf(reachdown(db)).constructor.name, 'DeferredLevelDOWN')
+
+ sub.put('key', { a: 1 }, function (err) {
+ t.ifError(err, 'no put error')
+
+ sub.get('key', function (err, value) {
+ t.ifError(err, 'no get error')
+ t.same(value, { a: 1 })
+ })
+
+ t.is(Object.getPrototypeOf(reachdown(db)).constructor.name, 'MemDOWN')
+
+ reachdown(db).get('!test!key', { asBuffer: false }, function (err, value) {
+ t.ifError(err, 'no get error')
+ t.is(value, '{"a":1}')
+ })
+ })
+})
+
 function getKey (entry) {
  return entry.key
 }