gun-flint/dist/Adapter/node-adapter.js

Micro-framework for building Gun adapters

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _get2 = require('babel-runtime/helpers/get');

var _get3 = _interopRequireDefault(_get2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _util = require('./../util');

var _util2 = _interopRequireDefault(_util);

var _baseAdapter = require('./base-adapter');

var _baseAdapter2 = _interopRequireDefault(_baseAdapter);

var _adapterContext = require('./adapter-context');

var _adapterContext2 = _interopRequireDefault(_adapterContext);

var _union = require('./union');

var _union2 = _interopRequireDefault(_union);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Read/write hooks for the node adapter
 *
 * @private
 * @param {object} adapter - A plain object with adapter methods
 * @class
 */
var Adapter = function (_BaseAdapter) {
  (0, _inherits3.default)(Adapter, _BaseAdapter);

  function Adapter() {
    (0, _classCallCheck3.default)(this, Adapter);
    return (0, _possibleConstructorReturn3.default)(this, (Adapter.__proto__ || (0, _getPrototypeOf2.default)(Adapter)).apply(this, arguments));
  }

  (0, _createClass3.default)(Adapter, [{
    key: 'bootstrap',


    /**
     * @override
     * @instance
     * @public
     * 
     * @param {Gun} Gun   The Gun constructor 
     */
    value: function bootstrap(Gun) {
      (0, _get3.default)(Adapter.prototype.__proto__ || (0, _getPrototypeOf2.default)(Adapter.prototype), 'bootstrap', this).call(this, Gun);

      this._union = _union2.default.bind(this, this.Gun);
    }

    /**
     * @override
     * @instance
     * @public
     * 
     * @param {string}   key      the node key 
     * @param {string}   [field]  the field requested, if applicable
     * @param {callback} done     Call after read completed
     */

  }, {
    key: 'get',
    value: function get(key, field, done) {
      var _this2 = this;

      this._get(key, function (err, result) {
        if (result && field) {
          result = _this2.Gun.state.to(result, field);
        }
        done(err, result);
      });
    }

    /**
     *  @param {Object|String}   result    - A Gun node; or stringified Gun node
     *  @param {Function}        callback - Call once read finished
     *  @return {void}
     */

  }, {
    key: 'read',
    value: function read(result, done) {
      result = this.Gun.text.is(result) ? JSON.parse(result) : result;
      done(null, result);
    }

    /**
     *  @param {Object}   delta    - A delta for the current node
     *  @param {Function} callback - Called once write finished
     *  @return {void}
     */

  }, {
    key: 'write',
    value: function write(delta, done) {
      var _this3 = this;

      var keys = (0, _keys2.default)(delta);

      /**
      * @param  {Error} [err] - An error given by get request
      * @returns {undefined}
      */
      function writeHandler(err, key, node, existing) {

        // Merge the delta with existing node
        var errorOk = !err || err.code() === 400;
        if (errorOk && node && existing) {
          node = this._union(node, existing);
        }

        // Write merged node to storage
        if (node && this.Gun.obj.is(node)) {
          this._put(key, node, done);
        }
      }

      // Each node in the delta...
      keys.forEach(function (key) {

        // First retrieve existing node in order to union
        _this3._get(key, function (err, existing) {
          var nodeDelta = delta[key];
          writeHandler.call(_this3, err, key, nodeDelta, existing);
        });
      }, this);
    }
  }]);
  return Adapter;
}(_baseAdapter2.default);

exports.default = Adapter;