Add getSync() method

Category: addition

Author: vweevers

README.md

@@ -158,6 +158,10 @@ Get a value from the database by `key`. The optional `options` object may contai
 
 Returns a promise for the value. If the `key` was not found then the value will be `undefined`.
 
+### `db.getSync(key[, options])`
+
+Synchronously get a value from the database by `key`. This blocks the event loop but can be significantly faster than `db.get()`. Options are the same. Returns the value, or `undefined` if not found.
+
 ### `db.getMany(keys[, options])`
 
 Get multiple values from the database by an array of `keys`. The optional `options` object may contain:
@@ -1509,6 +1513,12 @@ If the database indicates support of snapshots via `db.supports.implicitSnapshot
 
 The default `_get()` returns a promise for an `undefined` value. It must be overridden.
 
+### `db._getSync(key, options)`
+
+Synchronously get a value by `key`. Receives the same options as `db._get()`. Must return a value, or `undefined` if not found.
+
+The default `_getSync()` throws a [`LEVEL_NOT_SUPPORTED`](#level_not_supported) error. It should be overridden but support of `_getSync()` is currently opt-in. Set `manifest.getSync` to `true` in order to enable tests.
+
 ### `db._getMany(keys, options)`
 
 Get multiple values by an array of `keys`. The `options` object will always have the following properties: `keyEncoding` and `valueEncoding`. Must return a promise. If an error occurs, reject the promise. Otherwise resolve the promise with an array of values. If a key does not exist, set the relevant value to `undefined`.

abstract-level.js

@@ -351,6 +351,73 @@ class AbstractLevel extends EventEmitter {
     return undefined
   }
 
+  getSync (key, options) {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
+    this._assertValidKey(key)
+
+    // Fast-path for default options (known encoding, no cloning, no snapshot)
+    if (options == null) {
+      const encodedKey = this.#keyEncoding.encode(key)
+      const mappedKey = this.prefixKey(encodedKey, this.#keyEncoding.format, true)
+      const value = this._getSync(mappedKey, this.#defaultOptions.entryFormat)
+
+      try {
+        return value !== undefined ? this.#valueEncoding.decode(value) : undefined
+      } catch (err) {
+        throw new ModuleError('Could not decode value', {
+          code: 'LEVEL_DECODE_ERROR',
+          cause: err
+        })
+      }
+    }
+
+    const snapshot = options.snapshot
+    const keyEncoding = this.keyEncoding(options.keyEncoding)
+    const valueEncoding = this.valueEncoding(options.valueEncoding)
+    const keyFormat = keyEncoding.format
+    const valueFormat = valueEncoding.format
+
+    // Forward encoding options. Avoid cloning if possible.
+    if (options.keyEncoding !== keyFormat || options.valueEncoding !== valueFormat) {
+      options = { ...options, keyEncoding: keyFormat, valueEncoding: valueFormat }
+    }
+
+    const encodedKey = keyEncoding.encode(key)
+    const mappedKey = this.prefixKey(encodedKey, keyFormat, true)
+
+    let value
+
+    // Keep snapshot open during operation
+    snapshot?.ref()
+
+    try {
+      value = this._getSync(mappedKey, options)
+    } finally {
+      // Release snapshot
+      snapshot?.unref()
+    }
+
+    try {
+      return value !== undefined ? valueEncoding.decode(value) : undefined
+    } catch (err) {
+      throw new ModuleError('Could not decode value', {
+        code: 'LEVEL_DECODE_ERROR',
+        cause: err
+      })
+    }
+  }
+
+  async _getSync (key, options) {
+    throw new ModuleError('Database does not support getSync()', {
+      code: 'LEVEL_NOT_SUPPORTED'
+    })
+  }
+
   async getMany (keys, options) {
     options = getOptions(options, this.#defaultOptions.entry)
 

types/abstract-level.d.ts

@@ -78,11 +78,13 @@ declare class AbstractLevel<TFormat, KDefault = string, VDefault = string>
    * Get a value from the database by {@link key}.
    */
   get (key: KDefault): Promise<VDefault | undefined>
+  get<K = KDefault, V = VDefault> (key: K, options: AbstractGetOptions<K, V>): Promise<V | undefined>
 
-  get<K = KDefault, V = VDefault> (
-    key: K,
-    options: AbstractGetOptions<K, V>
-  ): Promise<V | undefined>
+  /**
+   * Synchronously get a value from the database by {@link key}.
+   */
+  getSync (key: KDefault): VDefault | undefined
+  getSync<K = KDefault, V = VDefault> (key: K, options: AbstractGetOptions<K, V>): V | undefined
 
   /**
    * Get multiple values from the database by an array of {@link keys}.