nolo-cli 0.108.0-alpha.2 → 0.108.1

package/node_modules/abstract-level/test/iterator-range-test.js

@@ -0,0 +1,277 @@
+'use strict'
+
+let db
+
+const data = (function () {
+  const d = []
+  let i = 0
+  let k
+  for (; i < 100; i++) {
+    k = (i < 10 ? '0' : '') + i
+    d.push({
+      key: k,
+      value: String(Math.random())
+    })
+  }
+  return d
+}())
+
+exports.setUp = function (test, testCommon) {
+  test('iterator() range setup', async function (t) {
+    db = testCommon.factory()
+    await db.open()
+    return db.batch(data.map(function ({ key, value }) {
+      return { type: 'put', key, value }
+    }))
+  })
+}
+
+exports.range = function (test, testCommon) {
+  function rangeTest (name, opts, expected) {
+    test('iterator() range with ' + name, async function (t) {
+      const entries = await db.iterator(opts).all()
+
+      t.is(entries.length, expected.length, 'correct number of entries')
+      t.same(entries, expected.map(o => [o.key, o.value]))
+    })
+
+    // Test the documented promise that in reverse mode,
+    // "the returned entries are the same, but in reverse".
+    if (!opts.reverse && !('limit' in opts)) {
+      const reverseOpts = { ...opts, reverse: true }
+
+      rangeTest(
+        name + ' (flipped)',
+        reverseOpts,
+        expected.slice().reverse()
+      )
+    }
+  }
+
+  rangeTest('no options', {}, data)
+
+  rangeTest('reverse=true', {
+    reverse: true
+  }, data.slice().reverse())
+
+  rangeTest('gte=00', {
+    gte: '00'
+  }, data)
+
+  rangeTest('gte=50', {
+    gte: '50'
+  }, data.slice(50))
+
+  rangeTest('lte=50 and reverse=true', {
+    lte: '50',
+    reverse: true
+  }, data.slice().reverse().slice(49))
+
+  rangeTest('gte=49.5 (midway)', {
+    gte: '49.5'
+  }, data.slice(50))
+
+  rangeTest('gte=49999 (midway)', {
+    gte: '49999'
+  }, data.slice(50))
+
+  rangeTest('lte=49.5 (midway) and reverse=true', {
+    lte: '49.5',
+    reverse: true
+  }, data.slice().reverse().slice(50))
+
+  rangeTest('lt=49.5 (midway) and reverse=true', {
+    lt: '49.5',
+    reverse: true
+  }, data.slice().reverse().slice(50))
+
+  rangeTest('lt=50 and reverse=true', {
+    lt: '50',
+    reverse: true
+  }, data.slice().reverse().slice(50))
+
+  rangeTest('lte=50', {
+    lte: '50'
+  }, data.slice(0, 51))
+
+  rangeTest('lte=50.5 (midway)', {
+    lte: '50.5'
+  }, data.slice(0, 51))
+
+  rangeTest('lte=50555 (midway)', {
+    lte: '50555'
+  }, data.slice(0, 51))
+
+  rangeTest('lt=50555 (midway)', {
+    lt: '50555'
+  }, data.slice(0, 51))
+
+  rangeTest('gte=50.5 (midway) and reverse=true', {
+    gte: '50.5',
+    reverse: true
+  }, data.slice().reverse().slice(0, 49))
+
+  rangeTest('gt=50.5 (midway) and reverse=true', {
+    gt: '50.5',
+    reverse: true
+  }, data.slice().reverse().slice(0, 49))
+
+  rangeTest('gt=50 and reverse=true', {
+    gt: '50',
+    reverse: true
+  }, data.slice().reverse().slice(0, 49))
+
+  // first key is actually '00' so it should avoid it
+  rangeTest('lte=0', {
+    lte: '0'
+  }, [])
+
+  // first key is actually '00' so it should avoid it
+  rangeTest('lt=0', {
+    lt: '0'
+  }, [])
+
+  rangeTest('gte=30 and lte=70', {
+    gte: '30',
+    lte: '70'
+  }, data.slice(30, 71))
+
+  // The gte and lte options should take precedence over gt and lt respectively.
+  rangeTest('gte=30 and lte=70 and gt=40 and lt=60', {
+    gte: '30',
+    lte: '70',
+    gt: '40',
+    lt: '60'
+  }, data.slice(30, 71))
+
+  // Also test the other way around: if gt and lt were to select a bigger range.
+  rangeTest('gte=30 and lte=70 and gt=20 and lt=80', {
+    gte: '30',
+    lte: '70',
+    gt: '20',
+    lt: '80'
+  }, data.slice(30, 71))
+
+  rangeTest('gt=29 and lt=71', {
+    gt: '29',
+    lt: '71'
+  }, data.slice(30, 71))
+
+  rangeTest('gte=30 and lte=70 and reverse=true', {
+    lte: '70',
+    gte: '30',
+    reverse: true
+  }, data.slice().reverse().slice(29, 70))
+
+  rangeTest('gt=29 and lt=71 and reverse=true', {
+    lt: '71',
+    gt: '29',
+    reverse: true
+  }, data.slice().reverse().slice(29, 70))
+
+  rangeTest('limit=20', {
+    limit: 20
+  }, data.slice(0, 20))
+
+  rangeTest('limit=20 and gte=20', {
+    limit: 20,
+    gte: '20'
+  }, data.slice(20, 40))
+
+  rangeTest('limit=20 and reverse=true', {
+    limit: 20,
+    reverse: true
+  }, data.slice().reverse().slice(0, 20))
+
+  rangeTest('limit=20 and lte=79 and reverse=true', {
+    limit: 20,
+    lte: '79',
+    reverse: true
+  }, data.slice().reverse().slice(20, 40))
+
+  // the default limit value is -1
+  rangeTest('limit=-1 (all)', {
+    limit: -1
+  }, data)
+
+  rangeTest('limit=0 (empty)', {
+    limit: 0
+  }, [])
+
+  rangeTest('lte after limit', {
+    limit: 20,
+    lte: '50'
+  }, data.slice(0, 20))
+
+  rangeTest('lte before limit', {
+    limit: 50,
+    lte: '19'
+  }, data.slice(0, 20))
+
+  rangeTest('gte after database end', {
+    gte: '9a'
+  }, [])
+
+  rangeTest('gt after database end', {
+    gt: '9a'
+  }, [])
+
+  rangeTest('lte after database end and reverse=true', {
+    lte: '9a',
+    reverse: true
+  }, data.slice().reverse())
+
+  rangeTest('lt after database end', {
+    lt: 'a'
+  }, data.slice())
+
+  rangeTest('lt at database end', {
+    lt: data[data.length - 1].key
+  }, data.slice(0, -1))
+
+  rangeTest('lte at database end', {
+    lte: data[data.length - 1].key
+  }, data.slice())
+
+  rangeTest('lt before database end', {
+    lt: data[data.length - 2].key
+  }, data.slice(0, -2))
+
+  rangeTest('lte before database end', {
+    lte: data[data.length - 2].key
+  }, data.slice(0, -1))
+
+  rangeTest('lte and gte after database and reverse=true', {
+    lte: '9b',
+    gte: '9a',
+    reverse: true
+  }, [])
+
+  rangeTest('lt and gt after database and reverse=true', {
+    lt: '9b',
+    gt: '9a',
+    reverse: true
+  }, [])
+
+  rangeTest('gt greater than lt', {
+    gt: '20',
+    lt: '10'
+  }, [])
+
+  rangeTest('gte greater than lte', {
+    gte: '20',
+    lte: '10'
+  }, [])
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('iterator() range teardown', async function (t) {
+    return db.close()
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.range(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

package/node_modules/abstract-level/test/iterator-seek-test.js

@@ -0,0 +1,335 @@
+'use strict'
+
+const { Buffer } = require('buffer')
+const identity = (v) => v
+
+exports.all = function (test, testCommon) {
+  exports.sequence(test, testCommon)
+  exports.seek(test, testCommon)
+}
+
+exports.sequence = function (test, testCommon) {
+  for (const deferred of [false, true]) {
+    for (const mode of ['iterator', 'keys', 'values']) {
+      test(`${mode}().seek() throws if next() has not completed (deferred: ${deferred})`, async function (t) {
+        const db = testCommon.factory()
+        if (!deferred) await db.open()
+
+        const it = db[mode]()
+        const promise = it.next()
+
+        t.throws(() => it.seek('two'), (err) => err.code === 'LEVEL_ITERATOR_BUSY')
+
+        await promise
+        await db.close()
+      })
+
+      test(`${mode}().seek() does not throw after close() (deferred: ${deferred})`, async function (t) {
+        const db = testCommon.factory()
+        if (!deferred) await db.open()
+
+        const it = db[mode]()
+        await it.close()
+
+        t.doesNotThrow(() => it.seek('two'))
+
+        await db.close()
+      })
+    }
+  }
+}
+
+exports.seek = function (test, testCommon) {
+  const testData = () => [
+    // Note that 'three' sorts before 'two'
+    { type: 'put', key: 'one', value: '1' },
+    { type: 'put', key: 'two', value: '2' },
+    { type: 'put', key: 'three', value: '3' }
+  ]
+
+  const bufferTestData = () => [
+    // Note that 'b9' sorts before 'c0'
+    { type: 'put', key: Buffer.from('80', 'hex'), value: '1', keyEncoding: 'buffer' },
+    { type: 'put', key: Buffer.from('c0', 'hex'), value: '2', keyEncoding: 'buffer' },
+    { type: 'put', key: Buffer.from('b9', 'hex'), value: '3', keyEncoding: 'buffer' }
+  ]
+
+  test('prepare byte-aware tests', function (t) {
+    const data = bufferTestData()
+    t.ok(data[0].key.toString() === data[1].key.toString(), 'would be equal when not byte-aware')
+    t.ok(data[0].key.compare(data[1].key) < 0, 'but less than when byte-aware')
+    t.end()
+  })
+
+  for (const mode of ['iterator', 'keys', 'values']) {
+    const mapEntry = mode === 'iterator' ? e => e : mode === 'keys' ? e => e[0] : e => e[1]
+
+    test(`${mode}().seek() to string target`, async function (t) {
+      const db = testCommon.factory()
+      await db.batch(testData())
+      const it = db[mode]()
+
+      it.seek('two')
+
+      t.same(await it.next(), mapEntry(['two', '2']), 'match')
+      t.same(await it.next(), undefined, 'end of iterator')
+
+      return db.close()
+    })
+
+    if (testCommon.supports.encodings.buffer) {
+      test(`${mode}().seek() to buffer target`, async function (t) {
+        // For this test to be meaningful it must use bytes outside the utf8 range
+        const data = bufferTestData()
+        const db = testCommon.factory()
+        await db.batch(data)
+        const it = db[mode]({ keyEncoding: 'buffer' })
+
+        // Seek to second key
+        it.seek(data[1].key)
+
+        t.same(await it.next(), mapEntry([data[1].key, '2']), 'match')
+        t.same(await it.next(), undefined, 'end of iterator')
+
+        return db.close()
+      })
+    }
+
+    test(`${mode}().seek() to target with custom encoding`, async function (t) {
+      const db = testCommon.factory()
+      await db.batch(testData())
+      const it = db[mode]()
+      const keyEncoding = { encode: () => 'two', decode: identity, format: 'utf8' }
+
+      it.seek('xyz', { keyEncoding })
+
+      t.same(await it.next(), mapEntry(['two', '2']), 'match')
+      t.same(await it.next(), undefined, 'end of iterator')
+
+      return db.close()
+    })
+
+    test(`${mode}().seek() on reverse iterator`, async function (t) {
+      const db = testCommon.factory()
+      await db.batch(testData())
+      const it = db[mode]({ reverse: true, limit: 1 })
+
+      // Should land on key equal to or smaller than 'three!' which is 'three'
+      it.seek('three!')
+
+      t.same(await it.next(), mapEntry(['three', '3']), 'match')
+      t.same(await it.next(), undefined, 'end of iterator')
+
+      return db.close()
+    })
+
+    test(`${mode}().seek() to out of range target`, async function (t) {
+      const db = testCommon.factory()
+      await db.batch(testData())
+      const it = db[mode]()
+
+      it.seek('zzz')
+      t.same(await it.next(), undefined, 'end of iterator')
+
+      return db.close()
+    })
+
+    test(`${mode}().seek() on reverse iterator to out of range target`, async function (t) {
+      const db = testCommon.factory()
+      await db.batch(testData())
+      const it = db[mode]({ reverse: true })
+
+      it.seek('zzz')
+
+      t.same(await it.next(), mapEntry(['two', '2']), 'match')
+      t.same(await it.next(), mapEntry(['three', '3']), 'match')
+      t.same(await it.next(), mapEntry(['one', '1']), 'match')
+      t.same(await it.next(), undefined, 'end of iterator')
+
+      return db.close()
+    })
+
+    test(`${mode}().seek() can be used to iterate twice`, async function (t) {
+      const db = testCommon.factory()
+      await db.batch(testData())
+      const it = db[mode]()
+
+      t.same(await it.nextv(10), [['one', '1'], ['three', '3'], ['two', '2']].map(mapEntry), 'match')
+      t.same(await it.nextv(10), [], 'end of iterator')
+
+      it.seek('one')
+
+      t.same(await it.nextv(10), [['one', '1'], ['three', '3'], ['two', '2']].map(mapEntry), 'match again')
+      t.same(await it.nextv(10), [], 'end of iterator again')
+
+      await it.close()
+      return db.close()
+    })
+
+    test(`${mode}().seek() can be used to iterate twice, within limit`, async function (t) {
+      const db = testCommon.factory()
+      await db.batch(testData())
+      const limit = 4
+      const it = db[mode]({ limit })
+
+      t.same(await it.nextv(10), [['one', '1'], ['three', '3'], ['two', '2']].map(mapEntry), 'match')
+      t.same(await it.nextv(10), [], 'end of iterator')
+
+      it.seek('one')
+
+      t.same(await it.nextv(10), [['one', '1']].map(mapEntry), 'limit reached')
+      t.same(await it.nextv(10), [], 'end of iterator')
+
+      it.seek('one')
+      t.same(await it.nextv(10), [], 'does not reset after limit has been reached')
+
+      await it.close()
+      return db.close()
+    })
+
+    if (testCommon.supports.implicitSnapshots) {
+      for (const reverse of [false, true]) {
+        for (const deferred of [false, true]) {
+          test(`${mode}().seek() respects snapshot (reverse: ${reverse}, deferred: ${deferred})`, async function (t) {
+            const db = testCommon.factory()
+            if (!deferred) await db.open()
+
+            const it = db[mode]({ reverse })
+
+            // Add entry after having created the iterator (and its snapshot)
+            await db.put('a', 'a')
+
+            // Seeking should not create a new snapshot, which'd include the new entry
+            it.seek('a')
+            t.same(await it.next(), undefined)
+
+            return db.close()
+          })
+        }
+      }
+    }
+
+    test(`${mode}().seek() respects range`, async function (t) {
+      const db = testCommon.factory()
+      await db.open()
+      const ops = []
+
+      for (let i = 0; i < 10; i++) {
+        ops.push({ type: 'put', key: String(i), value: String(i) })
+      }
+
+      await db.batch(ops)
+      const promises = []
+
+      expect({ gt: '5' }, '4', undefined)
+      expect({ gt: '5' }, '5', undefined)
+      expect({ gt: '5' }, '6', '6')
+
+      expect({ gte: '5' }, '4', undefined)
+      expect({ gte: '5' }, '5', '5')
+      expect({ gte: '5' }, '6', '6')
+
+      // The gte option should take precedence over gt.
+      expect({ gte: '5', gt: '7' }, '4', undefined)
+      expect({ gte: '5', gt: '7' }, '5', '5')
+      expect({ gte: '5', gt: '7' }, '6', '6')
+      expect({ gte: '5', gt: '3' }, '4', undefined)
+      expect({ gte: '5', gt: '3' }, '5', '5')
+      expect({ gte: '5', gt: '3' }, '6', '6')
+
+      expect({ lt: '5' }, '4', '4')
+      expect({ lt: '5' }, '5', undefined)
+      expect({ lt: '5' }, '6', undefined)
+
+      expect({ lte: '5' }, '4', '4')
+      expect({ lte: '5' }, '5', '5')
+      expect({ lte: '5' }, '6', undefined)
+
+      // The lte option should take precedence over lt.
+      expect({ lte: '5', lt: '3' }, '4', '4')
+      expect({ lte: '5', lt: '3' }, '5', '5')
+      expect({ lte: '5', lt: '3' }, '6', undefined)
+      expect({ lte: '5', lt: '7' }, '4', '4')
+      expect({ lte: '5', lt: '7' }, '5', '5')
+      expect({ lte: '5', lt: '7' }, '6', undefined)
+
+      expect({ lt: '5', reverse: true }, '4', '4')
+      expect({ lt: '5', reverse: true }, '5', undefined)
+      expect({ lt: '5', reverse: true }, '6', undefined)
+
+      expect({ lte: '5', reverse: true }, '4', '4')
+      expect({ lte: '5', reverse: true }, '5', '5')
+      expect({ lte: '5', reverse: true }, '6', undefined)
+
+      expect({ gt: '5', reverse: true }, '4', undefined)
+      expect({ gt: '5', reverse: true }, '5', undefined)
+      expect({ gt: '5', reverse: true }, '6', '6')
+
+      expect({ gte: '5', reverse: true }, '4', undefined)
+      expect({ gte: '5', reverse: true }, '5', '5')
+      expect({ gte: '5', reverse: true }, '6', '6')
+
+      expect({ gt: '7', lt: '8' }, '7', undefined)
+      expect({ gte: '7', lt: '8' }, '7', '7')
+      expect({ gte: '7', lt: '8' }, '8', undefined)
+      expect({ gt: '7', lte: '8' }, '8', '8')
+
+      await Promise.all(promises)
+      return db.close()
+
+      function expect (range, target, expected) {
+        promises.push(async function () {
+          const ite = db[mode](range)
+          ite.seek(target)
+
+          const item = await ite.next()
+          const json = JSON.stringify(range)
+          const msg = 'seek(' + target + ') on ' + json + ' yields ' + expected
+
+          // Either a key or value depending on mode
+          t.is(mode === 'iterator' ? item[0] : item, expected, msg)
+
+          return ite.close()
+        })
+      }
+    })
+
+    // Tests the specific case where an iterator can (theoretically) tell that
+    // a seek() would be out of range by comparing the seek target against
+    // range options, before performing an actual seek. MemoryLevel works this
+    // way for example. Also test the same scenario without an explicit seek()
+    // which should have the same result.
+    for (const reverse of [false, true]) {
+      for (const seek of [true, false]) {
+        const props = `reverse = ${reverse}, seek = ${seek}`
+        const name = `${mode}() seek outside of range options (${props})`
+        const key = 'a'
+
+        test(name, async function (t) {
+          const db = testCommon.factory()
+
+          await db.open()
+          await db.put(key, '123')
+
+          // Pick ranges that exclude the key
+          const ranges = [
+            { gt: 'x', reverse },
+            { gte: 'x', reverse },
+            { lt: '0', reverse },
+            { lte: '0', reverse }
+          ]
+
+          // Test each range
+          for (let i = 0; i < ranges.length; i++) {
+            const iterator = db[mode](ranges[i])
+            if (seek) iterator.seek(key)
+            t.same(await iterator.next(), undefined, `end of iterator ${i}`)
+            await iterator.close()
+          }
+
+          return db.close()
+        })
+      }
+    }
+  }
+}

package/node_modules/abstract-level/test/iterator-snapshot-test.js

@@ -0,0 +1,56 @@
+'use strict'
+
+exports.snapshot = function (test, testCommon) {
+  const make = (run) => async function (t) {
+    const db = testCommon.factory()
+    await db.open()
+    await db.put('z', 'from snapshot')
+
+    // For this test it is important that we don't read eagerly.
+    // NOTE: highWaterMarkBytes is not an abstract option, but
+    // it is supported by classic-level and others. Also set the
+    // old & equivalent leveldown highWaterMark option for compat.
+    const it = db.iterator({ highWaterMarkBytes: 0, highWaterMark: 0 })
+
+    await run(t, db, it)
+    await it.close()
+
+    return db.close()
+  }
+
+  test('delete key after snapshotting', make(async function (t, db, it) {
+    await db.del('z')
+    t.same(await it.next(), ['z', 'from snapshot'], 'correct entry')
+  }))
+
+  test('overwrite key after snapshotting', make(async function (t, db, it) {
+    await db.put('z', 'not from snapshot')
+    t.same(await it.next(), ['z', 'from snapshot'], 'correct entry')
+  }))
+
+  test('add key after snapshotting that sorts first', make(async function (t, db, it) {
+    await db.put('a', 'not from snapshot')
+    t.same(await it.next(), ['z', 'from snapshot'], 'correct entry')
+  }))
+
+  // NOTE: adapted from memdown
+  test('delete key after snapshotting, with more entries available', async function (t) {
+    const db = testCommon.factory()
+    await db.open()
+    await Promise.all([db.put('a', 'A'), db.put('b', 'B'), db.put('c', 'C')])
+
+    const iterator = db.iterator({ gte: 'a' })
+    t.same(await iterator.next(), ['a', 'A'])
+
+    await db.del('b')
+    t.same(await iterator.next(), ['b', 'B'])
+    t.same(await iterator.next(), ['c', 'C'])
+
+    await iterator.close()
+    return db.close()
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.snapshot(test, testCommon)
+}