LogoLogo
  • Home
  • Services
    • Fiber
    • Accessor
    • Schema
    • Form
    • Translator
  • Components
    • <Router/>
    • <Memo />
  • Observables
    • Async
    • Value
    • Store
    • List
    • Local Storage Value
    • Local Storage Store
    • Local Storage List
  • Hooks
    • useAsync
    • useAffect
    • useStream
    • useAction
    • useDebounce
    • useThrottle
    • usePrevious
    • useIdle
    • useValue
    • useList
    • useStore
    • useForm
    • useFormBinder
    • useTranslator
    • useQuery
  • Helpers
    • Tag
    • Input Helpers
    • Promise Helpers
    • Save Helpers
    • Pagination Helpers
    • Clipboard Helpers
    • Calendar Helpers
    • Local Storage Helpers
Powered by GitBook
On this page
  • Concepts
  • Quick start
  • Combining schemas
  • Conditional validations
  • Custom validations
  • Custom sanitizers
  • Translations
  • Schema.test()
  • Schema.validate()
  • Schema.verify()
  • Schema.sanitize()
  • Schema.sanitizeAndTest()
  • Schema.sanitizeAndValidate()
  • Schema.sanitizeAndVerify()
  • Schema.testAsync()
  • Schema.validateAsync()
  • Schema.verifyAsync()
  • Schema.sanitizeAsync()
  • Schema.sanitizeAndTestAsync()
  • Schema.sanitizeAndValidateAsync()
  • Schema.sanitizeAndVerifyAsync()
  • Schema.also()
  • Schema.and()
  • Schema.or()
  • Schema.map()
  • schema()
  • schema.string()
  • schema.number()
  • schema.boolean()
  • schema.date()
  • schema.array()
  • schema.object()
  • schema.mixed()
  • string()
  • string.required()
  • string.optional()
  • string.equals()
  • string.length()
  • string.min()
  • string.max()
  • string.between()
  • string.matches()
  • string.email()
  • string.url()
  • string.startsWith()
  • string.endsWith()
  • string.includes()
  • string.omits()
  • string.oneOf()
  • string.noneOf()
  • string.numeric()
  • string.alpha()
  • string.alphaNumeric()
  • string.alphaDashes()
  • string.alphaUnderscores()
  • string.alphaNumericDashes()
  • string.alphaNumericUnderscores()
  • string.date()
  • string.dateBefore()
  • string.dateBeforeOrEqual()
  • string.dateAfter()
  • string.dateAfterOrEqual()
  • string.dateBetween()
  • string.dateBetweenOrEqual()
  • string.time()
  • string.timeBefore()
  • string.timeBeforeOrEqual()
  • string.timeAfter()
  • string.timeAfterOrEqual()
  • string.timeBetween()
  • string.timeBetweenOrEqual()
  • string.dateTime()
  • string.toDefault()
  • string.toUpperCase()
  • string.toLowerCase()
  • string.toCapitalized()
  • string.toCamelCase()
  • string.toSnakeCase()
  • string.toKebabCase()
  • string.toConstantCase()
  • string.toTrimmed()
  • number()
  • number.required()
  • number.optional()
  • number.equals()
  • number.min()
  • number.max()
  • number.between()
  • number.between()
  • number.negative()
  • number.integer()
  • number.oneOf()
  • number.noneOf()
  • number.toDefault()
  • number.toRounded()
  • number.toFloored()
  • number.toCeiled()
  • number.toTrunced()
  • boolean()
  • boolean.required()
  • boolean.optional()
  • boolean.equals()
  • boolean.toDefault()
  • date()
  • date.required()
  • date.optional()
  • date.equals()
  • date.after()
  • date.before()
  • date.between()
  • date.toDefault()
  • array()
  • array.required()
  • array.optional()
  • array.equals()
  • array.length()
  • array.min()
  • array.max()
  • array.between()
  • array.someOf()
  • array.noneOf()
  • array.shape()
  • array.toDefault()
  • array.toFiltered()
  • array.toMapped()
  • array.toCompact()
  • array.toUnique()
  • object()
  • object.required()
  • object.optional()
  • object.equals()
  • object.shape()
  • object.allowUnknownKeys()
  • object.forbidUnknownKeys()
  • object.shapeUnknownKeys()
  • object.shapeUnknownValues()
  • object.toDefault()
  • object.toCamelCaseKeys()
  • object.toSnakeCaseKeys()
  • object.toKebabCaseKeys()
  • object.toConstantCaseKeys()
  • object.toMappedValues()
  • object.toMappedKeys()
  • mixed()
  • mixed.required()
  • mixed.optional()
  • mixed.equals()
  • mixed.oneOf()
  • mixed.noneOf()
  • mixed.toDefault()

Was this helpful?

  1. Services

Schema

Delightfully simple, feature packed and customisable tool for validation and sanitization of any kind of data. Can be used on the client side as well as on the server side.

PreviousAccessorNextForm

Last updated 3 years ago

Was this helpful?

Source code is hosted on

  • Works with React, React Native, Angular, Vue or NodeJs

  • Plentitude of validation methods for different data types

  • Many useful sanitization methods for data normalization

  • Typed from tail to toe for amazing developer experience

  • Very intuitive and easy to use

  • Extremely flexible and extendable

  • Supports sync and async logic

  • Encourages you to build reusable schemas

  • Combine multiple schemas into more complex ones

  • Conditionally connect schemas for complex scenarios

  • Write custom validation and sanitization logic with ease

  • Easily override error messages

  • Comes translated into 6 different languages (English, German, French, Italian, Spanish and Russian)

  • Easily add a new language or override translation

