Class: ObjectNode

Methods

addAdditionalPropertiesValidator(node){ObjectNode}

lib/object.js, line 129

Add a validation node to validate any additional properties that fall outside the explicitly defined field validations

Name	Type	Description
node	boolean | object	validation node to be used on any additional properties that fall outside the explicitly defined field validations

Examples

// Create an Object where any additional properties must be a string property

assert = require('assert'),
  StringNode = require('vitesse').StringNode,
  Compiler = require('vitesse').Compiler,
  ObjectNode = require('vitesse').ObjectNode,
var string = new StringNode(null, null, {typeCheck:true});
var schema = new ObjectNode(null, null, {typeCheck:true})
  .addAdditionalPropertiesValidator(string);

var compiler = new Compiler({});
// Compile the AST
var func = compiler.compile(schema);

// Validate {}
var results = func.validate([]);
assert.equal(1, results.length);
assert.equal('field is not an object', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate {ca:1}
var results = func.validate({ca:1});
assert.equal(1, results.length);
assert.equal('field is not a string', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === string);

// Validate {ca:'test'}
var results = func.validate({ca:'test'});
assert.equal(0, results.length);

// Create an Object where any additional properties are not allowed

assert = require('assert'),
  StringNode = require('vitesse').StringNode,
  Compiler = require('vitesse').Compiler,
  ObjectNode = require('vitesse').ObjectNode,
var schema = new ObjectNode(null, null, {typeCheck:true})
  .addAdditionalPropertiesValidator(false);

var compiler = new Compiler({});
// Compile the AST
var func = compiler.compile(schema);

// Validate {}
var results = func.validate([]);
assert.equal(1, results.length);
assert.equal('field is not an object', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate {ca:1}
var results = func.validate({ca:1});
assert.equal(1, results.length);
assert.equal('illegal fields on object', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate {}
var results = func.validate({});
assert.equal(0, results.length);

addChild(field, node){ObjectNode}

lib/object.js, line 86

Add field validation

Name	Type	Description
field	string	object field name to be validated
node	object	validation node to be used for this field validation

Example

// Create an Object specifying a field to be of a specific type

assert = require('assert'),
  StringNode = require('vitesse').StringNode,
  Compiler = require('vitesse').Compiler,
  ObjectNode = require('vitesse').ObjectNode,
var string = new StringNode(null, null, {typeCheck:true});
var schema = new ObjectNode(null, null, {typeCheck:true})
  .addChild('brand', string);

var compiler = new Compiler({});
// Compile the AST
var func = compiler.compile(schema);

// Validate {}
var results = func.validate([]);
assert.equal(1, results.length);
assert.equal('field is not an object', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate {ca:1}
var results = func.validate({brand:100});
assert.equal(1, results.length);
assert.equal('field is not a string', results[0].message);
assert.deepEqual(['object', 'brand'], results[0].path);
assert.ok(results[0].rule === string);

// Validate {ca:'test'}
var results = func.validate({brand:'test'});
assert.equal(0, results.length);

addCustomValidator(node){ObjectNode}

lib/object.js, line 103

Add a custom object validator

Name	Type	Description
node	CustomNode	custom validation node to be used for this field validation

Example

// Create an Object custom validation that validates the number of properties on an object.

assert = require('assert'),
  Compiler = require('vitesse').Compiler,
  ObjectNode = require('vitesse').ObjectNode,
  CustomNode = require('../lib/custom');
var customValidator = new CustomNode()
  .setContext({ max: 4 })
  .setValidator(function(object, context) {
    if(Object.keys(object).length > context.max) {
      return new Error('object contains more properties ' + context.max);
    }
  });

var schema = new ObjectNode(null, null, {typeCheck:true})
  .addCustomValidator(customValidator);
var compiler = new Compiler({});
// Compile the AST
var func = compiler.compile(schema, {});

// Validate {}
var results = func.validate([]);
assert.equal(1, results.length);
assert.equal('field is not an object', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate {a:1, b:2, c:3, d:4, e:5}
var results = func.validate({a:1, b:2, c:3, d:4, e:5});
assert.equal(1, results.length);
assert.equal('object contains more properties 4', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === customValidator);

// Validate {a:1, b:2}
var results = func.validate({a:1, b:2});
assert.equal(0, results.length);

addDependency(field, dependencyType, object){ObjectNode}

lib/object.js, line 117

Add a dependency between fields (field b must exist if field a does/field a must be an integer and exist if b is an integer and exists)

Name	Type	Description
field	string	that is dependent on condition
dependencyType	string	(['array', 'schema']) the type of node we are dependent on
object	array | object	the array or schema object for the dependency

addPatternPropertiesValidator(patterns){ObjectNode}

lib/object.js, line 141

Specifies an object of pattern validations {: ..Node}

Name	Type	Description
patterns	object	each pattern matches fields on the object that have to satisfy the validation node for that pattern.

Example

// Create an Object where certain pattern match fields must validate against specific schema

assert = require('assert'),
  StringNode = require('vitesse').StringNode,
  Compiler = require('vitesse').Compiler,
  ObjectNode = require('vitesse').ObjectNode,
var string = new StringNode(null, null, {typeCheck:true});
var schema = new ObjectNode(null, null, {typeCheck:true})
  .addPatternPropertiesValidator({
    "^ca$": string
  });

var compiler = new Compiler({});
// Compile the AST
var func = compiler.compile(schema);

// Validate {}
var results = func.validate([]);
assert.equal(1, results.length);
assert.equal('field is not an object', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate {ca:1}
var results = func.validate({ca:1});
assert.equal(1, results.length);
assert.equal('field is not a string', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === string);

// Validate {ca:'test'}
var results = func.validate({ca:'test'});
assert.equal(0, results.length);

addValidation(validation){ObjectNode}

lib/object.js, line 48

Add a validation language node

Name	Type	Description
validation	object	validation operation valid ones are $gt,$gte,$lt,$lte

Example

// Create an Object validation that validates the number of properties on an object.

assert = require('assert'),
  Compiler = require('vitesse').Compiler,
  ObjectNode = require('vitesse').ObjectNode,
  CustomNode = require('../lib/custom');
var schema = new ObjectNode(null, null, {typeCheck:true})
  .addValidation({$gte: 2, $lte: 5});
var compiler = new Compiler({});
// Compile the AST
var func = compiler.compile(schema, {});

// Validate {}
var results = func.validate([]);
assert.equal(1, results.length);
assert.equal('field is not an object', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate {a:1}
var results = func.validate({a:1});
assert.equal(1, results.length);
assert.equal('number fails validation {"$gte":2,"$lte":5}', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate {a:1, b:2}
var results = func.validate({a:1, b:2});
assert.equal(0, results.length);

generate(context)

lib/object.js, line 187

Generate the code for this node

Name	Type	Description
context	object	the generation context for this node

path(){array}

lib/object.js, line 176

Return the current object path

Returns:

array containing the path to this node

prohibitedFields(required){ObjectNode}

lib/object.js, line 165

Specifies the prohibited fields on the object

Name	Type	Description
required	array	an array of prohibited fields for the object

Example

// Create an Object with prohibited fields

assert = require('assert'),
  Compiler = require('vitesse').Compiler,
  ObjectNode = require('vitesse').ObjectNode,
var schema = new ObjectNode(null, null, {typeCheck:true})
  .prohibitedFields(['a', 'b']);
var compiler = new Compiler({});
// Compile the AST
var func = compiler.compile(schema, {});

// Validate {}
var results = func.validate([]);
assert.equal(1, results.length);
assert.equal('field is not an object', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate {a:1}
var results = func.validate({a:1});
assert.equal(1, results.length);
assert.equal('object has prohibited fields ["a","b"]', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate {c:1, d:2}
var results = func.validate({c:1, d:2});
assert.equal(0, results.length);

requiredFields(required){ObjectNode}

lib/object.js, line 153

Specifies required fields on the object

Name	Type	Description
required	array	an array of required fields for the object

Example

// Create an Object with required fields

assert = require('assert'),
  Compiler = require('vitesse').Compiler,
  ObjectNode = require('vitesse').ObjectNode,
var schema = new ObjectNode(null, null, {typeCheck:true})
  .requiredFields(['a', 'b']);
var compiler = new Compiler({});
// Compile the AST
var func = compiler.compile(schema, {});

// Validate {}
var results = func.validate([]);
assert.equal(1, results.length);
assert.equal('field is not an object', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate {a:1}
var results = func.validate({a:1});
assert.equal(1, results.length);
assert.equal('object is missing required fields ["a","b"]', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate {a:1, b:2}
var results = func.validate({a:1, b:2});
assert.equal(0, results.length);

setTypeCheck(typeCheck){ObjectNode}

lib/object.js, line 73

Type check value

Name	Type	Description
typeCheck	boolean	type check value