Merge pull request #26 from CodingCarlos/develop

v1.0.0

Author: CodingCarlos

README.md

@@ -7,6 +7,9 @@
 
 A data modeling tool for NodeJS. It's 100% database agnostic, and 100% customizable.
 
+# Warning! Breaking changes in v1.0!
+If you have been using this package in versions under 1.0.0, you have to update your code. [Follow the migration guide](migration.md) to use the v1.x library. 
+
 # How to install
 Use NPM to install the package:
 ```
@@ -45,7 +48,19 @@ var data = {
 	age: 17  // Age does not match with min value
 };
 
-var result = user.modelate(data); // => { name: 'Paco }
+var result = user.modelate(data); 
+/* Result:
+{ data: { 
+	name: 'Paco 
+  }, 
+  error: [{ 
+  	model: 'User', 
+  	field: 'age', 
+  	validator: 'value', 
+  	constrains: { max: 95, min: 18 }
+  }]
+}
+*/
 ```
 
 # Modifiers
@@ -55,12 +70,7 @@ Modifiers are just functions. It will be executed for each property, and return
 
 ## Default
 If there are not data for that property, it will create a given default value:
-```javascript
-{
-	default: String	// Check if data has a JS type
-}
-```
-For example:
+
 ```javascript
 {
 	default: 'Default value'
@@ -237,40 +247,18 @@ This will validate `asd` but not `sdf`
 
 # Tests
 
-I'm currently adding tests to this code. I'm using Jasmine, and saving tests in `/spec` folder.
+Are built with Jasmine, and stored in `/spec` folder.
 
-To run tests, just execute:
+First time you run tests, you might need to install Jasmine, and other dependencies. Just execute:
 ```
-npm test
+npm install
 ```
 
-First time you run tests, you might need to install Jasmine, and other possible test dependencies. To do it fastly, just execute:
+To run tests, just execute:
 ```
