nickclaw/vlad

JSON schema validation with a chainable syntax.

vlad

A simple asynchronous JSON validator with a chainable syntax.

npm install vlad

Example

Object Validation

var validate = vlad.promise({
    email: vlad.string,
    location: vlad({
        long: vlad.number.required.within(-180, 180),
        lat: vlad.number.required.within(-90, 90)
    }),

    tags: vlad.array.of(vlad.string.within(3, 10))
});

validate(validObject).then(function(value) {
    /*{
        email: "[email protected]",
        location: {
            long: 70.235,
            lat: 60.234
        },
        tags: ['foo', 'bar']
    }*/
});


validate(invalidObject).catch(function(err) {
    /* GroupValidationError {
        message: "Invalid object.",
        fields: {
            email: FieldValidationError {message: '...'},
            location: GroupValidationError {
                message: 'Invalid object.',
                fields: {
                    long: FieldValidationError {message: '...'}
                }
            },
            tags: ArrayValidationError {
                message: 'Invalid array.',
                fields: [
                    undefined,
                    FieldValidationError {message: '...'},
                    undefined
                ]
            }
        }
    }*/
});

Express Middleware

router.post('/',
    vlad.middleware('body', {
        email: vlad.string.required.pattern(/.*@.*/)
    }),
    function(req, res) {
        res.send(200);
    }
);

router.use(function(err, req, res, next) {
    if (err instanceof vlad.ValidationError) {
        res.status(400).send(err.toJSON());
    } else {
        res.sendStatus(500);
    }
});

Subvalidators

var validate = vlad({
    field: vlad.string.required
});

validate({ field: 'hello world' }).then( /* handle */ );
validate.field('hello world').then( /* handle */ )

API Reference

• Creation
  • vlad(schema)
  • vlad.sync(schema)
  • vlad.promise(schema)
  • vlad.callback(schema)
  • vlad.middleware([prop, ] schema)
• Validation
  • Subvalidators
• Schema
  • Property
  • Function
  • Object
• Property Types
  • Base Property
  • vlad.string
    • vlad.addFormat(name, handler)
  • vlad.number
  • vlad.integer
  • vlad.boolean
  • vlad.date
  • vlad.array
  • vlad.enum(options)
  • vlad.equals(value [, message])
  • vlad.any
  • vlad.or
• Errors
  • vlad.ValidationError(message)
  • vlad.FieldValidationError(message)
  • vlad.GroupValidationError(message, fields)
  • vlad.ArrayValidationError(message, fields)
  • vlad.SchemaFormatError(message)

vlad's Issues

Default Values

Write Tests

• util function tests
• chaining tests
• jsonschema

Descriptive errors

Right now vlad uses the jsonschema node module to parse schema. Unfortunately the error message returned by it are not great. Possibly look into modifying jsonschema to return better error messages, writing my own limited JSON schema validator, or using another type of validation entirely.

vladidate function

What do we want to return from the vladidate function?

If we want to be synchronous the function would either have to return the validated value, or throw an error. Which I'd rather not do because it means lots of try-catch statements for nested vladidators.

With asynchronous operation we get a little better control flow with errors.

vladidate(obj, function(err, value) {
    if (err) return handle(err);
    success(value);
});

// or

vladidate(obj)
    .then(function(value) { success(value); })
    .catch(function(err) { handle(err); });

It would also let people do custom asynchronous validation which could also be potentially added to the chainable properties.

var checkServiceUrl = 'some/url';
var vladidate = vlad({
    a: vlad.string.test(checkServiceAsync.bind(null, checkServiceUrl)),
    b: function(value) {
        return checkWithServiceAsync(checkServiceUrl, value);
    })
});

Required Values

Write README.md