tcomb-validator-plus

tcomb-validator-plus
====================

Advanced validation helpers for tcomb-validation

Features
--------

- Used validator.js for strings
- Custom error messages
- Context binding
- Compile from simple schema

Extending rules
---------------

``js
import createValidator from 'tcomb-validator-plus'
import extend from 'tcomb-validator-plus/extend'
import gt from 'tcomb-validator-plus/getType'
import {intersection} from 'tcomb'

function fakeLocalize(message, context) {
return {
message,
context
}
}

const validate = createValidator(fakeLocalize)

const password = (min, max) => intersection([
gt('isLengthMin')(min),
gt('isLengthMax', 'password greate than #{val}')(max)
])

extend('password', password)


const schema = struct({
password: gt('password')(3, 5),
})
const compiledSchema = compile({
password: 'password'
})

const data = {
password: '12'
}

const errors = {
errors: {
password: {
context: {
actual: '12',
val: 3
},
message: 'isLengthMin'
}
},
isError: true,
params: {
password: '12'
}
}

const obj = validate(schema)(data)
assert.deepEqual(obj, errors)
const obj2 = validate(compiledSchema)(data)
assert.deepEqual(obj2, errors)
`

Simple usage
------------

`js
// simple-1.js
import assert from 'power-assert'
import createValidator from 'tcomb-validator-plus'
import compile from 'tcomb-validator-plus/compile'

function fakeLocalize(message, context) {
return {
message,
context
}
}

const validate = createValidator(fakeLocalize)

const myValidate = validate(compile({
confirmed: {v: 'required', l: 'check confirm'},
password: [
['isLengthMin', 3],
{l: 'password greate than #{val}', v: ['isLengthMax', 5]}
],
confirmPassword: [
['isLengthMin', 3],
{l: 'password greate than #{val}', v: ['isLengthMax', 5]}
],
user: {v: 'required', l: 'user required'},
opts: {v: ['listOf', ['opt1', 'opt2']], l: '#{actual} is not a one of #{val}'},
__: {v: ['equal', 'password', 'confirmPassword'], l: 'Passwords are not equal'}
}))

const data = {
confirmed: false,
password: '1234',
confirmPassword: '1235',
user: '',
opts: ['opt1', 'opt3']
}

const errors = {
errors: {
confirmed: {
message: 'check confirm',
context: {
actual: false
}
},
user: {
message: 'user required',
context: {
actual: ''
path: ['user'],
}
},
opts: {
message: '#{actual} is not a one of #{val}',
context: {
val: 'opt1, opt2',
actual: 'opt3'
}
}
},
isError: true,
params: {
confirmed: false,
password: '1234',
confirmPassword: '1235',
user: '',
opts: ['opt1', 'opt3']
}
}

const obj1 = myValidate(data)
assert.deepEqual(obj1, errors)

const data2 = {
confirmed: true,
password: '1234',
confirmPassword: '1235',
user: 'test',
opts: ['opt1', 'opt2']
}

const errors = {
errors: {
__: {
context: {
from: 'password',
to: 'confirmPassword',
actual: {
confirmed: true,
password: '1234',
confirmPassword: '1235',
user: 'test',
opts: [
'opt1',
'opt2'
]
}
},
message: 'Passwords are not equal'
}
},
isError: true,
{
confirmed: true,
password: '1234',
confirmPassword: '1235',
user: 'test',
opts: ['opt1', 'opt2']
}
}

const obj2 = myValidate(data2)
assert.deepEqual(obj2, errors)
`

Promise usage
-------------

`js
import {validate} from 'tcomb-validation'
import assert from 'power-assert'
import createValidator from 'tcomb-validator-plus'
import promisifyValidate, {ParamsError} from 'tcomb-validator-plus/promisifyValidate'
import compile from 'tcomb-validator-plus/compile'

function fakeLocalize(message, context) {
return {
message,
context
}
}

const validate = promisifyValidate(createValidator(fakeLocalize))

const myValidate = validate(compile({
confirmed: {v: 'required', l: 'check confirm'},
password: [
['isLengthMin', 3],
{l: 'password greate than #{val}', v: ['isLengthMax', 5]}
],
confirmPassword: [
['isLengthMin', 3],
{l: 'password greate than #{val}', v: ['isLengthMax', 5]}
],
user: {v: 'required', l: 'user required'},
opts: {v: ['listOf', ['opt1', 'opt2']], l: '#{actual} is not a one of #{val}'},
__: {v: ['equal', 'password', 'confirmPassword'], l: 'Passwords are not equal'}
}))

const data = {
confirmed: false,
password: '1234',
confirmPassword: '1235',
user: '',
opts: ['opt1', 'opt3']
}

const errors = {
errors: {
confirmed: {
message: 'check confirm',
context: {
actual: false
}
},
user: {
message: 'user required',
context: {
actual: ''
path: ['user'],
}
},
opts: {
message: '#{actual} is not a one of #{val}',
context: {
val: 'opt1, opt2',
actual: 'opt3'
}
}
},
isError: true,
params: {
confirmed: false,
password: '1234',
confirmPassword: '1235',
user: '',
opts: ['opt1', 'opt3']
}
}

myValidate(data)
.then(params => {
assert.deepEqual(params, data)
})
.catch(e => {
assert.deepEqual(e.errors, errors)
})
``