nolo-cli 0.108.0-alpha.2 → 0.108.0

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

@@ -0,0 +1,209 @@
+'use strict'
+
+const { Buffer } = require('buffer')
+
+exports.all = function (test, testCommon) {
+  for (const deferred of [false, true]) {
+    // NOTE: adapted from subleveldown
+    test(`sublevel.clear() (deferred: ${deferred})`, async function (t) {
+      const db = testCommon.factory()
+      const sub1 = db.sublevel('1')
+      const sub2 = db.sublevel('2')
+
+      if (!deferred) await sub1.open()
+      if (!deferred) await sub2.open()
+
+      await populate([sub1, sub2], ['a', 'b'])
+      await verify(['!1!a', '!1!b', '!2!a', '!2!b'])
+
+      await clear([sub1], {})
+      await verify(['!2!a', '!2!b'])
+
+      await populate([sub1], ['a', 'b'])
+      await clear([sub2], { lt: 'b' })
+      await verify(['!1!a', '!1!b', '!2!b'])
+      await db.close()
+
+      async function populate (subs, items) {
+        return Promise.all(subs.map(sub => {
+          return sub.batch(items.map(function (item) {
+            return { type: 'put', key: item, value: item }
+          }))
+        }))
+      }
+
+      async function clear (subs, opts) {
+        return Promise.all(subs.map(sub => {
+          return sub.clear(opts)
+        }))
+      }
+
+      async function verify (expected) {
+        const keys = await db.keys().all()
+        t.same(keys, expected)
+      }
+    })
+  }
+
+  for (const method of ['batch', 'chained batch']) {
+    test(`${method} with descendant sublevel option`, async function (t) {
+      t.plan(25)
+
+      const db = testCommon.factory()
+      await db.open()
+
+      const a = db.sublevel('a')
+      const b = a.sublevel('b')
+      const c = b.sublevel('c')
+
+      await Promise.all([a.open(), b.open(), c.open()])
+
+      // Note: may return a transcoder encoding
+      const utf8 = db.keyEncoding('utf8')
+
+      const put = method === 'batch'
+        ? (db, key, opts) => db.batch([{ type: 'put', key, value: 'x', ...opts }])
+        : (db, key, opts) => db.batch().put(key, key, opts).write()
+
+      const del = method === 'batch'
+        ? (db, key, opts) => db.batch([{ type: 'del', key, ...opts }])
+        : (db, key, opts) => db.batch().del(key, opts).write()
+
+      // Note: not entirely a noop. Use of sublevel option triggers data to be encoded early
+      db.on('write', (ops) => t.same(ops[0].key, utf8.encode('1'), 'got put 1'))
+      await put(db, '1', { sublevel: db })
+
+      db.removeAllListeners('write')
+      db.on('write', (ops) => t.same(ops[0].key, utf8.encode('!a!2'), 'got put 2'))
+      await put(db, '2', { sublevel: a })
+      await put(a, '2', { sublevel: a }) // Same
+
+      db.removeAllListeners('write')
+      db.on('write', (ops) => t.same(ops[0].key, utf8.encode('!a!!b!3'), 'got put 3'))
+      await put(db, '3', { sublevel: b })
+      await put(a, '3', { sublevel: b }) // Same
+      await put(b, '3', { sublevel: b }) // Same
+
+      db.removeAllListeners('write')
+      db.on('write', (ops) => t.same(ops[0].key, utf8.encode('!a!!b!!c!4'), 'got put 4'))
+      await put(db, '4', { sublevel: c })
+      await put(a, '4', { sublevel: c }) // Same
+      await put(b, '4', { sublevel: c }) // Same
+      await put(c, '4', { sublevel: c }) // Same
+
+      t.same(await db.keys().all(), ['!a!!b!!c!4', '!a!!b!3', '!a!2', '1'], 'db has entries')
+      t.same(await a.keys().all(), ['!b!!c!4', '!b!3', '2'], 'sublevel a has entries')
+      t.same(await b.keys().all(), ['!c!4', '3'], 'sublevel b has entries')
+      t.same(await c.keys().all(), ['4'], 'sublevel c has entries')
+
+      // Test deletes
+      db.removeAllListeners('write')
+      db.on('write', (ops) => t.same(ops[0].key, utf8.encode('1'), 'got del 1'))
+      await del(db, '1', { sublevel: db })
+
+      db.removeAllListeners('write')
+      db.on('write', (ops) => t.same(ops[0].key, utf8.encode('!a!2'), 'got del 2'))
+      await del(db, '2', { sublevel: a })
+      await del(a, '2', { sublevel: a }) // Same
+
+      db.removeAllListeners('write')
+      db.on('write', (ops) => t.same(ops[0].key, utf8.encode('!a!!b!3'), 'got del 3'))
+      await del(db, '3', { sublevel: b })
+      await del(a, '3', { sublevel: b }) // Same
+      await del(b, '3', { sublevel: b }) // Same
+
+      db.removeAllListeners('write')
+      db.on('write', (ops) => t.same(ops[0].key, utf8.encode('!a!!b!!c!4'), 'got del 4'))
+      await del(db, '4', { sublevel: c })
+      await del(a, '4', { sublevel: c }) // Same
+      await del(b, '4', { sublevel: c }) // Same
+      await del(c, '4', { sublevel: c }) // Same
+
+      t.same(await db.keys().all(), [], 'db has no entries')
+      return db.close()
+    })
+
+    // See https://github.com/Level/abstract-level/issues/80
+    test(`${method} with nondescendant sublevel option`, async function (t) {
+      const db = testCommon.factory()
+      await db.open()
+
+      const a = db.sublevel('a')
+      const b = db.sublevel('b')
+
+      await Promise.all([a.open(), b.open()])
+
+      // The b sublevel is not a descendant of a, so the sublevel option
+      // has to be forwarded to db so that the key gets the correct prefix.
+      if (method === 'batch') {
+        await a.batch([{ type: 'put', key: 'k', value: 'v', sublevel: b }])
+      } else {
+        await a.batch().put('k', 'v', { sublevel: b }).write()
+      }
+
+      t.same(await db.keys().all(), ['!b!k'], 'written to sublevel b')
+    })
+  }
+
+  for (const deferred of [false, true]) {
+    for (const keyEncoding of ['buffer', 'view']) {
+      if (!testCommon.supports.encodings[keyEncoding]) continue
+
+      // NOTE: adapted from subleveldown. See https://github.com/Level/subleveldown/issues/87
+      test(`iterate sublevel keys with bytes above 196 (${keyEncoding}, deferred: ${deferred})`, async function (t) {
+        const db = testCommon.factory()
+        const sub1 = db.sublevel('a', { keyEncoding })
+        const sub2 = db.sublevel('b', { keyEncoding })
+        const length = (db) => db.keys().all().then(x => x.length)
+
+        if (!deferred) await sub1.open()
+        if (!deferred) await sub2.open()
+
+        const batch1 = []
+        const batch2 = []
+        const keys = []
+
+        // TODO: write before creating the sublevels, to make the deferred test more meaningful
+        for (let i = 0; i < 256; i++) {
+          const key = keyEncoding === 'buffer' ? Buffer.from([i]) : new Uint8Array([i])
+          keys.push(key)
+          batch1.push({ type: 'put', key, value: 'aa' })
+          batch2.push({ type: 'put', key, value: 'bb' })
+        }
+
+        await Promise.all([sub1.batch(batch1), sub2.batch(batch2)])
+
+        const entries1 = await sub1.iterator().all()
+        const entries2 = await sub2.iterator().all()
+
+        t.is(entries1.length, 256, 'sub1 yielded all entries')
+        t.is(entries2.length, 256, 'sub2 yielded all entries')
+        t.ok(entries1.every(x => x[1] === 'aa'))
+        t.ok(entries2.every(x => x[1] === 'bb'))
+
+        const many1 = await sub1.getMany(keys)
+        const many2 = await sub2.getMany(keys)
+
+        t.is(many1.length, 256, 'sub1 yielded all values')
+        t.is(many2.length, 256, 'sub2 yielded all values')
+        t.ok(many1.every(x => x === 'aa'))
+        t.ok(many2.every(x => x === 'bb'))
+
+        const singles1 = await Promise.all(keys.map(k => sub1.get(k)))
+        const singles2 = await Promise.all(keys.map(k => sub2.get(k)))
+
+        t.is(singles1.length, 256, 'sub1 yielded all values')
+        t.is(singles2.length, 256, 'sub2 yielded all values')
+        t.ok(singles1.every(x => x === 'aa'))
+        t.ok(singles2.every(x => x === 'bb'))
+
+        await sub1.clear()
+
+        t.same(await length(sub1), 0, 'cleared sub1')
+        t.same(await length(sub2), 256, 'did not clear sub2')
+
+        await db.close()
+      })
+    }
+  }
+}

