Vitesse

Class: ArrayNode

ArrayNode

new ArrayNode(){ArrayNode}

lib/array.js, line 17

The ArrayNode class represents a validation of an array value

Returns:
ArrayNode instance.

Methods

addAdditionalItemsValidation(node){ArrayNode}

lib/array.js, line 108

Controls whether it’s valid to have additional items in the array beyond what is defined in the schema

Name Type Description
node object

validation node for the additional items
Examples
// Create an Array validation that requires positional elements as well as additional items validation

assert = require('assert'),
  Compiler = require('vitesse').Compiler,
  StringNode = require('vitesse').StringNode,
  IntegerNode = require('vitesse').IntegerNode,
  ArrayNode = require('vitesse').ArrayNode,
  CustomNode = require('../lib/custom');
var integer = new IntegerNode(null, null, {typeCheck:true});
var string = new StringNode(null, null, {typeCheck:true});
var schema = new ArrayNode(null, null, {typeCheck:true})
  .addPositionalItemValidation(0, string)
  .addPositionalItemValidation(1, integer)
  .addAdditionalItemsValidation(integer);

// Create a compiler
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 array', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

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

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

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

// Validate ['1']
var results = func.validate(['1']);
assert.equal(0, results.length);
// Create an Array validation that requires positional elements as well as additional items validation

assert = require('assert'),
  Compiler = require('vitesse').Compiler,
  StringNode = require('vitesse').StringNode,
  IntegerNode = require('vitesse').IntegerNode,
  ArrayNode = require('vitesse').ArrayNode,
  CustomNode = require('../lib/custom');
var integer = new IntegerNode(null, null, {typeCheck:true});
var string = new StringNode(null, null, {typeCheck:true});
var schema = new ArrayNode(null, null, {typeCheck:true})
  .addPositionalItemValidation(0, string)
  .addPositionalItemValidation(1, integer)
  .addAdditionalItemsValidation(false);

// Create a compiler
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 array', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

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

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

// Validate ['1', 2, 'test']
var results = func.validate(['1', 2, 'test']);
assert.equal(1, results.length);
assert.equal('array contains invalid items', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate ['1']
var results = func.validate(['1']);
assert.equal(0, results.length);

addCustomValidator(node){ArrayNode}

lib/array.js, line 145

Add a custom object validator

Name Type Description
node CustomNode

custom validation node to be used for this field validation
Example
// Create a Custom validator

assert = require('assert'),
  Compiler = require('vitesse').Compiler,
  ArrayNode = require('vitesse').ArrayNode,
  CustomNode = require('../lib/custom');

var customValidator = new CustomNode()
  .setContext({ max: 4 })
  .setValidator(function(object, context) {
    if(object.length > context.max) {
      return new Error('array longer than maximum size ' + context.max);
    }
  });

var schema = new ArrayNode(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 array', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate [1, 2, 3, 4, 5]
var results = func.validate([1, 2, 3, 4, 5]);
assert.equal(1, results.length);
assert.equal('array longer than maximum size 4', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === customValidator);

// Validate [1, 2, 3]
var results = func.validate([1, 2, 3]);
assert.equal(0, results.length);

addItemValidation(node){ArrayNode}

lib/array.js, line 120

Validate all items in the array against the provided validation

Name Type Description
node object

validation node for the additional items
Example
// Create an Array validation that requires all elements to be a string.

assert = require('assert'),
  Compiler = require('vitesse').Compiler,
  StringNode = require('vitesse').StringNode,
  ArrayNode = require('vitesse').ArrayNode,
  CustomNode = require('../lib/custom');
var string = new StringNode(null, null, {typeCheck:true});
var schema = new ArrayNode(null, null, {typeCheck:true})
  .addItemValidation(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 array', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

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

// Validate ['1']
var results = func.validate(['1']);
assert.equal(0, results.length);

addPositionalItemValidation(i, node){ArrayNode}

lib/array.js, line 96

Add a array positional validation (say validate item 1 as a string, item 2 as a number)

Name Type Description
i number

the index in the array to validate
node object

validation node for this item
Example
// Create an Array validation that requires positional elements to pass specific validations

assert = require('assert'),
  Compiler = require('vitesse').Compiler,
  StringNode = require('vitesse').StringNode,
  IntegerNode = require('vitesse').IntegerNode,
  ArrayNode = require('vitesse').ArrayNode,
  CustomNode = require('../lib/custom');
var integer = new IntegerNode(null, null, {typeCheck:true});
var string = new StringNode(null, null, {typeCheck:true});
var schema = new ArrayNode(null, null, {typeCheck:true})
  .addPositionalItemValidation(0, string)
  .addPositionalItemValidation(1, integer);

// Create a compiler
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 array', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

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

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

// Validate ['1', 2, 'test']
var results = func.validate(['1', 2, 'test']);
assert.equal(0, results.length);

// Validate ['1']
var results = func.validate(['1']);
assert.equal(0, results.length);

addValidation(validation){ArrayNode}

lib/array.js, line 58

Add a validation language node

Name Type Description
validation object

validation operation valid ones are $gt,$gte,$lt,$lte
Example
// Create an Array validation that validates the length of the array and type.

assert = require('assert'),
  Compiler = require('vitesse').Compiler,
  ArrayNode = require('vitesse').ArrayNode,
  CustomNode = require('../lib/custom');
var schema = new ArrayNode(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 array', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

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

// Validate number 100
var results = func.validate([1, 2, 3]);
assert.equal(0, results.length);

generate(context)

lib/array.js, line 167

Generate the code for this node

Name Type Description
context object

the generation context for this node

path(){array}

lib/array.js, line 156

Return the current object path

Returns:
array containing the path to this node

setTypeCheck(typeCheck){ArrayNode}

lib/array.js, line 75

Type check value

Name Type Description
typeCheck boolean

type check value

uniqueItems(uniqueItems){ArrayNode}

lib/array.js, line 133

Type check value

Name Type Description
uniqueItems boolean

all entries in the array should be unique
Example
// Create an Array validation that requires all elements to be unique

assert = require('assert'),
  Compiler = require('vitesse').Compiler,
  ArrayNode = require('vitesse').ArrayNode,
  CustomNode = require('../lib/custom');
var schema = new ArrayNode(null, null, {typeCheck:true})
  .uniqueItems(true);

// Create a compiler
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 array', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);

// Validate [1]
var results = func.validate([1]);
assert.equal(0, results.length);

// Validate [1, 2, 1]
var results = func.validate([1, 2, 1]);
assert.equal(1, results.length);
assert.equal('array contains duplicate values', results[0].message);
assert.deepEqual(['object'], results[0].path);
assert.ok(results[0].rule === schema);
comments powered by Disqus