joi
Extend
Extend
Purpose:
Extend lets you create custom validation functions that can be used in your schemas.
Explanation:
Imagine you have a specific rule that you need to apply to many different fields in your schema. Instead of writing the same rule over and over, you can create a custom validation function and use it wherever you need it.
Syntax:
Explanation:
The
extendfunction takes a callback function that returns an object with the following properties:type: The type of validation function you're creating (e.g.,string,number,custom).base: The base Joi type that your custom validation extends (e.g.,joi.string(),joi.number())messages: Custom error messages to use for this validation.validate: The actual validation logic.
Example:
Let's create a custom validation function to check if a value is a valid email address:
Real-World Example:
Suppose you have a registration form with a field for the user's name and email address. You can use the extend function to create custom validation rules for both of these fields:
This way, you can ensure that the user's name is not empty and that their email address is valid, without having to write the same validation rules twice.
Objects
Objects
In Node.js, objects are like containers that can hold data of different types. Think of them as boxes that can store anything from strings to numbers to even other objects. Objects are created using curly braces, { }, like this:
Here's a breakdown of each property in the person object:
name: A string holding the name of the person.
age: A number representing the age of the person.
pets: An array of strings holding the names of the person's pets.
Accessing Object Properties
To access the data stored in an object, we use the dot notation (.) or bracket notation ([]):
Both methods work the same, but bracket notation is useful when the property name contains spaces or special characters.
Adding and Removing Properties
We can add new properties to an object using the dot or bracket notation, followed by the assignment operator (=):
To remove a property, we use the delete keyword:
Object Methods
In addition to properties, objects can also contain methods, which are like functions that can operate on the object's data. Methods are defined using the function keyword, followed by the method name and parentheses:
In the above example, drive is a method of the car object that logs a message when called.
Real-World Applications
Objects are widely used in Node.js applications to represent various kinds of data:
User profiles for authentication and authorization.
Product catalogs for e-commerce websites.
Data structures for storing and organizing complex data.
Configuration settings for applications and services.
Required
Required in Joi
Concept:
Required means that a field must have a non-null value when validating data.
Usage:
To mark a field as required, use the .required() method:
Example:
Output:
Potential Applications:
Ensuring that critical information is always provided.
Enforcing consistency in data formats.
Preventing incomplete or invalid data from being stored or processed.
Custom Error Messages:
You can customize the error message for required fields using the .messages() method:
Output:
Best Practices
Best Practices for Using Joi
1. Validate Input Early and Often
Check user input as soon as possible, ideally in the request handler.
This helps catch errors early and prevent them from propagating through the code.
Example:
2. Use Strict Mode
Turn on Joi's strict mode to prevent unexpected behavior.
This will throw an error if any unvalidated properties are found in the input.
Example:
3. Handle Validation Errors Gracefully
Provide clear and user-friendly error messages.
Return a consistent HTTP status code, such as 400 (Bad Request).
Example:
4. Use Custom Error Messages
Customize error messages to provide more context and help users fix errors.
Example:
5. Validate Arrays and Objects
Use Joi's array and object schemas to check the structure and contents of complex data.
Example Array Validation:
Example Object Validation:
Potential Applications:
Form validation in web applications
Data validation in APIs and microservices
Input sanitization to prevent malicious attacks
Data integrity checks in databases and document stores
Arrays
Arrays in Node.js Joi
Joi is a library for validating JavaScript objects. It provides a variety of validation methods, including those for arrays.
Required Arrays
To validate that an array is required, use the .required() method.
Optional Arrays
To validate that an array is optional, use the .optional() method.
Array Length
To validate the length of an array, use the .length() method.
Array Elements
To validate the elements of an array, use the .elements() method.
Real-World Example
Consider a shopping cart application. A shopping cart can contain multiple items, so we can model the shopping cart using an array of items.
This schema ensures that the shopping cart contains only valid items. Each item must have a name and a quantity.
Preferences
Preferences
What are Preferences?
Preferences are like a list of rules that tell your code how to behave. They can be used to validate data, convert values, or format output.
Types of Preferences
There are different types of preferences, each with its own purpose:
String preferences validate and manipulate strings.
Number preferences validate and manipulate numbers.
Date preferences validate and manipulate dates.
Object preferences validate and manipulate objects.
How to Use Preferences
To use a preference, you create an object like this:
The schema object above contains a single preference, which validates that the name property is a string with a length between 3 and 20 characters.
Real-World Applications
Preferences can be used in a variety of real-world applications, including:
Validating data from web forms
Converting values from one format to another
Formatting output for display
Example
Here's an example of how to use preferences to validate data from a web form:
In this example, the schema object contains a preference that validates that the name property is a string with a length between 3 and 20 characters. The data object contains a name property with the value 'John'. The schema.validate() method is used to validate the data against the schema. If the data is valid, the error object will be null. Otherwise, the error object will contain a list of error messages.
Schema
Schema Explained
What is a Schema?
Imagine a Schema as a blueprint for your data. It defines how your data should look, kind of like a recipe. It makes sure your data is consistent and structured, which is important for computers to understand it.
Basic Types:
String: Text data, like your name or address.
Number: Numeric data, like your age or balance.
Boolean: True or false values, like whether you're a student.
Date: Dates and times, like your birthday.
Advanced Types:
Object: A collection of key-value pairs, like a dictionary.
Array: A list of values, like your grocery list.
Mixed: Can be any type, useful when you're not sure.
Validation:
Schemas can also check if your data meets certain rules, like:
Required: Ensure fields are not empty.
Min: Set a minimum value for numbers.
Max: Set a maximum value for numbers.
Pattern: Check if a string matches a specific pattern.
Example:
Real-World Applications:
User Registration: Ensure that all required fields are filled in and data is valid.
Data Processing: Validate and normalize data before analysis or storage.
API Design: Define the format of data sent and received by your API.
Form Validation: Check user input on web forms before submitting it.
Benefits of Using Schemas:
Consistent Data: Ensures data is structured and formatted correctly.
Error Prevention: Catches errors early on, reducing chances of data corruption.
Simplifies Development: Provides a clear understanding of data expectations.
Improved Data Quality: Validated data improves the reliability and accuracy of your analyses and decisions.
Optional
Optional
In Node.js's Joi library, the optional() method allows you to define a schema property as optional, meaning that it doesn't have to be provided in the input data to be validated.
Simplified Explanation:
Think of it like a checkbox that you can leave unchecked. You don't have to fill in the optional field, but if you do, the value must still match the defined schema.
Code Example:
In this example, the age field is optional, so it's not present in the input data. However, if we had provided a value for age, such as:
The validation would still pass, as long as age is a number.
Applications in the Real World:
Optional properties can be useful in a variety of scenarios, such as:
Forms with optional fields that users may not always fill in
Configuration files where certain settings can be omitted
API endpoints that accept optional query parameters or request body properties
Installation
Installation
What is Node.js joi?
Node.js joi is a library that helps validate data in JavaScript applications. Validation means making sure that data is correct and matches the expected format.
Why use Node.js joi?
Using joi has several benefits:
Data integrity: Ensures that data meets certain criteria, reducing errors and bugs in your application.
Improved user experience: Provides helpful error messages to users, making it easy to fix any data issues.
Time-saving: Automates data validation, saving you time in the long run.
Installation
Using npm:
Using yarn:
Usage
Example:
Real-World Applications
User registration: Validating user input to ensure that all required information is provided and in the correct format.
Data entry forms: Ensuring that data entered into forms matches expected values, preventing errors and saving time.
API requests: Validating request payloads to ensure that the data is in the correct format and meets any security requirements.
Additional Features
Extensibility: Create custom validation rules to handle specific requirements.
Internationalization: Provides support for different languages and locales.
Integration: Works seamlessly with other popular JavaScript frameworks and libraries.
Debugging
Debugging
Imagine you're building a puzzle. You have all the pieces, but you can't quite get them to fit together. Debugging is like that. It's figuring out why your code isn't working and how to fix it.
Logging
Logging is like leaving notes for yourself (or for anyone else who might look at your code in the future). You can use log statements to track the flow of your program and see where things go wrong.
Breakpoints
Breakpoints are like pauses in your code. You can add breakpoints to stop the execution of your program at a specific point so you can inspect the values of variables and see what's happening.
Inspecting Variables
You can use the debugger keyword to stop your program at any point and inspect the values of variables.
Profiling
Profiling is a way to see how your program is performing. It can help you identify bottlenecks and areas for optimization.
Testing
Testing is a systematic way of ensuring that your code works as expected. You can write tests to verify the behavior of your code and catch bugs early on.
Applications in the Real World
Debugging is essential for any software development project. It helps you identify and fix bugs quickly, saving time and frustration.
Logging can be used to monitor the performance of a system or track down errors.
Breakpoints can help you debug complex code or identify the source of a crash.
Inspecting variables can help you understand how your code is executing and why it's not behaving as expected.
Profiling can help you optimize your code and make it more efficient.
Testing can help you catch bugs early on and ensure that your code works as intended.
Changelog
Changelog
Simplifying and Explaining the Changelog
1. Changes to the Schema Validation Process:
Simplified syntax: Made it easier to write schema definitions.
Improved error messages: Errors are now more detailed and helpful for debugging.
2. New Validation Features:
Custom validators: Allows you to create your own validation rules beyond Joi's built-in ones.
Asynchronous validation: Supports validating asynchronous data, such as data fetched from a database.
Real-World Applications
1. Simplifying Data Validation in Forms:
Using Joi's simplified syntax, you can easily define schema for form inputs.
Validation errors will be displayed clearly, guiding users to correct their input.
2. Validating API Request Bodies:
Joi allows you to validate the structure and data types of API request bodies.
This ensures that your API receives expected data and prevents unexpected errors.
3. Validating Database Records:
Joi can validate data before it is inserted into a database.
This ensures data integrity and prevents invalid or malicious data from entering.
4. Creating Custom Validation Rules:
For specialized scenarios, Joi's custom validators allow you to define your own validation logic.
This is useful for checking specific data patterns or business rules.
5. Asynchronous Validation:
Joi supports validating asynchronous data, such as data retrieved from a remote server.
This allows you to validate data without blocking your application's execution.
Complete Code Implementations
1. Form Validation with Simplified Syntax:
2. Asynchronous Validation with Custom Validator:
Introduction
Introduction to Joi
What is Joi?
Joi is a library for validating and sanitizing data in Node.js. It helps you ensure that the data you receive is in the correct format and meets certain requirements.
Why use Joi?
Validation: Joi allows you to define rules for what data is valid. This prevents you from receiving and processing invalid data, which can cause errors.
Sanitization: Joi can clean up data by removing unwanted characters or formatting it in a specific way. This ensures that your data is safe and consistent.
User-friendly: Joi provides a clear and intuitive syntax for defining validation and sanitization rules.
How does Joi work?
Joi uses schemas to define validation rules. A schema is a set of instructions that describes the expected format and content of data.
Example:
This schema defines a simple object with two properties: name and email. The name property must be a non-empty string, and the email property must be a valid email address.
Validation:
To validate data against a schema, you use the validate() method:
In this example, schema.validate(data) returns an object with two properties: error and value. If the data is valid, error will be null and value will contain the sanitized data. Otherwise, error will be an object containing details about the validation errors.
Sanitization:
Joi can also sanitize data by removing unwanted characters or formatting it in a specific way. To do this, you use the strip() method:
In this example, schema.strip(dirtyData) returns a new object with the name property trimmed of whitespace and the email property formatted without spaces.
Real-World Applications
User registration forms: Joi can be used to validate and sanitize user input on registration forms, ensuring that the data is complete and in the correct format.
API requests: Joi can be used to validate and sanitize data received from API requests, preventing invalid or malicious data from being accepted.
Data storage: Joi can be used to validate and sanitize data before it is stored in a database, ensuring data quality and consistency.
Strings
Strings are sequences of characters. In Node.js, strings are represented as objects of the String class.
1. Length:
The length property returns the number of characters in the string.
2. Concatenation:
The + operator can be used to concatenate strings.
3. Searching:
The indexOf() method returns the index of the first occurrence of a substring. If the substring is not found, it returns -1.
4. Slicing:
The slice() method extracts a substring from the string. It takes two arguments: the starting index and the ending index (optional). If the ending index is not provided, it extracts the substring from the starting index to the end of the string.
5. Trimming:
The trim() method removes leading and trailing whitespace from the string.
6. Regular Expressions:
Regular expressions can be used to search for patterns within strings.
Real-World Examples:
Validating user input: You can use strings to validate user input, such as checking if an email address is in the correct format.
Parsing JSON data: Strings can be used to parse JSON data, which is often represented as a string.
Creating HTML templates: Strings can be used to create HTML templates, which can then be rendered to generate dynamic web pages.
Internationalization: Strings can be used for internationalization, allowing you to translate your application into multiple languages.
Case Studies
Case Study: Validating User Input
Problem: You need to ensure that the data entered by users on your website or app is valid and meets certain criteria.
Solution: Use Joi to validate the user input. Joi is a library that allows you to define validation rules and check if the input data matches those rules.
Simplified Example:
Applications:
User registration forms
Payment processing
Data collection
Form submissions
Case Study: Enforcing API Contracts
Problem: You have an API that receives data in a specific format, and you need to ensure that the data is in the correct format before processing it.
Solution: Use Joi to define the expected data format and validate the incoming data against it.
Simplified Example:
Applications:
API development
Data exchange
Microservice communication
Case Study: Schema Generation
Problem: You need to create a JSON schema that defines the structure and format of a particular dataset.
Solution: Use Joi to generate a JSON schema from a given object or data sample.
Simplified Example:
Applications:
Database design
Data integration
Data documentation
Validation
Validation in Node.js with Joi
Validation is the process of ensuring that data provided by a user meets certain criteria before it is processed. Joi is a powerful library in Node.js that helps you validate data to prevent errors.
Basic Validation
To validate a simple data object, you can use the object function:
This schema validates that the name field is a required string and the age field is a required number with a minimum value of 18. If the validation fails, it will output the error message.
Custom Validation
You can also create custom validation rules using the rule function:
In this example, the custom validation rule checks if the value is equal to invalid and returns an error if it is.
Real-World Applications
Validation is essential in scenarios such as:
User input: Validating user-provided data to prevent malicious or incorrect input.
API requests: Validating request parameters to ensure they adhere to expected formats.
Database operations: Validating data before performing database operations to prevent data corruption.
Business logic: Validating data used in business logic to ensure it meets business requirements.
Conclusion
Using Joi for data validation in Node.js provides a robust way to ensure data integrity, reduce errors, and improve overall application reliability. By understanding the basics of validation and customizing it to your specific needs, you can effectively validate data and ensure its accuracy.
Code Examples
Joi is a library for validating JavaScript objects. It is commonly used for validating user input, such as request bodies and query parameters.
Installation
Usage
To use Joi, you first need to create a schema that defines the expected structure of your object. A schema is a JavaScript object that contains rules for each property of the object you want to validate.
For example, the following schema defines a user object that has a required name property and an optional email property:
Once you have created a schema, you can use it to validate an object by calling the validate() method. The validate() method returns an object that contains the validated object, any errors that were found, and a boolean indicating whether the validation was successful.
Code Examples
Validate a request body
Validate a query parameter
Real-World Applications
Joi can be used in a variety of real-world applications, including:
Validating user input on web forms
Validating data in databases
Validating data in JSON documents
Validating data in XML documents
Booleans
Booleans in Joi
Joi is a popular JavaScript library for input validation. It allows you to define schemas that describe the expected data structure and type of your inputs. Booleans are a fundamental data type in JavaScript and Joi provides validation rules to ensure that your boolean inputs are valid.
isBoolean()
The isBoolean() rule checks if the input is a valid boolean value. Valid boolean values are true and false.
Example:
valid()
The valid() rule allows you to define a set of valid boolean values for your input.
Example:
forbidden()
The forbidden() rule checks if the input is false. This is useful for cases where you want to ensure that a certain boolean field is always set to true.
Example:
Real-World Applications
Booleans are used in various real-world applications, including:
Form Validation: Ensuring that form fields that should be boolean (like checkboxes or switches) are valid boolean values.
Database Queries: Filtering or sorting data based on boolean values, such as
is_activeoris_deleted.API Endpoints: Validating request body or query parameters that represent boolean values, such as
is_enabledoris_read.Feature Flags: Controlling the availability of features based on boolean values, such as
is_new_feature_enabled.
Any
Any
The any type in Joi is a wildcard type that will validate any value. It is useful when you don't want to specify a specific type for a property, or when you want to allow multiple types.
For example, the following schema will validate any value for the name property:
This schema would be valid for the following values:
The any type can also be used to validate multiple types. For example, the following schema will validate a string or a number for the age property:
This schema would be valid for the following values:
Real-World Applications
The any type can be useful in a variety of real-world applications, such as:
Validating input from a form that allows multiple types of input.
Validating data from a database that may contain different types of data.
Creating a schema for a JSON document that may contain different types of data.
Potential Applications
Here are some potential applications for the any type:
A schema for a JSON document that may contain different types of data, such as strings, numbers, and booleans.
A schema for a form that allows multiple types of input, such as text, numbers, and dates.
A schema for a database table that may contain different types of data, such as strings, numbers, and dates.
Labels
Labels
Labels are a way to add extra information to your Joi schema. They can be used for validation, documentation, or other purposes.
Simplified Explanation:
Imagine a label as a little note that you can attach to your Joi schema. This note can contain additional information about the schema, such as:
What the schema is for (e.g., "Email address")
What the schema's constraints are (e.g., "Must be between 5 and 10 characters long")
Any other relevant information
Example:
Uses and Applications
Labels have a variety of uses in real-world scenarios:
Documentation: Labels can be used to provide additional documentation for your schemas, making them easier to understand and use.
Validation: Labels can be used to help validate data by providing additional constraints or rules.
Error handling: Labels can be used to provide more informative error messages when data fails validation.
Better Code Examples
Here's an improved example that demonstrates the use of labels in action:
In this example, the labels are used to provide additional information about the validation rules and to help generate more informative error messages.
Potential Applications
Here are some potential applications for labels in real-world scenarios:
Validating API request payloads
Validating form data
Configuring database models
Documenting internal APIs
FAQs
FAQ 1: What is Joi?
Joi is a Node.js library that helps you validate and sanitize data. It allows you to define rules for what data should look like, and then it checks that your data matches those rules. This can help you catch errors early on in your code, preventing them from causing problems later.
Example:
Potential applications:
Validating user input on a website
Ensuring that data from a database is consistent
Checking that data meets certain requirements before being processed
FAQ 2: Why use Joi?
There are many benefits to using Joi, including:
Early error detection: Joi can help you catch errors early on in your code, preventing them from causing problems later.
Improved code readability: Joi makes your code more readable by defining the rules for your data in a single place.
Increased confidence in your code: Joi gives you confidence that your data is valid and meets your requirements.
Reduced risk of security vulnerabilities: Joi can help you reduce the risk of security vulnerabilities by ensuring that your data is properly validated.
FAQ 3: How do I use Joi?
To use Joi, you first need to install it using npm:
Once Joi is installed, you can create a schema to define the rules for your data. A schema is a JavaScript object that defines the name and type of each property in your data.
For example, the following schema defines a data object with two properties: name and age:
Once you have created a schema, you can use it to validate data. To validate data, you pass the data to the validate() method of the schema. The validate() method returns an object that contains the error (if any) and the validated data.
For example, the following code validates the data object against the schema defined above:
Real-world example:
Let's say you have a website that allows users to create accounts. You want to ensure that the data that users enter is valid before creating their accounts. You can use Joi to validate the data that users enter.
The following code shows how you can use Joi to validate the data that users enter when creating an account:
By using Joi to validate the data that users enter, you can be confident that the data is valid and that the user's account is created with the correct information.
Alternatives
1. Ajv (Another JSON Schema Validator)
What it is: Another library for validating data against JSON schemas.
Pros: Fast, supports large schemas, extensive documentation.
Cons: Some features require paid plans.
Example:
Real-world application: Validating user registration data.
2. Zod
What it is: A modern and lightweight data validation library.
Pros: Intuitive syntax, type-safe, supports nested shapes.
Cons: Some limitations in customization.
Example:
Real-world application: Validating API request payloads.
3. Superstruct
What it is: A struct-based data validation library that combines Joi and TypeScript.
Pros: TypeScript integration, type annotations, simple syntax.
Cons: Limited schema language, not as actively developed as other alternatives.
Example:
Real-world application: Defining data models for TypeScript applications.
4. yup
What it is: A high-level data validation library with a focus on async validation.
Pros: Async/await support, nested schemas, type casting.
Cons: Can be slower than other alternatives.
Example:
Real-world application: Validating form submissions.
5. Formik
What it is: A form management library that includes data validation.
Pros: Integration with React, handles both frontend and backend validation.
Cons: Only suitable for form validation.
Example:
Real-world application: Creating dynamic forms with validation.
Monitoring
Monitoring with Joi
Introduction: Joi is a popular Node.js library used for data validation. It can help you ensure that the data you receive from users or external sources is correct and consistent. Joi also provides features for monitoring your validations and collecting metrics about them.
Topics:
1. Log Validation Attempts: You can enable logging for all validation attempts. This can be useful for debugging purposes or for analyzing the performance of your validations.
Code Snippet:
2. Collect Validation Metrics: Joi provides a plugin called "stats" that you can use to collect metrics about your validations. This can be useful for tracking the number of successful and failed validations, as well as the average time it takes to perform a validation.
Code Snippet:
Real-World Applications:
Logging Validation Attempts: This can be useful for identifying and troubleshooting any issues with your data validation process.
Collecting Validation Metrics: This can help you monitor the performance of your validations and identify any areas that need improvement.
Conclusion: Joi's monitoring features can help you ensure that your data validations are reliable and efficient. You can use these features to identify and troubleshoot any issues with your validations, as well as to track the performance of your validation process.
Allow
Joi's Allow
Joi is a Node.js library used for validating data. The allow feature in Joi allows you to specify a list of values that are considered valid for a given field.
Basic Usage
This schema will only allow strings with the values "foo", "bar", or "baz". Any other string will be considered invalid.
Conditional Allow
You can also use the allow feature with conditional statements. This allows you to specify different sets of allowed values depending on the value of another field.
In this schema, the gender field can only be "male" if the name field is "John". Otherwise, gender must be "female".
Real-World Applications
The allow feature can be used in a variety of real-world applications, such as:
Validating user input forms
Ensuring that data in a database is consistent
Creating custom validation rules for specific domains
Improved Examples
Here is an improved version of the basic usage example:
The valid method is a more concise way to specify a list of allowed values.
Here is an improved version of the conditional allow example:
The when method allows you to specify a chain of conditions. This syntax is more concise than the original example.
Examples
Joi: A Flexible and Validating Schema Language
1. Basic Validation:
Explanation: Joi allows you to check the structure and data types of objects, ensuring they meet your requirements.
Example:
2. Nested Schemas:
Explanation: You can build complex schemas with nested objects and arrays.
Example:
3. Alternatives and Combinations:
Explanation: Joi allows you to create schemas that check for alternatives or combinations of data.
Example:
4. Custom Validators:
Explanation: Joi provides a way to define custom validators for specific scenarios.
Example:
5. Real-World Applications:
Data Validation in APIs: Ensure that incoming requests meet the expected structure and data types.
Database Schema Validation: Verify that data being inserted or updated in a database conforms to the desired format.
Data Transformation: Joi can be used as a tool to transform and clean data before processing or storage.
Error Handling: Joi's error messages provide clear and informative feedback to developers, making it easier to identify and fix data issues.
Versioning
1. Semantic Versioning
Imagine you have a toy car that you love. You want to make some improvements to it, but you don't want to break the car. Semantic versioning is a set of rules that helps you update your toy car without breaking it.
Major Version (x): Big changes, like adding a new engine or changing the shape.
Minor Version (y): Small improvements, like adding new wheels or a different paint color.
Patch Version (z): Tiny fixes, like fixing a loose screw or a broken light.
Example:
This means you started with a basic toy car (major version 1). You then added new wheels and painted it (minor version 0). You finally tightened a loose screw (patch version 0).
2. Version Validation
Now, let's say you want to upgrade your toy car to a new version. Semantic versioning helps you check if the new version is compatible with your current car.
You can use the joi library to validate versions:
This validation ensures that the version format is correct (e.g., "v1.0.0").
3. Version Comparisons
Finally, you need to compare different versions to decide which one to use. The joi library provides operators for comparing versions:
Joi.version().greater('v1.0.0')Joi.version().less('v2.0.0')Joi.version().least('v1.2.0')Joi.version().most('v1.2.0')
Example:
This validation checks if the number is greater than 5 and less than 10.
Real-World Applications:
API Versioning: Different versions of APIs may have different features and behavior. Semantic versioning helps developers manage changes and ensure compatibility.
Software Updates: Software companies release new versions to fix bugs, add features, or improve performance. Semantic versioning helps users understand the scope of the changes.
Package Management: Package managers like npm use semantic versioning to track package releases and ensure compatibility between different versions.
Support
Simplifying Node.js Joi Support Topic
Introduction
Joi is a popular Node.js library for validating data. It provides a set of rules that you can use to check that data is in the correct format, has the correct values, and meets certain requirements.
Topics
1. Installation
To install Joi, run the following command in your terminal:
2. Validation
Joi provides a number of different validation methods that you can use to check data. The most common methods are:
validate(): Validates a value against a schema.
assert(): Throws an error if a value does not validate against a schema.
For example, the following code validates a string to ensure that it is an email address:
3. Error Handling
If a value does not validate against a schema, Joi will return an error object. This object contains a list of the errors that were found.
You can handle errors by using the following methods:
catch(): Catches errors that are thrown by the
validate()orassert()methods.errors(): Returns an array of errors that were found during validation.
For example, the following code catches errors that are thrown by the validate() method:
4. Custom Validators
Joi allows you to create your own custom validators. This is useful for validating data that does not fit into the standard Joi schemas.
To create a custom validator, you can use the extend() method. This method takes two arguments:
name: The name of the validator.
fn: The function that implements the validator.
For example, the following code creates a custom validator that checks that a string is a valid password:
Real-World Applications
Joi can be used in a variety of real-world applications, including:
Validating user input on web forms.
Validating data from APIs.
Validating data from databases.
Validating data from files.
Conclusion
Joi is a powerful and easy-to-use library for validating data in Node.js. By understanding the basics of Joi, you can use it to ensure that your data is always in the correct format and meets your requirements.
Basic Usage
Basic Usage of Joi
What is Joi?
Joi is a library that helps you validate data in JavaScript. It's like a security guard that checks if your data is valid before letting it pass into your program.
Why use Joi?
Using Joi helps you:
Prevent errors: By validating data, you can catch errors early on, before they cause problems in your program.
Improve security: Validating data can prevent malicious users from sending bad data to your program.
Save time: By automating data validation, you can save time spent manually checking data.
How to use Joi
Let's start with a simple example:
Explanation:
In this example:
We create a Joi schema by defining the rules for our data.
We validate our input data against the schema using
schema.validate().If there are any errors, the
errorproperty of the validation result will contain an array of error messages.If there are no errors, the
errorproperty will benull.
Complete Code Implementation
Potential Applications
Joi can be used in a variety of applications, including:
API validation
Form validation
Data parsing
Schema enforcement
Data migration
Configuration validation
Modifiers
Modifiers in Joi
Think of modifiers as special "tools" that you can use to add extra rules or change the behavior of your Joi schema.
Required
Makes a field mandatory.
Example:
Optional
Makes a field optional.
Example:
Default
Specifies a default value for a field if it's not provided.
Example:
Allow
Allows multiple values for a field.
Example:
Keys
Validates an object's keys against a schema.
Example:
Min and Max
Sets minimum and maximum values for a number field.
Example:
Length
Sets minimum and maximum lengths for a string field.
Example:
Pattern
Validates a string field against a regular expression.
Example:
Real World Applications:
Required: Ensure that important fields (like user name or password) are always provided.
Optional: Allow users to skip non-essential fields (like a profile picture).
Default: Provide reasonable default values for fields that users often leave empty (like country or time zone).
Allow: Allow multiple values for fields like tags or categories.
Keys: Validate the structure of dynamically generated objects or configuration files.
Min and Max: Set boundaries for numerical values like age or account balance.
Length: Ensure that strings are within a specific range of characters (e.g., password length).
Pattern: Validate email addresses or phone numbers using regular expressions.
Roadmap
Roadmap
Introduction of Joi
A popular library in Node.js that helps you with data validation.
Key Features of Joi
Schema-Based Validation: Define expected data structure using a schema.
Error Handling: Receive clear and detailed error messages when validation fails.
Type Checking: Ensure data types match your expectations (e.g., numbers, strings, arrays).
Nested Schema Validation: Validate complex objects with multiple levels of nesting.
Extensibility: Ability to create custom validation rules for specific needs.
How to Use Joi
Real-World Applications
API Request Validation: Ensure data received from clients is valid before processing.
Database Input Validation: Prevent invalid data from being stored in the database.
User Input Validation: Validate forms and ensure user input conforms to expectations.
Data Transformation: Convert and normalize data into a consistent format.
Model Validation: Define expected data structure for models in object-oriented programming.
Potential Applications
E-commerce Websites: Validate user addresses, product details, and order information.
Banking Applications: Verify account numbers, transactions, and customer information.
Healthcare Systems: Validate patient records, medical diagnoses, and prescriptions.
Government Portals: Ensure citizen data, tax returns, and other sensitive information is valid.
Social Networking Platforms: Moderate user content and prevent spam or malicious activity.
Integration Testing
Integration Testing with Node.js Joi
What is Integration Testing?
It's like making sure all the parts of your system work together nicely. It checks that the database, servers, and other components interact correctly.
Why is it important?
It helps prevent bugs and ensure that your system is reliable and meets your expectations.
How to do Integration Testing?
1. Use Joi to validate data:
Joi is a library that helps you validate user input.
It ensures that the data you receive from users is correct and matches your requirements.
Example:
2. Test the endpoints in your system:
Endpoints are the URLs or API calls that your system exposes.
You can use a testing framework like Jest to make HTTP requests to your endpoints and check if they return the expected results.
Example:
Real-World Applications:
- E-commerce website: Checks if the order information provided by the user is valid before proceeding with the payment.
- Social network: Ensures that the user profiles are complete and meet the site's requirements before allowing them to interact with others.
- Banking application: Verifies the authenticity of the user's identity and the accuracy of the financial transactions.
Tutorials
Introduction to Joi
Joi is a library for JavaScript that helps you validate data. It's particularly useful when you're working with user-submitted data, such as in a web form or API request.
Basic Usage
To use Joi, you first need to create a schema that defines the rules for your data. A schema is simply a JavaScript object that specifies the allowed types, values, and constraints for each field.
For example, here's a simple schema that validates a user's name:
This schema requires the name field to be a string and not null.
Once you have a schema, you can use it to validate data by calling the validate() method:
The validate() method returns a result object that contains the validated data, as well as any errors that were found.
Types
Joi supports a variety of data types, including:
string()number()date()boolean()array()object()
You can use these types to create schemas that validate data of any type.
Constraints
In addition to types, you can also specify constraints on your data. Constraints are rules that limit the allowed values for a field.
For example, here's a schema that validates a user's age and requires it to be between 18 and 65:
Real-World Applications
Joi can be used in a variety of real-world applications, such as:
Validating user input on web forms
Validating API requests
Validating data before storing it in a database
Validating data before sending it to another system
Conclusion
Joi is a powerful library that can help you ensure that your data is valid. It's easy to use and can be customized to meet your specific needs.
Community Resources
Community Resources
GitHub
GitHub is a website and online platform where people can collaborate and share code.
Joi has a GitHub repository where you can find the source code, documentation, and issues for Joi.
Contribution: You can contribute to Joi by reporting issues, suggesting new features, or writing code.
Discord
Discord is an online instant messaging and voice chat platform.
Joi has a Discord server where you can join a community of Joi users and developers.
Ask questions, discuss best practices, and get support from other Joi users.
Stack Overflow
Stack Overflow is a question-and-answer website for software developers.
Search for questions about Joi or ask your own questions.
Get help from experienced Joi users and developers.
Real-World Code Example
Potential Applications
Form validation: Validating user input before submitting forms to prevent malicious data or errors.
API request validation: Ensuring that API requests have the correct structure and data to prevent unexpected errors.
Data validation: Validating data from databases, CSV files, or other sources to ensure consistency and accuracy.
Contributing Guidelines
Contributing to Node.js Joi
What is Joi?
Joi is a library that helps you validate data in JavaScript. It's like a gatekeeper that makes sure your data is correct before you use it.
Why contribute?
By contributing to Joi, you can help make it better for everyone who uses it. You can fix bugs, add new features, or improve documentation.
How to contribute
1. Find an issue to work on
Go to the Joi GitHub page and look for issues that are labeled "help wanted." These issues are a good place to start if you're new to contributing.
2. Create a fork
Click the "Fork" button on the Joi GitHub page. This will create a copy of the Joi repository in your own account.
3. Make your changes
Clone your forked repository to your local computer. Then, make your changes to the code.
4. Test your changes
Run tests to make sure your changes don't break anything.
5. Create a pull request
Once you're happy with your changes, create a pull request. This will send your changes to the Joi team for review.
Detailed Topics
Coding Style
Follow the coding style conventions used in the Joi codebase. You can use a code linter to help you with this.
Testing
Write tests for your changes. Tests help ensure that your changes don't break anything.
Documentation
Update the documentation to reflect your changes. Documentation is important for other developers to understand how to use Joi.
Real World Examples
Validating user input
This example validates user input using a schema defined with Joi. The result variable will contain either the validated data or an error if the input is invalid.
Validating data from a database
This example validates data from a database using a schema defined with Joi. The result variable will contain either the validated data or an error if the data is invalid.
Potential Applications
Joi can be used in a variety of applications, including:
Web applications
Mobile applications
API development
Data validation for any JavaScript application
Binary
Binary in Node.js Joi
Joi is a library for validating JavaScript objects. One of its features is the ability to validate binary data, such as images or documents.
Data Uniformity
Binary data in Node.js is represented as a Buffer object. joi expects the binary data to be in this format for validation.
Validation Syntax
To validate binary data, use the binary() method:
This schema will validate any Buffer object.
Validation Options
You can customize the validation with the following options:
encoding: Specify the encoding of the binary data, such as
'base64'or'hex'.allowUnknown: Allow unknown binary types.
maxSize: Limit the size of the binary data in bytes.
Real-World Applications
Validating user-uploaded profile pictures
Validating attachments in email messages
Ensuring the integrity of data stored in a database
Complete Example
To validate a base64-encoded image:
This example demonstrates how to validate a binary image using joi.
Data Types
Data Types in Node.js Joi
Joi is a data validation library that helps you ensure that the data you receive from users or other sources is valid before using it. It provides a wide range of data types that you can use to validate your data.
String
The string() data type validates that the input is a string. You can specify a minimum and maximum length, and you can also specify a regular expression to match the string against.
Number
The number() data type validates that the input is a number. You can specify a minimum and maximum value, and you can also specify whether the number should be an integer or a floating-point number.
Boolean
The boolean() data type validates that the input is a boolean value.
Date
The date() data type validates that the input is a valid date. You can specify a format for the date, or you can use the default format.
Array
The array() data type validates that the input is an array. You can specify a minimum and maximum length, and you can also specify the type of elements that the array should contain.
Object
The object() data type validates that the input is an object. You can specify the properties that the object should contain, and you can also specify the type of each property.
Potential Applications in Real World
Joi's data types can be used in a variety of real-world applications, including:
Validating user input on web forms
Validating data from APIs
Validating data from databases
Configuring applications
Testing data
Default
Default Values
In Joi, you can specify a default value for a field. This is useful if you want to ensure that the field has a value even if the user doesn't provide one.
Syntax:
Example:
Real-world applications:
Ensuring that a user has a default avatar if they don't upload one.
Setting a default shipping address if the user doesn't provide one.
Dynamic Defaults:
You can also specify a function as the default value. This allows you to generate a default value based on other fields in the object.
Syntax:
Example:
Real-world applications:
Generating a default welcome message based on the user's age.
Setting a default discount code based on the total amount of the order.
Lazy Defaults:
Lazy defaults are similar to dynamic defaults, but they are only evaluated when the field is actually accessed. This can improve performance if the default value is not needed for every request.
Syntax:
Example:
Real-world applications:
Retrieving a user's profile picture only when it is needed.
Calculating a user's total balance only when they log in.
Numbers
Numbers
Overview
The Numbers type in Joi checks if the value is a number. It supports further validation with other methods like integer(), min(), max(), etc.
Usage
Methods
integer
Checks if the value is an integer.
min
Checks if the value is greater than or equal to the specified minimum.
max
Checks if the value is less than or equal to the specified maximum.
positive
Checks if the value is a positive number.
negative
Checks if the value is a negative number.
examples
Example 1: Validate an age field
Example 2: Validate a price field
Example 3: Validate a discount percentage field
Applications
Validating user input in web forms
Validating data in databases
Validating data in API requests
Conditional Validation
Conditional Validation in Node.js with Joi
Conditional validation allows you to validate data based on the value of another field in the same object. Here's a simplified explanation:
Imagine you have a form with the following fields:
First Name
Last Name
Email
Password
Now, you want to enforce the following business rules:
If the user chooses to receive marketing emails, they must provide an email address.
If the password is longer than 10 characters, it must contain at least one number.
How to Implement Conditional Validation with Joi
Joi provides the when method to implement conditional validation. Here's an example:
Explanation:
The
emailfield is optional unless themarketingEmailOptInfield is set to true.The
passwordfield must be at least 10 characters long and contain at least one number if thepasswordLengthfield is set to 10.
Real-World Applications
User Registration: Enforce a strong password policy for users who choose to register with a password.
Subscription Forms: Allow users to opt in to marketing emails and validate their email address accordingly.
Order Processing: Validate additional information based on the type of payment selected, such as a credit card number for card payments.
Potential Improvements
You can make your validation rules more robust by using the following:
Custom error messages: Describe any validation errors in clear, user-friendly language.
Multiple conditions: Define multiple conditions for a field using the
whenmethod'sisandthenoptions.Additional libraries: Integrate with libraries like Express Validator or Yup for more advanced validation capabilities.
Example with Custom Error Messages:
Logging
Logging in Joi
Joi is a popular library for validating data in Node.js applications. It provides a variety of features, including the ability to log validation errors.
Using log
logThe log method allows you to specify a custom logging function that will be used to log validation errors. This can be useful if you want to customize the way that errors are logged, or if you want to integrate with a third-party logging system.
The log method takes a single argument, which is a function that will be called with the following parameters:
error: The validation error that occurred.data: The data that was being validated.options: The validation options that were used.
The following example shows how to use the log method to log validation errors to the console:
In this example, the log function will be called whenever a validation error occurs. The function will be passed the error object, the data that was being validated, and the validation options that were used.
Real-World Applications
Logging validation errors can be useful in a variety of real-world applications, such as:
Identifying and fixing data quality issues
Debugging validation errors
Integrating with third-party logging systems
Creating custom error messages
By using the log method, you can customize the way that validation errors are logged to meet the specific needs of your application.
Symbols
Symbols
Symbols are special values that are used to represent unique identifiers. They are similar to strings, but they are guaranteed to be unique. This makes them useful for cases where you need to be able to identify an object uniquely, such as when you are working with objects in a database.
Creating Symbols
Symbols can be created using the Symbol() function. This function takes a string as an argument, which is used to create a new symbol.
As you can see in the example above, the two symbols are not equal, even though they have the same string. This is because symbols are unique.
Using Symbols
Symbols can be used in a variety of ways. One common use is to identify objects in a database. For example, you could use a symbol to represent the primary key of a table. This would allow you to quickly identify the row that you are looking for.
Another common use of symbols is to represent properties on objects. For example, you could use a symbol to represent the name of a property. This would allow you to access the property without having to use the string name.
Real-World Examples
There are many real-world applications for symbols. Here are a few examples:
Databases: Symbols can be used to represent primary keys and foreign keys. This makes it easier to work with objects in a database.
Objects: Symbols can be used to represent properties on objects. This allows you to access properties without having to use the string name.
Security: Symbols can be used to create unique identifiers for users and passwords. This helps to protect against security breaches.
Conclusion
Symbols are a powerful tool that can be used to represent unique identifiers. They are used in a variety of applications, including databases, objects, and security.
Dates
Dates
Dates represent specific points in time. Joi provides various methods for validating and manipulating dates.
Creating a Date Schema
To create a schema for a date field, use the date() method:
Validation Examples
Valid date strings:
"2023-03-08"
"2023-03-08T12:30:00Z"
Invalid date strings:
"March 8, 2023"
"03/08/2023"
Manipulation Options
Joi also allows you to manipulate dates using various options:
iso: Validate dates in ISO 8601 format.
timestamp: Convert dates to Unix timestamps (milliseconds since epoch).
format: Specify the date format to use for validation (e.g., "MM/DD/YYYY").
Example:
Real-World Applications
Validating dates for appointments or events
Storing timestamps for logs or transaction history
Comparing dates for age verification or calculating time differences
Code Implementation
Example 1: Validating a Date in ISO 8601 Format
Example 2: Retrieving a Timestamp
End-to-End Testing
End-to-End Testing with Joi
What is End-to-End Testing?
Imagine a long pipe that carries water from one end to another. End-to-end testing is like putting a big sponge at the end of the pipe to make sure the water reaches its destination without leaking anywhere in between.
What is Joi?
Joi is like a super smart gatekeeper that checks everything that comes through a door. It makes sure that only the right kind of things can enter, and it catches any mistakes that would let bad things in.
How End-to-End Testing Works with Joi
We can use Joi to test our entire application from start to finish, like a big sponge at the end of our pipe. Here's how:
Define the Rules: We tell Joi what kind of data we expect to come in and out of our application. For example, we might say that a user's name should be a string with a minimum length of 3 characters.
Validate Input: When data enters our application, Joi checks it against our rules. If the data matches the rules, it's allowed in. If it doesn't, we catch the error and take action, like showing the user a friendly error message.
Test the Output: After our application processes the data, we use Joi to check if the output meets our expectations. This makes sure that our application is doing what it's supposed to do.
Code Example:
Here's a simple code example using Joi for end-to-end testing:
Real-World Applications:
End-to-end testing with Joi can be used in many real-world applications, such as:
Ensuring that data entered by users is valid before it's stored in a database.
Verifying that the results of a complex business process meet the expected format.
Testing the functionality of an entire API by sending requests and checking the responses.
Making sure that changes to an application don't break existing functionality.
Functions
Functions
Functions are essential building blocks in Node.js Joi for validating and transforming data. They provide a powerful way to define custom validation rules and manipulate data before it is validated.
1. Validation Functions
Validation functions are used to check if a value meets a specific criteria. They return a boolean value indicating whether the validation passed or failed.
Example:
Real-World Application:
In user registration forms, you can use validation functions to ensure that:
Age is a valid number (not a string)
User is within the allowed age range
2. Transformation Functions
Transformation functions are used to modify or manipulate data before it is validated. They can be used to:
Convert data from one type to another
Remove unwanted characters
Format data in a specific way
Example:
Real-World Application:
In usernames, you can use transformation functions to lowercase them for case-insensitive comparisons.
3. Custom Functions
Custom functions allow you to define your own validation and transformation rules. They can be used when existing functions do not meet your specific requirements.
Example:
Real-World Application:
In security checks, you can define a custom function to ensure that passwords contain both letters and numbers.
4. Async Functions
Async functions are used for asynchronous validation or transformation. They can be used when fetching data from external sources or performing computationally expensive operations.
Example:
Real-World Application:
In user registration, you can use async functions to verify that the entered email address is not already registered in the database.
Custom Types
Custom Types
Custom types allow you to validate data against your own custom rules and logic.
Creating Custom Types
Using Custom Types
Real-World Applications
Validating email addresses in a specific format
Validating phone numbers in a specific country code format
Validating dates within a specific range
Validating passwords against complexity rules
Validating custom data structures, such as JSON or XML
Potential Applications in Real World
User Registration: Validating email addresses and phone numbers to ensure they're in the correct format.
Product Orders: Validating order dates to ensure they're within a valid time frame.
Data Import: Validating custom data structures to ensure they conform to a specific format.
API Requests: Validating request parameters against custom business rules.
UI Input: Validating user input on web forms to ensure it meets specific criteria.
Performance Optimization
Performance Optimization in Node.js Joi
1. Caching Schema Definitions
What it is: Joi stores schema definitions internally. When you validate a value, Joi needs to look up the definition. Caching speeds up this process.
How to do it: Use
Joi.compile(schema)to compile the schema and store it in a variable. Then, usecompiledSchema.validate(value)to perform validation.Real-world application: In applications with multiple validation instances, caching prevents the need to recompile the schema for each instance.
2. Lazy Validation
What it is: Joi validates all properties of an object by default. Lazy validation allows you to skip validation of optional or nullable properties until they are accessed.
How to do it: Use
Joi.lazy()to mark properties as lazy.Real-world application: In large objects with many nullable properties, lazy validation can significantly improve performance.
3. Avoid Deeply Nested Schemas
What it is: Nested schemas can slow down validation. Joi splits nested schemas into multiple validation steps, which can be costly.
How to do it: Refactor deeply nested schemas into flatter structures.
Real-world application: In complex data models, optimizing schema structure can prevent performance bottlenecks.
4. Use the "allowUnknown" Option
What it is: Joi will throw an error if it encounters unknown properties in an object. The "allowUnknown" option suppresses these errors.
How to do it: Add
{ allowUnknown: true }to the schema definition.Real-world application: In dynamic data sources where the schema may change, using "allowUnknown" prevents validation failures due to unknown properties.
5. Async Validation
What it is: Joi supports async validation for properties that depend on external data sources. This prevents blocking the validation process.
How to do it: Use
Joi.reach(schema, 'path.to.property').async()to define async validation.Real-world application: In validations that require database lookups or API calls, async validation ensures responsiveness and scalability.
Example Code
Meta
Meta
Meta properties in Joi are used to add additional information or constraints to a schema without affecting the validation of the data itself. They can be used to provide information about the schema, such as its purpose, description, or default value.
type() The type() meta property specifies the type of the schema. This can be useful for documentation purposes or for generating code based on the schema.
description() The description() meta property adds a description to the schema. This can be used to provide additional information about the purpose or usage of the schema.
label() The label() meta property sets a label for the schema. This can be used to identify the schema in error messages or other output.
default() The default() meta property specifies a default value for the schema. This value will be used if the data being validated does not have a value for the schema.
allow() The allow() meta property specifies an array of allowed values for the schema. This can be used to restrict the data being validated to a specific set of values.
forbidden() The forbidden() meta property specifies an array of forbidden values for the schema. This can be used to prevent the data being validated from containing certain values.
options() The options() meta property allows you to specify additional options for the schema. These options can be used to customize the behavior of the schema, such as whether it is required or not.
keys() The keys() meta property allows you to specify the keys of an object schema. This can be used to enforce the presence or absence of certain keys in the data being validated.
pattern() The pattern() meta property allows you to specify a regular expression pattern that the data being validated must match. This can be used to validate data based on a specific format, such as an email address or a phone number.
regex() The regex() meta property is an alias for the pattern() meta property.
example() The example() meta property adds an example value to the schema. This can be used to provide a concrete example of valid data for the schema.
id() The id() meta property sets an ID for the schema. This can be used to identify the schema in error messages or other output.
strip() The strip() meta property allows you to strip certain properties from the data being validated. This can be useful for removing sensitive data or for normalizing the data before validation.
with() The with() meta property allows you to specify a set of keys that must be present in the data being validated in order for the schema to be valid. This can be used to enforce relationships between different parts of the data.
without() The without() meta property allows you to specify a set of keys that must not be present in the data being validated in order for the schema to be valid. This can be used to prevent conflicting data from being submitted.
Potential Applications in Real World
Meta properties can be used in a variety of real-world applications, such as:
Generating documentation for schemas
Creating code based on schemas
Enforcing data validation rules
Normalizing data before validation
Identifying and preventing data conflicts
Forbidden
Forbidden in Joi
Simplified Explanation:
Joi's Forbidden rule is like a bouncer at a club who checks if something you're trying to do is not allowed. If it's not on the allowed list, the bouncer (Joi) says "no way!"
Detailed Explanation:
The Forbidden rule lets you specify that a certain value or key is not allowed in your data. This is useful when you know that some values or keys should never be present in your application.
Code Snippets:
Real World Applications:
Example 1: In a user registration form, you might want to forbid users from entering certain names like "admin" or "root".
Example 2: In a travel booking system, you might want to forbid users from selecting countries that are not within the allowed list.
Potential Issues:
Security: If you don't use the Forbidden rule correctly, it can lead to security vulnerabilities. Make sure to carefully consider what values or keys you forbid.
Flexibility: Forbidding specific values or keys can make your application less flexible. If you need to change the allowed values or keys in the future, you will need to update your schema.
Unit Testing
Unit Testing
Imagine you're building a car and want to make sure each part works as expected. Unit testing is like checking each part of the car (like the engine, wheels, and lights) individually before putting them all together.
joi
joi is a library in Node.js used to validate user input. It checks if the data entered matches the rules set by the programmer. Validation is important to ensure that data is correct and consistent.
Testing joi
To test joi, you write a function that defines rules for what the input should be like. Then, you pass sample data to the function and check if the function returns what you expect.
Example:
In this example, we define a schema that specifies that name should be a required string and age should be a positive integer. We then pass sample data to the schema and check if it validates without any errors.
Applications:
Web Applications: Ensuring that form input is correct before it's saved to the database.
APIs: Checking that requests contain valid parameters.
Data Validation: Verifying the integrity of data before it's used in calculations or decisions.