package/node_modules/abstract-level/test/traits/closed.js

@@ -0,0 +1,42 @@
+'use strict'
+
+module.exports = function (name, testCommon, run) {
+  const test = testCommon.test
+
+  for (const deferred of [false, true]) {
+    test(`${name} on closed db fails (deferred open: ${deferred})`, async function (t) {
+      let error
+
+      const db = testCommon.factory()
+      if (!deferred) await db.open()
+
+      await db.close()
+
+      try {
+        await run(t, db)
+      } catch (err) {
+        error = err
+      }
+
+      t.is(error && error.code, 'LEVEL_DATABASE_NOT_OPEN')
+    })
+
+    test(`${name} on closing db fails (deferred open: ${deferred})`, async function (t) {
+      let error
+
+      const db = testCommon.factory()
+      if (!deferred) await db.open()
+
+      const promise = db.close()
+
+      try {
+        await run(t, db)
+      } catch (err) {
+        error = err
+      }
+
+      await promise
+      t.is(error && error.code, 'LEVEL_DATABASE_NOT_OPEN')
+    })
+  }
+}

package/node_modules/abstract-level/test/traits/index.js

@@ -0,0 +1,4 @@
+'use strict'
+
+exports.open = require('./open')
+exports.closed = require('./closed')

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

@@ -0,0 +1,62 @@
+'use strict'
+
+module.exports = function (name, testCommon, options, run) {
+  if (typeof options === 'function') {
+    run = options
+    options = {}
+  }
+
+  const test = testCommon.test
+  const deferred = options.deferred !== false
+
+  test(`${name} on open db`, async function (t) {
+    const db = testCommon.factory()
+
+    await db.open()
+    t.is(db.status, 'open')
+
+    await run(t, db)
+    t.is(db.status, 'open')
+
+    return db.close()
+  })
+
+  deferred && test(`${name} on opening db`, async function (t) {
+    const db = testCommon.factory()
+    t.is(db.status, 'opening')
+    await run(t, db)
+    t.is(db.status, 'open')
+    return db.close()
+  })
+
+  test(`${name} on reopened db`, async function (t) {
+    const db = testCommon.factory()
+
+    await db.close()
+    t.is(db.status, 'closed')
+
+    await db.open()
+    t.is(db.status, 'open')
+
+    await run(t, db)
+    t.is(db.status, 'open')
+
+    return db.close()
+  })
+
+  deferred && test(`${name} on reopening db`, async function (t) {
+    const db = testCommon.factory()
+
+    await db.close()
+    t.is(db.status, 'closed')
+
+    const promise = db.open()
+    t.is(db.status, 'opening')
+
+    await run(t, db)
+    t.is(db.status, 'open')
+
+    await promise
+    return db.close()
+  })
+}

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

