ciphermask/app/scripts/lib/remote-store.js

const Dnode = require('dnode')
const inherits = require('util').inherits

module.exports = {
  HostStore: HostStore,
  RemoteStore: RemoteStore,
}

function BaseStore (initState) {
  this._state = initState || {}
  this._subs = []
}

BaseStore.prototype.set = function (key, value) {
  throw Error('Not implemented.')
}

BaseStore.prototype.get = function (key) {
  return this._state[key]
}

BaseStore.prototype.subscribe = function (fn) {
  this._subs.push(fn)
  var unsubscribe = this.unsubscribe.bind(this, fn)
  return unsubscribe
}

BaseStore.prototype.unsubscribe = function (fn) {
  var index = this._subs.indexOf(fn)
  if (index !== -1) this._subs.splice(index, 1)
}

BaseStore.prototype._emitUpdates = function (state) {
  this._subs.forEach(function (handler) {
    handler(state)
  })
}

//
// host
//

inherits(HostStore, BaseStore)
function HostStore (initState, opts) {
  BaseStore.call(this, initState)
}

HostStore.prototype.set = function (key, value) {
  this._state[key] = value
  process.nextTick(this._emitUpdates.bind(this, this._state))
}

HostStore.prototype.createStream = function () {
  var dnode = Dnode({
    // update: this._didUpdate.bind(this),
  })
  dnode.on('remote', this._didConnect.bind(this))
  return dnode
}

HostStore.prototype._didConnect = function (remote) {
  this.subscribe(function (state) {
    remote.update(state)
  })
  remote.update(this._state)
}

//
// remote
//

inherits(RemoteStore, BaseStore)
function RemoteStore (initState, opts) {
  BaseStore.call(this, initState)
  this._remote = null
}

RemoteStore.prototype.set = function (key, value) {
  this._remote.set(key, value)
}

RemoteStore.prototype.createStream = function () {
  var dnode = Dnode({
    update: this._didUpdate.bind(this),
  })
  dnode.once('remote', this._didConnect.bind(this))
  return dnode
}

RemoteStore.prototype._didConnect = function (remote) {
  this._remote = remote
}

RemoteStore.prototype._didUpdate = function (state) {
  this._state = state
  this._emitUpdates(state)
}