Nested Schema Validation

index.js

@@ -54,28 +54,35 @@ Anchor.prototype.rules = require('./lib/match/rules');
  */
 
 Anchor.prototype.to = function (ruleset, context) {
+ "use strict";
 
- var errors = [];
+ var errors = [], self = this;
 
  // If ruleset doesn't contain any explicit rule keys,
  // assume that this is a type
 
+ if (util.isPlainObject(ruleset) || util.isArray(ruleset)) {
+
+ if (util.has(ruleset, 'type') && util.keys(ruleset).length == 1) {
+ // backward compatible for anchor(data).to({ type: typeDef })
+ errors = errors.concat(Anchor.match.type.call(context, self.data, ruleset['type']));
+ } else if (util.difference(util.keys(ruleset), util.keys(this.rules)).length === 0) {
+ // backward compatible for anchor(data).to({ ruleName: ruleArgs })
+ // Look for explicit rules
+ util.forOwn(ruleset, function (args, ruleName) {
+ // Validate a non-type rule
+ errors = errors.concat(Anchor.match.rule.call(context, self.data, ruleName, args));
+ });
+ } else {
+ // Use deep match to descend into the collection and verify each item and/or key
+ // Stop at default maxDepth (50) to prevent infinite loops in self-associations
+ errors = errors.concat(Anchor.match.schema.call(context, self.data, ruleset));
+ }
+ } else {
+ errors = errors.concat(Anchor.match.rule.call(context, self.data, ruleset.toString(), ruleset));
+ }
 
- // Look for explicit rules
- for (var rule in ruleset) {
 
- if (rule === 'type') {
-
- // Use deep match to descend into the collection and verify each item and/or key
- // Stop at default maxDepth (50) to prevent infinite loops in self-associations
- errors = errors.concat(Anchor.match.type.call(context, this.data, ruleset['type']));
- }
-
- // Validate a non-type rule
- else {
- errors = errors.concat(Anchor.match.rule.call(context, this.data, rule, ruleset[rule]));
- }
- }
 
  // If errors exist, return the list of them
  if (errors.length) {
@@ -186,19 +193,21 @@ Anchor.prototype.defaults = function (ruleset) {
  */
 
 Anchor.prototype.define = function (name, definition) {
+ "use strict";
 
  // check to see if we have an dictionary
- if ( util.isObject(name) ) {
+ if ( util.isPlainObject(name) && definition === undefined ) {
+ definition = name;
 
  // if so all the attributes should be validation functions
- for (var attr in name){
- if(!util.isFunction(name[attr])){
- throw new Error('Definition error: \"' + attr + '\" does not have a definition');
- }
- }
+ util.forOwn(definition, function (value, attr) {
+ if(!util.isFunction(value)) {
+ throw new Error('Definition error: \"' + attr + '\" does not have a definition');
+ }
+ });
 
  // add the new custom data types
- util.extend(Anchor.prototype.rules, name);
+ util.extend(Anchor.prototype.rules, definition);
 
  return this;
 

lib/match/deepMatchType.js

@@ -0,0 +1,156 @@
+/**
+ * Module dependencies
+ */
+
+var util = require('util');
+var _ = require('lodash');
+var rules = require('./rules');
+var errorFactory = require('./errorFactory');
+var matchType = require('./matchType');
+
+// var JSValidationError
+
+// Exposes `matchType` as `deepMatchType`.
+module.exports = deepMatchType;
+
+
+var RESERVED_KEYS = {
+ $validate: '$validate',
+ $message: '$message'
+};
+
+// Max depth value
+var MAX_DEPTH = 50;
+
+
+
+/**
+ * Match a complex collection or model against a schema
+ *
+ * @param {?} data
+ * @param {?} ruleset
+ * @param {Number} depth
+ * @param {String} keyName
+ * @param {String} customMessage
+ * (optional)
+ *
+ * @returns {[]} a list of errors (or an empty list if no errors were found)
+ */
+
+function deepMatchType(data, ruleset, depth, keyName, customMessage) {
+
+ var self = this;
+
+ // Prevent infinite recursion
+ depth = depth || 0;
+ if (depth > MAX_DEPTH) {
+ return [
+ new Error({ message: 'Exceeded MAX_DEPTH when validating object. Maybe it\'s recursively referencing itself?'})
+ ];
+ }
+
+ // (1) Base case - primitive
+ // ----------------------------------------------------
+ // If ruleset is not an object or array, use the provided function to validate
+ if (!_.isObject(ruleset)) {
+ return matchType.call(self, data, ruleset, keyName, customMessage);
+ }
+
+
+ // (2) Recursive case - Array
+ // ----------------------------------------------------
+ // If this is a schema rule, check each item in the data collection
+ else if (_.isArray(ruleset)) {
+ if (ruleset.length !== 0) {
+ if (ruleset.length > 1) {
+ return [
+ new Error({ message: '[] (or schema) rules must contain exactly one item.'})
+ ];
+ }
+
+ // Handle plurals (arrays with a schema rule)
+ // Match each object in data array against ruleset until error is detected
+ return _.reduce(data, function getErrors(errors, datum) {
+ errors = errors.concat(deepMatchType.call(self, datum, ruleset[0], depth + 1, keyName, customMessage));
+ return errors;
+ }, []);
+ }
+ // Leaf rules land here and execute the iterator fn
+ else return matchType.call(self, data, ruleset, keyName, customMessage);
+ }
+
+ // (3) Recursive case - POJO
+ // ----------------------------------------------------
+ // If the current rule is an object, check each key
+ else {
+
+ // Note:
+ // 
+ // We take advantage of a couple of preconditions at this point:
+ // (a) ruleset must be an Object
+ // (b) ruleset must NOT be an Array
+
+
+ // *** Check for special reserved keys ***
+
+ // { $message: '...' } specified as data type
+ // uses supplied message instead of the default
+ var _customMessage = ruleset[RESERVED_KEYS.$message];
+
+ // { $validate: {...} } specified as data type
+ // runs a sub-validation (recursive)
+ var subValidation = ruleset[RESERVED_KEYS.$validate];
+
+ // Don't allow a `$message` without a `$validate`
+ if (_customMessage) {
+ if (!subValidation) {
+ return [{
+ code: 'E_USAGE',
+ status: 500,
+ $message: _customMessage,
+ property: keyName,
+ message: 'Custom messages ($message) require a subvalidation - please specify a `$validate` option on `'+keyName+'`'
+ }];
+ }
+ else {
+ // Use the specified message as the `customMessage`
+ customMessage = _customMessage;
+ }
+ }
+
+ // Execute subvalidation rules
+ if (subValidation) {
+ if (!subValidation.type) {
+ return [
+ new Error({message: 'Sub-validation rules (i.e. using $validate) other than `type` are not currently supported'})
+ ];
+ }
+
+ return deepMatchType.call(self, data, subValidation.type, depth+1, keyName, customMessage);
+ }
+
+
+
+
+
+ // Don't treat empty object as a ruleset
+ // Instead, treat it as 'object'
+ if (_.keys(ruleset).length === 0) {
+ return matchType.call(self, data, ruleset, keyName, customMessage);
+ } else {
+ // Iterate through rules in dictionary until error is detected
+ return _.reduce(ruleset, function(errors, subRule, key) {
+
+ // Prevent throwing when encountering unexpectedly "shallow" data
+ // (instead- this should be pushed as an error where "undefined" is
+ // not of the expected type: "object")
+ if (!_.isObject(data)) {
+ return errors.concat(errorFactory(data, 'object', key, customMessage));
+ } else {
+ return errors.concat(deepMatchType.call(self, data[key], ruleset[key], depth + 1, key, customMessage));
+ }
+ }, []);
+ }
+ }
+}
+

lib/match/errorFactory.js

@@ -34,9 +34,10 @@ module.exports = function errorFactory(value, ruleName, keyName, customMessage)
  // errMsg += keyName ? '(' + keyName + ') ' : '';
  // errMsg += 'is not of type "' + ruleName + '"';
 
+ var expectedType = _.isString(ruleName) ? ruleName : Object.prototype.toString.call(ruleName);
  errMsg = util.format(
  '`%s` should be a %s (instead of "%s", which is a %s)',
- keyName, ruleName, value, typeof value
+ keyName, expectedType, value, typeof value
  );
  }
 
@@ -48,6 +49,6 @@ module.exports = function errorFactory(value, ruleName, keyName, customMessage)
  message: errMsg,
  rule: ruleName,
  actualType: typeof value,
- expectedType: ruleName
+ expectedType: expectedType
  }];
 };

lib/match/index.js

@@ -1,4 +1,5 @@
 module.exports = {
- type: require('./matchType'),
+ schema: require('./matchSchema'),
+ type: require('./deepMatchType'),
  rule: require('./matchRule')
 };

lib/match/matchRule.js

@@ -13,7 +13,7 @@ var rules = require('./rules');
  * or a list of errors if things go wrong
  */
 
-module.exports = function matchRule (data, ruleName, args) {
+module.exports = function matchRule (data, ruleName, args, keyName) {
  var self = this,
  errors = [];
 
@@ -45,9 +45,10 @@ module.exports = function matchRule (data, ruleName, args) {
  // If outcome is false, an error occurred
  if (!outcome) {
  return [{
+ property: keyName,
  rule: ruleName,
  data: data,
- message: util.format('"%s" validation rule failed for input: %s', ruleName, util.inspect(data))
+ message: util.format('"%s" validation rule failed for value of `%s`: %s', ruleName, keyName, util.inspect(data))
  }];
  }
  else {

lib/match/matchRuleset.js

@@ -0,0 +1,55 @@
+/**
+ * Module dependencies
+ */
+
+var _ = require('lodash')
+ , util = require('util')
+ , matchType = require('./matchType')
+ , matchRule = require('./matchRule')
+ ;
+
+
+/**
+ * Match a value against a ruleset.
+ *
+ * @param {*} data
+ * @param {{}} ruleset
+ * @param {string} keyName
+ *
+ * @returns {[]} a list of errors, or an empty list in the absence of them
+ */
+module.exports = function matchRuleset (data, ruleset, keyName) {
+ "use strict";
+
+ var errors = [], self = this;
+
+ if (!_.isPlainObject(ruleset)) {
+ return [{
+ property: keyName,
+ message: util.format('Ruleset definition for property `%s` should be a plain object.', keyName)
+ }];
+ }
+
+ if (!_.has(ruleset, 'type')) {
+ ruleset['type'] = {};
+ }
+
+ // if no explicit `required` rule, then treat as optional TODO: What about `null` and empty string same?
+ if (data === undefined && !ruleset.required) {
+ return errors;
+ }
+
+ _.forOwn(ruleset, function (value, key) {
+ "use strict";
+
+ if (key === 'type') {
+ // Validate a type rule
+ errors = errors.concat(matchType.call(self, data, value, keyName));
+ } else {
+ // Validate a non-type rule
+ errors = errors.concat(matchRule.call(self, data, key, value, keyName));
+ }
+ });
+
+ return errors;
+};