@@ -0,0 +1,275 @@
+'use strict'
+
+const { AbstractLevel, AbstractChainedBatch, AbstractSnapshot } = require('..')
+const { AbstractIterator, AbstractKeyIterator, AbstractValueIterator } = require('..')
+const noop = function () {}
+
+exports.illegalKeys = [
+  { name: 'null key', key: null },
+  { name: 'undefined key', key: undefined }
+]
+
+exports.illegalValues = [
+  { name: 'null key', value: null },
+  { name: 'undefined value', value: undefined }
+]
+
+// Utility to ensure we're not fooled by `await 123`. Instead do `await assertPromise(123)`
+exports.assertPromise = function (p) {
+  if (typeof p !== 'object' || p === null || typeof p.then !== 'function') {
+    throw new TypeError('Expected a promise')
+  }
+
+  return p
+}
+
+exports.mockLevel = function (methods, ...args) {
+  class TestLevel extends AbstractLevel {}
+  for (const k in methods) TestLevel.prototype[k] = methods[k]
+  if (!args.length) args = [{ encodings: { utf8: true } }]
+  return new TestLevel(...args)
+}
+
+exports.mockIterator = function (db, options, methods, ...args) {
+  class TestIterator extends AbstractIterator {}
+  for (const k in methods) TestIterator.prototype[k] = methods[k]
+  return new TestIterator(db, options, ...args)
+}
+
+exports.mockChainedBatch = function (db, methods, ...args) {
+  class TestBatch extends AbstractChainedBatch {}
+  for (const k in methods) TestBatch.prototype[k] = methods[k]
+  return new TestBatch(db, ...args)
+}
+
+// Mock encoding where null and undefined are significant types
+exports.nullishEncoding = {
+  name: 'nullish',
+  format: 'utf8',
+  encode (v) {
+    return v === null ? '\x00' : v === undefined ? '\xff' : String(v)
+  },
+  decode (v) {
+    return v === '\x00' ? null : v === '\xff' ? undefined : v
+  }
+}
+
+// Replacement for sinon package (which breaks too often, on features we don't use)
+exports.createSpy = function (fn = noop) {
+  let calls = []
+
+  const spy = function (...args) {
+    const returnValue = fn(...args)
+    calls.push({ thisValue: this, args, returnValue })
+    spy.callCount++
+    return returnValue
+  }
+
+  spy.callCount = 0
+  spy.getCall = function (n) {
+    return calls[n]
+  }
+
+  spy.resetHistory = function () {
+    calls = []
+    spy.callCount = 0
+  }
+
+  return spy
+}
+
+const kEntries = Symbol('entries')
+const kPosition = Symbol('position')
+const kOptions = Symbol('options')
+
+/**
+ * A minimal and non-optimized implementation for use in tests. Only supports utf8.
+ * Don't use this as a reference implementation.
+ */
+class MinimalLevel extends AbstractLevel {
+  constructor (options) {
+    super({
+      encodings: { utf8: true },
+      seek: true,
+      has: true,
+      explicitSnapshots: true,
+      getSync: true
+    }, options)
+
+    this[kEntries] = new Map()
+  }
+
+  async _put (key, value, options) {
+    this[kEntries].set(key, value)
+  }
+
+  async _get (key, options) {
+    const entries = (options.snapshot || this)[kEntries]
+
+    // Is undefined if not found
+    return entries.get(key)
+  }
+
+  _getSync (key, options) {
+    const entries = (options.snapshot || this)[kEntries]
+    return entries.get(key)
+  }
+
+  async _getMany (keys, options) {
+    const entries = (options.snapshot || this)[kEntries]
+    return keys.map(k => entries.get(k))
+  }
+
+  async _has (key, options) {
+    const entries = (options.snapshot || this)[kEntries]
+    return entries.has(key)
+  }
+
+  async _hasMany (keys, options) {
+    const entries = (options.snapshot || this)[kEntries]
+    return keys.map(k => entries.has(k))
+  }
+
+  async _del (key, options) {
+    this[kEntries].delete(key)
+  }
+
+  async _clear (options) {
+    const entries = (options.snapshot || this)[kEntries]
+
+    for (const [k] of sliceEntries(entries, options, true)) {
+      this[kEntries].delete(k)
+    }
+  }
+
+  async _batch (operations, options) {
+    const entries = new Map(this[kEntries])
+
+    for (const op of operations) {
+      if (op.type === 'put') entries.set(op.key, op.value)
+      else entries.delete(op.key)
+    }
+
+    this[kEntries] = entries
+  }
+
+  _iterator (options) {
+    return new MinimalIterator(this, options)
+  }
+
+  _keys (options) {
+    return new MinimalKeyIterator(this, options)
+  }
+
+  _values (options) {
+    return new MinimalValueIterator(this, options)
+  }
+
+  _snapshot (options) {
+    return new MinimalSnapshot(this, options)
+  }
+}
+
+class MinimalSnapshot extends AbstractSnapshot {
+  constructor (db, options) {
+    super(options)
+    this[kEntries] = new Map(db[kEntries])
+  }
+}
+
+class MinimalIterator extends AbstractIterator {
+  constructor (db, options) {
+    super(db, options)
+    const entries = (options.snapshot || db)[kEntries]
+    this[kEntries] = sliceEntries(entries, options, false)
+    this[kOptions] = options
+    this[kPosition] = 0
+  }
+}
+
+class MinimalKeyIterator extends AbstractKeyIterator {
+  constructor (db, options) {
+    super(db, options)
+    const entries = (options.snapshot || db)[kEntries]
+    this[kEntries] = sliceEntries(entries, options, false)
+    this[kOptions] = options
+    this[kPosition] = 0
+  }
+}
+
+class MinimalValueIterator extends AbstractValueIterator {
+  constructor (db, options) {
+    super(db, options)
+    const entries = (options.snapshot || db)[kEntries]
+    this[kEntries] = sliceEntries(entries, options, false)
+    this[kOptions] = options
+    this[kPosition] = 0
+  }
+}
+
+for (const Ctor of [MinimalIterator, MinimalKeyIterator, MinimalValueIterator]) {
+  const mapEntry = Ctor === MinimalIterator ? e => e.slice() : Ctor === MinimalKeyIterator ? e => e[0] : e => e[1]
+
+  Ctor.prototype._next = async function () {
+    const entry = this[kEntries][this[kPosition]++]
+    if (entry === undefined) return undefined
+    return mapEntry(entry)
+  }
+
+  Ctor.prototype._nextv = async function (size, options) {
+    const entries = this[kEntries].slice(this[kPosition], this[kPosition] + size)
+    this[kPosition] += entries.length
+    return entries.map(mapEntry)
+  }
+
+  Ctor.prototype._all = async function (options) {
+    const end = this.limit - this.count + this[kPosition]
+    const entries = this[kEntries].slice(this[kPosition], end)
+    this[kPosition] = this[kEntries].length
+    return entries.map(mapEntry)
+  }
+
+  Ctor.prototype._seek = function (target, options) {
+    this[kPosition] = this[kEntries].length
+
+    if (!outOfRange(target, this[kOptions])) {
+      // Don't care about performance here
+      for (let i = 0; i < this[kPosition]; i++) {
+        const key = this[kEntries][i][0]
+
+        if (this[kOptions].reverse ? key <= target : key >= target) {
+          this[kPosition] = i
+        }
+      }
+    }
+  }
+}
+
+const outOfRange = function (target, options) {
+  if ('gte' in options) {
+    if (target < options.gte) return true
+  } else if ('gt' in options) {
+    if (target <= options.gt) return true
+  }
+
+  if ('lte' in options) {
+    if (target > options.lte) return true
+  } else if ('lt' in options) {
+    if (target >= options.lt) return true
+  }
+
+  return false
+}
+
+const sliceEntries = function (entries, options, applyLimit) {
+  entries = Array.from(entries)
+    .filter((e) => !outOfRange(e[0], options))
+    .sort((a, b) => a[0] > b[0] ? 1 : a[0] < b[0] ? -1 : 0)
+
+  if (options.reverse) entries.reverse()
+  if (applyLimit && options.limit !== -1) entries = entries.slice(0, options.limit)
+
+  return entries
+}
+
+exports.MinimalLevel = MinimalLevel