yarn add @corets/schema
npm install --save @corets/schema

Concepts

Every schema specialises on a specific data type and comes with various assertion and sanitization methods. Some methods you'll be able to find on every schema, others are exclusive to a specific kind of schema.

Assertions are used for validation purposes to ensure that a value is valid.

Check out this React form library, it has a support for schemas and changes the way you work with forms:

Quick start

Here is an example of all the available schemas and how to import them:

import { 
    string, 
    number, 
    array, 
    boolean, 
    date, 
    object, 
    mixed 
} from "@corets/schema"

Let's describe a simple user object.

  • Property email must be of type string and a valid email address

  • Property fullName must be a string between 3 and 100 characters

  • Property roles must be an array containing at least one role, valid roles are admin, publisher and developer, no duplicates are allowed

  • Property tags must be an array of strings, each at least 3 characters long and consisting of letters and dashes

This schema contains some validation as well as some sanitization logic.

import { array, object, string } from "@corets/schema"

const roles = ["admin", "publisher", "developer"]

const userSchema = object({  
    email: string().email(),  
    fullName: string().min(3).max(100),  
    roles: array().min(1).someOf(roles).toUnique(),  
    tags: array(string().min(3).alphaDashes())
})

Quick check if an object is valid according to the schema:

const valid = userSchema.test({ ... })

if (valid) {
    // continue ...
}

Get a detailed list of errors:

const errors = userSchema.validate({ ... })

if ( ! errors) {
    // continue ...
}

The errors object would look something like this:

{  
    "field": ["first error", "second error"],  
    "nested.field": ["first error", "second error"],
}

Run sanitizers without any validation:

const sanitizedValue = userSchema.sanitize({ ... })

Test, validate and sanitize at the same time:

const [valid, sanitizedValue] = userSchema.sanitizeAndTest({ ... })
const [errors, sanitizedValue] = userSchema.sanitizeAndValidate({ ... })

Combining schemas

Schemas can be freely combined with one another. When describing arrays and objects there is no way around this. Here is an example of two schemas being combined:

import { array, string } from "@corets/schema"

const usernameSchema = string().alphaNumeric().between(3, 10)
const usernameListSchema = array(usernameSchema).min(3)
const errors = usernameListSchema.validate(["foo", "bar", "baz"])

Consider writing schemas that are reusable.

Conditional validations

import { string } from "@corets/schema"

string().and(string().numeric())
import { number, string } from "@corets/schema"

number().or(string().numeric())
import { string } from "@corets/schema"

string().also(string().numeric())

Conditional schemas can be wrapped into a function, this allows you to define schemas dynamically during the validation:

import { string } from "@corets/schema"

string().and(() => string().numeric())
string().or(() => string().numeric())
string().also(() => string().numeric())

You can freely define validations and sanitizers at runtime using logical links.

Logical links can be used to attach custom validation logic:

import { string } from "@corets/schema"

string().min(3).max(20)
    .and(async (v) => await isUsernameTaken(v) && "Username is already taken")

Custom validations

Example of a validation function returning an error message:

import { number } from "@corets/schema"

const customValidation = (value: any) => value < 12 && "Must be bigger than 12"

number().and(customValidation)
number().or(customValidation)
number().also(customValidation)

You can also return multiple error messages at once using an array.

Example of a validation function returning a schema:

import { string } from "@corets/schema"

const customValidation = (value: any) => value.includes("@") && string().email()

string().and(customValidation)
string().or(customValidation)
string().also(customValidation)

Example of a validation function returning schema validation errors:

import { string } from "@corets/schema"

const customValidation = (value: any) => 
    value.includes("@") && string().email().verify(value)

string().and(customValidation)
string().or(customValidation)
string().also(customValidation)

Custom sanitizers

import { string } from "@corets/schema"

const customSanitizer = (value: any) => value.toString()
const sanitizedValue = string().map(customSanitizer).sanitize(1234)

Translations

All the translation logic is handled by this library:

You can change default language:

import { schemaTranslator } from "@corets/schema"

schemaTranslator.setLanguage("en")

You can also request a specific language during validation:

import { string } from "@corets/schema"

string().validate("foo", { language: "ru", fallbackLanguage: "en" })
string().verify("foo", { language: "ru", fallbackLanguage: "en" })
string().sanitizeAndValidate("foo", { language: "ru", fallbackLanguage: "en" })
string().sanitizeAndVerify("foo", { language: "ru", fallbackLanguage: "en" })

Get a full list of all translations:

import { schemaTranslator } from "@corets/schema"

console.log(schemaTranslator.getTranslations())

Schema.test()

This method simply indicates whether a value is valid or not by returning a boolean.

Example of a failed assertion:

import { string } from "@corets/schema"

const schema = string().min(3).alphaNumeric()
// false
const valid = schema.test("foo-bar")

if (valid) {
    // continue ...
}

Schema.validate()

This method returns a validation result containing detailed error messages about why a value did not pass validation.

Example of a failed validation:

import { string } from "@corets/schema"

const schema = string().min(3).alphaNumeric()
const errors = schema.validate("foo-bar")

