nolo-cli 0.108.0-alpha.2 → 0.108.0

package/node_modules/classic-level/index.d.ts

@@ -0,0 +1,343 @@
+import {
+  AbstractLevel,
+  AbstractDatabaseOptions,
+  AbstractOpenOptions,
+  AbstractGetOptions,
+  AbstractGetManyOptions,
+  AbstractHasOptions,
+  AbstractHasManyOptions,
+  AbstractPutOptions,
+  AbstractDelOptions,
+  AbstractBatchOperation,
+  AbstractBatchOptions,
+  AbstractChainedBatch,
+  AbstractChainedBatchWriteOptions,
+  AbstractIteratorOptions,
+  AbstractIterator,
+  AbstractKeyIterator,
+  AbstractKeyIteratorOptions,
+  AbstractValueIterator,
+  AbstractValueIteratorOptions,
+  AbstractSnapshot,
+  Transcoder
+} from 'abstract-level'
+
+/**
+ * An {@link AbstractLevel} database backed by
+ * [LevelDB](https://github.com/google/leveldb).
+ *
+ * @template KDefault The default type of keys if not overridden on operations.
+ * @template VDefault The default type of values if not overridden on operations.
+ */
+declare class ClassicLevel<KDefault = string, VDefault = string>
+  extends AbstractLevel<string | Buffer | Uint8Array, KDefault, VDefault> {
+  /**
+   * Database constructor.
+   *
+   * @param location Directory path (relative or absolute) where LevelDB will
+   * store its files.
+   * @param options Options, of which some will be forwarded to {@link open}.
+   */
+  constructor (
+    location: string,
+    options?: DatabaseOptions<KDefault, VDefault> | undefined
+  )
+
+  /**
+   * Location that was passed to the constructor.
+   */
+  get location (): string
+
+  open (): Promise<void>
+  open (options: OpenOptions): Promise<void>
+
+  get (key: KDefault): Promise<VDefault | undefined>
+  get<K = KDefault, V = VDefault> (key: K, options: GetOptions<K, V>): Promise<V | undefined>
+
+  getSync (key: KDefault): VDefault | undefined
+  getSync<K = KDefault, V = VDefault> (key: K, options: GetOptions<K, V>): V | undefined
+
+  getMany (keys: KDefault[]): Promise<(VDefault | undefined)[]>
+  getMany<K = KDefault, V = VDefault> (keys: K[], options: GetManyOptions<K, V>): Promise<(V | undefined)[]>
+
+  has (key: KDefault): Promise<boolean>
+  has<K = KDefault> (key: K, options: HasOptions<K>): Promise<boolean>
+
+  hasMany (keys: KDefault[]): Promise<boolean[]>
+  hasMany<K = KDefault> (keys: K[], options: HasManyOptions<K>): Promise<boolean[]>
+
+  put (key: KDefault, value: VDefault): Promise<void>
+  put<K = KDefault, V = VDefault> (key: K, value: V, options: PutOptions<K, V>): Promise<void>
+
+  del (key: KDefault): Promise<void>
+  del<K = KDefault> (key: K, options: DelOptions<K>): Promise<void>
+
+  batch (operations: Array<BatchOperation<typeof this, KDefault, VDefault>>): Promise<void>
+  batch<K = KDefault, V = VDefault> (operations: Array<BatchOperation<typeof this, K, V>>, options: BatchOptions<K, V>): Promise<void>
+  batch (): ChainedBatch<typeof this, KDefault, VDefault>
+
+  iterator (): Iterator<typeof this, KDefault, VDefault>
+  iterator<K = KDefault, V = VDefault> (options: IteratorOptions<K, V>): Iterator<typeof this, K, V>
+
+  keys (): KeyIterator<typeof this, KDefault>
+  keys<K = KDefault> (options: KeyIteratorOptions<K>): KeyIterator<typeof this, K>
+
+  values (): ValueIterator<typeof this, KDefault, VDefault>
+  values<K = KDefault, V = VDefault> (options: ValueIteratorOptions<K, V>): ValueIterator<typeof this, K, V>
+
+  snapshot (options?: any | undefined): Snapshot
+
+  /**
+   * Get the approximate number of bytes of file system space used by the range
+   * `[start..end)`.
+   */
+  approximateSize (start: KDefault, end: KDefault): Promise<number>
+  approximateSize<K = KDefault> (start: K, end: K, options: StartEndOptions<K>): Promise<number>
+
+  /**
+   * Manually trigger a database compaction in the range `[start..end)`.
+   */
+  compactRange (start: KDefault, end: KDefault): Promise<void>
+  compactRange<K = KDefault> (start: K, end: K, options: StartEndOptions<K>): Promise<void>
+
+  /**
+   * Get internal details from LevelDB.
+   */
+  getProperty (property: string): string
+
+  /**
+   * Completely remove an existing LevelDB database directory. Can be used in
+   * place of a full directory removal to only remove LevelDB-related files.
+   */
+  static destroy (location: string): Promise<void>
+
+  /**
+   * Attempt a restoration of a damaged database. Can also be used to perform
+   * a compaction of the LevelDB log into table files.
+   */
+  static repair (location: string): Promise<void>
+}
+
+/**
+ * Options for the database constructor.
+ */
+export interface DatabaseOptions<K, V>
+  extends AbstractDatabaseOptions<K, V>, Omit<OpenOptions, 'passive'> {}
+
+/**
+ * Options for the {@link ClassicLevel.open} method.
+ */
+export interface OpenOptions extends AbstractOpenOptions {
+  /**
+   * Unless set to `false`, all _compressible_ data will be run through the
+   * Snappy compression algorithm before being stored. Snappy is very fast so
+   * leave this on unless you have good reason to turn it off.
+   *
+   * @defaultValue `true`
+   */
+  compression?: boolean | undefined
+
+  /**
+   * The size (in bytes) of the in-memory
+   * [LRU](http://en.wikipedia.org/wiki/Least_Recently_Used)
+   * cache with frequently used uncompressed block contents.
+   *
+   * @defaultValue `8 * 1024 * 1024`
+   */
+  cacheSize?: number | undefined
+
+  /**
+   * The maximum size (in bytes) of the log (in memory and stored in the `.log`
+   * file on disk). Beyond this size, LevelDB will convert the log data to the
+   * first level of sorted table files. From LevelDB documentation:
+   *
+   * > Larger values increase performance, especially during bulk loads. Up to
+   * > two write buffers may be held in memory at the same time, so you may
+   * > wish to adjust this parameter to control memory usage. Also, a larger
+   * > write buffer will result in a longer recovery time the next time the
+   * > database is opened.
+   *
+   * @defaultValue `4 * 1024 * 1024`
+   */
+  writeBufferSize?: number | undefined
+
+  /**
+   * The _approximate_ size of the blocks that make up the table files. The
+   * size relates to uncompressed data (hence "approximate"). Blocks are
+   * indexed in the table file and entry-lookups involve reading an entire
+   * block and parsing to discover the required entry.
+   *
+   * @defaultValue `4096`
+   */
+  blockSize?: number | undefined
+
+  /**
+   * The maximum number of files that LevelDB is allowed to have open at a
+   * time. If your database is likely to have a large working set, you may
+   * increase this value to prevent file descriptor churn. To calculate the
+   * number of files required for your working set, divide your total data size
+   * by `maxFileSize`.
+   *
+   * @defaultValue 1000
+   */
+  maxOpenFiles?: number | undefined
+
+  /**
+   * The number of entries before restarting the "delta encoding" of keys
+   * within blocks. Each "restart" point stores the full key for the entry,
+   * between restarts, the common prefix of the keys for those entries is
+   * omitted. Restarts are similar to the concept of keyframes in video
+   * encoding and are used to minimise the amount of space required to store
+   * keys. This is particularly helpful when using deep namespacing / prefixing
+   * in your keys.
+   *
+   * @defaultValue `16`
+   */
+  blockRestartInterval?: number | undefined
+
+  /**
+   * The maximum amount of bytes to write to a file before switching to a new
+   * one. From LevelDB documentation:
+   *
+   * > If your filesystem is more efficient with larger files, you could
+   * > consider increasing the value. The downside will be longer compactions
+   * > and hence longer latency / performance hiccups. Another reason to
+   * > increase this parameter might be when you are initially populating a
+   * > large database.
+   *
+   * @defaultValue `2 * 1024 * 1024`
+   */
+  maxFileSize?: number | undefined
+
+  /**
+   * Allows multi-threaded access to a single DB instance for sharing a DB
+   * across multiple worker threads within the same process.
+   *
+   * @defaultValue `false`
+   */
+  multithreading?: boolean | undefined
+}
+
+/**
+ * Additional options for the {@link ClassicLevel.get}, {@link ClassicLevel.getMany},
+ * {@link ClassicLevel.has} and {@link ClassicLevel.hasMany} methods.
+ */
+declare interface ReadOptions {
+  /**
+   * Unless set to `false`, LevelDB will fill its in-memory
+   * [LRU](http://en.wikipedia.org/wiki/Least_Recently_Used) cache with data
+   * that was read.
+   *
+   * @defaultValue `true`
+   */
+  fillCache?: boolean | undefined
+}
+
+/**
+ * Options for the {@link ClassicLevel.get} method.
+ */
+export interface GetOptions<K, V> extends AbstractGetOptions<K, V>, ReadOptions {}
+
+/**
+ * Options for the {@link ClassicLevel.getMany} method.
+ */
+export interface GetManyOptions<K, V> extends AbstractGetManyOptions<K, V>, ReadOptions {}
+
+/**
+ * Options for the {@link ClassicLevel.has} method.
+ */
+export interface HasOptions<K> extends AbstractHasOptions<K>, ReadOptions {}
+
+/**
+ * Options for the {@link ClassicLevel.hasMany} method.
+ */
+export interface HasManyOptions<K> extends AbstractHasManyOptions<K>, ReadOptions {}
+
+/**
+ * Additional options for the {@link ClassicLevel.iterator}, {@link ClassicLevel.keys}
+ * and {@link ClassicLevel.values} methods.
+ */
+export interface AdditionalIteratorOptions {
+  /**
+   * If set to `true`, LevelDB will fill its in-memory
+   * [LRU](http://en.wikipedia.org/wiki/Least_Recently_Used) cache with data
+   * that was read.
+   *
+   * @defaultValue `false`
+   */
+  fillCache?: boolean | undefined
+
+  /**
+   * Limit the amount of data that the iterator will hold in memory.
+   */
+  highWaterMarkBytes?: number | undefined
+}
+
+/**
+ * Additional options for the {@link ClassicLevel.put}, {@link ClassicLevel.del}
+ * and {@link ClassicLevel.batch} methods.
+ */
+declare interface WriteOptions {
+  /**
+   * If set to `true`, LevelDB will perform a synchronous write of the data
+   * although the operation will be asynchronous as far as Node.js or Electron
+   * is concerned. Normally, LevelDB passes the data to the operating system
+   * for writing and returns immediately. In contrast, a synchronous write will
+   * use [`fsync()`](https://man7.org/linux/man-pages/man2/fsync.2.html) or
+   * equivalent, so the operation will not complete until the data is actually
+   * on disk. Synchronous writes are significantly slower than asynchronous
+   * writes.
+   *
+   * @defaultValue `false`
+   */
+  sync?: boolean | undefined
+}
+
+/**
+ * Options for the {@link ClassicLevel.put} method.
+ */
+export interface PutOptions<K, V> extends AbstractPutOptions<K, V>, WriteOptions {}
+
+/**
+ * Options for the {@link ClassicLevel.del} method.
+ */
+export interface DelOptions<K> extends AbstractDelOptions<K>, WriteOptions {}
+
+/**
+ * Options for the {@link ClassicLevel.batch} method.
+ */
+export interface BatchOptions<K, V> extends AbstractBatchOptions<K, V>, WriteOptions {}
+
+/**
+ * Options for the {@link ChainedBatch.write} method.
+ */
+export interface ChainedBatchWriteOptions extends AbstractChainedBatchWriteOptions, WriteOptions {}
+
+export class ChainedBatch<TDatabase, KDefault, VDefault> extends AbstractChainedBatch<TDatabase, KDefault, VDefault> {
+  write (): Promise<void>
+  write (options: ChainedBatchWriteOptions): Promise<void>
+}
+
+/**
+ * Options for the {@link ClassicLevel.approximateSize} and
+ * {@link ClassicLevel.compactRange} methods.
+ */
+export interface StartEndOptions<K> {
+  /**
+   * Custom key encoding for this operation, used to encode `start` and `end`.
+   */
+  keyEncoding?: string | Transcoder.PartialEncoder<K> | undefined
+}
+
+// Export remaining types so that consumers don't have to guess whether they're extended
+export type BatchOperation<TDatabase, K, V> = AbstractBatchOperation<TDatabase, K, V>
+
+export type Iterator<TDatabase, K, V> = AbstractIterator<TDatabase, K, V>
+export type KeyIterator<TDatabase, K> = AbstractKeyIterator<TDatabase, K>
+export type ValueIterator<TDatabase, K, V> = AbstractValueIterator<TDatabase, K, V>
+
+export type IteratorOptions<K, V> = AbstractIteratorOptions<K, V> & AdditionalIteratorOptions
+export type KeyIteratorOptions<K> = AbstractKeyIteratorOptions<K> & AdditionalIteratorOptions
+export type ValueIteratorOptions<K, V> = AbstractValueIteratorOptions<K, V> & AdditionalIteratorOptions
+
+export type Snapshot = AbstractSnapshot

