Mighty

The last validation library you will ever need!

Key Features

1. Zero dependencies.
2. Framework agnostic, can be integrated in any codebase.
3. Expressive, intuitive and easy to get along with over 250 built-in validation rules.

Installation

About Mighty

Validation is a common task in any web application. Data passed to the application via forms —or any type of input for that matter— must always be validated against a set of rules. Mighty can handle in an easy and expressive way.

Mighty is fast, powerful, robust, and easy to use validation library that is just fun to work with, it makes validating any data a breeze. Thanks to the power of the Mighty Validation Expression Language (mVEL) it is not like anything you've seen before. With its validation approach and over 250 built-in rules there is pretty much nothing that you cannot validate with it, in a very expressive and compact manner. Simply put, Mighty is validation on steroids! It is indeed the last validation library you will ever need.

Mighty provides several different approaches to validate data. It's most common use-case is validating incoming data via HTTP requests, but it of course is not limited to that; Mighty provides also attributes in the form of constraints to easily validate models and/or any kind of objects.

Mighty includes a wide variety of convenient validation rules that you may apply as a single rule or combine them with each other using operators to build up even more complex validations.

Quickstart

To learn about Mighty's powerful validation features, let's cut straight to the point and take a look at some examples:

General Data Validation

Validating form data using the Validator::class:

Objects Validation

Validating the state of an object using Constraint::class attributes:

An example of the output of validating a validatable object would look like this:

Check also ValidatableObjectChild.

Hint: More examples can be found in the Examples section.

Mighty Validation Expression Language

Mighty has the concept of Validation Expression. The Validation Expression in its simplest forms is just a string that describes how Mighty should validate the given data. These strings are based on the Mighty Validation Expression Language Specification (mVEL). mVEL is pretty simple, human-readable and easy to cope with. It is a combination of well established concepts and/or specifications like Boolean Algebra, Bitwise Operators, JSON, and CSV.

Therefore, Validation Expression may be defined as a string that contains some rules separated by Bitwise Operators which will build an expression that when evaluated using Boolean Algebra logic, will result in the final result of the validation. The rules can have arguments, the types of these arguments can be denoted using the same rules of JSON types. A rule can also have multiple arguments and the arguments are separated by commas (CSV).

For example  required&string&between:2,255|null  is a valid Validation Expression, this expression can be understood as the following:

1. The expression has four rules.
2. The expression contains the rules:
   1. required Asserts that the input is present.
   2. string Asserts that the input is a string.
   3. between:2,255 Asserts that the input is a string with a length between 2 and 255.
   4. null Asserts that the input is null.
3. The final result is the result of evaluating the expression resulting from the result of each rule glued together using bitwise operators.

The required&string&between:2,255|null expression means that the input must be present; AND of type string; AND between 2 and 255 in length; OR null. So it's a nullable string that when is not null must be between 2 and 255 characters long.

Lets say the the input was "Mighty is Awesome!", the result of the expression required&string&between:2,255|null against that input would be 1&1&1|0 which will result in 1 which is true, if the input was null the result would be 0&0&0|1 = 1, if the input was X the result would be 0&0&0|0 = 0, etc ...

Unlike other validations implementations, the concept of Boolean Algebra using Bitwise Operators, gives the possibility to build up complex validations that are very readable and compact while keeping the rules to a minimum number, reusing existing logic in reversed or compound manner, and finally keeping the code base as DRY as it can be. The benefits can be summarized in the following points:

1. A rule can be NOTed (using ~) to do the exact opposite of what it normally does.
2. A complex rule can be the result of ANDing (using &), ORing (using |), or XORing (using ^), two or more simple rules.
3. Rules can be grouped together and/or given higher precedence by using parentheses, namely OPEN (using () and CLOSE (using )).
4. A Validation Expression can also have behavior, which is a character the prefixes the Validation Expression string that will affect all rules. Available behaviors are:
   1. NORMAL: execute all rules, default behavior (no prefix).
   2. OPTIMISTIC: stop executing rules after the first success (? prefix).
   3. PESSIMISTIC: stop executing rules after the first failure (! prefix).
5. Readability can be improved by aliasing some rules or adding rules sets as macros and executing them using the [macro] syntax.

Also the concept of JSON ensures arguments data-types safety, and the concept of CSV makes sure the arguments list has clear parsing rules.

The nicest thing, you don't have to memorize all the rules nor the Validation Expression Language syntax. The Validation class is a fluent interface that can be used to build a Validation Expression. It knows about all Mighty available rules and has full IDE-Intellisense support to make it as easy as it gets. For example:

Fact: It usually takes more words to describe what a validation expression does than the validation expression itself!

Examples