if ( ! errors) {
    // continue ...
}

This is what the validation result might look like:

{  
    "field": ["first error", "second error"],  
    "nested.field": ["first error", "second error"],
}

When validating anything but an object, you'll find all the error messages under the key self.

Schema.verify()

Example of a failed validation:

import { string } from "@corets/schema"

const errors = string().min(10).verify("foo")

Here is an example of how the error messages would look like:

[  
    {    
        "type": "string_min",    
        "message": "Must be at least \"2\" characters long",    
        "args": [10],    
        "value": "foo",    
        "link": undefined,    
        "path": undefined  
    }
]

Schema.sanitize()

This method applies sanitizers and returns the sanitized value:

import { string } from "@corets/schema"

const schema = string().toTrimmed().toCamelCase()
const value = schema.sanitize("  foo bar  ")

Schema.sanitizeAndTest()

Example of a successful test with sanitizers:

import { string } from "@corets/schema"

const schema = string().min(4).toCamelCase()
const [valid, value] = schema.sanitizeAndTest("foo bar")

Example of a failed test with sanitizers:

import { string } from "@corets/schema"

const schema = string().min(4).toTrimmed()
const [valid, value] = schema.sanitizeAndTest("  foo  ")

As you can see, even though the string " foo " has a length greater than 4. During the sanitization, value gets trimmed, becomes"foo" and therefore the test will fail.

Schema.sanitizeAndValidate()

Example of a successful validation with sanitizers:

import { string } from "@corets/schema"

const schema = string().min(4).toCamelCase()
const [errors, value] = schema.sanitizeAndValidate("foo bar")

Example of a failed validation with sanitizers:

import { string } from "@corets/schema"

const schema = string().min(4).toTrimmed()
const [errors, value] = schema.sanitizeAndValidate("  foo  ")

This is what the errors would look like:

{  
    "self": ["Must be at least \"4\" characters long"],
}

Schema.sanitizeAndVerify()

Schema.testAsync()

This library has no async validation or sanitization methods itself, but you can add your own.

Schema.validateAsync()

This library has no async validation or sanitization methods itself, but you can add your own.

Schema.verifyAsync()

This library has no async validation or sanitization methods itself, but you can add your own.

Schema.sanitizeAsync()

This library has no async validation or sanitization methods itself, but you can add your own.

Schema.sanitizeAndTestAsync()

This library has no async validation or sanitization methods itself, but you can add your own.

Schema.sanitizeAndValidateAsync()

This library has no async validation or sanitization methods itself, but you can add your own.

Schema.sanitizeAndVerifyAsync()

This library has no async validation or sanitization methods itself, but you can add your own.

Schema.also()

Connects multiple schemas or attaches a custom validation function to a schema. Connections made with this link are invoked regardless of the status of the parent schema. This is perfect when you try to combine multiple schemas or attach a custom validation function to a schema to make it behave like one single unit.

import { string } from "@corets/schema"

const usernameSchema = string().alphaNumeric()
const advancedUsernameSchema = string().min(3).max(20).also(usernameSchema)
const uniqueUsernameSchema = advancedUsernameSchema.also(
    async (v) => await isUsernameTaken(v) && "Username already taken"
)

Schema.and()

Logically connects multiple schemas, or a custom validation function to a schema. Schemas and validation functions connected using this link will only be executed if the parent schema validated successfully. This is a good way to connect expensive validation logic, like a database call, and make sure that it is only invoked when it's really necessary.

import { string } from "@corets/schema"

const usernameSchema = string().alphaNumeric()
const advancedUsernameSchema = string().min(3).max(20).and(usernameSchema)
const uniqueUsernameSchema = advancedUsernameSchema.and(
    async (v) => await isUsernameTaken(v) && "Username already taken"
)

Schema.or()

Logically connects multiple schemas, or a custom validation function to a schema. Schemas and validation functions connected using this link will only be executed if the parent schema validation has failed. This is useful if you want to provide an alternative validation procedure.

import { string } from "@corets/schema"

const usernameOrEmail = string()
    .alphaNumeric().min(3).max(20)
    .or(v => v.includes("@") && string().email())

Schema.map()

Attach a custom sanitizer function to a schema.

import { mixed } from "@corets/schema"

mixed().map(v => v.toString())

schema()

This factory is used as a central entry point to create any kind of schema by providing the default value first.

import { schema } from "@corets/schema"

const stringSchema = schema("foo").string()

The example above is equivalent to this:

import { string } from "@corets/schema"

const schema = string().toDefault("foo")

Defining a default value is optional, but might be useful when validating forms.

schema.string()

import { schema } from "@corets/schema"

schema("foo").string()

schema.number()

import { schema } from "@corets/schema"

schema(123).number()

schema.boolean()

import { schema } from "@corets/schema"

schema(true).boolean()

schema.date()

import { schema } from "@corets/schema"

schema(new Date()).date()

schema.array()

import { schema } from "@corets/schema"

schema(["foo"]).array()

schema.object()

import { schema } from "@corets/schema"

schema({ foo: "bar" }).object()

schema.mixed()

import { schema } from "@corets/schema"

schema("foo").mixed()

string()

Contains various validators and sanitisers for strings:

import { string } from "@corets/schema"

string()

Create a schema instance without the factory function:

import { StringSchema } from "@corets/schema"

new StringSchema()

string.required()

