Validating form values is an important step in ensuring the integrity and accuracy of the data being collected. One popular tool for this task is Joi, a JavaScript object schema validation library. With Joi, you can define a schema for your form values and then validate user input against that schema.

To use Joi, you first need to install it using npm:

npm install joi

Schema

Once installed, you can import Joi into your JavaScript code and use it to define a schema for your form values. For example, if your form has a field for a user's name, you could define a schema that requires the value to be a non-empty string:

const Joi =require('joi');

const schema = Joi.object({
    name: Joi.string().required()
});

Validation

You can then use the schema to validate user input. For example, the following code checks if the user's input for the name field is valid according to the schema:

const { error } = schema.validate({name:'John Doe'});

if(error){
    // The user's input for the name field is not valid
}

Joi offers a wide range of options for defining and validating your form values. For example, you can specify the minimum and maximum length of a string, the minimum and maximum value of a number, or the presence of specific characters in a string. You can also specify that certain fields are required, or that they must match a specific pattern.

Required

You can make an email required as follows:

const schema = Joi.object({
    email: Joi.string().required()
});

Of course, you need to validate it afterward as we did above. Let's just see the code anyways.

const { error } = schema.validate({email:'john@example.com'});

if(error){
    // The user's input for the email field is not valid
}

Optional

o specify that a field is optional in a Joi schema, you can use the optional method. This method allows a value to be either provided or left undefined.

For example, if your form has a field for a user's phone number, you could define a schema that allows the value to be either a string or undefined:

const schema = Joi.object({
    phone: Joi.string().optional()
});

You can then use the schema to validate user input. For example, the following code checks if the user's input for the phone field is valid according to the schema:

const { error } = schema.validate({phone:'123-456-7890'});

if(error){
    // The user's input for the phone field is not valid
}

If the user does not provide a value for the phone field, the validation will still pass, since the field is optional according to the schema.

In addition to the optional method, Joi also provides the allow method, which allows you to specify a list of specific values that are considered valid for an optional field. For example, you could use the allow method to specify that an optional field can only be null or undefined:

const schema = Joi.object({
    phone: Joi.string().allow(null,undefined)
});

This can be useful for cases where you want to explicitly differentiate between a field that has been left empty and a field that has been explicitly set to a null or undefined value.

Min and max

To specify a minimum or maximum value for a field in a Joi schema, you can use the min and max methods. These methods allow you to specify the minimum and maximum allowed values for a field, respectively.

For example, if your form has a field for a user's age, you could define a schema that requires the value to be a number between 18 and 99:

const schema = Joi.object({
    age: Joi.number().min(18).max(99)
});

You can then use the schema to validate user input. For example, the following code checks if the user's input for the age field is valid according to the schema:

const { error } = schema.validate({age:25});

if(error){
    // The user's input for the age field is not valid
}

In addition to the min and max methods, Joi also provides the greater and less methods, which allow you to specify a minimum or maximum value, respectively, that a field must be strictly greater or less than.

For example, you could use the greater and less methods to specify that a field must be a number strictly greater than 0 and strictly less than 100:

const schema = Joi.object({
    age: Joi.number().greater(0).less(100)
});

These methods can be useful for defining more precise and specific constraints on the values allowed for a field in your form.

Check the presence of specific character

To check for the presence of specific characters in a string field in a Joi schema, you can use the regex method. This method allows you to specify a regular expression that the value must match in order to be considered valid.

For example, if your form has a field for a user's password, you could define a schema that requires the value to contain at least one lowercase letter, one uppercase letter, and one number:

const schema = Joi.object({
    password: Joi.string().regex(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$/)
});

You can then use the schema to validate user input. For example, the following code checks if the user's input for the password field is valid according to the schema:

const{ error }= schema.validate({password:'p@ssw0rd'});

if(error){
    // The user's input for the password field is not valid
}

The regex a method is a powerful tool for defining complex constraints on the values allowed for a field in your form. You can use it to check for the presence of specific characters, patterns, or combinations of characters in a string value.

Conclusion

By using Joi to validate your form values, you can ensure that the data you collect is accurate and reliable. This can be especially important when working with sensitive data, such as personal information or financial transactions.