[[constraints]]
== Constraints

Constraints are validation and conversion functions applied
to user input.

They are used in various places in Cowboy, including the
router and the request match functions.

=== Syntax

Constraints are provided as a list of fields. For each field
in the list, specific constraints can be applied, as well as
a default value if the field is missing.

A field can take the form of an atom `field`, a tuple with
constraints `{field, Constraints}` or a tuple with constraints
and a default value `{field, Constraints, Default}`.
The `field` form indicates the field is mandatory.

Note that when used with the router, only the second form
makes sense, as it does not use the default and the field
is always defined.

Constraints for each field are provided as an ordered list
of atoms or funs to apply. Built-in constraints are provided
as atoms, while custom constraints are provided as funs.

When multiple constraints are provided, they are applied in
the order given. If the value has been modified by a constraint
then the next one receives the new value.

For example, the following constraints will first validate
and convert the field `my_value` to an integer, and then
check that the integer is positive:

[source,erlang]
----
PositiveFun = fun(V) when V > 0 -> true; (_) -> false end,
{my_value, [int, PositiveFun]}.
----

When there's only one constraint, it can be provided directly
without wrapping it into a list:

[source,erlang]
----
{my_value, int}
----

=== Built-in constraints

Built-in constraints are specified as an atom:

[cols="<,<",options="header"]
|===
| Constraint | Description
| int        | Converts binary value to integer.
| nonempty   | Ensures the binary value is non-empty.
|===

=== Custom constraints

Custom constraints are specified as a fun. This fun takes
a single argument and must return one of `true`, `{true, NewValue}`
or `false`.

`true` indicates the input is valid, `false` otherwise.
The `{true, NewValue}` tuple is returned when the input
is valid and the value has been converted. For example,
the following constraint will convert the binary input
to an integer:

[source,erlang]
----
fun (Value0) when is_binary(Value0) ->
    try binary_to_integer(Value0) of
        Value -> {true, Value}
    catch _:_ ->
        false
    end.
----

Constraint functions should only crash because the programmer
made an error when chaining constraints incorrectly (for example
if the constraints were `[int, int]`, and not because of input.
If the input is invalid then `false` must be returned.

In our snippet, the `is_binary/1` guard will crash only
because of a programmer error, and the try block is there
to ensure that we do not crash when the input is invalid.