Value must be a non-empty string:

import { string } from "@corets/schema"

string().required()
string().required(true, "Message")
string().required(() => true, () => "Message")

string.optional()

import { string } from "@corets/schema"

string().optional()
string().optional("Message")
string().optional(() => "Message")

string.equals()

String must be equal to the given value:

import { string } from "@corets/schema"

string().equals("foo")
string().equals("foo", "Message")
string().equals(() => "foo", () => "Message")

string.length()

String must have an exact length:

import { string } from "@corets/schema"

string().length(3)
string().length(3, "Message")
string().length(() => 3, () => "Message")

string.min()

String must not be shorter than given value:

import { string } from "@corets/schema"

string().min(3)
string().min(3, "Message")
string().min(() => 3, () => "Message")

string.max()

String must not be longer than given value:

import { string } from "@corets/schema"

string().max(3)
string().max(3, "Message")
string().max(() => 3, () => "Message")

string.between()

String must have a length between min and max:

import { string } from "@corets/schema"

string().between(3, 6)
string().between(3, 6, "Message")
string().between(() => 3, () => 6, () => "Message")

string.matches()

String must match given RegExp:

import { string } from "@corets/schema"

string().matches(/^red/)
string().matches(/^red/, "Message")
string().matches(() => /^red/, () => "Message")

string.email()

String must be a valid email address:

import { string } from "@corets/schema"

string().email()
string().email("Message")
string().email(() => "Message")

string.url()

String must be a valid URL:

import { string } from "@corets/schema"

string().url()
string().url("Message")
string().url(() => "Message")

string.startsWith()

String must start with a given value:

import { string } from "@corets/schema"

string().startsWith("foo")
string().startsWith("foo", "Message")
string().startsWith(() => "foo", () => "Message")

string.endsWith()

String must end with a given value:

import { string } from "@corets/schema"

string().endsWith("foo")
string().endsWith("foo", "Message")
string().endsWith(() => "foo", () => "Message")

string.includes()

String must include a given substring:

import { string } from "@corets/schema"

string().includes("foo")
string().includes("foo", "Message")
string().includes(() => "foo", () => "Message")

string.omits()

String must not include a given substring:

import { string } from "@corets/schema"

string().omits("foo")
string().omits("foo", "Message")
string().omits(() => "foo", () => "Message")

string.oneOf()

String must be one of the whitelisted values:

import { string } from "@corets/schema"

string().oneOf(["foo", "bar"])
string().oneOf(["foo", "bar"], "Message")
string().oneOf(() => ["foo", "bar"], () => "Message")

string.noneOf()

String must not be one of the blacklisted values:

import { string } from "@corets/schema"

string().noneOf(["foo", "bar"])
string().noneOf(["foo", "bar"], "Message")
string().noneOf(() => ["foo", "bar"], () => "Message")

string.numeric()

String must contain numbers only, including floats:

import { string } from "@corets/schema"

string().numeric()
string().numeric("Message")
string().numeric(() => "Message")

string.alpha()

String must contain letters only:

import { string } from "@corets/schema"

string().alpha()
string().alpha("Message")
string().alpha(() => "Message")

string.alphaNumeric()

String must contain numbers and letters only:

import { string } from "@corets/schema"

string().alphaNumeric()
string().alphaNumeric("Message")
string().alphaNumeric(() => "Message")

string.alphaDashes()

String must contain letters and dashes - only:

import { string } from "@corets/schema"

string().alphaDashes()
string().alphaDashes("Message")
string().alphaDashes(() => "Message")

string.alphaUnderscores()

String must contain letters and underscores _ only:

import { string } from "@corets/schema"

string().alphaUnderscores()
string().alphaUnderscores("Message")
string().alphaUnderscores(() => "Message")

string.alphaNumericDashes()

String must contain letters, numbers and dashes only:

import { string } from "@corets/schema"

string().alphaNumericDashes()
string().alphaNumericDashes("Message")
string().alphaNumericDashes(() => "Message")

string.alphaNumericUnderscores()

String must contain letters, numbers and underscores only:

import { string } from "@corets/schema"

string().alphaNumericUnderscores()
string().alphaNumericUnderscores("Message")
string().alphaNumericUnderscores(() => "Message")

string.date()

String must be a valid ISO date string:

import { string } from "@corets/schema"

string().date()
string().date("Message")
string().date(() => "Message")

string.dateBefore()

String must be a valid ISO date string before the given date:

import { string } from "@corets/schema"

string().dateBefore(new Date())
string().dateBefore(new Date(), "Message")
string().dateBefore(() => new Date(), () => "Message")

string.dateBeforeOrEqual()

import { string } from "@corets/schema"

string().dateBeforeOrEqual(new Date())
string().dateBeforeOrEqual(new Date(), "Message")
string().dateBeforeOrEqual(() => new Date(), () => "Message")

string.dateAfter()

String must be a valid ISO date string after the given date:

import { string } from "@corets/schema"

string().dateAfter(new Date())
string().dateAfter(new Date(), "Message")
string().dateAfter(() => new Date(), () => "Message")

string.dateAfterOrEqual()

import { string } from "@corets/schema"

string().dateAfterOrEqual(new Date())
string().dateAfterOrEqual(new Date(), "Message")
string().dateAfterOrEqual(() => new Date(), () => "Message")

string.dateBetween()

String must be a valid ISO date string between the two given dates:

