revalidator

What is revalidator?

The revalidator npm package is a versatile tool for validating JavaScript objects against a defined schema. It supports a wide range of validation rules and custom validation logic, making it suitable for various data validation needs.

What are revalidator's main functionalities?

Basic Schema Validation

This feature allows you to define a schema with various properties and validate an object against it. The code sample demonstrates how to validate a person's name and age.

const revalidator = require('revalidator');

const schema = {
  properties: {
    name: {
      description: 'Name of the person',
      type: 'string',
      required: true,
      minLength: 2
    },
    age: {
      description: 'Age of the person',
      type: 'integer',
      minimum: 0
    }
  }
};

const person = { name: 'John', age: 30 };
const result = revalidator.validate(person, schema);
console.log(result);

Custom Validation

This feature allows you to add custom validation logic using the 'conform' function. The code sample shows how to validate a password to ensure it is at least 8 characters long.

const revalidator = require('revalidator');

const schema = {
  properties: {
    password: {
      description: 'User password',
      type: 'string',
      conform: function (value) {
        return value.length >= 8;
      },
      messages: {
        conform: 'Password must be at least 8 characters long'
      }
    }
  }
};

const user = { password: 'short' };
const result = revalidator.validate(user, schema);
console.log(result);

Nested Object Validation

This feature supports validation of nested objects. The code sample demonstrates how to validate an address object within a person object.

const revalidator = require('revalidator');

const schema = {
  properties: {
    address: {
      type: 'object',
      properties: {
        street: { type: 'string', required: true },
        city: { type: 'string', required: true }
      }
    }
  }
};

const person = { address: { street: '123 Main St', city: 'Anytown' } };
const result = revalidator.validate(person, schema);
console.log(result);

Other packages similar to revalidator

ajv

AJV (Another JSON Schema Validator) is a popular JSON schema validator that supports JSON Schema draft-07 and later. It is known for its high performance and extensive features, including asynchronous validation and custom keywords. Compared to revalidator, AJV offers more advanced features and better performance for large-scale applications.

joi

Joi is a powerful schema description language and data validator for JavaScript. It allows you to create blueprints for JavaScript objects to ensure validation. Joi is known for its expressive and readable syntax, making it easier to define complex validation rules. Compared to revalidator, Joi provides a more intuitive API and better integration with Node.js applications.

yup

Yup is a JavaScript schema builder for value parsing and validation. It is often used in conjunction with form libraries like Formik. Yup provides a fluent API for building schemas and supports various validation methods. Compared to revalidator, Yup is more focused on form validation and offers better integration with React applications.

README

revalidator

A cross-browser / node.js validator with JSONSchema compatibility as the primary goal.

Example

The core of revalidator is simple and succinct: revalidator.validate(obj, schema):

  var revalidator = require('revalidator');

  console.dir(revalidator.validate(someObject, {
    properties: {
      url: {
        description: 'the url the object should be stored at',
        type: 'string',
        pattern: '^/[^#%&*{}\\:<>?\/+]+$',
        required: true
      },
      challenge: {
        description: 'a means of protecting data (insufficient for production, used as example)',
        type: 'string',
        minLength: 5
      },
      body: {
        description: 'what to store at the url',
        type: 'any',
        default: null
      }
    }
  }));

This will return with a value indicating if the obj conforms to the schema. If it does not, a descriptive object will be returned containing the errors encountered with validation.

  {
    valid: true // or false
    errors: [/* Array of errors if valid is false */]
  }

In the browser, the validation function is exposed on window.validate by simply including revalidator.js.

Installation

Installing npm (node package manager)

  $ curl http://npmjs.org/install.sh | sh

Installing revalidator

  $ [sudo] npm install revalidator

Usage

revalidator takes json-schema as input to validate objects.

revalidator.validate (obj, schema, options)

This will return with a value indicating if the obj conforms to the schema. If it does not, a descriptive object will be returned containing the errors encountered with validation.

{
  valid: true // or false
  errors: [/* Array of errors if valid is false */]
}

Available Options

• validateFormats: Enforce format constraints (default true)
• validateFormatsStrict: When validateFormats is true treat unrecognized formats as validation errors (default false)
• validateFormatExtensions: When validateFormats is true also validate formats defined in validate.formatExtensions (default true)
• additionalProperties: When additionalProperties is true allow additional unvisited properties on the object. (default true)
• cast: Enforce casting of some types (for integers/numbers are only supported) when it's possible, e.g. "42" => 42, but "forty2" => "forty2" for the integer type.

Schema

For a property an value is that which is given as input for validation where as an expected value is the value of the below fields

required

If true, the value should not be undefined

{ required: true }

allowEmpty

If false, the value must not be an empty string

{ allowEmpty: false }

type

The type of value should be equal to the expected value

{ type: 'string' }
{ type: 'number' }
{ type: 'integer' }
{ type: 'array' }
{ type: 'boolean' }
{ type: 'object' }
{ type: 'null' }
{ type: 'any' }
{ type: ['boolean', 'string'] }

pattern

The expected value regex needs to be satisfied by the value

{ pattern: /^[a-z]+$/ }

maxLength

The length of value must be greater than or equal to expected value

{ maxLength: 8 }

minLength

The length of value must be lesser than or equal to expected value

{ minLength: 8 }

minimum

Value must be greater than or equal to the expected value

{ minimum: 10 }

maximum

Value must be lesser than or equal to the expected value

{ maximum: 10 }

allowEmpty

Value may not be empty

{ allowEmpty: false }

exclusiveMinimum

Value must be greater than expected value

{ exclusiveMinimum: 9 }

exclusiveMaximum

Value must be lesser than expected value

{ exclusiveMaximum: 11 }

divisibleBy

Value must be divisible by expected value

{ divisibleBy: 5 }
{ divisibleBy: 0.5 }

minItems

Value must contain more than expected number of items

{ minItems: 2 }

maxItems

Value must contain fewer than expected number of items

{ maxItems: 5 }

uniqueItems

Value must hold a unique set of values

{ uniqueItems: true }

enum

Value must be present in the array of expected values

{ enum: ['month', 'year'] }

format

Value must be a valid format

{ format: 'url' }
{ format: 'email' }
{ format: 'ip-address' }
{ format: 'ipv6' }
{ format: 'date-time' }
{ format: 'date' }
{ format: 'time' }
{ format: 'color' }
{ format: 'host-name' }
{ format: 'utc-millisec' }
{ format: 'regex' }

conform

Value must conform to constraint denoted by expected value

{ conform: function (v) {
    if (v%3==1) return true;
    return false;
  }
}

dependencies

Value is valid only if the dependent value is valid

{
  town: { required: true, dependencies: 'country' },
  country: { maxLength: 3, required: true }
}

Nested Schema

We also allow nested schema

{
  properties: {
    title: {
      type: 'string',
      maxLength: 140,
      required: true
    },
    author: {
      type: 'object',
      required: true,
      properties: {
        name: {
          type: 'string',
          required: true
        },
        email: {
          type: 'string',
          format: 'email'
        }
      }
    }
  }
}

Custom Messages

We also allow custom messages for different constraints

{
  type: 'string',
  format: 'url'
  messages: {
    type: 'Not a string type',
    format: 'Expected format is a url'
  }

{
  conform: function () { ... },
  message: 'This can be used as a global message'
}

Tests

All tests are written with vows and should be run with npm:

  $ npm test

Author: Charlie Robbins, Alexis Sellier

Contributors: Fedor Indutny, Bradley Meck, Laurie Harper, Martijn Swaagman

License: Apache 2.0