persistent.js

const levelup = require('levelup')
const leveldown = require('leveldown')
const config = require('../config')('persistent')
const path = require('path')
const lodash = require('lodash')
const { promisify } = require('util')
const { decode, encode } = require('./de')

const openDatabase = (file, options) =>
  promisify(levelup)(leveldown(file, options))

const createPersistent = async (base) => {
  const file = path.format({
    dir: path.normalize(config.path),
    base
  })
  const db = await openDatabase(file)

  const getDecoded = (key) =>
    db.get(key, {asBuffer: false}).then((data) => decode(data))

  const setEncoded = (key, value) =>
    db.put(key, encode(value))

  const get = async (path, options) => {
    let localPath = lodash.toPath(path)
    const key = localPath.shift()

    try {
      const hash = await getDecoded(key, options)
      if (localPath.length === 0) {
        return hash
      }

      return lodash.get(hash, localPath)
    } catch (err) {
      if (err.type === 'NotFoundError') {
        return undefined
      } else {
        throw err
      }
    }
  }

  const set = async (path, value, options) => {
    let localPath = lodash.toPath(path)
    const key = localPath.shift()

    if (localPath.length === 0) {
      await setEncoded(key, value, options)
    } else {
      try {
        let currValue = await getDecoded(key, options)
        lodash.set(currValue, localPath, value)
        await setEncoded(key, currValue)
      } catch (err) {
        if (err.type === 'NotFoundError') {
          await setEncoded(key, lodash.set({}, localPath, value), options)
        } else {
          throw err
        }
      }
    }
  }

  return {
    get,
    set
  }
}

module.exports = createPersistent