Here are some examples of real world scenarios:

Validating a Single Value

Validating Structured Data

Hint: When providing message overrides to the Validator::class, it is advised to use the Rule\Validation::class to set array keys. This class contains all Mighty built-in rules names as class constants.

Extending the Validator

The validator can be extended in three ways:

• By adding a rule.
• By adding an alias.
• By adding a macro.

Hint: Check out the default Validator to see more examples.

Constraints

Mighty consists of over 250 rules/attributes that can be used to validate any data or the values of classes, class constants, properties, and methods.

The attributes are split into three main groups:

1. Generic Constraint Attributes
2. Special Constraint Attributes
3. Rule Constraint Attributes

Generic Constraint Attributes Group

The Generic Constraint Attributes are located under the MAKS\Mighty\Validation namespace.

This group consists currently of one attribute only; that is the Constraint attribute. This attribute takes a Validation Expression to validate the data it is applied to. It is also the base class for all other attributes.

Special Constraint Attributes Group

The Special Constraint Attributes are located under the MAKS\Mighty\Validation\Constraint namespace.

This group contains attributes that do a specific job that is available only in the context of attributes. It consists of the following attributes:

• Rule: This attribute is used to validate any data using a single validation rule. It is also the base class for all attributes in the Rule Constraint Attributes Group.
• Callback: This attribute is used to validate any data using a callback function.
• Valid: This attribute is used to validate the validity of a validatable object.
• Shape: This attribute is used to validate the shape of an array or object. Note that this is the only attribute that validates a set of values (structured data) rather than a single value.
• Compound: This attribute is used to combine a set of constraints to build up a Validation Expression. The constraints can be combined using any operator, and can also have a behavior. It serves as an object-oriented way to build up a Validation Expression.

Note: Note that the constraints that are allowed to be used with the Shape::class and Compound::class attributes must be an actual instances of the Constraint::class, Rule::class, or Compound::class. The Callback::class, Valid::class, or Shape::class of the Special Constraint Attributes Group are NOT allowed. If you have a need for this feature, open an issue and we'll discuss implementing it

Rule Constraint Attributes Group

The Rule Constraint Attributes are located under the MAKS\Mighty\Validation\Constraint\Rule namespace.

This group contains attributes that are based on a single validation rule. It consists of most of the attributes Mighty provides. Refer to the Validations section for the full list.

Adding a Custom Constraint

Mighty has a huge list of built-in constraints, it's really rare that you will need anything other than what Mighty provides. Nonetheless, sometimes the need arises for a custom constraint, the is how you can achieve that:

Note: Custom constraints are considered a part of the Special Constraint Attributes Group (i.e. not allowed to be used with/inside the Shape::class and Compound::class constraints)

Validations

The following table lists all available rules including their Attribute and Method equivalents:

Rules and Aliases

• Validation::class
• Constraint/Rule/*

Macros

Benchmarks

By now it may seem like Mighty is doing too much and performance concerns are starting to arise. Well, there is no need to worry about that. Mighty is really fast and is optimized to provide the best performance. Here are some benchmarks of the performance of the validator:

Not So Scientific Benchmark

The performance of Mighty Validator and Laravel Validator in a laravel application. The test was carried out using an array of 50000 elements, half of them are integers and the other half are numeric strings. Each validator was tested 10 times (consecutively) and the average result of these 10 was collected:

So Mighty is about 12.5X times faster than Laravel Validator with XDebug disabled and about 4X times faster with XDebug enabled.

Scientific Benchmark

The benchmark is done using PHPBench. Here is a quick overview:

Fact: The most recent benchmark result can also be found in the CI pipeline, which will be updated with each Push/PR to the upsteam.

Notes

1. Mighty generates really friendly error messages by default (currently only in English). These messages can be easily overwritten on Validator/Constraint bases. You may want to have these messages in different languages, for that, the MAKS\Mighty\Rule::setMessageTranslator() method can be used. This method is a convenient way to set a global message translator, it takes a closure that gets the raw message (with placeholders) as an argument and must return the translated version of that message.
2. Refer to the Mighty Validation Expression Language Specification to learn more about the theory behind Mighty and to get a grasp of how the language works.
3. Refer to Mighty API Documentation to learn more about the PHP API. The API is well-documented and there shouldn't be anything that is not covered there.
4. Mighty is currently a pure validation library, it doesn't do any kind of transformation on the data. The engine and the current design is flexible enough and can be used to easily implement a Sanitizer on top of it, there is no plan to make this at the moment but it may be a future milestone.

License

Mighty is an open-source project licensed under the MIT license.
Copyright (c) 2022 Marwan Al-Soltany. All rights reserved.