flash-store.ts

import * as path  from 'path'

import {
  path as appRoot,
}                   from 'app-root-path'

import rimraf     from 'rimraf'
import { SnapDB } from 'snap-db'

import {
  log,
  VERSION,
}             from './config'

import {
  AsyncMap,
}             from './async-map'

export interface IteratorOptions<K> {
  gt?      : K
  gte?     : K
  lt?      : K
  lte?     : K
  reverse? : boolean

  keys?   : boolean
  values? : boolean
  limit?  : number

  prefix?  : K
}

export class FlashStore<K = string, V = any> implements AsyncMap<K, V> {

  private snapDb: SnapDB<K>

  /**
   * FlashStore is a Key-Value database tool and makes using leveldb more easy for Node.js
   *
   * Creates an instance of FlashStore.
   * @param {string} [workdir=path.join(appRoot, 'flash-store.workdir')]
   * @example
   * import { FlashStore } from 'flash-store'
   * const flashStore = new FlashStore('flashstore.workdir')
   */
  constructor (
    public workdir = path.join(appRoot, '.flash-store'),
  ) {
    log.verbose('FlashStore', 'constructor(%s)', workdir)

    // we use seperate workdir for snapdb, leveldb, and rocksdb etc.
    const snapdbWorkdir = path.join(workdir, 'snapdb')

    this.snapDb = new SnapDB({
      dir: snapdbWorkdir,   // database folder
      key: 'string',        // key type, can be "int", "string" or "float"
    })
  }

  public version (): string {
    return VERSION
  }

  /**
   * Set data in database
   *
   * @param {K} key
   * @param {V} value
   * @returns {Promise<void>}
   * @example
   * await flashStore.set(1, 1)
   */
  public async set (key: K, value: V): Promise<void> {
    log.verbose('FlashStore', 'set(%s, %s) value type: %s', key, value, typeof value)

    // FIXME(huan): string for SnapDB only
    if (typeof key !== 'string') {
      throw new Error('only support string as key')
    }
    await this.snapDb.put(key, JSON.stringify(value))
  }

  /**
   * Get value from database by key
   *
   * @param {K} key
   * @returns {(Promise<V | null>)}
   * @example
   * console.log(await flashStore.get(1))
   */
  public async get (key: K): Promise<V | undefined> {
    log.verbose('FlashStore', 'get(%s)', key)
    try {
      // FIXME(huan): string for SnapDB only
      if (typeof key !== 'string') {
        throw new Error('only support string as key')
      }
      const val = await this.snapDb.get(key)
      return val && JSON.parse(val)
    } catch (e) {
      if (/^NotFoundError/.test(e)) {
        // The leveldb will throw NotFoundError for non-exist keys
        return undefined
      }
      throw e
    }
  }

  /**
   * Del data by key
   *
   * @param {K} key
   * @returns {Promise<void>}
   * @example
   * await flashStore.delete(1)
   */
  public async delete (key: K): Promise<void> {
    log.verbose('FlashStore', 'delete(%s)', key)
    // FIXME(huan): string for SnapDB only
    if (typeof key !== 'string') {
      throw new Error('only support string as key')
    }
    await this.snapDb.delete(key)
  }

  /**
   * @typedef IteratorOptions
   *
   * @property { K }        gt        - Matches values that are greater than a specified value
   * @property { K }        gte       - Matches values that are greater than or equal to a specified value.
   * @property { K }        lt        - Matches values that are less than a specified value.
   * @property { K }        lte       - Matches values that are less than or equal to a specified value.
   * @property { boolean }  reverse   - Reverse the result set
   * @property { number }   limit     - Limits the number in the result set.
   * @property { K }        prefix    - Make the same prefix key get together.
   */

  /**
   * Find keys by IteratorOptions
   *
   * @param {IteratorOptions} [options={}]
   * @returns {AsyncIterableIterator<K>}
   * @example
   * const flashStore = new FlashStore('flashstore.workdir')
   * for await(const key of flashStore.keys({gte: 1})) {
   *   console.log(key)
   * }
   */
  public async * keys (options: IteratorOptions<K> = {}): AsyncIterableIterator<K> {
    log.verbose('FlashStore', 'keys()')

    const keysOptions = {
      ...options,
      values: false,  // do not include values
    }
    for await (const [key] of this.entries(keysOptions)) {
      yield key
    }
  }

  /**
   * Find all values
   *
   * @returns {AsyncIterableIterator<V>}
   * @example
   * const flashStore = new FlashStore('flashstore.workdir')
   * for await(const value of flashStore.values()) {
   *   console.log(value)
   * }
   */
  public async * values (options: IteratorOptions<K> = {}): AsyncIterableIterator<V> {
    log.verbose('FlashStore', 'values()')

    const valuesOptions = {
      ...options,
      keys: false,  // do not include the keys
    }

    for await (const [, value] of this.entries(valuesOptions)) {
      yield value
    }

  }

  /**
   * Get the size of the database
   * @returns {Promise<number>}
   * @example
   * const size = await flashStore.size
   * console.log(`database size: ${size}`)
   */
  public get size (): Promise<number> {
    log.verbose('FlashStore', 'size()')
    return this.snapDb.getCount()
  }

  /**
   * FIXME(huan): use better way to do this
   */
  public async has (key: K): Promise<boolean> {
    const val = await this.get(key)
    return !!val
  }

  /**
   *
   */
  public async clear (): Promise<void> {
    log.verbose('FlashStore', 'clear()')
    await this.snapDb.empty()
  }

  /**
   * @private
   */
  public async * entries (options?: IteratorOptions<K>): AsyncIterableIterator<[K, V]> {
    log.verbose('FlashStore', '*entries(%s)', JSON.stringify(options))

    const iterator = await this.snapDb.queryIt(options || {})

    for await (const [key, val] of iterator) {
      const valObj = val === undefined ? undefined : JSON.parse(val)
      // FIXME(huan): key has to be string for SnapDB
      yield [key as any, valObj]
    }
  }

  public async * [Symbol.asyncIterator] (): AsyncIterableIterator<[K, V]> {
    log.verbose('FlashStore', '*[Symbol.asyncIterator]()')
    yield * this.entries()
  }

  public async close (): Promise<void> {
    log.verbose('FlashStore', 'close()')
    await this.snapDb.close()
  }

  /**
   * Destroy the database
   *
   * @returns {Promise<void>}
   */
  public async destroy (): Promise<void> {
    log.verbose('FlashStore', 'destroy()')
    await this.snapDb.close()
    await new Promise(resolve => rimraf(this.workdir, resolve))
  }

}

export default FlashStore