apemanstore/lib/apemanstore.js

/**
 * @class Apemanstore
 * @param {Object} state - Preloaded state variables
 * @param {Object} [options={}] - Optional settings
 */
'use strict'

const {
  create: createStore,
  devTool
} = require('bredux')
const reducer = require('./reducer')
const {
  SET,
  UPDATE,
  DEL,
  PUSH,
  PUSH_ALL,
  POP,
  SHIFT,
  POP_ALL,
  REJECT,
  FLIP,
  INCREMENT,
  DECREMENT
} = require('./operations')

const { get, set } = require('json-pointer')

class ApemanstoreBase {
  constructor (state, options = {}) {
    const s = this
    let {
      scopeName = '/',
      store = createStore(reducer, state, [
        devTool && devTool()
      ])
    } = options
    s._store = store
    s._scopeName = scopeName
  }

  /**
   * Dispatch operation
   * @private
   * @param {string} operation - Type of operation
   * @param {string} field - Name of field
   * @param {*} value - Operation value
   * @param {boolean} [isError=false]
   */
  $do (operation, field, value, isError = false) {
    const s = this
    s._store.dispatch({
      type: [ s._scopeName, operation ].join(':'),
      meta: { field: field },
      payload: value,
      error: isError
    })
  }

  /**
   * Get store value
   * @param {string} field - Name of field
   * @returns {*} - Stored value
   */
  get (field) {
    const s = this
    return [
      field
    ].reduce((state = {}, key) => state[ key ], s.toJSON())
  }

  /**
   * Create sub store with scope
   * @param {string} namespace - Name of scope
   * @returns {Apemanstore}
   */
  sub (namespace) {
    const s = this
    let invalid = /[\/@]/.test(namespace)
    if (invalid) {
      throw new Error(`[apemanstore] Invalid scope name: ${namespace}`)
    }
    let scopeName = [ s._scopeName, `${namespace}` ].join('/').replace(/^\/\//, '/')
    let sub = new Apemanstore(null, {
      scopeName,
      store: s._store
    })
    sub.super = () => s
    return sub
  }

  /**
   * Convert in to state variables
   * @returns {Object}
   */
  toJSON () {
    const s = this
    let state = s._store.getState()
    let scopeName = s._scopeName
    return Object.keys(state)
      .sort()
      .filter((key) => key.indexOf(scopeName) === 0)
      .reduce((collapsed, key) => {
        let subKeys = key.substring(scopeName.length)
          .split(/\//g)
          .filter(Boolean)
          .map((subKey) => `@${subKey}`)
        let assigning = collapsed
        for (let subKey of subKeys) {
          assigning[ subKey ] = assigning[ subKey ] || {}
          assigning = assigning[ subKey ]
        }
        Object.assign(assigning, state[ key ])
        return collapsed
      }, {})
  }
}

/** @lends Apemanstore */
class Apemanstore extends ApemanstoreBase {
  // ---------------
  // Operation methods
  // ---------------

  /**
   * Set a value on field
   * @param {string} field
   * @param {*} value
   */
  set (field, value) {
    const s = this
    let byObject = (arguments.length === 1) && (typeof arguments[ 0 ] === 'object')
    if (byObject) {
      Object.keys(arguments[ 0 ]).forEach((field) => {
        s.set(field, arguments[ 0 ][ field ])
      })
    } else {
      s.$do(SET, field, value)
    }
  }

  /**
   * Do update operation
   * @param {string} field - Operation target field
   * @param {*} value - Operation value
   */
  update (field, value) {
    const s = this
    s.$do(UPDATE, field, value)
  }

  /**
   * Do del operation
   * @param {string} field - Operation target field
   * @param {*} value - Operation value
   */
  del (field, value) {
    const s = this
    s.$do(DEL, field, value)
  }

  /**
   * Do push operation
   * @param {string} field - Operation target field
   * @param {*} value - Operation value
   */
  push (field, value) {
    const s = this
    s.$do(PUSH, field, value)
  }

  /**
   * Do push_all operation
   * @param {string} field - Operation target field
   * @param {*} value - Operation value
   */
  pushAll (field, value) {
    const s = this
    s.$do(PUSH_ALL, field, value)
  }

  /**
   * Do pop operation
   * @param {string} field - Operation target field
   * @param {*} value - Operation value
   */
  pop (field, value) {
    const s = this
    s.$do(POP, field, value)
  }

  /**
   * Do shift operation
   * @param {string} field - Operation target field
   * @param {*} value - Operation value
   */
  shift (field, value) {
    const s = this
    s.$do(SHIFT, field, value)
  }

  /**
   * Do pop_all operation
   * @param {string} field - Operation target field
   * @param {*} value - Operation value
   */
  popAll (field, value) {
    const s = this
    s.$do(POP_ALL, field, value)
  }

  /**
   * Do reject operation
   * @param {string} field - Operation target field
   * @param {*} value - Operation value
   */
  reject (field, value) {
    const s = this
    s.$do(REJECT, field, value)
  }

  /**
   * Do flip operation
   * @param {string} field - Operation target field
   * @param {boolean} [value] - Operation value
   */
  flip (field, value) {
    const s = this
    s.$do(FLIP, field, value)
  }

  /**
   * Do increment operation
   * @param {string} field - Operation target field
   * @param {number} value - Operation value
   */
  increment (field, value) {
    const s = this
    s.$do(INCREMENT, field, value)
  }

  /**
   * Do decrement operation
   * @param {string} field - Operation target field
   * @param {number} value - Operation value
   */
  decrement (field, value) {
    const s = this
    s.$do(DECREMENT, field, value)
  }
}

module.exports = Apemanstore