class-o-mat/lib/class-o-mat/field-o-mat.js

ALPHA VERSION ONLY: class-o-mats will help to create getter-setter functionality with validations that can be attached to a container class for easier coding. Some basic validations are included. class-o-mats also has the ability to store params as bloc

'use strict';

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

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _dec, _class, _class2, _temp;

var _bunyan = require('bunyan');

var _bunyan2 = _interopRequireDefault(_bunyan);

var _mixinDecorator = require('mixin-decorator');

var _mixinDecorator2 = _interopRequireDefault(_mixinDecorator);

var _lodash = require('lodash.clonedeep');

var _lodash2 = _interopRequireDefault(_lodash);

var _types = require('../constants/types');

var _accessorMethods2 = require('./_accessor-methods');

var _accessorMethods3 = _interopRequireDefault(_accessorMethods2);

var _eventMethodsOMat = require('./_event-methods-o-mat');

var _eventMethodsOMat2 = _interopRequireDefault(_eventMethodsOMat);

var _apiMethodsOMat = require('./_api-methods-o-mat');

var _apiMethodsOMat2 = _interopRequireDefault(_apiMethodsOMat);

var _fieldFunctions = require('../methods/field-functions');

var _classOMatFieldFunctions = require('./class-o-mat-field-functions');

var _fieldValidatorOMat = require('./field-validator-o-mat');

var _fieldValidatorOMat2 = _interopRequireDefault(_fieldValidatorOMat);

var _fieldReducerOMat = require('./field-reducer-o-mat');

var _fieldReducerOMat2 = _interopRequireDefault(_fieldReducerOMat);

var _fieldActionOMat = require('./field-action-o-mat');

var _fieldActionOMat2 = _interopRequireDefault(_fieldActionOMat);

var _stack = require('../prototype/stack');

var _stack2 = _interopRequireDefault(_stack);

var _queue = require('../prototype/queue');

var _queue2 = _interopRequireDefault(_queue);

var _buildField = require('../methods/build-field');

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var log = _bunyan2.default.createLogger({ name: "FieldOMat" });

var lb = function lb(db) {
  if (db === false) return;
};

/**
 * Class Field creates a specification for a single function to be 
 * added to the class to be constructed.
 * This will decide what function name will get or set the field,
 * what type of getter or setter and any reducers, actions or validations.
 */
