Validus Validation Library for F#

Validus provides an applicative computation expression via the validate { ... } block. This allows you to run multiple validators and, instead of failing at the first error, accumulate all validation errors into a single result.

• Use let! field = validator "label" value to validate a field and bind the result.
• Use and! field = validator "label" value to validate an additional field while accumulating errors.
• The return statement is only executed if all validators within the block return Ok.

validate {
  let! first = firstNameValidator "First name" dto.FirstName
  and! last = nameValidator "Last name" dto.LastName
  and! age = Check.optional (Check.Int.between 1 120) "Age" dto.Age

  return { Name = { First = first; Last = last }; Age = age }
}

Use ValidatorGroup to chain multiple validation rules together. You can compose rules using:

• .And(validator): All validators must pass.
• .Then(validator): The second validator only executes if the previous one succeeded (waterfall pattern).
• .Build(): Finalizes the group into a single validator.

You can also apply a validator to a collection by mapping it over the list/sequence.

let emailValidator =
    ValidatorGroup(Check.String.betweenLen 8 512)
        .And(emailPatternValidator)
        .Then(mailAddressValidator) // only executes when prior two steps are `Ok`
        .Build()

"fake@test" |> emailValidator "Login email"

Use Check.Int (and related numeric modules) to validate that numbers meet specific comparison criteria. You can use standard error messages or provide a custom message via Check.WithMessage.

Supported types for comparison include: int16, int, int64, decimal, float, DateTime, DateTimeOffset, and TimeSpan.

open Validus

// Standard error message
let greaterThanOrEqualTo100 =
  Check.Int.greaterThanOrEqualTo 100 "fieldName"

// Custom error message
let msg = sprintf "%s must be greater than or equal to 100"
let greaterThanOrEqualTo100Custom =
  Check.WithMessage.Int.greaterThanOrEqualTo 100 msg "fieldName"

// Available comparison methods:
// - greaterThanOrEqualTo
// - lessThan
// - lessThanOrEqualTo

You can create custom validation logic using Validator.create. This function takes an error message and a rule function (which returns a bool).

let myValidator = 
    let rule v = v = "expected_value"
    let msg = "Value must be expected_value"
    Validator.create msg rule

// Usage
"expected_value" |> myValidator "My Field"

let fooValidator =
    let fooRule v = v = "foo"
    let fooMessage = sprintf "%s must be a string that matches 'foo'"
    Validator.create fooMessage fooRule

"bar" |> fooValidator "Test string"

Use Check.String (or similar modules for array, list, or seq) to validate the length of collections or strings.

Available length-based validators:

• betweenLen min max: Checks if length is within range.
• equalsLen len: Checks if length is exactly equal to len.
• greaterThanLen len: Checks if length is greater than len.
• greaterThanOrEqualToLen len: Checks if length is $\ge$ len.
• lessThanLen len: Checks if length is less than len.
• lessThanOrEqualToLen len: Checks if length is $\le$ len.
• empty: Checks if the collection/string is empty.
• notEmpty: Checks if the collection/string is not empty.

open Validus

// Check if string is between 1 and 100 chars
let between1and100Chars = Check.String.betweenLen 1 100 "fieldName"

// Check if string is not empty
let stringIsNotEmpty = Check.String.notEmpty "fieldName"

Use Check.List.exists to validate that a collection contains at least one element that satisfies a given predicate function.

open Validus

// Checks if the list contains the value 1
let collectionContains = Check.List.exists (fun x -> x = 1) "fieldName"

Use Check.String.pattern to ensure a string matches a specific regular expression. You can provide a custom error message using Check.WithMessage.String.pattern.

open Validus

// Standard error message
let stringIsChars = Check.String.pattern "[a-z]+" "fieldName"

// Custom error message
let msg = "must follow the pattern [a-z]"
let stringIsCharsCustom = Check.WithMessage.String.pattern "[a-z]" msg "fieldName"

The Check module provides validators for equality and inequality. These apply to string, int16, int, int64, decimal, float, DateTime, DateTimeOffset, TimeSpan, 'a array, 'a list, 'a seq.

Use Check.[Type].equals or Check.[Type].notEquals for default English error messages, or Check.WithMessage.[Type].equals / Check.WithMessage.[Type].notEquals to provide a custom message.

Note: These validators require a field name string as an argument.

// Standard error message
let equalsFoo = Check.String.equals "foo" "fieldName"

// Custom error message
let equalsFooCustom = Check.WithMessage.String.equals "foo" "must equal foo" "fieldName"

// Inequality
let notEqualsFoo = Check.String.notEquals "foo" "fieldName"

The Check module provides validators for numeric and temporal ranges. These apply to int16, int, int64, decimal, float, DateTime, DateTimeOffset, TimeSpan.

• Check.[Type].between min max "fieldName": Checks if a value is within an inclusive range.
• Check.[Type].greaterThan threshold "fieldName": Checks if a value is strictly greater than the threshold.

Custom messages can be provided via Check.WithMessage.[Type].between or Check.WithMessage.[Type].greaterThan.

// Between
let between1and100 = Check.Int.between 1 100 "fieldName"

// Greater Than
let greaterThan100 = Check.Int.greaterThan 100 "fieldName"