-npm install
+npm test
 ```
 
-And now you can run tests ^^
-
-## Test coverage:
-Master version might not have the last test updates. Check out the `develop` branch to see the last updates. Also, the actual test coverage (in `develop` branch) is fully referenced in #3 issue.
-
- - [x] Core
-	 - [x] Exported module
-	 - [x] Model
-	 - [x] Modelate
-	 - [x] Validate
- - [ ] Validators
-	 - [x] Type
-	 - [x] Length
-	 - [x] Value
-	 - [x] Custom function
-	 - [x] Date
-	 - [x] Regex
-	 - [x] Email
-	 - [ ] Model (Need help with this #15)
- - [x] Modifiers
-	 - [x] Default
-
 
 # Contribute
 You can use this code as you like. If you find a bug, or want to ask for a feature, just open an issue, and we'll do our best. If you can fix it, do a pull request to dev branch, and we promise to review it as fast as possible to merge it.

examples/validators/default.js

@@ -6,12 +6,15 @@ var Modelate = require('../../index');
 var model = {
 	name: {
 		default: 'I am the default value'
-	}
+	},
+	surname: {
+		default: 'No surname setted'
+	} 
 };
 var user = Modelate('User').set(model);
 
-var data = {};
+var data = {surname: 'Santos'};
 var result = user.modelate(data);
 
 
-console.log(result);	// Shall be { name: 'I am the default value' }
+console.log(result);	// Shall be { name: 'I am the default value', surname: 'Santos' }

index.js

@@ -2,6 +2,10 @@
 const model = require('./lib/model');
 const modelate = require('./lib/modelate');
 
+console.warn('---');
+console.warn('CAUTION!! This is an experimental release of Modelate. Everything might change from one day to other.');
+console.warn('---');
+
 /**
  *	Modelate instance.
  */

lib/modelate.js

@@ -8,30 +8,42 @@ const modify = require('./modify').check;
  *	Create a new modelate, validating all properties
  *	Options might be:
  *	 - model: {Object} A model to use (instead of this.modelName)
+ *	 - modelName: {String} A name for the model to use (instead of this.modelName)
  *	@param data {Object} The data to validate
  *	@param opts {Object} Options for the modelate.
  */
 function modelate(data, opts) {
-	if ((!this.modelName && !(opts && !opts.model)) || !data || typeof data !== 'object') {
-		return {};
+	const modelateResponse = {
+		data: {},
+		error: null
 	}
 
-	const model = (opts && opts.model) || models[this.modelName];
+	if ((!this.modelName && (!(opts && !opts.model) || !(opts && !opts.modelName))) || !data || typeof data !== 'object') {
+		return modelateResponse;
+	}
+
+	var modelName = (opts && opts.modelName) || this.modelName;
+
+	const model = (opts && opts.model) || models[modelName];
 	const result = util.clone(model) || {};
+	const errors = [];
 
 	for (const prop in model) {
 		// Step 1: Apply the modifiers
 		data[prop] = modify(data[prop], model[prop]);
 
 		// Step 2: validate the result
-		if (validate(data[prop], model[prop])) {
+		if (validate(data[prop], model[prop], errors, modelName, prop)) {
 			result[prop] = data[prop];
 		} else {
 			delete result[prop];
 		}
 	}
 
-	return result;
+	modelateResponse.data = result;
+	modelateResponse.error = (errors.length !== 0) ? errors : null;
+
+	return modelateResponse;
 }
 
 module.exports = modelate;

lib/modifiers/default.js

@@ -8,14 +8,14 @@
 
 function modify(data, model) {
 	if (!model.default) {
-		return null;
+		return data;
 	}
 
-	if (!data) {
+	if (!data && data !== false && data !== 0) {
 		return model.default;
 	}
 
-	return null;
+	return data;
 }
 
 

lib/modify.js

@@ -19,8 +19,9 @@ const modifiers = fs.readdirSync(directory).map(function(file) {
 function modify(data, model) {
 	let newValue = data;
 	for (let i = 0; i < modifiers.length; i++) {
-		newValue = modifiers[i].check(data, model);
+		newValue = modifiers[i].check(newValue, model);
 	}
+
 
 	return newValue;
 }

lib/validate.js

@@ -16,10 +16,27 @@ const validators = fs.readdirSync(directory).map(function(file) {
  *	@param data {Object} Data to validate
  *	@param model {Object} Model to apply validations
  */
-function validate(data, model) {
+function validate(data, model, errors, modelName, fieldName) {
+	if (!errors) {
+		errors = [];
+	} else if (!Array.isArray(errors)) {
+		throw new TypeError('Validation errors is not an array.');
+		return false;
+	}
+
 	for (let i = 0; i < validators.length; i++) {
-		if (!validators[i].check(data, model)) {
-			console.error('Validation for "' + data + '" failed! Reason: ', validators[i].name);
+		if (!validators[i].check(data, model, errors)) {
+			
+			const error = {
+				model: modelName,
+				field: fieldName,
+				validator: validators[i].name,
+				value: data,
+				constrains: model[validators[i].name]
+			}
+
+			errors.push(error);
+
 			return false;
 		}
 	}

lib/validators/model.js

@@ -8,24 +8,32 @@ var models = require('../model').models;
  *		model: String	// Check if data has a model type
  *	}
  */
-function isValid(data, model) {
+function isValid(data, model, errors) {
 	if (!model.model) {
 		return true;
 	}
-
 	if(!models[model.model]) {
 		return false;
 	}
 
-	var validate = module.parent.parent.exports;
-	var valid = validate(data, { model: models[model.model] });
-
-	// Return if data is of model's type.
-	// var eq = util.equal(data, valid);
-	// return eq;
+	// Load parent modelate
+	var modelate = module.parent.parent.exports;
+	// Launch modelate of data with requested model
+	var valid = modelate(data, { 
+		model: models[model.model], 
+		modelName: model.model 
+	}, []);
+
+	// Populate errors to parent model
+	if (valid.error) {
+		for (var i = 0; i < valid.error.length; i++) {
+			errors.push(valid.error[i]);
+		}
+	}
 
 	// Turn data into a valid model...
-	reference(data, valid);
+	reference(data, valid.data);
+
 	// And return true (data is parsed, so data is modelated)
 	return true;
 }

lib/validators/required.js

@@ -0,0 +1,22 @@
+/**
+ *	Required validator
+ *
+ *	{
+ *		required: Boolean
+ *	}
+ */
+
+function isValid(data, model) {
+	if (!model.required) {
+		return true;
+	}
+
+	if(model.required && typeof data !== 'undefined') {
+		return true;
+	}
+	
+	return false;
+}
+
+
+module.exports = isValid;

lib/validators/type.js

@@ -7,7 +7,7 @@
  */
 
 function isValid(data, model) {
-	if (!model.type) {
+	if (!model.type || typeof data === 'undefined') {
 		return true;
 	}