Arstotzka

JS data validation tool featuring laconic schema format and a sexy name.

Usage

See detailed usage example in usage.js

const schema = {
	id: "number",
	username: ["string", x => x.length < 10],
	post: "string",
	comments: Arstotzka.ARRAY_OF({
		author: ["string", Arstotzka.OPTIONAL],
		text: "string"
	})
}

const goodData = {
	id: 1337,
	username: "mr.hands",
	post: "Henlo there",
	comments: [
		{author: "Johnny", text: "henlo"},
		{text: "hey hey"},
		{author: "miles", text: "birb"},
	]
}

console.log(Arstotzka.validate(goodData, schema, {allowExtraProperties: false})); // Prints an array of errors

Import:

Arstotzka is an ES6 module, so:

import * as Arstotzka from "arstotzka";

or, if you are okay with polluting namespace:

import { validate, OPTIONAL, ARRAY_OF, ANY_OF, DYNAMIC } from "arstotzka";

Schema format:

Schema is a value that can be either of

• string: such schema will make validator check coresponding value's type with typeof operator, with exception of "array" constraint -- validator will treat this type as special case; "string", "number", "array"

• function: such schema will make validator call it, pass corresponding value to it, and log an error if returned value is falsy; x => !isNaN(x), x => x.length < 10

• object: object schema requires corresponding value to also be an object, and will recursively match it's properties against provided value; {name: "string", age: x => x.length > 21}

• array, which elements are any of above. That will require a value it matched against to fullfill every requirement; ["string", x => x != x.trim()], ["number", x => x >= 0, x => x % 1 === 0]

• Arstotzka.ARRAY_OF(): the function accepts any of above and returns a special constraint appliable to an array of values; Arstotzka.ARRAY_OF("number"), Arstotzka.ARRAY_OF({id: "number", text: "string"}), Arstotzka.ARRAY_OF(["number", x => x > 0]), Arstotzka.ARRAY_OF(Arstotzka.ARRAY_OF("number"))

• Arstotzka.ANY_OF(): the function accepts array or vararg of schemas and returns a special constraint, which will produce a specific error only if every provided schema is violated; Arstotzka.ANY_OF(["number", ["string", x => !isNaN(parseInt(x))]])

• Arstotzka.DYNAMIC(): the function accepts a callback that should return a valid schema, allowing to define schema at runtime; Arstotzka.DYNAMIC(x => dynSchema[x.type])

• Arstotzka.OPTIONAL: unlike others, this schema doesn't imply any requirements, but prevents validator from logging an error in case it's property is not present in target object;

Applying a schema to a property that is an object can be done by combining object schema with anything via array schema;

Available options:

• allErrors (default is true) : If false, will return errors as soon as encountered, interrupting validation
• allowExtraProperties (default is true) : If false, adds specific error to a list for every property of target object not present in schema

Error format

{ // Example error item:
	propertyName: 'age', // Name of a property that failed validation
	id: 'typeMismatch', // String describing type of an error. Can be used to localize error message
	message: 'Provided type is not allowed by schema', // Error message that coressponds to error id
	expected: 'number', // Arbitrary-purpose fields
	got: null
}

All error ids and messages can be found at Arstotzka.ERRORS

License

Shared under WTFPL license.