Merge pull request #1 from CodingCarlos/develop

First version ^^

Author: CodingCarlos

README.md

@@ -1,2 +1,100 @@
 # modelate
-A data modeling tool for NodeJS
+A data modeling tool for NodeJS. It's 100% database agnostic, and 100% customizable.
+
+# How does it work?
+Create a model, and turn your objects into that model. 
+
+```javascript
+var Modelate = require('./index');
+
+var model = {
+	name: {
+		type: 'string',
+		length: {	
+			max: 10,
+			min: 1
+		},
+		value: {
+			eq: 'Paco'
+		}
+	},
+	age: {
+		type: 'number',
+		value: {
+			max: 95,
+			min: 18
+		}
+	}
+}
+
+var user = Modelate('User').model(model);
+var data = {
+	name: 'Paco',
+	age: 17  // Age does not match with min value
+};
+
+var result = user.modelate(data); // => { name: 'Paco }
+```
+# Validators
+Validators are just functions. It will be executed for each property, and return a boolean value indicating if the content match the model requirements or not. 
+
+ - [Type](#type)
+ - [Length](#length)
+ - [Value](#value)
+ - [Custom function](#custom-function)
+ 
+ ## Type
+ If the data has not the specifed type, validation will fail, and that field will not be added to final validated data.
+ 
+ ```javascript
+ {
+     type: String	// Check if data has a JS type (uses typeof)
+ }
+ ```
+  
+ ## Length
+ Check data length. It uses default .length param, so it's valid for so much types.
+ 
+ ```javascript
+{
+	length: {
+    eq: Number,		// Exact allowed value
+		max: Number,	// Maximum allowed value
+		min: Number		// Minimum allowed value
+	}
+}
+ ```
+ 
+ ## Value
+  Check data length. It uses default .length param, so it's valid for so much types.
+ 
+ ```javascript
+{
+	value: {
+ 		eq: String || Number,		// Exact allowed value (equals)
+ 		max: Number,				// Maximum allowed value
+ 		min: Number,				// Minimum allowed value
+ 		contains: String || Number	// The value contains 
+ 	}
+}
+ ```
+
+## Custom function
+Use a custom function to check at your own criteria. The only necessary thing is the function to return true or false-
+ 
+```javascript
+{
+	func: function	A function to validate. Must return true or false.
+}
+```
+
+The function might look like this: 
+```
+function is42(value) {
+  var allowed = [42, '42', 'cuarenta y dos', 'fourty two', 'the answer to the life the universe and everything'];
+  if(allowedValues.indexOf(value) === -1) {
+    return false;
+  }
+  return true;
+}
+```

index.js

@@ -0,0 +1,28 @@
+/**/
+const model = require('./lib/model');
+const modelate = require('./lib/modelate');
+
+const models = model.models;
+
+
+function Modelate(name) {
+	const self = this;
+
+	self.modelName = name;
+	self.model = model.add;
+	self.modelate = modelate;
+
+	models[name] = {};
+
+	return this;
+}
+
+
+module.exports = Modelate;
+/*{
+	add: function () { },
+	remove: null,
+	list: null,
+	modelate: null
+};*/
+

lib/model.js

@@ -0,0 +1,14 @@
+const models = {};
+
+function model(data) {
+	// ToDo: Validate model
+	// ToDo: Check if model already exists to merge instead of set
+	models[this.name] = data;
+
+	return this;
+}
+
+module.exports = {
+	models: models,
+	add: model
+};

lib/modelate.js

@@ -0,0 +1,20 @@
+const util = require('./util');
+
+const models = require('./model').models;
+const validate = require('./validate');
+
+function modelate(data) {
+	const model = util.clone(models[this.name]);
+
+	for(let prop in model) {
+		if(validate(data[prop], model[prop])) {
+			model[prop] = data[prop];
+		} else {
+			delete model[prop];
+		}
+	}
+
+	return model;
+}
+
+module.exports = modelate;

lib/util.js

@@ -0,0 +1,51 @@
+/** Deep Copy
+ *	Return a copy of the object passed as param, doing (recursivelly) copys of
+ *	all the objects the initial has.
+ *	
+ *  Caution!!! 
+ *  This function is recursive. Copying a very deep object might concern heavy
+ *  performance issues. Use your brain before the function.
+ */
+function deepCopy(oldObj) {
+    var newObj = oldObj;
+    if (oldObj && typeof oldObj === 'object') {
+        newObj = Object.prototype.toString.call(oldObj) === '[object Array]' ? [] : {};
+        for (var i in oldObj) {
+            newObj[i] = deepCopy(oldObj[i]);
+        }
+    }
+    return newObj;
+}
+
+/** Merge
+ *  Perform a complete merge of two objects.
+ *
+ *	Caution!!! 
+ *  A third parameter, avoidDeepCopy is also included to avoid creating a deep
+ *  copy of the objects. With this parameter to true, original objects may get
+ *  updated, linked or similar unexpected behaviour.
+ */
+function merge(old, obj, avoidDeepCopy) {
+    
+    let dest, orig;
+
+    if(avoidDeepCopy) {
+        dest = old;
+        orig = obj;
+    } else {
+        dest = deepCopy(old);
+        orig = deepCopy(obj);
+    }
+    
+    for(let prop in orig) {
+        dest[prop] = orig[prop];
+    }
+
+    return dest;
+}
+
+
+module.exports = {
+	merge: merge,
+	clone: deepCopy
+};

lib/validate.js

@@ -0,0 +1,31 @@
+
+// Add validator names here
+const validators = ['type', 'length', 'value', 'func'];
+
+// Turn validator names to validator instances.
+for(let i = 0; i < validators.length; i++) {
+	validators[i] = validator(validators[i]);
+} 
+
+// Validate
+function validate(data, model) {	
+	for(let i = 0; i < validators.length; i++) {
+		if(!validators[i].check(data, model)) {
+			console.error('Validation for "' + data + '" failed! Reason: ', validators[i].name);
+			return false;
+		}
+	} 
+	
+	return true;
+}
+
+// Create new validator instances
+function validator(name) {
+	return {
+		name: name,
+		check: require('./validators/' + name)
+	};
+}
+
+
+module.exports = validate;

lib/validators/func.js

@@ -0,0 +1,17 @@
+/**	
+ *	Custom function validator
+ *
+ *	{
+ *		func: function	A function to validate. Must return true or false.
+ *	}
+ */
+
+function isValid(data, model) {
+	if(!model.func) {
+		return true;
+	}
+	
+	return model.func(data);
+}
+
+module.exports = isValid;

lib/validators/length.js

@@ -0,0 +1,36 @@
+/**	
+ *	Length validator
+ *
+ *	{
+ *		length: {
+ *			eq: Number,		// Exact allowed value
+ *			max: Number,	// Maximum allowed value
+ *			min: Number		// Minimum allowed value
+ *		}
+ *	}
+ */
+
+function isValid(data, model) {
+	if(!model.length) {
+		return true;
+	}
+
+	// Data hasn't the exact eq lenght 
+	if(model.length.eq && data.length !== model.length.eq) {
+		return false;
+	}
+
+	// Data is higher than max 
+	if(model.length.max && data.length > model.length.max) {
+		return false;
+	}
+
+	// Data is lower than min
+	if(model.length.min && data.length < model.length.min) {
+		return false;
+	}
+
+	return true;
+}
+
+module.exports = isValid;

lib/validators/type.js

@@ -0,0 +1,21 @@
+/**	
+ *	Type validator
+ *
+ *	{
+ *		type: String	// Check if data has a JS type (uses typeof)
+ *	}
+ */
+
+function isValid(data, model) {
+	if(!model.type) {
+		return false;
+	}
+
+	if((typeof(data)).toUpperCase() === model.type.toUpperCase()) {
+		return true;
+	} 
+
+	return false;
+}
+
+module.exports = isValid;

lib/validators/value.js

@@ -0,0 +1,64 @@
+/**	
+ *	Value validator
+ *
+ *	{
+ *		value: {
+ *			eq: String || Number,		// Exact allowed value (equals)
+ *			max: Number,				// Maximum allowed value
+ *			min: Number,				// Minimum allowed value
+ *			contains: String || Number	// The value contains 
+ *		}
+ *	}
+ */
+
+function isValid(data, model) {
+	if(!model.value) {
+		return true;
+	}
+
+	// Data is different than equals
+	if(model.value.eq) {
+		if(typeof(data) === typeof(model.value.eq) && data !== model.value.eq) {
+			// Same data type and different values
+			return false;
+		} else { 
+			// Different types: Try to convert one to other.
+			var parsed = data;
+			var type = typeof(model.value.eq);
+			switch(type.toLowerCase()) {
+				case 'string':
+					parsed = String(data);
+					break;
+				case 'number':
+					parsed = Number(data);
+					break;
+				case 'boolean':
+					parsed = Boolean(data);
+					break;
+			}
+
+			if(data !== model.value.eq) {
+				return false;
+			}
+		}
+	}
+
+	// Data is higher than max 
+	if(model.value.max && Number(data) > Number(model.value.max)) {
+		return false;
+	}
+
+	// Data is lower than min
+	if(model.value.min && Number(data) < Number(model.value.min)) {
+		return false;
+	}
+
+	// Data does not contain something
+	if(model.value.contains && data.indexOf(model.value.contains) === -1) {
+		return false;
+	}
+
+	return true;
+}
+
+module.exports = isValid;