nolo-cli 0.108.0-alpha.1 → 0.108.0

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

@@ -0,0 +1,262 @@
+'use strict'
+
+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.range = function (test, testCommon) {
+  function rangeTest (name, opts, expected) {
+    test('clear() range with ' + name, async function (t) {
+      const db = await prepare()
+
+      await db.clear(opts)
+      await verify(t, db, expected)
+
+      return db.close()
+    })
+  }
+
+  async function prepare (t) {
+    const db = testCommon.factory()
+
+    await db.open()
+    await db.batch(data.map(function ({ key, value }) {
+      return { type: 'put', key, value }
+    }))
+
+    return db
+  }
+
+  async function verify (t, db, expected) {
+    const it = db.iterator({ keyEncoding: 'utf8', valueEncoding: 'utf8' })
+    const entries = await it.all()
+
+    t.is(entries.length, expected.length, 'correct number of entries')
+    t.same(entries, expected.map(kv => [kv.key, kv.value]))
+  }
+
+  function exclude (data, start, end, expectedLength) {
+    data = data.slice()
+    const removed = data.splice(start, end - start + 1) // Inclusive
+    if (expectedLength != null) checkLength(removed, expectedLength)
+    return data
+  }
+
+  // For sanity checks on test arguments
+  function checkLength (arr, length) {
+    if (arr.length !== length) {
+      throw new RangeError('Expected ' + length + ' elements, got ' + arr.length)
+    }
+
+    return arr
+  }
+
+  rangeTest('no options', {}, [])
+
+  // Reversing has no effect without limit
+  rangeTest('reverse=true', {
+    reverse: true
+  }, [])
+
+  rangeTest('gte=00', {
+    gte: '00'
+  }, [])
+
+  rangeTest('gte=50', {
+    gte: '50'
+  }, data.slice(0, 50))
+
+  rangeTest('lte=50 and reverse=true', {
+    lte: '50',
+    reverse: true
+  }, data.slice(51))
+
+  rangeTest('gte=49.5 (midway)', {
+    gte: '49.5'
+  }, data.slice(0, 50))
+
+  rangeTest('gte=49999 (midway)', {
+    gte: '49999'
+  }, data.slice(0, 50))
+
+  rangeTest('lte=49.5 (midway) and reverse=true', {
+    lte: '49.5',
+    reverse: true
+  }, data.slice(50))
+
+  rangeTest('lt=49.5 (midway) and reverse=true', {
+    lt: '49.5',
+    reverse: true
+  }, data.slice(50))
+
+  rangeTest('lt=50 and reverse=true', {
+    lt: '50',
+    reverse: true
+  }, data.slice(50))
+
+  rangeTest('lte=50', {
+    lte: '50'
+  }, data.slice(51))
+
+  rangeTest('lte=50.5 (midway)', {
+    lte: '50.5'
+  }, data.slice(51))
+
+  rangeTest('lte=50555 (midway)', {
+    lte: '50555'
+  }, data.slice(51))
+
+  rangeTest('lt=50555 (midway)', {
+    lt: '50555'
+  }, data.slice(51))
+
+  rangeTest('gte=50.5 (midway) and reverse=true', {
+    gte: '50.5',
+    reverse: true
+  }, data.slice(0, 51))
+
+  rangeTest('gt=50.5 (midway) and reverse=true', {
+    gt: '50.5',
+    reverse: true
+  }, data.slice(0, 51))
+
+  rangeTest('gt=50 and reverse=true', {
+    gt: '50',
+    reverse: true
+  }, data.slice(0, 51))
+
+  // First key is actually '00' so it should avoid it
+  rangeTest('lte=0', {
+    lte: '0'
+  }, data)
+
+  // First key is actually '00' so it should avoid it
+  rangeTest('lt=0', {
+    lt: '0'
+  }, data)
+
+  rangeTest('gte=30 and lte=70', {
+    gte: '30',
+    lte: '70'
+  }, exclude(data, 30, 70))
+
+  // 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'
+  }, exclude(data, 30, 70))
+
+  // 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'
+  }, exclude(data, 30, 70))
+
+  rangeTest('gt=29 and lt=71', {
+    gt: '29',
+    lt: '71'
+  }, exclude(data, 30, 70))
+
+  rangeTest('gte=30 and lte=70 and reverse=true', {
+    lte: '70',
+    gte: '30',
+    reverse: true
+  }, exclude(data, 30, 70))
+
+  rangeTest('gt=29 and lt=71 and reverse=true', {
+    lt: '71',
+    gt: '29',
+    reverse: true
+  }, exclude(data, 30, 70))
+
+  rangeTest('limit=20', {
+    limit: 20
+  }, data.slice(20))
+
+  rangeTest('limit=20 and gte=20', {
+    limit: 20,
+    gte: '20'
+  }, exclude(data, 20, 39, 20))
+
+  rangeTest('limit=20 and reverse=true', {
+    limit: 20,
+    reverse: true
+  }, data.slice(0, -20))
+
+  rangeTest('limit=20 and lte=79 and reverse=true', {
+    limit: 20,
+    lte: '79',
+    reverse: true
+  }, exclude(data, 60, 79, 20))
+
+  rangeTest('limit=-1 should clear whole database', {
+    limit: -1
+  }, [])
+
+  rangeTest('limit=0 should not clear anything', {
+    limit: 0
+  }, data)
+
+  rangeTest('lte after limit', {
+    limit: 20,
+    lte: '50'
+  }, data.slice(20))
+
+  rangeTest('lte before limit', {
+    limit: 50,
+    lte: '19'
+  }, data.slice(20))
+
+  rangeTest('gte after database end', {
+    gte: '9a'
+  }, data)
+
+  rangeTest('gt after database end', {
+    gt: '9a'
+  }, data)
+
+  rangeTest('lte after database end and reverse=true', {
+    lte: '9a',
+    reverse: true
+  }, [])
+
+  rangeTest('lte and gte after database and reverse=true', {
+    lte: '9b',
+    gte: '9a',
+    reverse: true
+  }, data)
+
+  rangeTest('lt and gt after database and reverse=true', {
+    lt: '9b',
+    gt: '9a',
+    reverse: true
+  }, data)
+
+  rangeTest('gt greater than lt', {
+    gt: '20',
+    lt: '10'
+  }, data)
+
+  rangeTest('gte greater than lte', {
+    gte: '20',
+    lte: '10'
+  }, data)
+}
+
+exports.all = function (test, testCommon) {
+  exports.range(test, testCommon)
+}

