nolo-cli 0.108.0-alpha.2 → 0.108.1

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

@@ -0,0 +1,132 @@
+'use strict'
+
+const input = [{ key: '1', value: '1' }, { key: '2', value: '2' }]
+
+let db
+
+exports.setup = function (test, testCommon) {
+  test('async iterator setup', async function (t) {
+    db = testCommon.factory()
+    await db.open()
+    return db.batch(input.map(entry => ({ ...entry, type: 'put' })))
+  })
+}
+
+exports.asyncIterator = function (test, testCommon) {
+  for (const mode of ['iterator', 'keys', 'values']) {
+    test(`for await...of ${mode}()`, async function (t) {
+      t.plan(1)
+
+      const it = db[mode]({ keyEncoding: 'utf8', valueEncoding: 'utf8' })
+      const output = []
+
+      for await (const item of it) {
+        output.push(item)
+      }
+
+      t.same(output, input.map(({ key, value }) => {
+        return mode === 'iterator' ? [key, value] : mode === 'keys' ? key : value
+      }))
+    })
+
+    testCommon.supports.permanence && test(`for await...of ${mode}() (deferred)`, async function (t) {
+      t.plan(1)
+
+      const db = testCommon.factory()
+      await db.batch(input.map(entry => ({ ...entry, type: 'put' })))
+      await db.close()
+
+      // Don't await
+      db.open()
+
+      const it = db[mode]({ keyEncoding: 'utf8', valueEncoding: 'utf8' })
+      const output = []
+
+      for await (const item of it) {
+        output.push(item)
+      }
+
+      t.same(output, input.map(({ key, value }) => {
+        return mode === 'iterator' ? [key, value] : mode === 'keys' ? key : value
+      }))
+
+      await db.close()
+    })
+
+    testCommon.supports.implicitSnapshots && test(`for await...of ${mode}() (deferred, with snapshot)`, async function (t) {
+      t.plan(2)
+
+      const db = testCommon.factory()
+      const it = db[mode]({ keyEncoding: 'utf8', valueEncoding: 'utf8' })
+      const promise = db.batch(input.map(entry => ({ ...entry, type: 'put' })))
+      const output = []
+
+      for await (const item of it) {
+        output.push(item)
+      }
+
+      t.same(output, [], 'used snapshot')
+
+      // Wait for data to be written
+      await promise
+
+      for await (const item of db[mode]({ keyEncoding: 'utf8', valueEncoding: 'utf8' })) {
+        output.push(item)
+      }
+
+      t.same(output, input.map(({ key, value }) => {
+        return mode === 'iterator' ? [key, value] : mode === 'keys' ? key : value
+      }))
+
+      await db.close()
+    })
+
+    for (const deferred of [false, true]) {
+      test(`for await...of ${mode}() (empty, deferred: ${deferred})`, async function (t) {
+        const db = testCommon.factory()
+        const entries = []
+
+        if (!deferred) await db.open()
+
+        for await (const item of db[mode]({ keyEncoding: 'utf8', valueEncoding: 'utf8' })) {
+          entries.push(item)
+        }
+
+        t.same(entries, [])
+        await db.close()
+      })
+    }
+
+    test(`for await...of ${mode}() does not permit reuse`, async function (t) {
+      t.plan(3)
+
+      const it = db[mode]()
+
+      // eslint-disable-next-line no-unused-vars
+      for await (const item of it) {
+        t.pass('nexted')
+      }
+
+      try {
+        // eslint-disable-next-line no-unused-vars
+        for await (const item of it) {
+          t.fail('should not be called')
+        }
+      } catch (err) {
+        t.is(err.code, 'LEVEL_ITERATOR_NOT_OPEN')
+      }
+    })
+  }
+}
+
+exports.teardown = async function (test, testCommon) {
+  test('async iterator teardown', async function (t) {
+    return db.close()
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setup(test, testCommon)
+  exports.asyncIterator(test, testCommon)
+  exports.teardown(test, testCommon)
+}

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

@@ -0,0 +1,214 @@
+'use strict'
+
+const { Buffer } = require('buffer')
+const { illegalKeys, illegalValues } = require('./util')
+
+let db
+
+exports.setUp = function (test, testCommon) {
+  test('batch([]) setup', async function (t) {
+    db = testCommon.factory()
+    return db.open()
+  })
+}
+
+exports.args = function (test, testCommon) {
+  test('batch([]) with missing value fails', function (t) {
+    t.plan(1)
+
+    db.batch([{ type: 'put', key: 'foo1' }]).catch((err) => {
+      t.is(err.code, 'LEVEL_INVALID_VALUE', 'correct error code')
+    })
+  })
+
+  test('batch([]) with illegal values fails', function (t) {
+    t.plan(illegalValues.length * 2)
+
+    for (const { name, value } of illegalValues) {
+      db.batch([{ type: 'put', key: 'foo1', value }]).catch(function (err) {
+        t.ok(err instanceof Error, name + ' - is Error')
+        t.is(err.code, 'LEVEL_INVALID_VALUE', name + ' - correct error code')
+      })
+    }
+  })
+
+  test('batch([]) with missing key fails', function (t) {
+    t.plan(1)
+
+    db.batch([{ type: 'put', value: 'foo1' }]).catch(function (err) {
+      t.is(err.code, 'LEVEL_INVALID_KEY', 'correct error code')
+    })
+  })
+
+  test('batch([]) with illegal keys fails', function (t) {
+    t.plan(illegalKeys.length * 2)
+
+    for (const { name, key } of illegalKeys) {
+      db.batch([{ type: 'put', key, value: 'foo1' }]).catch(function (err) {
+        t.ok(err instanceof Error, name + ' - is Error')
+        t.is(err.code, 'LEVEL_INVALID_KEY', name + ' - correct error code')
+      })
+    }
+  })
+
+  test('batch([]) with missing or incorrect type fails', function (t) {
+    t.plan(4)
+
+    db.batch([{ key: 'key', value: 'value' }]).catch(function (err) {
+      t.is(err.name, 'TypeError')
+      t.is(err.message, "A batch operation must have a type property that is 'put' or 'del'", 'correct error message')
+    })
+
+    db.batch([{ key: 'key', value: 'value', type: 'foo' }]).catch(function (err) {
+      t.is(err.name, 'TypeError')
+      t.is(err.message, "A batch operation must have a type property that is 'put' or 'del'", 'correct error message')
+    })
+  })
+
+  test('batch([]) with missing or nullish operations fails', function (t) {
+    t.plan(2 * 2)
+
+    for (const array of [null, undefined]) {
+      db.batch(array).catch(function (err) {
+        t.is(err.name, 'TypeError')
+        t.is(err.message, "The first argument 'operations' must be an array", 'correct error message')
+      })
+    }
+  })
+
+  test('batch([]) with empty operations array and empty options', async function (t) {
+    await db.batch([])
+    await db.batch([], null)
+    await db.batch([], undefined)
+    await db.batch([], {})
+  })
+
+  ;[null, undefined, 1, true].forEach(function (operation) {
+    const type = operation === null ? 'null' : typeof operation
+
+    test(`batch([]) with ${type} operation fails`, function (t) {
+      t.plan(1)
+
+      db.batch([operation]).catch(function (err) {
+        // We can either explicitly check the type of the op and throw a TypeError,
+        // or skip that for performance reasons in which case the next thing checked
+        // will be op.key or op.type. Doesn't matter, because we've documented that
+        // TypeErrors and such are not part of the semver contract.
+        t.ok(err.name === 'TypeError' || err.code === 'LEVEL_INVALID_KEY')
+      })
+    })
+  })
+}
+
+exports.batch = function (test, testCommon) {
+  test('simple batch([])', async function (t) {
+    const db = testCommon.factory()
+    await db.open()
+    await db.batch([{ type: 'del', key: 'non-existent' }]) // should not error
+    t.is(await db.get('foo'), undefined, 'not found')
+    await db.batch([{ type: 'put', key: 'foo', value: 'bar' }])
+    t.is(await db.get('foo'), 'bar')
+    await db.batch([{ type: 'del', key: 'foo' }])
+    t.is(await db.get('foo'), undefined, 'not found')
+    return db.close()
+  })
+
+  test('batch([]) with multiple operations', async function (t) {
+    t.plan(3)
+
+    await db.batch([
+      { type: 'put', key: 'foobatch1', value: 'bar1' },
+      { type: 'put', key: 'foobatch2', value: 'bar2' },
+      { type: 'put', key: 'foobatch3', value: 'bar3' },
+      { type: 'del', key: 'foobatch2' }
+    ])
+
+    const promises = [
+      db.get('foobatch1').then(function (value) {
+        t.is(value, 'bar1')
+      }),
+      db.get('foobatch2').then(function (value) {
+        t.is(value, undefined, 'not found')
+      }),
+      db.get('foobatch3').then(function (value) {
+        t.is(value, 'bar3')
+      })
+    ]
+
+    return Promise.all(promises)
+  })
+
+  for (const encoding of ['utf8', 'buffer', 'view']) {
+    if (!testCommon.supports.encodings[encoding]) continue
+
+    // NOTE: adapted from memdown
+    test(`empty values in batch with ${encoding} valueEncoding`, async function (t) {
+      const db = testCommon.factory({ valueEncoding: encoding })
+      const values = ['', Uint8Array.from([]), Buffer.alloc(0)]
+      const expected = encoding === 'utf8' ? values[0] : encoding === 'view' ? values[1] : values[2]
+
+      await db.open()
+      await db.batch(values.map((value, i) => ({ type: 'put', key: String(i), value })))
+
+      for (let i = 0; i < values.length; i++) {
+        const value = await db.get(String(i))
+
+        // Buffer is a Uint8Array, so this is allowed
+        if (encoding === 'view' && Buffer.isBuffer(value)) {
+          t.same(value, values[2])
+        } else {
+          t.same(value, expected)
+        }
+      }
+
+      return db.close()
+    })
+
+    test(`empty keys in batch with ${encoding} keyEncoding`, async function (t) {
+      const db = testCommon.factory({ keyEncoding: encoding })
+      const keys = ['', Uint8Array.from([]), Buffer.alloc(0)]
+
+      await db.open()
+
+      for (let i = 0; i < keys.length; i++) {
+        await db.batch([{ type: 'put', key: keys[i], value: String(i) }])
+        t.same(await db.get(keys[i]), String(i), `got value ${i}`)
+      }
+
+      return db.close()
+    })
+  }
+}
+
+exports.atomic = function (test, testCommon) {
+  test('batch([]) is atomic', async function (t) {
+    t.plan(3)
+
+    try {
+      await db.batch([
+        { type: 'put', key: 'foobah1', value: 'bar1' },
+        { type: 'put', value: 'bar2' },
+        { type: 'put', key: 'foobah3', value: 'bar3' }
+      ])
+    } catch (err) {
+      t.is(err.code, 'LEVEL_INVALID_KEY', 'should error and not commit anything')
+    }
+
+    t.is(await db.get('foobah1'), undefined, 'not found')
+    t.is(await db.get('foobah3'), undefined, 'not found')
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('batch([]) teardown', async function (t) {
+    return db.close()
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.args(test, testCommon)
+  exports.batch(test, testCommon)
+  exports.atomic(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

package/node_modules/abstract-level/test/chained-batch-test.js

@@ -0,0 +1,315 @@
+'use strict'
+
+let db
+
+exports.setUp = function (test, testCommon) {
+  test('chained batch setup', async function (t) {
+    db = testCommon.factory()
+    return db.open()
+  })
+}
+
+exports.args = function (test, testCommon) {
+  test('chained batch has db reference', async function (t) {
+    const batch = db.batch()
+    t.ok(batch.db === db)
+    return batch.close()
+  })
+
+  test('chained batch.put() with missing or nullish value fails', async function (t) {
+    t.plan(3 * 2)
+
+    for (const args of [[null], [undefined], []]) {
+      const batch = db.batch()
+
+      try {
+        batch.put('key', ...args)
+      } catch (err) {
+        t.is(err.code, 'LEVEL_INVALID_VALUE', 'correct error code')
+        t.is(batch.length, 0, 'length is not incremented on error')
+      }
+
+      await batch.close()
+    }
+  })
+
+  test('chained batch.put() with missing of nullish key fails', async function (t) {
+    t.plan(3 * 2)
+
+    for (const args of [[], [null, 'foo'], [undefined, 'foo']]) {
+      const batch = db.batch()
+
+      try {
+        batch.put(...args)
+      } catch (err) {
+        t.is(err.code, 'LEVEL_INVALID_KEY', 'correct error code')
+        t.is(batch.length, 0, 'length is not incremented on error')
+      }
+
+      await batch.close()
+    }
+  })
+
+  test('chained batch.del() with missing or nullish key fails', async function (t) {
+    t.plan(3 * 2)
+
+    for (const args of [[null], [undefined], []]) {
+      const batch = db.batch()
+
+      try {
+        batch.del(...args)
+      } catch (err) {
+        t.is(err.code, 'LEVEL_INVALID_KEY', 'correct error code')
+        t.is(batch.length, 0, 'length is not incremented on error')
+      }
+
+      await batch.close()
+    }
+  })
+
+  test('chained batch.clear() does not throw if empty', async function (t) {
+    return db.batch().clear().close()
+  })
+
+  test('chained batch.put() after write() fails', async function (t) {
+    t.plan(1)
+
+    const batch = db.batch().put('foo', 'bar')
+    await batch.write()
+
+    try {
+      batch.put('boom', 'bang')
+    } catch (err) {
+      t.is(err.code, 'LEVEL_BATCH_NOT_OPEN', 'correct error code')
+    }
+  })
+
+  test('chained batch.del() after write() fails', async function (t) {
+    t.plan(1)
+
+    const batch = db.batch().put('foo', 'bar')
+    await batch.write()
+
+    try {
+      batch.del('foo')
+    } catch (err) {
+      t.is(err.code, 'LEVEL_BATCH_NOT_OPEN', 'correct error code')
+    }
+  })
+
+  test('chained batch.clear() after write() fails', async function (t) {
+    t.plan(1)
+
+    const batch = db.batch().put('foo', 'bar')
+    await batch.write()
+
+    try {
+      batch.clear()
+    } catch (err) {
+      t.is(err.code, 'LEVEL_BATCH_NOT_OPEN', 'correct error code')
+    }
+  })
+
+  test('chained batch.write() after write() fails', async function (t) {
+    t.plan(1)
+
+    const batch = db.batch().put('foo', 'bar')
+    await batch.write()
+
+    try {
+      await batch.write()
+    } catch (err) {
+      t.is(err.code, 'LEVEL_BATCH_NOT_OPEN', 'correct error code')
+    }
+  })
+
+  test('chained batch.write() after close() fails', async function (t) {
+    t.plan(1)
+
+    const batch = db.batch().put('foo', 'bar')
+    await batch.close()
+
+    try {
+      await batch.write()
+    } catch (err) {
+      t.is(err.code, 'LEVEL_BATCH_NOT_OPEN', 'correct error code')
+    }
+  })
+
+  test('chained batch.write() with no operations', async function (t) {
+    return db.batch().write()
+  })
+
+  test('chained batch.close() with no operations', async function (t) {
+    return db.batch().close()
+  })
+
+  test('chained batch.close() is idempotent', async function (t) {
+    const batch = db.batch()
+    await batch.close()
+    await batch.close()
+    return Promise.all([batch.close(), batch.close()])
+  })
+}
+
+exports.batch = function (test, testCommon) {
+  test('simple chained batch', async function (t) {
+    await db.batch([
+      { type: 'put', key: 'one', value: '1' },
+      { type: 'put', key: 'two', value: '2' },
+      { type: 'put', key: 'three', value: '3' }
+    ])
+
+    const batch = db.batch()
+      .put('1', 'one')
+      .del('2', 'two')
+      .put('3', 'three')
+
+    t.is(batch.length, 3, 'length was incremented')
+
+    batch.clear()
+    t.is(batch.length, 0, 'length is reset')
+
+    batch.put('one', 'I')
+      .put('two', 'II')
+      .del('three')
+      .put('foo', 'bar')
+
+    t.is(batch.length, 4, 'length was incremented')
+
+    await batch.write()
+
+    t.same(await db.iterator().all(), [
+      ['foo', 'bar'],
+      ['one', 'I'],
+      ['two', 'II']
+    ])
+  })
+
+  test('chained batch requires database to be open', async function (t) {
+    t.plan(5)
+
+    const db1 = testCommon.factory()
+    const db2 = testCommon.factory()
+
+    try {
+      db1.batch()
+    } catch (err) {
+      t.is(err.code, 'LEVEL_DATABASE_NOT_OPEN')
+    }
+
+    await db2.open()
+    const batch = db2.batch()
+    await db2.close()
+
+    try {
+      batch.put('beep', 'boop')
+    } catch (err) {
+      t.is(err.code, 'LEVEL_BATCH_NOT_OPEN')
+    }
+
+    try {
+      batch.del('456')
+    } catch (err) {
+      t.is(err.code, 'LEVEL_BATCH_NOT_OPEN')
+    }
+
+    try {
+      batch.clear()
+    } catch (err) {
+      t.is(err.code, 'LEVEL_BATCH_NOT_OPEN')
+    }
+
+    try {
+      await batch.write()
+    } catch (err) {
+      t.is(err.code, 'LEVEL_BATCH_NOT_OPEN')
+    }
+
+    // Should be a noop (already closed)
+    await batch.close()
+
+    return Promise.all([db1.close(), db2.close()])
+  })
+
+  // NOTE: adapted from levelup
+  test('chained batch with per-operation encoding options', async function (t) {
+    t.plan(2)
+
+    const db = testCommon.factory()
+    await db.open()
+
+    const utf8 = db.keyEncoding('utf8')
+    const json = db.valueEncoding('json')
+
+    db.once('write', function (operations) {
+      t.same(operations, [
+        { type: 'put', key: 'a', value: 'a', keyEncoding: utf8, valueEncoding: json, encodedKey: utf8.encode('a'), encodedValue: utf8.encode('"a"') },
+        { type: 'put', key: 'b', value: 'b', keyEncoding: utf8, valueEncoding: utf8, encodedKey: utf8.encode('b'), encodedValue: utf8.encode('b') },
+        { type: 'put', key: '"c"', value: 'c', keyEncoding: utf8, valueEncoding: utf8, encodedKey: utf8.encode('"c"'), encodedValue: utf8.encode('c') },
+        { type: 'del', key: 'c', keyEncoding: json, encodedKey: utf8.encode('"c"'), arbitraryOption: true }
+      ])
+    })
+
+    await db.batch()
+      .put('a', 'a', { valueEncoding: 'json' })
+      .put('b', 'b')
+      .put('"c"', 'c')
+      .del('c', { keyEncoding: 'json', arbitraryOption: true })
+      .write()
+
+    t.same(await db.iterator().all(), [
+      ['a', '"a"'],
+      ['b', 'b']
+    ])
+
+    return db.close()
+  })
+}
+
+exports.events = function (test, testCommon) {
+  test('db.close() on chained batch write event', async function (t) {
+    const db = testCommon.factory()
+    await db.open()
+
+    let promise
+
+    db.on('write', function () {
+      // Should not interfere with the current write() operation
+      promise = db.close()
+    })
+
+    await db.batch().put('a', 'b').write()
+    await promise
+
+    t.ok(promise, 'event was emitted')
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('chained batch teardown', async function (t) {
+    return db.close()
+  })
+}
+
+exports.dispose = function (test, testCommon) {
+  // Can't use the syntax yet (https://github.com/tc39/proposal-explicit-resource-management)
+  Symbol.asyncDispose && test('Symbol.asyncDispose', async function (t) {
+    const db = testCommon.factory()
+    await db.open()
+
+    const batch = db.batch()
+    await batch[Symbol.asyncDispose]()
+
+    return db.close()
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.args(test, testCommon)
+  exports.batch(test, testCommon)
+  exports.events(test, testCommon)
+  exports.tearDown(test, testCommon)
+  exports.dispose(test, testCommon)
+}