form-schema-validation v2.0.1

FORM SCHEMA VALIDATION

1. Features
2. Installation
3. How to use
4. Constructor
5. Methods
6. Types
7. Example of custom validator
8. Example of additional validator
9. Example of Schema definition
10. Example of schema in schema
11. Schema keys description
12. Custom validation messages
13. Switch of keys validation

Features

• sync validation
• async validation (Promise)
• validate object structure
• validate object keys
• validate required fields
• validate optional fields
• validate by type
• validate by custom type
• validate by one of type
• validate field by custom validators
• validate fields relations by custom validators
• validate whole object tree by custom additional validators

Installation

$ npm install form-schema-validation --save

How to use

Schema give you posibility to validate object using schema validation. You can defined schema and use validate method to check object. Validate method allways returns errors object but if You don't have errors object is empty so You can check errors by

import Schema from 'form-schema-validation';

const schema = new Schema({
    companyName: {
        type: String
    }
});

const modelObject = {
    companyName: 'Test Company'
};

const errors = schema.validate(modelObject); // {}
const error = Object.keys(errors).length > 0; // false

Promises support

You can use validators that return Promise. If You return promis in validator then shema.validate(model) will return Promise.

import Schema from 'form-schema-validation';

const customValidator = {
    validator: (value) => {
        return new Promise((resolve) => {
            setTimeout(() => {
                resolve(value === 'test');
            }, 1000);
        });
    },
    errorMessage: 'async test error',
}

const schema = new Schema({
    companyName: {
        type: String,
        validators:[customValidator]
    }
});

const modelObject = {
    companyName: 'Test Company'
};

const results = schema.validate(modelObject); // Promise
results.then((errors) => {
    console.log(Object.keys(errors).length > 0); // true
});

Constructor

Methods

Types

Custom validator attributes

Example of custom validator

This validator will check two fields. You can validate one field on base another field.

const validateIfFieldTitleIsFilled = (minLength, message) => ({
    validator: (value, field, model, schema) => {
        if (model.title) {
            return !!value;
        }
        return true;
    },
    errorMessage: message
});

Example of additional validator

Additional validator can set error deep in the objects tree.

const fooSchema = new Schema({
    fooStart: {
        type: String,
    },
    fooEnd: {
        type: String,
    },
});
const modelSchema = new Schema({
    foo: {
        type: fooSchema,
        required: true,
    },
});
const dataModel = {
    foo: {
        fooStart: 'start',
        fooEnd: 'end',
    },
};

modelSchema.addValidator((model, schema) => {
    if(model.foo.fooStart === 'start') {
        schema.setModelError('foo.fooStart', 'my foo error message');
    }
});

modelSchema.validate(dataModel);

Example of dynamic error messages

There can be a need for error messages generated based on the validation outcome. In that case a string or array of strings can be returned from the validator function. Error messages returned from validator function have higher priority that the errorMessage property.

const MIN_AGE = 18;
const validateIfOfAge = () => ({
    validator: (value, fieldSchema, formData) => {
        const { age } = formData;
        if (age <= MIN_AGE) {
            return [`Given ${age} is lower than required age of ${MIN_AGE}`];
        }
    }
});

Example of Schema definition

If You want create new schema You must put object to constructor with information about object keys names and type of value on key.

import Schema from 'form-schema-validation';

const min = (minLength, message) => ({
    validator: (value) => {
        return value.length > minLength;
    },
    errorMessage: message
});

const schema = new Schema({
    companyName: {
        type: String,
        required: true,
        label: 'Company name',
        validators: [min(2, 'Company name should be longer then 2 chars')]
    },
    createdAt: {
        type: Schema.oneOfTypes([Date, String]),
        defaultValue: new Date(),
        label: 'When start'
    },
    workers: {
        type: Number,
        label: 'How many workers we have'
    }
});

Example of schema in schema

import Schema from 'form-schema-validation';

const userSchema = new Schema({
    name: {
        type: String,
        required: true
    },
    surname: {
        type: String,
        required: true
    },
    age: {
        type: Number
    }
});

const groupSchema = new Schema({
    name: {
        type: String,
        required: true,
        label: 'Group name'
    },
    createdAt: {
        type: Date,
        defaultValue: new Date(),
        label: 'Created at'
    },
    members: {
        type: [userSchema],
        label: 'Members'
    }
});

Example of use new schema type

import Schema, { SchemaType } from 'form-schema-validation';

const fooType = new SchemaType('Foo', {
    getDefaultValue() {
        return 'foo';
    },
    validator(value, key) {
        if (value.indexOf('foo') > -1 || value === '') {
            return true;
        }
        this.setError(key, 'foo error');
        return false;
    },
    requiredValidator(value, key) {
        if (value.indexOf('foo') > -1) {
            return true;
        }
        this.setError(key, 'foo required');
        return false;
    },
});

const schema = new Schema({
    foo: {
        type: fooType,
    },
    bar: {
        type: String,
    },
});

const modelWithErrors = {
    foo: 'test',
    bar: '',
};
const modelWithoutErros = {
    foo: '',
    bar: '',
};
const modelWithoutErros2 = {
    foo: 'foo',
    bar: '',
};

Schema keys description

When You defined schema You can use this keys:

Custom validation messages

import Schema from 'form-schema-validation';

const ErrorMessages = {
    notDefinedKey(key) { return `Key '${key}' is not defined in schema`; },
    modelIsUndefined() { return 'Validated model is undefined'; },
    validateRequired(key) { return `Field '${key}' is required`; },
    validateString(key) { return `Field '${key}' is not a String`; },
    validateNumber(key) { return `Field '${key}' is not a Number`; },
    validateObject(key) { return `Field '${key}' is not a Object`; },
    validateArray(key) { return `Field '${key}' is not a Array`; },
    validateBoolean(key) { return `Field '${key}' is not a Boolean`; },
    validateDate(key) { return `Field '${key}' is not a Date`; }
};

const groupSchema = new Schema({
    name: {
        type: String,
        required: true,
        label: 'Group name'
    },
    createdAt: {
        type: Date,
        defaultValue: new Date(),
        label: 'Created at'
    },
    members: {
        type: [userSchema],
        label: 'Members'
    }
}, ErrorMessages);

Switch of keys validation

import Schema from 'form-schema-validation';

const schema = new Schema({
    companyName: {
        type: String,
        required: true
    }
}, false, false);

const modelObject = {
    companyName: 'Test Company',
    _id: 'test1234567890',
};

const errors = schema.validate(modelObject);
console.log(Object.keys(errors).length > 0); // false