index.js

/**
 * Module dependencies
 */

var util = require('lodash');
var _ = require('lodash');

/**
 * Public access
 */

module.exports = function (entity) {
  return new Validator(entity);
};

/**
 * Constructor of individual instance of Offshore Validator
 * Specify the function, object, or list to be validatored
 */

function Validator(entity) {
  if (util.isFunction(entity)) {
    this.fn = entity;
    throw new Error ('Offshore Validator does not support functions yet!');
  } else {
    this.data = entity;
  }
  return this;
}

/**
 * Built-in data type rules
 */

Validator.prototype.rules = require('./lib/match/rules');

/**
 * Enforce that the data matches the specified ruleset
 */

Validator.prototype.to = function (ruleset, context) {

  var errors = [];

  // If ruleset doesn't contain any explicit rule keys,
  // assume that this is a type

  // 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(Validator.match.type.call(context, this.data, ruleset.type));
    }

    // Validate a dbType rule
    else if (rule === 'dbType') {

      // only if a validation rule exists for it so it doesn't break on an adapter that
      // doesn't support the particular dbType
      if (Validator.prototype.rules[ruleset.dbType]) {
        errors = errors.concat(Validator.match.type.call(context, this.data, ruleset.dbType));
      }
    }

    // Validate a non-type rule
    else {

      // Normalize the value if it looks like a boolean
      if (ruleset[rule] === 'true') {
        ruleset[rule] = true;
      }

      if (ruleset[rule] === 'false') {
        ruleset[rule] = false;
      }

      // If the value is false, then we shouldn't even run the validation
      if (ruleset[rule] === false) {
        break;
      }

      // If the rule value is a boolean we don't need to pass the value along.
      // Otherwise we can pass it along so it's options are available in
      // the validation.
      var ruleVal = _.isBoolean(ruleset[rule]) ? undefined : ruleset[rule];
      errors = errors.concat(Validator.match.rule.call(context, this.data, rule, ruleVal));
    }
  }

  // If errors exist, return the list of them
  if (errors.length) {
    return errors;
  }

  // No errors, so return false
  else {
    return false;
  }
};

Validator.prototype.hasErrors = Validator.prototype.to;

/**
 * Coerce the data to the specified ruleset if possible
 * otherwise throw an error
 * Priority: this should probably provide the default
 * implementation in Offshore core.  Currently it's completely
 * up to the adapter to define type coercion.
 *
 * Which is fine!.. but complicates custom CRUD adapter development.
 * Much handier would be an evented architecture, that allows
 * for adapter developers to write:
 *
{
// Called before find() receives criteria
// Here, criteria refers to just attributes (the `where`)
// limit, skip, and sort are not included
coerceCriteria: function (criteria) {
return criteria;
},

// Called before create() or update() receive values
coerceValues: function () {}

}
 *
 * Adapter developers would be able to use Validator.prototype.cast()
 * to declaritively define these type coercions.

 * Down the line, we could take this further for an even nicer API,
 * but for now, this alone would be a nice improvement.
 *
 */

Validator.prototype.cast = function (ruleset) {
  todo(ruleset);
};

/**
 * Coerce the data to the specified ruleset no matter what
 */

Validator.prototype.hurl = function (ruleset) {

  // Iterate trough given data attributes
  // to check if they exist in the ruleset
  for (var attr in this.data) {
    if (this.data.hasOwnProperty(attr)) {

      // If it doesnt...
      if (!ruleset[attr]) {

        // Declaring err here as error helpers live in match.js
        var err = new Error('Validation error: Attribute \"' + attr + '\" is not in the ruleset.');

        // just throw it
        throw err;
      }
    }
  }

  // Once we make sure that attributes match
  // we can just proceed to deepMatch
  Validator.match(this.data, ruleset, this);
};

/**
 * Specify default values to automatically populated when undefined
 */

Validator.prototype.defaults = function (ruleset) {
  todo(ruleset);
};

/**
 * Declare a custom data type
 * If function definition is specified, `name` is required.
 * Otherwise, if dictionary-type `definition` is specified,
 * `name` must not be present.
 *
 * @param {String} name				[optional]
 * @param {Object|Function}	definition
 */

Validator.prototype.define = function (name, definition) {

  // check to see if we have an dictionary
  if ( util.isObject(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');
      }
    }

    // add the new custom data types
    util.extend(Validator.prototype.rules, name);

    return this;
  }

  if ( util.isFunction(definition) && util.isString(name) ) {
    // Add a single data type
    Validator.prototype.rules[name] = definition;
    return this;
  }

  throw new Error('Definition error: \"' + name + '\" is not a valid definition.');
};

/**
 * Specify custom ruleset
 */

Validator.prototype.as = function (ruleset) {
  todo(ruleset);
};

/**
 * Specify named arguments and their rulesets as an object
 */

Validator.prototype.args = function (args) {
  todo(args);
};

/**
 * Specify each of the permitted usages for this function
 */

Validator.prototype.usage = function () {
  var usages = util.toArray(arguments);
  todo(usages);
};

/**
 * Deep-match a complex collection or model against a schema
 */

Validator.match = require('./lib/match');

/**
 * Expose `define` so it can be used globally
 */

module.exports.define = Validator.prototype.define;

function todo() {
  throw new Error('Not implemented yet!');
}