import { string } from "@corets/schema"

string().dateBetween(new Date(), new Date())
string().dateBetween(new Date(), new Date(), "Message")
string().dateBetween(() => new Date(), () => new Date(), () => "Message")

string.dateBetweenOrEqual()

import { string } from "@corets/schema"

string().dateBetweenOrEqual(new Date(), new Date())
string().dateBetweenOrEqual(new Date(), new Date(), "Message")
string().dateBetweenOrEqual(() => new Date(), () => new Date(), () => "Message")

string.time()

String must be a valid ISO time string:

import { string } from "@corets/schema"

string().time()
string().time("Message")
string().time(() => "Message")

string.timeBefore()

String must be a valid time string before the given time:

import { string } from "@corets/schema"

string().timeBefore("10:00")
string().timeBefore("10:00", "Message")
string().timeBefore(() => "10:00", () => "Message")

string.timeBeforeOrEqual()

import { string } from "@corets/schema"

string().timeBeforeOrEqual("10:00")
string().timeBeforeOrEqual("10:00", "Message")
string().timeBeforeOrEqual(() => "10:00", () => "Message")

string.timeAfter()

String must be a valid time string after the given time:

import { string } from "@corets/schema"

string().timeAfter("10:00")
string().timeAfter("10:00", "Message")
string().timeAfter(() => "10:00", () => "Message")

string.timeAfterOrEqual()

import { string } from "@corets/schema"

string().timeAfterOrEqual("10:00")
string().timeAfterOrEqual("10:00", "Message")
string().timeAfterOrEqual(() => "10:00", () => "Message")

string.timeBetween()

String must be a valid time string between the two given times:

import { string } from "@corets/schema"

string().timeBetween("10:00", "15:00")
string().timeBetween("10:00", "15:00", "Message")
string().timeBetween(() => "10:00", () => "15:00", () => "Message")

string.timeBetweenOrEqual()

import { string } from "@corets/schema"

string().timeBetweenOrEqual("10:00", "15:00")
string().timeBetweenOrEqual("10:00", "15:00", "Message")
string().timeBetweenOrEqual(() => "10:00", () => "15:00", () => "Message")

string.dateTime()

String must be a valid ISO date time string:

import { string } from "@corets/schema"

string().dateTime()
string().dateTime("Message")
string().dateTime(() => "Message")

string.toDefault()

Provide a fallback value in case the underlying value is not a string:

import { string } from "@corets/schema"

string().toDefault("default value")
string().toDefault("default value")
string().toDefault(() => "default value")

string.toUpperCase()

Convert string to all upper case:

import { string } from "@corets/schema"

string().toUpperCase()

string.toLowerCase()

Convert string to all lower case:

import { string } from "@corets/schema"

string().toLowerCase()

string.toCapitalized()

Capitalize first letter:

import { string } from "@corets/schema"

string().toCapitalized()

string.toCamelCase()

Convert string to camelCase:

import { string } from "@corets/schema"

string().toCamelCase()

string.toSnakeCase()

Convert string to snake_case:

import { string } from "@corets/schema"

string().toSnakeCase()

string.toKebabCase()

Convert string to kebab-case:

import { string } from "@corets/schema"

string().toKebabCase()

string.toConstantCase()

Convert string to CONSTANT_CASE:

import { string } from "@corets/schema"

string().toConstantCase()

string.toTrimmed()

Trim surrounding whitespace:

import { string } from "@corets/schema"

string().toTrimmed()

number()

Contains various validators and sanitizers for numbers:

import { number } from "@corets/schema"

number()

Create a schema instance without the factory function:

import { NumberSchema } from "@corets/schema"

new NumberSchema()

number.required()

Value must be a number:

import { number } from "@corets/schema"

number().required()
number().required("Message")
number().required(() => false, () => "Message")

number.optional()

import { number } from "@corets/schema"

number().optional()
number().optional("Message")
number().optional(() => "Message")

number.equals()

Number must be equal to the given value:

import { number } from "@corets/schema"

number().equals(3)
number().equals(3, "Message")
number().equals(() => 3, () => "Message")

number.min()

Number must not be smaller than the given value:

import { number } from "@corets/schema"

number().min(5)
number().min(5, "Message")
number().min(() => 5, () => "Message")

number.max()

Number must not be bigger than the given value:

import { number } from "@corets/schema"

number().max(10)
number().max(10, "Message")
number().max(() => 10, () => "Message")

number.between()

Number must be between the two given numbers:

import { number } from "@corets/schema"

number().between(5, 10)
number().between(5, 10, "Message")
number().between(() => 5, () => 10, () => "Message")

number.between()

Number must be positive - bigger than zero:

import { number } from "@corets/schema"

number().positive()
number().positive("Message")
number().positive(() => "Message")

number.negative()

Number must be negative:

import { number } from "@corets/schema"

number().negative()
number().negative("Message")
number().negative(() => "Message")

number.integer()

Number must be an integer:

import { number } from "@corets/schema"

number().integer()
number().integer("Message")
number().integer(() => "Message")

number.oneOf()

Number must be one of the whitelisted values:

import { number } from "@corets/schema"

number().oneOf([10, 20])
number().oneOf([10, 20], "Message")
number().oneOf(() => [10, 20], () => "Message")

number.noneOf()

Number must not be one of the blacklisted values:

import { number } from "@corets/schema"