package/node_modules/classic-level/index.js

@@ -0,0 +1,311 @@
+'use strict'
+
+const { AbstractLevel, AbstractSnapshot } = require('abstract-level')
+const ModuleError = require('module-error')
+const fsp = require('fs/promises')
+const binding = require('./binding')
+const { ChainedBatch } = require('./chained-batch')
+const { Iterator } = require('./iterator')
+
+const kContext = Symbol('context')
+const kLocation = Symbol('location')
+
+class ClassicLevel extends AbstractLevel {
+  #sharedBuffer = null
+
+  constructor (location, options) {
+    if (typeof location !== 'string' || location === '') {
+      throw new TypeError("The first argument 'location' must be a non-empty string")
+    }
+
+    super({
+      encodings: {
+        buffer: true,
+        utf8: true,
+        view: true
+      },
+      has: true,
+      createIfMissing: true,
+      errorIfExists: true,
+      explicitSnapshots: true,
+      getSync: true,
+      additionalMethods: {
+        approximateSize: true,
+        compactRange: true
+      },
+      signals: {
+        iterators: true
+      }
+    }, options)
+
+    this[kLocation] = location
+    this[kContext] = binding.db_init()
+  }
+
+  get location () {
+    return this[kLocation]
+  }
+
+  async _open (options) {
+    if (options.createIfMissing) {
+      await fsp.mkdir(this[kLocation], { recursive: true })
+    }
+
+    return binding.db_open(this[kContext], this[kLocation], options)
+  }
+
+  async _close () {
+    return binding.db_close(this[kContext])
+  }
+
+  async _put (key, value, options) {
+    return binding.db_put(this[kContext], key, value, options)
+  }
+
+  async _get (key, options) {
+    let flags = 0
+
+    if (options.fillCache !== false) flags |= FLAG_FILL_CACHE
+    if (options.valueEncoding !== 'utf8') flags |= FLAG_VALUE_AS_BUFFER
+
+    if (options.keyEncoding !== 'utf8') {
+      flags |= FLAG_KEY_AS_BUFFER
+
+      // If address of ArrayBuffer can move then copy it.
+      // TODO: the spec says "Resizable ArrayBuffers are designed to be implementable with in-place
+      // growth" (backed by virtual memory) so if V8 / Node.js implemented it that way, copying is
+      // not necessary. Check if the address changes after a (significant) resize.
+      if (key.buffer.resizable) {
+        key = new Uint8Array(key)
+      }
+    }
+
+    return binding.db_get(
+      this[kContext],
+      flags,
+      key,
+      options.snapshot?.[kContext]
+    )
+  }
+
+  _getSync (key, options) {
+    let flags = 0
+
+    if (options.fillCache !== false) flags |= FLAG_FILL_CACHE
+    if (options.valueEncoding !== 'utf8') flags |= FLAG_VALUE_AS_BUFFER
+
+    if (options.keyEncoding !== 'utf8') {
+      return binding.db_get_sync(
+        this[kContext],
+        flags,
+        key,
+        options.snapshot?.[kContext]
+      )
+    } else {
+      let keySize
+
+      // Write key to a reused buffer. This is slightly faster than
+      // napi_get_value_string_utf8 but is mainly here as a starting
+      // point for encodings that write into a buffer (WIP).
+      if (this.#sharedBuffer === null) {
+        keySize = this.#createSharedBuffer(key)
+      } else {
+        keySize = this.#sharedBuffer.write(key)
+
+        // Resize if needed
+        if (keySize === this.#sharedBuffer.byteLength) {
+          keySize = this.#createSharedBuffer(key)
+        }
+      }
+
+      return binding.db_get_sync(
+        this[kContext],
+        flags | FLAG_SHARED_KEY,
+        keySize,
+        options.snapshot?.[kContext]
+      )
+    }
+  }
+
+  #createSharedBuffer (str) {
+    // Add at least 1 byte to detect when size is exceeded (without needing
+    // to precompute size on every write) and more to avoid frequent resizing.
+    this.#sharedBuffer = Buffer.allocUnsafe(Buffer.byteLength(str) + 64)
+
+    // Save buffer on the database so that we can subsequently read from a
+    // raw pointer instead of going through Node-API again.
+    binding.db_set_shared_buffer(this[kContext], this.#sharedBuffer)
+
+    return this.#sharedBuffer.write(str)
+  }
+
+  async _getMany (keys, options) {
+    return binding.db_get_many(
+      this[kContext],
+      keys,
+      options,
+      options.snapshot?.[kContext]
+    )
+  }
+
+  async _has (key, options) {
+    return binding.db_has(
+      this[kContext],
+      key,
+      options.fillCache,
+      options.snapshot?.[kContext]
+    )
+  }
+
+  async _hasMany (keys, options) {
+    // Use a space-efficient bitset (with 32-bit words) to contain found keys
+    const wordCount = (keys.length + 32) >>> 5
+    const buffer = new ArrayBuffer(wordCount * 4)
+    const bitset = new Uint32Array(buffer)
+
+    await binding.db_has_many(
+      this[kContext],
+      keys,
+      options.fillCache,
+      options.snapshot?.[kContext],
+      buffer
+    )
+
+    const values = new Array(keys.length)
+
+    for (let i = 0; i < values.length; i++) {
+      // Check if bit is set
+      values[i] = (bitset[i >>> 5] & (1 << (i & 31))) !== 0
+    }
+
+    return values
+  }
+
+  async _del (key, options) {
+    return binding.db_del(this[kContext], key, options)
+  }
+
+  async _clear (options) {
+    return binding.db_clear(
+      this[kContext],
+      options,
+      options.snapshot?.[kContext]
+    )
+  }
+
+  _chainedBatch () {
+    return new ChainedBatch(this, this[kContext])
+  }
+
+  async _batch (operations, options) {
+    return binding.batch_do(this[kContext], operations, options)
+  }
+
+  async approximateSize (start, end, options) {
+    if (arguments.length < 2) {
+      throw new TypeError("The arguments 'start' and 'end' are required")
+    } else if (typeof options !== 'object') {
+      options = null
+    }
+
+    if (this.status === 'opening') {
+      return this.deferAsync(() => this.approximateSize(start, end, options))
+    } else if (this.status !== 'open') {
+      throw new ModuleError('Database is not open: cannot call approximateSize()', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    } else {
+      const keyEncoding = this.keyEncoding(options && options.keyEncoding)
+      start = keyEncoding.encode(start)
+      end = keyEncoding.encode(end)
+      return binding.db_approximate_size(this[kContext], start, end)
+    }
+  }
+
+  async compactRange (start, end, options) {
+    if (arguments.length < 2) {
+      throw new TypeError("The arguments 'start' and 'end' are required")
+    } else if (typeof options !== 'object') {
+      options = null
+    }
+
+    if (this.status === 'opening') {
+      return this.deferAsync(() => this.compactRange(start, end, options))
+    } else if (this.status !== 'open') {
+      throw new ModuleError('Database is not open: cannot call compactRange()', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    } else {
+      const keyEncoding = this.keyEncoding(options && options.keyEncoding)
+      start = keyEncoding.encode(start)
+      end = keyEncoding.encode(end)
+      return binding.db_compact_range(this[kContext], start, end)
+    }
+  }
+
+  getProperty (property) {
+    if (typeof property !== 'string') {
+      throw new TypeError("The first argument 'property' must be a string")
+    }
+
+    // Is synchronous, so can't be deferred
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
+    return binding.db_get_property(this[kContext], property)
+  }
+
+  _iterator (options) {
+    return new Iterator(
+      this,
+      this[kContext],
+      options,
+      options.snapshot?.[kContext]
+    )
+  }
+
+  _snapshot (options) {
+    return new Snapshot(this[kContext], options)
+  }
+
+  static async destroy (location) {
+    if (typeof location !== 'string' || location === '') {
+      throw new TypeError("The first argument 'location' must be a non-empty string")
+    }
+
+    return binding.destroy_db(location)
+  }
+
+  static async repair (location) {
+    if (typeof location !== 'string' || location === '') {
+      throw new TypeError("The first argument 'location' must be a non-empty string")
+    }
+
+    return binding.repair_db(location)
+  }
+}
+
+// Defined here so that both ClassicLevel and Snapshot can access kContext
+class Snapshot extends AbstractSnapshot {
+  constructor (context, options) {
+    super(options)
+    this[kContext] = binding.snapshot_init(context)
+  }
+
+  async _close () {
+    // This is synchronous because that's faster than creating async work
+    binding.snapshot_close(this[kContext])
+  }
+}
+
+exports.ClassicLevel = ClassicLevel
+
+// Singular values are cheaper to transfer from JS to C++, so we
+// combine options into flags.
+const FLAG_FILL_CACHE = 1
+const FLAG_KEY_AS_BUFFER = 2
+const FLAG_VALUE_AS_BUFFER = 4
+const FLAG_SHARED_KEY = 8