var FieldOMat = (_dec = (0, _mixinDecorator2.default)(_accessorMethods3.default, _eventMethodsOMat2.default, _apiMethodsOMat2.default), _dec(_class = (_temp = _class2 = function () {
  function FieldOMat() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _types.NONE;

    _classCallCheck(this, FieldOMat);

    this.TYPE = _types.FIELD_O_MAT;
    this.cacheValidators = false;

    this._params = params === _types.NONE ? {
      abstract: false,

      actionOMats: [],
      reducerOMats: [],
      fallback: _types.NONE,

      upKey: '$',

      _default: null,
      accessorGetter: _fieldFunctions.getterSetter,

      isStack: false,
      isQueue: false,
      paramKeyPrefix: '___',
      validator: _types.NONE,
      validatorOMats: [],
      isRequired: false,

      ON_GET: _types.NONE,
      ON_SET: _types.NONE,
      ON_DELETE: _types.NONE,

      protected: false
    } : params;
  }

  _createClass(FieldOMat, [{
    key: 'init',
    value: function init(parent, key) {
      var initParams = { parent: parent, key: key, internalKey: key };
      var params = this._params;
      this._params = _extends({}, params, initParams);
      var validatorOMats = params.validatorOMats,
          actionOMats = params.actionOMats,
          reducerOMats = params.reducerOMats;

      validatorOMats.forEach(function (validatorOMat) {
        return validatorOMat.connect(fieldOMat);
      });
      return this;
    }

    /**
     * finish with this field and return to the ClassOMat
     * @return {ClassOMat} 
     */

  }, {
    key: '$',
    value: function $() {
      return this._params.parent;
    }
  }, {
    key: 'abstract',
    value: function abstract() {
      this._params.abstract = true;
      return this;
    }
  }, {
    key: 'notAbstract',
    value: function notAbstract() {
      this._params.abstract = false;
      return this;
    }
  }, {
    key: 'protected',
    value: function _protected() {
      this._params.protected = true;
      return this;
    }
  }, {
    key: 'accessorGetter',
    value: function accessorGetter() {
      for (var _len = arguments.length, p = Array(_len), _key = 0; _key < _len; _key++) {
        p[_key] = arguments[_key];
      }

      return _classOMatFieldFunctions.getterSetter.apply(undefined, [this, 'accessorGetter'].concat(p));
    }

    /**
     * CALLED FROM THE PARENT PARAMETER SET.
     * This will add the function specified by this FieldOMat 
     * to the Class that will be created.
     * @param  {Class} BaseClass
     * @return {Class} BaseClass with the new field added.
     */

  }, {
    key: 'addToClassMixins',
    value: function addToClassMixins(mixins) {
      var paramObjectKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '_params';

      var _paramKeyPrefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _types.NONE;

      var workingParams = _extends({ paramObjectKey: paramObjectKey }, this._params);

      this.default((0, _buildField.adjustDefault)(this._params));
      var thisAccessorMethod = (0, _buildField.build)(workingParams);
      var key = this._params.key;
      if (Array.isArray(thisAccessorMethod) === true) {
        mixins[key] = thisAccessorMethod[0];
        mixins['___' + key] = thisAccessorMethod[1];
        this._params.key = '___' + key;
      } else {
        mixins[key] = thisAccessorMethod;
      }
      return mixins;
    }
  }, {
    key: 'addChild',
    value: function addChild(classOMat) {
      return this.$().addChild(classOMat);
    }

    // FIELD FACTORY DEFINITION
    /**
     * get a clone of this field as a new field in the same classOMat
     * The new clone will be a sibling of the original FieldOMat in the param
     * @param  {string} key the key of the new clone
     * @return {FieldOMat}   The new clone
     */

  }, {
    key: 'again',
    value: function again(key) {
      var nextField = this.$().field(key);
      var _params = this._params,
          onSet = _params.onSet,
          _default = _params._default,
          accessorGetter = _params.accessorGetter,
          isStack = _params.isStack,
          isQueue = _params.isQueue,
          paramObjectKey = _params.paramObjectKey,
          validator = _params.validator;

      nextField.params({
        onSet: onSet,
        _default: _default,
        accessorGetter: accessorGetter,
        isStack: isStack,
        isQueue: isQueue,
        paramObjectKey: paramObjectKey,

        validator: validator
      }, true);
      return nextField;
    }
  }, {
    key: 'default',
    value: function _default() {
      for (var _len2 = arguments.length, p = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        p[_key2] = arguments[_key2];
      }

      return _classOMatFieldFunctions.getterSetter.apply(undefined, [this, '_default'].concat(p));
    }
  }, {
    key: 'deleteField',
    value: function deleteField(key) {
      return this.$().field(key);
    }
  }, {
    key: 'fallback',
    value: function fallback() {
      for (var _len3 = arguments.length, p = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
        p[_key3] = arguments[_key3];
      }

      return _classOMatFieldFunctions.getterSetter.apply(undefined, [this, 'fallback'].concat(p));
    }
  }, {
    key: 'field',
    value: function field(key) {
      return this.$().field(key);
    }
  }, {
    key: 'internalKey',
    value: function internalKey() {
      var key = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _types.NONE;

      if (key === _types.NONE) {
        return this._params.internalKey === _types.NONE ? this._params.key : this._params.internalKey;
      }

      this._params.internalKey = key;
      return this;
    }
  }, {
    key: 'required',
    value: function required() {
      this._params.isRequired = true;
      return this;
    }

    // THE GETTER AND SETTER FUNCTIONS TO BE SELECTED FROM FOR THIS FIELD
    // are in the _AccessorsOMat parent class

    /**
     * returns a FieldActionOMat to create reducers for this field.
     * @return {FieldActionOMat} 
     */

  }, {
    key: 'action',
    value: function action() {
      return new _fieldActionOMat2.default(this);
    }

    /**
     * returns a FieldReducerOMat to create reducers for this field.
     * @return {FieldReducerOMat} 
     */

  }, {
    key: 'reducer',
    value: function reducer() {
      return new _fieldReducerOMat2.default(this);
    }

    /**
     * sets the validator for this FieldOMat
     * @param  {Class} ValidatorOMat subclass of FieldValidatorOMat
     * @return {FieldOMat} this
     */

  }, {
    key: 'validate',
    value: function validate() {
      var ValidatorOMat = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _fieldValidatorOMat2.default;

      return new ValidatorOMat(this, this.key(), this.cacheValidators);
    }
  }, {
    key: '_acceptAction',
    value: function _acceptAction(actionOMat) {
      this._params.actionOMats.push(actionOMat);
    }
  }, {
    key: '_acceptReducer',
    value: function _acceptReducer(reducerOMat) {
      this._params.reducerOMats.push(reducerOMat);
    }
  }, {
    key: '_acceptValidator',
    value: function _acceptValidator(validator) {
      var validatorOMat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _types.NONE;

      this._params.validator = validator;
      this._params.validatorOMat = validatorOMat;
      return this;
    }
  }]);

  return FieldOMat;
}(), _class2.TYPE = _types.FIELD_O_MAT, _temp)) || _class);
exports.default = FieldOMat;
//# sourceMappingURL=field-o-mat.js.map