number().noneOf([10, 20])
number().noneOf([10, 20], "Message")
number().noneOf(() => [10, 20], () => "Message")

number.toDefault()

Default value in case the underlying value is not a number:

import { number } from "@corets/schema"

number().toDefault(10)
number().toDefault(() => 10)

number.toRounded()

import { number } from "@corets/schema"

const precision = 2

number().toRounded()
number().toRounded(precision)
number().toRounded(() => precision)

number.toFloored()

import { number } from "@corets/schema"

const precision = 2

number().toFloored()
number().toFloored(precision)
number().toFloored(() => precision)

number.toCeiled()

import { number } from "@corets/schema"

const precision = 2

number().toCeiled()
number().toCeiled(precision)
number().toCeiled(() => precision)

number.toTrunced()

import { number } from "@corets/schema"

number().toTrunced()

boolean()

Contains various validators and sanitizers for booleans:

import { boolean } from "@corets/schema"

boolean()

Create a schema instance without the factory function:

import { BooleanSchema } from "@corets/schema"

new BooleanSchema()

boolean.required()

Value must be a boolean:

import { boolean } from "@corets/schema"

boolean().required()
boolean().required(false, "Message")
boolean().required(() => false, () =>"Message")

boolean.optional()

import { boolean } from "@corets/schema"

boolean().optional()
boolean().optional("Message")
boolean().optional(() => "Message")

boolean.equals()

Number must be equal to the given value:

import { boolean } from "@corets/schema"

boolean().equals(true)
boolean().equals(true, "Message")
boolean().equals(() => true, () => "Message")

boolean.toDefault()

Provide a fallback value in case the underlying value is not a boolean:

import { boolean } from "@corets/schema"

boolean().toDefault(true)
boolean().toDefault(() => true)

date()

Contains various validators and sanitizers for dates:

import { date } from "@corets/schema"

date()

Create a schema instance without the factory function:

import { DateSchema } from "@corets/schema"

new DateSchema()

date.required()

Value must be a date:

import { date } from "@corets/schema"

date().required()
date().required(false, "Message")
date().required(() => false, () => "Message")

date.optional()

import { date } from "@corets/schema"

date().optional()
date().optional("Message")
date().optional(() => "Message")

date.equals()

Date must be equal to the given value:

import { date } from "@corets/schema"

date().equals(new Date())
date().equals(new Date(), "Message")
date().equals(() => new Date(), () => "Message")

date.after()

Underlying value must be after the given date:

import { date } from "@corets/schema"

date().after(new Date())
date().after(new Date(), "Message")
date().after(() => new Date(), () => "Message")

date.before()

Underlying value must be before the given date:

import { date } from "@corets/schema"

date().before(new Date())
date().before(new Date(), "Message")
date().before(() => new Date(), () => "Message")

date.between()

Underlying value must be between the two dates:

import { date } from "@corets/schema"

date().between(new Date(), new Date())
date().between(new Date(), new Date(), "Message")
date().between(() => new Date(), () => new Date(), () => "Message")

date.toDefault()

Provide a fallback value in case the underlying value is not a date:

import { date } from "@corets/schema"

date().toDefault(new Date())
date().toDefault(new Date(), "Message")
date().toDefault(() => new Date(), () => "Message")

array()

Contains various validators and sanitizers for arrays:

import { array, string } from "@corets/schema"

array()

Create a schema instance without the factory function:

import { ArraySchema } from "@corets/schema"

new ArraySchema()

Create an array schema with a separate schema for its children:

import { array, string } from "@corets/schema"

array(string().min(2))

array.required()

Value must be an array:

import { array } from "@corets/schema"

array().required()
array().required(false, "Message")
array().required(() => false, () => "Message")

array.optional()

import { array } from "@corets/schema"

array().optional()
array().optional("Message")
array().optional(() => "Message")

array.equals()

Array must be equal to the given value:

import { array } from "@corets/schema"

array().equals([1, 2])
array().equals([1, 2], "Message")
array().equals(() => [1, 2], () => "Message")

array.length()

Array must have an exact length:

import { array } from "@corets/schema"

array().length(3)
array().length(3, "Message")
array().length(() => 3, () => "Message")

array.min()

Array must not be shorter than the given length:

import { array } from "@corets/schema"

array().min(3)
array().min(3, "Message")
array().min(() => 3, () => "Message")

array.max()

Array must not be longer than the given length:

import { array } from "@corets/schema"

array().max(3)
array().max(3, "Message")
array().max(() => 3, () => "Message")

array.between()

Array must have a length between the two given values:

import { array } from "@corets/schema"

array().between(3, 5)
array().between(3, 5, "Message")
array().between(() => 3, () => 5, () => "Message")

array.someOf()

Array must only contain whitelisted values:

import { array } from "@corets/schema"

array().someOf([3, 4])
array().someOf([3, 4], "Message")
array().someOf(() => [3, 4], () => "Message")

array.noneOf()

Array must not contain any of the blacklisted values:

import { array } from "@corets/schema"

array().noneOf([3, 4])
array().noneOf([3, 4], "Message")
array().noneOf(() => [3, 4], () => "Message")

array.shape()

Specify a schema for array children, every item must be valid according to the given schema:

import { array, string } from "@corets/schema"

array().shape(string().min(3))
array().shape(() => string().min(3))
import { array, string } from "@corets/schema"