package/node_modules/abstract-level/test/clear-test.js

@@ -0,0 +1,110 @@
+'use strict'
+
+const isBuffer = require('is-buffer')
+const { Buffer } = require('buffer')
+
+exports.clear = function (test, testCommon) {
+  makeTest('string', ['a', 'b'])
+
+  if (testCommon.supports.encodings.buffer) {
+    makeTest('buffer', [Buffer.from('a'), Buffer.from('b')])
+    makeTest('mixed', [Buffer.from('a'), 'b'])
+
+    // These keys would be equal when compared as utf8 strings
+    makeTest('non-utf8 buffer', [Buffer.from('80', 'hex'), Buffer.from('c0', 'hex')])
+  }
+
+  function makeTest (type, keys) {
+    test('simple clear() on ' + type + ' keys', async function (t) {
+      const db = testCommon.factory()
+      const ops = keys.map(function (key) {
+        return {
+          type: 'put',
+          key,
+          value: 'foo',
+          keyEncoding: isBuffer(key) ? 'buffer' : 'utf8'
+        }
+      })
+
+      await db.open()
+      await db.batch(ops)
+      t.is((await db.iterator().all()).length, keys.length, 'has entries')
+
+      await db.clear()
+      t.is((await db.iterator().all()).length, 0, 'has no entries')
+
+      return db.close()
+    })
+  }
+
+  // NOTE: adapted from levelup
+  for (const deferred of [false, true]) {
+    for (const [gte, keyEncoding] of [['"b"', 'utf8'], ['b', 'json']]) {
+      test(`clear() with ${keyEncoding} encoding (deferred: ${deferred})`, async function (t) {
+        const db = testCommon.factory()
+
+        await db.open()
+        await db.batch([
+          { type: 'put', key: '"a"', value: 'a' },
+          { type: 'put', key: '"b"', value: 'b' }
+        ])
+
+        let promise
+
+        if (deferred) {
+          await db.close()
+          t.is(db.status, 'closed')
+          promise = db.open()
+          t.is(db.status, 'opening')
+        }
+
+        await db.clear({ gte, keyEncoding })
+        await promise
+
+        const keys = await db.keys().all()
+        t.same(keys, ['"a"'], 'got expected keys')
+
+        return db.close()
+      })
+    }
+  }
+}
+
+exports.events = function (test, testCommon) {
+  test('test clear() with options emits clear event', async function (t) {
+    t.plan(2)
+
+    const db = testCommon.factory()
+    await db.open()
+
+    t.ok(db.supports.events.clear)
+
+    db.on('clear', function (options) {
+      t.same(options, { gt: 567, custom: 123 })
+    })
+
+    await db.clear({ gt: 567, custom: 123 })
+    return db.close()
+  })
+
+  test('test clear() without options emits clear event', async function (t) {
+    t.plan(2)
+
+    const db = testCommon.factory()
+    await db.open()
+
+    t.ok(db.supports.events.clear)
+
+    db.on('clear', function (options) {
+      t.same(options, {})
+    })
+
+    await db.clear()
+    return db.close()
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.events(test, testCommon)
+  exports.clear(test, testCommon)
+}

package/node_modules/abstract-level/test/common.js

@@ -0,0 +1,90 @@
+'use strict'
+
+const kNone = Symbol('none')
+const kProtected = Symbol('protected')
+
+function testCommon (options) {
+  const factory = options.factory
+  const test = options.test
+
+  if (typeof factory !== 'function') {
+    throw new TypeError('factory must be a function')
+  }
+
+  if (typeof test !== 'function') {
+    throw new TypeError('test must be a function')
+  }
+
+  if (options.legacyRange != null) {
+    throw new Error('The legacyRange option has been removed')
+  }
+
+  let supports = kNone
+
+  return protect(options, {
+    test,
+    factory,
+    internals: options.internals || {},
+
+    // Expose manifest through testCommon to more easily skip tests based on
+    // supported features. Use a getter to only create a db once. Implicitly
+    // we also test that the manifest doesn't change after the db constructor.
+    get supports () {
+      if (supports === kNone) this.supports = this.factory().supports
+      return supports
+    },
+
+    // Prefer assigning early via manifest-test unless test.only() is used
+    // in which case we create the manifest on-demand. Copy it to be safe.
+    set supports (value) {
+      if (supports === kNone) supports = JSON.parse(JSON.stringify(value))
+    }
+  })
+}
+
+module.exports = testCommon
+
+// To help migrating from abstract-leveldown.
+// Throw if test suite options are used instead of db.supports
+function protect (options, testCommon) {
+  const legacyOptions = [
+    ['createIfMissing', true],
+    ['errorIfExists', true],
+    ['snapshots', true],
+    ['seek', true],
+    ['encodings', true],
+    ['deferredOpen', true],
+    ['streams', true],
+    ['clear', true],
+    ['getMany', true],
+    ['bufferKeys', false],
+    ['serialize', false],
+    ['idempotentOpen', false],
+    ['passiveOpen', false],
+    ['openCallback', false]
+  ]
+
+  Object.defineProperty(testCommon, kProtected, {
+    value: true
+  })
+
+  for (const [k, exists] of legacyOptions) {
+    const msg = exists ? 'has moved to db.supports' : 'has been removed'
+
+    // Options may be a testCommon instance
+    if (!options[kProtected] && k in options) {
+      throw new Error(`The test suite option '${k}' ${msg}`)
+    }
+
+    Object.defineProperty(testCommon, k, {
+      get () {
+        throw new Error(`The test suite option '${k}' ${msg}`)
+      },
+      set () {
+        throw new Error(`The test suite option '${k}' ${msg}`)
+      }
+    })
+  }
+
+  return testCommon
+}

package/node_modules/abstract-level/test/deferred-open-test.js

@@ -0,0 +1,209 @@
+'use strict'
+
+const { DeferredIterator } = require('../lib/deferred-iterator')
+
+exports.all = function (test, testCommon) {
+  async function verifyValues (t, db, entries) {
+    const promises = []
+
+    for (let i = 1; i <= entries; i++) {
+      promises.push(db.get('k' + i).then((v) => {
+        t.is(v, 'v' + i, 'value is ok')
+        t.is(db.status, 'open', 'status is ok')
+      }))
+    }
+
+    await Promise.all(promises)
+    t.is(await db.get('k' + (entries + 1)), undefined, 'not found')
+  }
+
+  // NOTE: copied from levelup
+  test('deferred open(): batch() on new database', async function (t) {
+    // Create database, opens in next tick
+    const db = testCommon.factory()
+    const entries = 3
+    const ops = []
+
+    // Add entries with batch([]), these should be deferred until the database is actually open
+    for (let i = 1; i <= entries; i++) {
+      ops.push({ type: 'put', key: 'k' + i, value: 'v' + i })
+    }
+
+    t.is(db.status, 'opening')
+
+    await db.batch(ops)
+    await verifyValues(t, db, entries)
+
+    return db.close()
+  })
+
+  // NOTE: copied from levelup
+  test('deferred open(): value of deferred operation is not stringified', async function (t) {
+    const db = testCommon.factory({ valueEncoding: 'json' })
+
+    t.is(db.status, 'opening')
+    await db.put('key', { thing: 2 })
+
+    t.is(db.status, 'open')
+    t.same(await db.get('key'), { thing: 2 })
+
+    return db.close()
+  })
+
+  // NOTE: copied from levelup
+  test('deferred open(): key of deferred operation is not stringified', async function (t) {
+    const db = testCommon.factory({ keyEncoding: 'json' })
+
+    t.is(db.status, 'opening')
+    await db.put({ thing: 2 }, 'value')
+
+    t.is(db.status, 'open')
+    t.same(await db.keys().all(), [{ thing: 2 }])
+
+    return db.close()
+  })
+
+  // NOTE: copied from deferred-leveldown
+  // TODO: move to iterator tests, if not already covered there
+  test('cannot operate on closed db', async function (t) {
+    t.plan(3)
+
+    const db = testCommon.factory()
+
+    await db.open()
+    await db.close()
+
+    try {
+      db.iterator()
+    } catch (err) {
+      t.is(err.code, 'LEVEL_DATABASE_NOT_OPEN')
+    }
+
+    try {
+      db.keys()
+    } catch (err) {
+      t.is(err.code, 'LEVEL_DATABASE_NOT_OPEN')
+    }
+
+    try {
+      db.values()
+    } catch (err) {
+      t.is(err.code, 'LEVEL_DATABASE_NOT_OPEN')
+    }
+  })
+
+  // NOTE: copied from deferred-leveldown
+  // TODO: move to iterator tests, if not already covered there
+  test('cannot operate on closing db', async function (t) {
+    t.plan(3)
+
+    const db = testCommon.factory()
+
+    await db.open()
+    const promise = db.close()
+
+    try {
+      db.iterator()
+    } catch (err) {
+      t.is(err.code, 'LEVEL_DATABASE_NOT_OPEN')
+    }
+
+    try {
+      db.keys()
+    } catch (err) {
+      t.is(err.code, 'LEVEL_DATABASE_NOT_OPEN')
+    }
+
+    try {
+      db.values()
+    } catch (err) {
+      t.is(err.code, 'LEVEL_DATABASE_NOT_OPEN')
+    }
+
+    return promise
+  })
+
+  // NOTE: copied from deferred-leveldown
+  // TODO: move to iterator tests, if not already covered there
+  test('deferred iterator - cannot operate on closed db', async function (t) {
+    t.plan(4)
+
+    const db = testCommon.factory()
+    const it = db.iterator({ gt: 'foo' })
+
+    await db.open()
+    await db.close()
+
+    t.ok(it instanceof DeferredIterator)
+
+    const promises = [
+      it.next().catch(function (err) {
+        t.is(err.code, 'LEVEL_ITERATOR_NOT_OPEN')
+      }),
+
+      it.nextv(10).catch(function (err) {
+        t.is(err.code, 'LEVEL_ITERATOR_NOT_OPEN')
+      }),
+
+      it.all().catch(function (err) {
+        t.is(err.code, 'LEVEL_ITERATOR_NOT_OPEN')
+      }),
+
+      // Was already closed
+      it.close().catch(function () {
+        t.fail('no close() error')
+      })
+    ]
+
+    try {
+      it.seek('foo')
+    } catch (err) {
+      // Should *not* throw
+      t.fail(err)
+    }
+
+    return Promise.all(promises)
+  })
+
+  // NOTE: copied from deferred-leveldown
+  // TODO: move to iterator tests, if not already covered there
+  test('deferred iterator - cannot operate on closing db', async function (t) {
+    t.plan(4)
+
+    const db = testCommon.factory()
+    const it = db.iterator({ gt: 'foo' })
+
+    t.ok(it instanceof DeferredIterator)
+
+    await db.open()
+    const promises = [
+      db.close(),
+
+      it.next().catch(function (err) {
+        t.is(err.code, 'LEVEL_ITERATOR_NOT_OPEN')
+      }),
+
+      it.nextv(10).catch(function (err) {
+        t.is(err.code, 'LEVEL_ITERATOR_NOT_OPEN')
+      }),
+
+      it.all().catch(function (err) {
+        t.is(err.code, 'LEVEL_ITERATOR_NOT_OPEN')
+      }),
+
+      // Is already closing
+      it.close().catch(function () {
+        t.fail('no close() error')
+      })
+    ]
+
+    try {
+      it.seek('foo')
+    } catch (err) {
+      // Should *not* throw
+      t.fail(err)
+    }
+
+    return Promise.all(promises)
+  })
+}