Merge pull request #35 from scup/hooks

After Hooks

Author: albertossilva

.travis.yml

@@ -5,14 +5,14 @@ cache:
   npm: true
   directories:
   - node_modules/
-script: npm run coverage
+script: npm run validate
 after_script:
 - git config credential.helper "store --file=.git/credentials"
 - echo "https://${GH_TOKEN}:@github.com" > .git/credentials
 - git config --global user.email "[email protected]"
 - git config --global user.name "Travis CI"
 - rm -rf lib
-- npm run build
+- npm run prepublish
 - bin/commit_lib_files.sh
 env:
   global:

README.md

@@ -200,3 +200,34 @@ To understand the validators [React PropTypes](https://facebook.github.io/react/
     console.log(entity.errors.requiredProp1); // undefined
     console.log(contextValidated.requiredProp1); // { errors: [Error: Error -1] }
   ```
+
+  ### Hooks
+  ```javascript
+  class EntityWithHook extends Speck {
+      static SCHEMA = {
+          fieldWithHook: {
+            validator: joiAdapter(Joi.number()),
+            hooks: {
+              afterSet(data, fieldName) {
+                // data is the whole data of the instance
+                // fieldName the current fieldName
+                // DO WHATEVER YOU WANT
+              }
+            }
+          },
+          anotherFieldWithHook: {
+            validator: joiAdapter(Joi.number()),
+            hooks: {
+              afterSet(data, fieldName) {
+                return { anotherField: data[fieldName] * 2 } // if the afterSet hook returns an object is merged to data
+              }
+            }
+          },
+          anotherField: joiAdapter(Joi.number()),
+      }
+  }
+
+  const myEntity = new EntityWithHook({ fieldWithHook: 'foo', anotherFieldWithHook: 'bar', anotherField: null });
+
+  myEntity.anotherFieldWithHook = 10 //according to the after set hook anotherField newValue will be 20
+```

lib/Speck.js

@@ -1,8 +1,10 @@
 'use strict';
 
+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 _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 _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
@@ -12,26 +14,41 @@ var _require = require('lodash'),
     clone = _require.clone,
     get = _require.get,
     isNil = _require.isNil,
-    isFunction = _require.isFunction;
+    isFunction = _require.isFunction,
+    noop = _require.noop;
+
+function applyAfterSetHook(field, data, afterSetHook) {
+  var newData = afterSetHook(data, field);
+  (typeof newData === 'undefined' ? 'undefined' : _typeof(newData)) === 'object' && _extends(data, newData);
+}
+
+function createGetterAndSetter(instance, field) {
+  var schemaField = instance.schema[field];
+
+  var afterSet = get(schemaField, 'hooks.afterSet');
+  var afterSetHook = typeof afterSet === 'function' ? applyAfterSetHook : noop;
 
-var createGetterAndSetter = function createGetterAndSetter(instance, field) {
   return {
-    set: function set(value) {
-      if (instance.data[field] !== value) {
-        instance.data[field] = value;
+    set: function set(newValue) {
+      if (instance.data[field] !== newValue) {
+        instance.data[field] = newValue;
+
+        afterSetHook(field, instance.data, afterSet);
+
         return instance._validate();
       }
     },
     get: function get() {
       return instance.data[field];
     },
+
     enumerable: true
   };
-};
+}
 
 var Speck = function () {
-  function Speck(data) {
-    var _this = this;
+  function Speck() {
+    var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
     _classCallCheck(this, Speck);
 
@@ -46,22 +63,24 @@ var Speck = function () {
     });
 
     Object.defineProperty(this, 'childrenEntities', {
-      value: Object.keys(this.constructor.SCHEMA).filter(function (field) {
-        return !!_this.constructor.SCHEMA[field].type;
-      }),
+      value: Object.keys(this.constructor.SCHEMA).filter(this.__fieldHasType.bind(this)),
       enumerable: false
     });
 
-    this.errors = {};
     Object.defineProperty(this, 'data', {
-      value: this._mergeDefault(data || {}),
+      value: this._mergeDefault(data),
       enumerable: false
     });
 
     this._validate();
   }
 
   _createClass(Speck, [{
+    key: '__fieldHasType',
+    value: function __fieldHasType(field) {
+      return !!this.constructor.SCHEMA[field].type;
+    }
+  }, {
     key: '__initFieldValue',
     value: function __initFieldValue(field, data) {
       var hasValue = !isNil(data[field]);
@@ -107,20 +126,19 @@ var Speck = function () {
     value: function __validateField(field) {
       var validator = typeof this.schema[field] === 'function' ? this.schema[field] : this.schema[field].validator;
 
-      var error = validator(this.data, field, this.constructor.name + 'Entity');
-
-      if (error) {
-        this.errors[field] = { errors: [error.message || error] };
-      }
+      return validator(this.data, field, this.constructor.name + 'Entity');
     }
   }, {
     key: '_validate',
     value: function _validate() {
       this.errors = {};
 
-      var field = void 0;
-      for (field in this.schema) {
-        this.__validateField(field);
+      for (var field in this.schema) {
+        var error = this.__validateField(field);
+
+        if (error) {
+          this.errors[field] = { errors: [error.message || error] };
+        }
       }
       this.valid = Object.keys(this.errors).length === 0;
 
@@ -169,10 +187,10 @@ var Speck = function () {
   }, {
     key: 'toJSON',
     value: function toJSON() {
-      var _this2 = this;
+      var _this = this;
 
       var rawData = Object.keys(this.data).reduce(function (data, field) {
-        return _extends(data, _defineProperty({}, field, _this2._fetchChild(_this2.data[field])));
+        return _extends(data, _defineProperty({}, field, _this._fetchChild(_this.data[field])));
       }, {});
 
       return JSON.parse(JSON.stringify(rawData));
@@ -187,7 +205,7 @@ var Speck = function () {
   }, {
     key: 'validateContext',
     value: function validateContext(context) {
-      var _this3 = this;
+      var _this2 = this;
 
       if (!get(this.contexts, context)) return this.errors;
 
@@ -196,15 +214,15 @@ var Speck = function () {
       };
       if (this.contexts[context].exclude && Object.keys(this.contexts[context].exclude).length > 0) {
         validation = function validation(error) {
-          return _this3.contexts[context].exclude.find(function (exclude) {
+          return _this2.contexts[context].exclude.find(function (exclude) {
             return exclude === error;
           }) === undefined;
         };
       }
 
       if (this.contexts[context].include && Object.keys(this.contexts[context].include).length > 0) {
         validation = function validation(error) {
-          return _this3.contexts[context].include.find(function (include) {
+          return _this2.contexts[context].include.find(function (include) {
             return include === error;
           }) !== undefined;
         };
@@ -213,8 +231,8 @@ var Speck = function () {
       var contextErrors = _extends({}, this.errors);
       if (this.contexts[context].fields) {
         Object.keys(this.contexts[context].fields).forEach(function (field) {
-          var result = _this3.contexts[context].fields[field](_this3, field, _this3.constructor.name);
-          if (result) contextErrors[field] = { errors: result };else delete contextErrors[field];
+          var result = _this2.contexts[context].fields[field](_this2, field, _this2.constructor.name);
+          result && (contextErrors[field] = { errors: result });
         });
       }
 

lib/SpeckHooks.js

@@ -0,0 +1 @@
+"use strict";

package.json

@@ -1,6 +1,6 @@
 {
   "name": "speck-entity",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "Domain entities with reactive validation",
   "main": "lib/index.js",
   "scripts": {
@@ -9,8 +9,8 @@
     "coverage": "nyc npm test",
     "lint": "standard -v \"src/**/*.js\" \"spec/**/*.js\"",
     "lint:fix": "standard -v --fix \"src/**/*.js\" \"spec/**/*.js\"",
-    "build": "babel src --out-dir lib",
-    "prepublish": "npm run build"
+    "prepublish": "babel src --out-dir lib",
+    "validate": "npm run lint && npm run coverage"
   },
   "nyc": {
     "branches": 95,

spec/SpeckHooks.spec.js

@@ -0,0 +1,59 @@
+const Speck = require('Speck')
+const { noop } = require('lodash')
+const { expect } = require('chai')
+const { mock, assert } = require('sinon')
+
+describe('SpeckHooks', function () {
+  beforeEach(function () {
+    class MyEntitiesWithHooks extends Speck {}
+    const afterSetMock = mock('afterSetHook')
+
+    MyEntitiesWithHooks.SCHEMA = {
+      anyField: noop,
+      fieldWithHook: {
+        validator: noop,
+        hooks: {
+          afterSet: afterSetMock
+        }
+      }
+    }
+
+    this.MyEntitiesWithHooks = MyEntitiesWithHooks
+    this.afterSetMock = afterSetMock
+  })
+
+  it('calls the hook afterSet after set happens', function () {
+    const data = { fieldWithHook: 'bla', anyField: 'foo' }
+    const instance = new this.MyEntitiesWithHooks(data)
+    instance.fieldWithHook = 'newValue'
+
+    assert.calledWithExactly(this.afterSetMock, { fieldWithHook: 'newValue', anyField: 'foo' }, 'fieldWithHook')
+  })
+
+  it('assigns result of afterSet to data', function () {
+    const data = { fieldWithHook: 'bla', anyField: 'foo' }
+    const instance = new this.MyEntitiesWithHooks(data)
+
+    const newData = { fieldWithHook: 'valueChanged', anyField: 'valueChanged' }
+    this.afterSetMock
+      .withExactArgs({ fieldWithHook: 'newValueToAssign', anyField: 'foo' }, 'fieldWithHook')
+      .returns(newData)
+
+    instance.fieldWithHook = 'newValueToAssign'
+
+    expect(instance.data).to.deep.equal(newData)
+  })
+
+  it('does not assign result of afterSet to data when it not object', function () {
+    const data = { fieldWithHook: 'bla', anyField: 'foo' }
+    const instance = new this.MyEntitiesWithHooks(data)
+
+    this.afterSetMock
+      .withExactArgs({ fieldWithHook: 'newValueToAssign', anyField: 'foo' }, 'fieldWithHook')
+      .returns('not object')
+
+    instance.fieldWithHook = 'newValueToAssign'
+
+    expect(instance.data).to.deep.equal({ fieldWithHook: 'newValueToAssign', anyField: 'foo' })
+  })
+})