array(string().min(3))
array(() => string().min(3))

array.toDefault()

Provide a default value in case the underlying value is not an array:

import { array } from "@corets/schema"

array().toDefault([1, 2])
array().toDefault(() => [1, 2])

array.toFiltered()

Filter out invalid array items manually:

import { array } from "@corets/schema"

const isString = (value) => typeof value === "string"

array().toFiltered(isString)

array.toMapped()

Map every array item manually:

import { array } from "@corets/schema"

const toUpperCase = (value) => typeof value === "string" 
    ? value.toUpperCase() 
    : value

array().toMapped(toUpperCase)

array.toCompact()

Filter out all falsey values like null, undefined, "" and 0:

import { array } from "@corets/schema"

array().toCompact()

array.toUnique()

Filter out all duplicate values:

import { array } from "@corets/schema"

array().toUnique()

object()

Contains various validators and sanitizers for objects:

import { object, string } from "@corets/schema"

object()

Create a schema instance without the factory function:

import { ObjectSchema } from "@corets/schema"

new ObjectSchema()

Create an object schema with a separate schema for each property:

import { object, string } from "@corets/schema"

object({
    foo: string().min(2)
})

object.required()

Value must be an object:

import { object } from "@corets/schema"

object().required()
object().required(false, "Message")
object().required(() => false, () => "Message")

object.optional()

import { object } from "@corets/schema"

object().optional()
object().optional("Message")
object().optional(() => "Message")

object.equals()

Underlying value must be equal to the given value:

import { object } from "@corets/schema"

object().equals({foo: "bar"})
object().equals({foo: "bar"}, "Message")
object().equals(() => {foo: "bar"}, () => "Message")

object.shape()

Shape an object and set up schemas for all of its properties:

import { object, string } from "@corets/schema"

object().shape({
    firstName: string().min(3).max(20) 
})
import { object, string } from "@corets/schema"

object({ 
    firstName: string().min(3).max(20) 
})

object.allowUnknownKeys()

import { object, string } from "@corets/schema"

object({ 
    firstName: string().min(3).max(20) 
}).allowUnknownKeys()

object.forbidUnknownKeys()

import { object, string } from "@corets/schema"

object({ 
    firstName: string().min(3).max(20) 
}).forbidUnknownKeys()

object.shapeUnknownKeys()

Shape unknown object keys to make sure they adhere to a certain standard:

import { object, string } from "@corets/schema"

object({ 
    firstName: string().min(3).max(20) 
}).shapeUnknownKeys(string().min(3).toCamelCase())

object.shapeUnknownValues()

Shape unknown object values to make sure they adhere to a standard:

import { object, string } from "@corets/schema"

object({ 
    firstName: string().min(3).max(20) 
}).shapeUnknownValues(string().min(3).max(20))

object.toDefault()

Provide a fallback value in case the underlying value is not an object:

import { object } from "@corets/schema"

object().toDefault({ title: "Foo" })
object().toDefault(() => ({ title: "Foo" }))

object.toCamelCaseKeys()

Transform all object keys to camelCase:

import { object } from "@corets/schema"

object().toCamelCaseKeys()
// disable deep mapping
object().toCamelCaseKeys(false)

object.toSnakeCaseKeys()

Transform all object keys to snake_case:

import { object } from "@corets/schema"

object().toSnakeCaseKeys()
// disable deep mapping
object().toSnakeCaseKeys(false)

object.toKebabCaseKeys()

Transform all object keys to kebab-case:

import { object } from "@corets/schema"

object().toKebabCaseKeys()
// disable deep mapping
object().toKebabCaseKeys(false)

object.toConstantCaseKeys()

Transform all object keys to CONSTANT_CASE:

import { object } from "@corets/schema"

object().toConstantCaseKeys()
// disable deep mapping
object().toConstantCaseKeys(false)

object.toMappedValues()

Transform all object values:

import { object } from "@corets/schema"

object().toMappedValues((value, key) => value)
// disable deep mapping
object().toConstantCaseKeys(false)

object.toMappedKeys()

Transform all object keys:

import { object } from "@corets/schema"

object().toMappedKeys((value, key) => key)
// disable deep mapping
object().toMappedKeys((value, key) => key, false)

mixed()

Contains various validators and sanitizers for mixed data types:

import { mixed } from "@corets/schema"

mixed()

Create a schema instance without the factory function:

import { MixedSchema } from "@corets/schema"

new MixedSchema()

mixed.required()

Value must not be null nor undefined:

import { mixed } from "@corets/schema"

mixed().required()
mixed().required(false, "Message")
mixed().required(() => false, () => "Message")

mixed.optional()

import { mixed } from "@corets/schema"

mixed().optional()
mixed().optional("Message")
mixed().optional(() => "Message")

mixed.equals()

Underlying value must be equal to the given value:

import { mixed } from "@corets/schema"

mixed().equals("yolo")
mixed().equals("yolo", "Message")
mixed().equals(() => "yolo", () => "Message")

mixed.oneOf()

Underlying value must be one of the whitelisted values:

import { mixed } from "@corets/schema"

mixed().oneOf(["foo", "bar"])
mixed().oneOf(["foo", "bar"], "Message")
mixed().oneOf(() => ["foo", "bar"], () => "Message")

mixed.noneOf()

Underlying value must not be one of the blacklisted values:

import { mixed } from "@corets/schema"

