Validate other models

Author: CodingCarlos

examples/chat.js

@@ -52,13 +52,15 @@ var myUserData = {
 	name: 'Paco',
 	surname: 'santos',
 	age: 19,
-	dni: '51402430A'
+	dni: '51402430A',
+	unexpected: 'property'
 };
-// var myUser = User.modelate(myUserData);
+var myUser = User.modelate(myUserData);
 // console.log(myUser);	
 
 var messageModel = {
 	user: {
+		type: 'object',
 		model: 'User'
 	},
 	// date: {
@@ -76,10 +78,10 @@ var Message = Modelate('Message').set(messageModel);
 
 // Modelate a message
 var myMessageData = {
-	message: 'I am using models inside models. Crazy.',
+	message: 'Using models inside models. Crazy.',
 	// date: new Date(),
-	// user: myUser
-	user: myUserData
+	user: myUser
+	// user: myUserData
 };
 var myMessage = Message.modelate(myMessageData);
 console.log(myMessage);	

index.js

@@ -2,9 +2,9 @@
 const model = require('./lib/model');
 const modelate = require('./lib/modelate');
 
-// const models = model.models;
-
-
+/**
+ *	Modelate instance.
+ */
 function Modelate(name) {
 	const self = this;
 
@@ -13,8 +13,6 @@ function Modelate(name) {
 	self.set = model.add;
 	self.modelate = modelate;
 
-	// models[name] = {};
-
 	return this;
 }
 

lib/model.js

@@ -3,11 +3,11 @@ const models = {};
 function model(data) {
 	// ToDo: Validate model
 	// ToDo: Check if model already exists to merge instead of set
-	for(let prop in data) {
-		if(data[prop].model) {
-			data[prop] = models[data[prop].model];
-		}
-	}
+	// for(let prop in data) {
+	// 	if(data[prop].model) {
+	// 		data[prop] = models[data[prop].model];
+	// 	}
+	// }
 
 	models[this.modelName] = data;
 

lib/modelate.js

@@ -1,21 +1,32 @@
 const util = require('./util');
 
 const models = require('./model').models;
-const validate = require('./validate');
+const validate = require('./validate').check;
 
-// var modelate = function modelate(data) {
-function modelate(data) {
-	const model = util.clone(models[this.modelName]);
+/**
+ *	Create a new modelate, validating all properties
+ *	Options might be:
+ *	 - model: {Object} A 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) {
+		return {};
+	}
+
+	const model = opts && opts.model || models[this.modelName];
+	const result = util.clone(model);
 
-	for(let prop in model) {
-		if(validate(data[prop], model[prop])) {
-			model[prop] = data[prop];
+	for (let prop in model) {
+		if (validate(data[prop], model[prop])) {
+			result[prop] = data[prop];
 		} else {
-			delete model[prop];
+			delete result[prop];
 		}
 	}
 
-	return model;
+	return result;
 }
 
 module.exports = modelate;

lib/util.js

@@ -1,20 +1,22 @@
 /** 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.
+ *  
+ *	@param oldObj {Object} Object to clone
  */
 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;
+		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
@@ -24,28 +26,110 @@ function deepCopy(oldObj) {
  *  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.
+ *
+ *  @param old {Object} Object to use as base
+ *  @param obj {Object} Object to get data from
+ *  @param avoidDeepCopy {booleam} Seting to true will update the "old" object
  */
 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;
+		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;
 }
 
+/** Equal
+ *  Check if two objects are equal.
+ *
+ *  Seen in:
+ *  https://github.com/epoberezkin/fast-deep-equal/
+ *
+ *  @param a {Object} First object
+ *  @param b {Object} Seccond object
+ */
+function equal(a, b) {
+	if (a === b) {
+		return true;
+	}
+
+	var arrA = Array.isArray(a);
+	var arrB = Array.isArray(b);
+	var i;
+
+	if (arrA && arrB) {
+		if (a.length !== b.length) {
+				return false;
+		}
+
+		for (i = 0; i < a.length; i++) {
+			if (!equal(a[i], b[i])) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	if (arrA !== arrB) {
+		return false;
+	}
+
+	if (a && b && typeof a === 'object' && typeof b === 'object') {
+		var keys = Object.keys(a);
+		if (keys.length !== Object.keys(b).length) {
+			return false;
+		}
+
+		var dateA = a instanceof Date;
+		var dateB = b instanceof Date;
+		if (dateA && dateB) {
+			return a.getTime() === b.getTime();
+		}
+
+		if (dateA !== dateB) {
+			return false;
+		}
+
+		var regexpA = a instanceof RegExp;
+		var regexpB = b instanceof RegExp;
+		if (regexpA && regexpB) { 
+			return a.toString() === b.toString();
+		}
+		if (regexpA !== regexpB) {
+			return false;
+		}
+
+		for (i = 0; i < keys.length; i++) {
+			if (!Object.prototype.hasOwnProperty.call(b, keys[i])) {
+				return false;
+			}
+		}
+
+		for (i = 0; i < keys.length; i++) {
+			if(!equal(a[keys[i]], b[keys[i]])) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	return false;
+}
 
 module.exports = {
 	merge: merge,
+	equal: equal,
 	clone: deepCopy
 };

lib/validate.js

@@ -1,14 +1,15 @@
 
 // Add validator names here
-const validators = ['type', 'length', 'value', 'func'];
+const validators = ['type', 'length', 'value', 'func', 'model'];
+// 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) {	
+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);
@@ -28,4 +29,4 @@ function validator(name) {
 }
 
 
-module.exports = validate;
+module.exports = {check: validate};

lib/validators/model.js

@@ -0,0 +1,47 @@
+var util = require('../util');
+var models = require('../model').models;
+// var validate = require('../validate');
+
+/**	
+ *	Type validator
+ *
+ *	{
+ *		type: String	// Check if data has a JS type (uses typeof)
+ *	}
+ */
+function isValid(data, model) {
+	if(!model.model) {
+		return true;
+	}
+
+	var validate = module.parent.parent.exports;
+	var valid = validate(data, {model: models[model.model]});
+
+	// var eq = util.equal(data, valid);
+	// return eq;
+	
+	// Turn data into a valid model...
+	reference(data, valid);
+	return true;
+}
+
+/**
+ *	Replace an object for other keeping the reference
+ *
+ *	@origin {Object} Object to replace
+ *	@newObj {Object} Object to use as new
+ */
+function reference(origin, newObj) {
+	// Clean object
+	for (let p in origin) {
+		delete origin[p];
+	}
+
+	// Insert new data
+	for (let p in newObj) {
+		origin[p] = newObj[p];
+	}
+
+}
+
+module.exports = isValid;