mixed().noneOf(["foo", "bar"])
mixed().noneOf(["foo", "bar"], "Message")
mixed().noneOf(() => ["foo", "bar"], () => "Message")

mixed.toDefault()

Provide a fallback value in case the underlying value is null or undefined:

import { mixed } from "@corets/schema"

mixed().toDefault("foo")
mixed().toDefault("foo", "Message")
mixed().toDefault(() => "foo", () => "Message")

There are two ways to run validations. For simple things like one-liners where you simply want to know if a value matches certain criteria, and get a true or false as result, you can use the method. For proper validation, with error messages instead of a simple true / false, you can use the method.

Sanitization methods are called before validation and are used to normalise the underlying values. For example, you can ensure that a string is capitalised and all object keys are camel-cased. Sanitization can help you reduce the number of validation errors by proactively fixing them in the first place. All sanitization methods start with the prefix to, for example: , .

Schemas can be logically linked together using methods , and . A relation will only be executed if the parent schema, that it is linked to, could validate successfully. A relation will only execute if the parent schema failed, the alternative schema will be attempted instead. A relation will execute regardless of the validation status of the parent schema.

Example of a relation, this schema will first ensure that the value is a string, and only if the first validation passes, it will test if the value is a numeric string:

Example of a relation, this schema will first check if the value is a number, and only if it's not, it will test if that value is a numeric string:

Example of an relation, this schema will execute both parts regardless of the validation outcome of the parent schema:

Methods , and do not always have to return another schema. They can be used for your custom validation functions. A custom validation function can return either another schema, a validation result, or an error message.

You can add a custom sanitizer with the method , here is an example of a sanitizer that converts everything to a string:

You can find all locales . For further examples of how to replace translations, add new languages, etc., please have a look at the docs.

This method works the same as , except it returns errors in a slightly different format. This format contains additional information about each error message and can be used for further processing of validation errors.

All sanitization methods start with the prefix to, for example: .

This method applies sanitizers on the underlying value and runs validation against the sanitized version. It returns a boolean indicating whether the value is valid, and the sanitized version of the value. Basically this calls the methods and sequentially.

All sanitization methods start with the prefix to, for example: .

This method applies sanitizers on the underlying value and runs validation against the sanitized version. It returns a validation result containing detailed error messages about why a value did not pass validation, and the sanitized version of the value. Basically this calls the methods and sequentially.

This method works exactly the same as except that it returns error messages in a different format with additional information that can be used for further processing. Take a look at to learn more about its use cases.

All sanitization methods start with the prefix to, for example: .

This is an async version of the method, that allows you to use async validators and sanitizers.

This is an async version of the method, that allows you to use async validators.

This is an async version of the method, that allows you to use async validators.

This is an async version of the method, that allows you to use async sanitizers.

This is an async version of the method, that allows you to use async validators and sanitizers.

This is an async version of the method, that allows you to use async validators and sanitizers.

This is an async version of the method, that allows you to use async validators and sanitizers.

See also for more examples.

See also and for more examples.

See also and for more examples.

See also for more examples.

Create a new schema starting with the default value:

Create a new schema starting with the default value:

Create a new schema starting with the default value:

Create a new schema starting with the default value:

Create a new schema starting with the default value:

Create a new schema starting with the default value:

Create a new schema starting with the default value:

Value might be a string, opposite of :

Similar to , but allows dates to be equal:

Similar to , but allows dates to be equal:

Similar to , but allows dates to be equal:

Similar to , but allows times to be equal:

Similar to , but allows times to be equal:

Similar to , but allows times to be equal:

Value might be a number, opposite of :

Round value using :

Round value using :

Round value using :

Trunc value using (drops everything after the decimal point):

Value might be a boolean, opposite of :

Value might be a date, opposite of :

Value might be a array, opposite of :

You can pass a shape directly to the method too:

Value might be an object, opposite of :

You can pass a shape directly to the method too:

Allow object to contain keys that have not been configured through :

Forbid object to contain keys that have not been configured through :

Value might als be a null or undefined, opposite of :

GitHub
Form
Translator
here
@corets/translator
lodash.round()
lodash.floor()
lodash.ceil()
Math.trunc()
Schema.test()
Schema.validate()
string.toTrimmed()
string.toCamelCase()
Schema.and()
Schema.or()
Schema.also()
Schema.and()
Schema.or()
Schema.also()
Schema.and()
Schema.or()
Schema.also()
Schema.and()
Schema.or()
Schema.also()
Schema.map()
Schema.validate()
string.toTrimmed()
Schema.sanitize()
Schema.test()
string.toTrimmed()
Schema.sanitize()
Schema.validate()
Schema.anitizeAndValidate()
Schema.verify()
string.toTrimmed()
Schema.test()
Schema.validate()
Schema.verify()
Schema.sanitize()
Schema.sanitizeAndTest()
Schema.sanitizeAndValidate()
Schema.sanitizeAndVerify()
custom validations
custom validations
conditional validations
custom validations
conditional validations
custom sanitizers
string()
number()
boolean()
date()
array()
object()
mixed()
string.required()
string.dateBefore()
string.dateAfter()
string.dateBetween()
string.timeBefore()
string.timeAfter()
string.timeBetween()
number.required()
boolean.required()
date.required()
array.required()
array()
object.required()
object()
object.shape()
object.shape()
mixed.required()