Outros Validadores

Existem muitos validadores disponíveis no composer que podem ser usados diretamente, como:

webman/validation (Recomendado)

top-think/think-validate

respect/validation

Validador webman/validation

Baseado em illuminate/validation, oferece validação manual, validação por anotação, validação em nível de parâmetro e conjuntos de regras reutilizáveis.

Instalação

composer require webman/validation

Conceitos Básicos

• Reutilização de Conjunto de Regras: Defina rules, messages, attributes e scenes reutilizáveis estendendo support\validation\Validator, que podem ser reutilizados tanto na validação manual quanto na validação por anotação.
• Validação por Anotação (Atributo) em Nível de Método: Use o atributo PHP 8 #[Validate] para vincular a validação aos métodos do controlador.
• Validação por Anotação (Atributo) em Nível de Parâmetro: Use o atributo PHP 8 #[Param] para vincular a validação aos parâmetros dos métodos do controlador.
• Tratamento de Exceções: Lança support\validation\ValidationException em caso de falha na validação; a classe de exceção é configurável.
• Validação de Banco de Dados: Se a validação envolver banco de dados, é necessário instalar composer require webman/database.

Validação Manual

Uso Básico

use support\validation\Validator;

$data = ['email' => 'user@example.com'];

Validator::make($data, [
    'email' => 'required|email',
])->validate();

Nota
validate() lança support\validation\ValidationException quando a validação falha. Se preferir não lançar exceções, use a abordagem fails() abaixo para obter as mensagens de erro.

Mensagens e atributos personalizados

use support\validation\Validator;

$data = ['contact' => 'user@example.com'];

Validator::make(
    $data,
    ['contact' => 'required|email'],
    ['contact.email' => 'Invalid email format'],
    ['contact' => 'Email']
)->validate();

Validar Sem Exceção (Obter Mensagens de Erro)

Se preferir não lançar exceções, use fails() para verificar e obter as mensagens de erro via errors() (retorna MessageBag):

use support\validation\Validator;

$data = ['email' => 'bad-email'];

$validator = Validator::make($data, [
    'email' => 'required|email',
]);

if ($validator->fails()) {
    $firstError = $validator->errors()->first();      // string
    $allErrors = $validator->errors()->all();         // array
    $errorsByField = $validator->errors()->toArray(); // array
    // handle errors...
}

Reutilização de Conjunto de Regras (Validador Personalizado)

namespace app\validation;

use support\validation\Validator;

class UserValidator extends Validator
{
    protected array $rules = [
        'id' => 'required|integer|min:1',
        'name' => 'required|string|min:2|max:20',
        'email' => 'required|email',
    ];

    protected array $messages = [
        'name.required' => 'Name is required',
        'email.required' => 'Email is required',
        'email.email' => 'Invalid email format',
    ];

    protected array $attributes = [
        'name' => 'Name',
        'email' => 'Email',
    ];
}

Reutilização na Validação Manual

use app\validation\UserValidator;

UserValidator::make($data)->validate();

Uso de Cenas (Opcional)

scenes é um recurso opcional; valida apenas um subconjunto de campos quando você chama withScene(...).

namespace app\validation;

use support\validation\Validator;

class UserValidator extends Validator
{
    protected array $rules = [
        'id' => 'required|integer|min:1',
        'name' => 'required|string|min:2|max:20',
        'email' => 'required|email',
    ];

    protected array $scenes = [
        'create' => ['name', 'email'],
        'update' => ['id', 'name', 'email'],
    ];
}

use app\validation\UserValidator;

// Nenhuma cena especificada -> valida todas as regras
UserValidator::make($data)->validate();

// Cena especificada -> valida apenas os campos dessa cena
UserValidator::make($data)->withScene('create')->validate();

Validação por Anotação (Nível de Método)

Regras Diretas

use support\Request;
use support\validation\annotation\Validate;

class AuthController
{
    #[Validate(
        rules: [
            'email' => 'required|email',
            'password' => 'required|string|min:6',
        ],
        messages: [
            'email.required' => 'Email is required',
            'password.required' => 'Password is required',
        ],
        attributes: [
            'email' => 'Email',
            'password' => 'Password',
        ]
    )]
    public function login(Request $request)
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Reutilização de Conjuntos de Regras

use app\validation\UserValidator;
use support\Request;
use support\validation\annotation\Validate;

class UserController
{
    #[Validate(validator: UserValidator::class, scene: 'create')]
    public function create(Request $request)
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Múltiplas Sobreposições de Validação

use support\validation\annotation\Validate;

class UserController
{
    #[Validate(rules: ['email' => 'required|email'])]
    #[Validate(rules: ['token' => 'required|string'])]
    public function send()
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Fonte de Dados da Validação

use support\validation\annotation\Validate;

class UserController
{
    #[Validate(
        rules: ['email' => 'required|email'],
        in: ['query', 'body', 'path']
    )]
    public function send()
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Use o parâmetro in para especificar a fonte de dados:

• query parâmetros de consulta da requisição HTTP, de $request->get()
• body corpo da requisição HTTP, de $request->post()
• path parâmetros de caminho da requisição HTTP, de $request->route->param()

in pode ser uma string ou array; quando é um array, os valores são mesclados em ordem, com valores posteriores sobrescrevendo os anteriores. Quando in não é passado, o padrão é ['query', 'body', 'path'].

Validação em Nível de Parâmetro (Param)

Uso Básico

use support\validation\annotation\Param;

class MailController
{
    public function send(
        #[Param(rules: 'required|email')] string $from,
        #[Param(rules: 'required|email')] string $to,
        #[Param(rules: 'required|string|min:1|max:500')] string $content
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Fonte de Dados da Validação

Da mesma forma, a validação em nível de parâmetro também suporta o parâmetro in para especificar a fonte:

use support\validation\annotation\Param;

class MailController
{
    public function send(
        #[Param(rules: 'required|email', in: ['body'])] string $from
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

rules suporta string ou array

use support\validation\annotation\Param;

class MailController
{
    public function send(
        #[Param(rules: ['required', 'email'])] string $from
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Mensagens / atributo personalizados

use support\validation\annotation\Param;

class UserController
{
    public function updateEmail(
        #[Param(
            rules: 'required|email',
            messages: ['email.email' => 'Invalid email format'],
            attribute: 'Email'
        )]
        string $email
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Reutilização de Constante de Regra

final class ParamRules
{
    public const EMAIL = ['required', 'email'];
}

class UserController
{
    public function send(
        #[Param(rules: ParamRules::EMAIL)] string $email
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Combinação de Nível de Método + Nível de Parâmetro

use support\Request;
use support\validation\annotation\Param;
use support\validation\annotation\Validate;

class UserController
{
    #[Validate(rules: ['token' => 'required|string'])]
    public function send(
        Request $request,
        #[Param(rules: 'required|email')] string $from,
        #[Param(rules: 'required|integer')] int $id
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Inferência Automática de Regras (Baseada na Assinatura do Parâmetro)

Quando #[Validate] é usado em um método, ou qualquer parâmetro desse método usa #[Param], este componente infere e completa automaticamente regras básicas de validação a partir da assinatura do parâmetro do método, depois mescla-as com as regras existentes antes da validação.

Exemplo: expansão equivalente de #[Validate]

1) Apenas habilitar #[Validate] sem escrever regras manualmente:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate]
    public function create(string $content, int $uid)
    {
    }
}

Equivalente a:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'required|string',
        'uid' => 'required|integer',
    ])]
    public function create(string $content, int $uid)
    {
    }
}

2) Apenas regras parciais escritas, o restante completado pela assinatura do parâmetro:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'min:2',
    ])]
    public function create(string $content, int $uid)
    {
    }
}

Equivalente a:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'required|string|min:2',
        'uid' => 'required|integer',
    ])]
    public function create(string $content, int $uid)
    {
    }
}

3) Valor padrão / tipo nullable:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate]
    public function create(string $content = 'default', ?int $uid = null)
    {
    }
}

Equivalente a:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'string',
        'uid' => 'integer|nullable',
    ])]
    public function create(string $content = 'default', ?int $uid = null)
    {
    }
}

Tratamento de Exceções

Exceção Padrão

A falha na validação lança support\validation\ValidationException por padrão, que estende Webman\Exception\BusinessException e não registra erros.

O comportamento padrão de resposta é tratado por BusinessException::render():

• Requisições normais: retorna mensagem em string, ex: token is required.
• Requisições JSON: retorna resposta JSON, ex: {"code": 422, "msg": "token is required.", "data":....}

Personalizar tratamento via exceção customizada

• Configuração global: exception em config/plugin/webman/validation/app.php

Suporte Multilíngue

O componente inclui pacotes de idioma chinês e inglês integrados e suporta sobrescritas do projeto. Ordem de carregamento:

1. Pacote de idioma do projeto resource/translations/{locale}/validation.php
2. Integrado ao componente vendor/webman/validation/resources/lang/{locale}/validation.php
3. Inglês integrado do Illuminate (fallback)

Nota
O idioma padrão do Webman é configurado em config/translation.php, ou pode ser alterado via locale('en');.

Exemplo de Sobrescrita Local

resource/translations/zh_CN/validation.php

return [
    'email' => ':attribute is not a valid email format.',
];

Carregamento Automático de Middleware

Após a instalação, o componente carrega automaticamente o middleware de validação via config/plugin/webman/validation/middleware.php; não é necessário registro manual.

Geração pela Linha de Comando

Use o comando make:validator para gerar classes de validador (saída padrão para o diretório app/validation).

Nota
Requer composer require webman/console

Uso Básico

• Gerar template vazio

php webman make:validator UserValidator

• Sobrescrever arquivo existente

php webman make:validator UserValidator --force
php webman make:validator UserValidator -f

Gerar regras a partir da estrutura da tabela

• Especificar nome da tabela para gerar regras base (infere $rules a partir do tipo de campo/nullable/comprimento etc.; exclui campos relacionados a ORM por padrão: laravel usa created_at/updated_at/deleted_at, thinkorm usa create_time/update_time/delete_time)

php webman make:validator UserValidator --table=wa_users
php webman make:validator UserValidator -t wa_users

• Especificar conexão do banco de dados (cenários de múltiplas conexões)

php webman make:validator UserValidator --table=wa_users --database=mysql
php webman make:validator UserValidator -t wa_users -d mysql

Cenas

• Gerar cenas CRUD: create/update/delete/detail

php webman make:validator UserValidator --table=wa_users --scenes=crud
php webman make:validator UserValidator -t wa_users -s crud

A cena update inclui o campo de chave primária (para localizar registros) mais os demais campos; delete/detail incluem apenas a chave primária por padrão.

Seleção de ORM (laravel (illuminate/database) vs think-orm)

• Seleção automática (padrão): Usa o que estiver instalado/configurado; quando ambos existem, usa illuminate por padrão
• Forçar especificação

php webman make:validator UserValidator --table=wa_users --orm=laravel
php webman make:validator UserValidator --table=wa_users --orm=thinkorm
php webman make:validator UserValidator -t wa_users -o thinkorm

Exemplo completo

php webman make:validator UserValidator -t wa_users -d mysql -s crud -o laravel -f

Testes Unitários

No diretório raiz do webman/validation, execute:

composer install
vendor\bin\phpunit -c phpunit.xml

Referência de Regras de Validação

Regras de Validação Disponíveis

[!IMPORTANT]

• O Webman Validation é baseado em illuminate/validation; os nomes das regras correspondem ao Laravel e não há regras específicas do Webman.
• O middleware valida dados de $request->all() (GET+POST) mesclados com parâmetros de rota por padrão, excluindo arquivos enviados; para regras de arquivo, mescle $request->file() nos dados você mesmo, ou chame Validator::make manualmente.
• current_password depende do guard de autenticação; exists/unique dependem da conexão do banco de dados e do query builder; essas regras não estão disponíveis quando os componentes correspondentes não estão integrados.

A seguir, todas as regras de validação disponíveis e seus propósitos:

Boolean

String

Numeric

Array

Date

File

Database

Utility

accepted

O campo deve ser "yes", "on", 1, "1", true ou "true". Comumente usado para cenários como verificar concordância do usuário com os termos de serviço.

accepted_if:anotherfield,value,...

Quando outro campo for igual ao valor especificado, o campo deve ser "yes", "on", 1, "1", true ou "true". Comumente usado para cenários de concordância condicional.

active_url

O campo deve ter um registro A ou AAAA válido. Esta regra primeiro usa parse_url para extrair o hostname da URL, depois valida com dns_get_record.

after:date

O campo deve ser um valor após a data fornecida. A data é passada para strtotime para converter em um DateTime válido:

use support\validation\Validator;

Validator::make($data, [
    'start_date' => 'required|date|after:tomorrow',
])->validate();

Você também pode passar outro nome de campo para comparação:

Validator::make($data, [
    'finish_date' => 'required|date|after:start_date',
])->validate();

Você pode usar o construtor fluente da regra date:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->after(\Carbon\Carbon::today()->addDays(7)),
    ],
])->validate();

afterToday e todayOrAfter expressam convenientemente "deve ser após hoje" ou "deve ser hoje ou posterior":

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->afterToday(),
    ],
])->validate();

after_or_equal:date

O campo deve ser na ou após a data fornecida. Consulte after para mais detalhes.

Você pode usar o construtor fluente da regra date:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->afterOrEqual(\Carbon\Carbon::today()->addDays(7)),
    ],
])->validate();

anyOf

Rule::anyOf permite especificar "satisfazer qualquer um dos conjuntos de regras". Por exemplo, a seguinte regra significa que username deve ser um endereço de e-mail ou uma string alfanumérica/underscore/hífen de pelo menos 6 caracteres:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'username' => [
        'required',
        Rule::anyOf([
            ['string', 'email'],
            ['string', 'alpha_dash', 'min:6'],
        ]),
    ],
])->validate();

alpha

O campo deve ser letras Unicode (\p{L} e \p{M}).

Para permitir apenas ASCII (a-z, A-Z), adicione a opção ascii:

Validator::make($data, [
    'username' => 'alpha:ascii',
])->validate();

alpha_dash

O campo pode conter apenas letras e números Unicode (\p{L}, \p{M}, \p{N}), mais hífen ASCII (-) e underscore (_).

Para permitir apenas ASCII (a-z, A-Z, 0-9), adicione a opção ascii:

Validator::make($data, [
    'username' => 'alpha_dash:ascii',
])->validate();

alpha_num

O campo pode conter apenas letras e números Unicode (\p{L}, \p{M}, \p{N}).

Para permitir apenas ASCII (a-z, A-Z, 0-9), adicione a opção ascii:

Validator::make($data, [
    'username' => 'alpha_num:ascii',
])->validate();

array

O campo deve ser um array PHP.

Quando a regra array tem parâmetros extras, as chaves do array de entrada devem estar na lista de parâmetros. No exemplo, a chave admin não está na lista permitida, portanto é inválida:

use support\validation\Validator;

$input = [
    'user' => [
        'name' => 'Taylor Otwell',
        'username' => 'taylorotwell',
        'admin' => true,
    ],
];

Validator::make($input, [
    'user' => 'array:name,username',
])->validate();

Recomenda-se definir explicitamente as chaves de array permitidas em projetos reais.

ascii

O campo pode conter apenas caracteres ASCII de 7 bits.

bail

Interrompe a validação de regras subsequentes para o campo quando a primeira regra falha.

Esta regra afeta apenas o campo atual. Para "parar na primeira falha globalmente", use o validador do Illuminate diretamente e chame stopOnFirstFailure().

before:date

O campo deve ser anterior à data fornecida. A data é passada para strtotime para converter em um DateTime válido. Como after, você pode passar outro nome de campo para comparação.

Você pode usar o construtor fluente da regra date:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->before(\Carbon\Carbon::today()->subDays(7)),
    ],
])->validate();

beforeToday e todayOrBefore expressam convenientemente "deve ser antes de hoje" ou "deve ser hoje ou anterior":

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->beforeToday(),
    ],
])->validate();

before_or_equal:date

O campo deve ser na ou antes da data fornecida. A data é passada para strtotime para converter em um DateTime válido. Como after, você pode passar outro nome de campo para comparação.

Você pode usar o construtor fluente da regra date:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->beforeOrEqual(\Carbon\Carbon::today()->subDays(7)),
    ],
])->validate();

between:min,max

O tamanho do campo deve estar entre min e max (inclusive). A avaliação para strings, números, arrays e arquivos é a mesma que size.

boolean

O campo deve ser convertível para boolean. Entradas aceitáveis incluem true, false, 1, 0, "1", "0".

Use o parâmetro strict para permitir apenas true ou false:

Validator::make($data, [
    'foo' => 'boolean:strict',
])->validate();

confirmed

O campo deve ter um campo correspondente {field}_confirmation. Por exemplo, quando o campo é password, password_confirmation é obrigatório.

Você também pode especificar um nome de campo de confirmação personalizado, ex: confirmed:repeat_username exige que repeat_username corresponda ao campo atual.

contains:foo,bar,...

O campo deve ser um array e deve conter todos os valores de parâmetro fornecidos. Esta regra é comumente usada para validação de array; você pode usar Rule::contains para construí-la:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'roles' => [
        'required',
        'array',
        Rule::contains(['admin', 'editor']),
    ],
])->validate();

doesnt_contain:foo,bar,...

O campo deve ser um array e não deve conter nenhum dos valores de parâmetro fornecidos. Você pode usar Rule::doesntContain para construí-la:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'roles' => [
        'required',
        'array',
        Rule::doesntContain(['admin', 'editor']),
    ],
])->validate();

current_password

O campo deve corresponder à senha do usuário autenticado atual. Você pode especificar o guard de autenticação como primeiro parâmetro:

Validator::make($data, [
    'password' => 'current_password:api',
])->validate();

[!WARNING]
Esta regra depende do componente de autenticação e da configuração do guard; não use quando a autenticação não estiver integrada.

date

O campo deve ser uma data válida (não relativa) reconhecível por strtotime.

date_equals:date

O campo deve ser igual à data fornecida. A data é passada para strtotime para converter em um DateTime válido.

date_format:format,...

O campo deve corresponder a um dos formatos fornecidos. Use date ou date_format. Esta regra suporta todos os formatos DateTime do PHP.

Você pode usar o construtor fluente da regra date:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->format('Y-m-d'),
    ],
])->validate();

decimal:min,max

O campo deve ser numérico com as casas decimais necessárias:

Validator::make($data, [
    'price' => 'decimal:2',
])->validate();

Validator::make($data, [
    'price' => 'decimal:2,4',
])->validate();

declined

O campo deve ser "no", "off", 0, "0", false ou "false".

declined_if:anotherfield,value,...

Quando outro campo for igual ao valor especificado, o campo deve ser "no", "off", 0, "0", false ou "false".

different:field

O campo deve ser diferente de field.

digits:value

O campo deve ser um inteiro com comprimento value.

digits_between:min,max

O campo deve ser um inteiro com comprimento entre min e max.

dimensions

O campo deve ser uma imagem e satisfazer as restrições de dimensão:

Validator::make($data, [
    'avatar' => 'dimensions:min_width=100,min_height=200',
])->validate();

Restrições disponíveis: min_width, max_width, min_height, max_height, width, height, ratio.

ratio é a proporção de aspecto; pode ser expressa como fração ou float:

Validator::make($data, [
    'avatar' => 'dimensions:ratio=3/2',
])->validate();

Esta regra tem muitos parâmetros; recomenda-se usar Rule::dimensions para construí-la:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'avatar' => [
        'required',
        Rule::dimensions()
            ->maxWidth(1000)
            ->maxHeight(500)
            ->ratio(3 / 2),
    ],
])->validate();

distinct

Ao validar arrays, os valores do campo não devem ser duplicados:

Validator::make($data, [
    'foo.*.id' => 'distinct',
])->validate();

Usa comparação frouxa por padrão. Adicione strict para comparação estrita:

Validator::make($data, [
    'foo.*.id' => 'distinct:strict',
])->validate();

Adicione ignore_case para ignorar diferenças de maiúsculas/minúsculas:

Validator::make($data, [
    'foo.*.id' => 'distinct:ignore_case',
])->validate();

doesnt_start_with:foo,bar,...

O campo não deve começar com nenhum dos valores especificados.

doesnt_end_with:foo,bar,...

O campo não deve terminar com nenhum dos valores especificados.

email

O campo deve ser um endereço de e-mail válido. Esta regra depende de egulias/email-validator, usa RFCValidation por padrão e pode usar outros métodos de validação:

Validator::make($data, [
    'email' => 'email:rfc,dns',
])->validate();

Métodos de validação disponíveis:

Você pode usar o construtor fluente de regras:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        'required',
        Rule::email()
            ->rfcCompliant(strict: false)
            ->validateMxRecord()
            ->preventSpoofing(),
    ],
])->validate();

[!WARNING]
dns e spoof requerem a extensão PHP intl.

encoding:encoding_type

O campo deve corresponder à codificação de caracteres especificada. Esta regra usa mb_check_encoding para detectar codificação de arquivo ou string. Pode ser usada com o construtor de regras de arquivo:

use Illuminate\Validation\Rules\File;
use support\validation\Validator;

Validator::make($data, [
    'attachment' => [
        'required',
        File::types(['csv'])->encoding('utf-8'),
    ],
])->validate();

ends_with:foo,bar,...

O campo deve terminar com um dos valores especificados.

enum

Enum é uma regra baseada em classe para validar que o valor do campo é um valor enum válido. Passe o nome da classe enum ao construir. Para valores primitivos, use Backed Enum:

use app\enums\ServerStatus;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'status' => [Rule::enum(ServerStatus::class)],
])->validate();

Use only/except para restringir valores enum:

use app\enums\ServerStatus;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'status' => [
        Rule::enum(ServerStatus::class)
            ->only([ServerStatus::Pending, ServerStatus::Active]),
    ],
])->validate();

Validator::make($data, [
    'status' => [
        Rule::enum(ServerStatus::class)
            ->except([ServerStatus::Pending, ServerStatus::Active]),
    ],
])->validate();

Use when para restrições condicionais:

use app\Enums\ServerStatus;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'status' => [
        Rule::enum(ServerStatus::class)->when(
            $isAdmin,
            fn ($rule) => $rule->only(ServerStatus::Active),
            fn ($rule) => $rule->only(ServerStatus::Pending),
        ),
    ],
])->validate();

exclude

O campo será excluído dos dados retornados por validate/validated.

exclude_if:anotherfield,value

Quando anotherfield for igual a value, o campo será excluído dos dados retornados por validate/validated.

Para condições complexas, use Rule::excludeIf:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'role_id' => Rule::excludeIf($isAdmin),
])->validate();

Validator::make($data, [
    'role_id' => Rule::excludeIf(fn () => $isAdmin),
])->validate();

exclude_unless:anotherfield,value

A menos que anotherfield seja igual a value, o campo será excluído dos dados retornados por validate/validated. Se value for null (ex: exclude_unless:name,null), o campo só é mantido quando o campo de comparação for null ou ausente.

exclude_with:anotherfield

Quando anotherfield existir, o campo será excluído dos dados retornados por validate/validated.

exclude_without:anotherfield

Quando anotherfield não existir, o campo será excluído dos dados retornados por validate/validated.

exists:table,column

O campo deve existir na tabela do banco de dados especificada.

Uso básico da regra Exists

Validator::make($data, [
    'state' => 'exists:states',
])->validate();

Quando column não é especificado, o nome do campo é usado por padrão. Então este exemplo valida se a coluna state existe na tabela states.

Especificando um nome de coluna personalizado

Acrescente o nome da coluna após o nome da tabela:

Validator::make($data, [
    'state' => 'exists:states,abbreviation',
])->validate();

Para especificar uma conexão de banco de dados, prefixe o nome da tabela com o nome da conexão:

Validator::make($data, [
    'email' => 'exists:connection.staff,email',
])->validate();

Você também pode passar um nome de classe de modelo; o framework resolverá o nome da tabela:

Validator::make($data, [
    'user_id' => 'exists:app\model\User,id',
])->validate();

Para condições de consulta personalizadas, use o construtor Rule:

use Illuminate\Database\Query\Builder;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        'required',
        Rule::exists('staff')->where(function (Builder $query) {
            $query->where('account_id', 1);
        }),
    ],
])->validate();

Você também pode especificar o nome da coluna diretamente em Rule::exists:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'state' => [Rule::exists('states', 'abbreviation')],
])->validate();

Para validar que um conjunto de valores existe, combine com a regra array:

Validator::make($data, [
    'states' => ['array', Rule::exists('states', 'abbreviation')],
])->validate();

Quando tanto array quanto exists estão presentes, uma única consulta valida todos os valores.

extensions:foo,bar,...

Valida que a extensão do arquivo enviado está na lista permitida:

Validator::make($data, [
    'photo' => ['required', 'extensions:jpg,png'],
])->validate();

[!WARNING]
Não confie apenas na extensão para validação de tipo de arquivo; use junto com mimes ou mimetypes.

file

O campo deve ser um arquivo enviado com sucesso.

filled

Quando o campo existir, seu valor não deve estar vazio.

gt:field

O campo deve ser maior que o field ou value fornecido. Ambos os campos devem ter o mesmo tipo. A avaliação para strings, números, arrays e arquivos é a mesma que size.

gte:field

O campo deve ser maior ou igual ao field ou value fornecido. Ambos os campos devem ter o mesmo tipo. A avaliação para strings, números, arrays e arquivos é a mesma que size.

hex_color

O campo deve ser um valor de cor hexadecimal válido.

image

O campo deve ser uma imagem (jpg, jpeg, png, bmp, gif ou webp).

[!WARNING]
SVG não é permitido por padrão devido ao risco de XSS. Para permitir, adicione allow_svg: image:allow_svg.

in:foo,bar,...

O campo deve estar na lista de valores fornecida. Você pode usar Rule::in para construir:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'zones' => [
        'required',
        Rule::in(['first-zone', 'second-zone']),
    ],
])->validate();

Quando combinado com a regra array, cada valor no array de entrada deve estar na lista in:

use support\validation\Rule;
use support\validation\Validator;

$input = [
    'airports' => ['NYC', 'LAS'],
];

Validator::make($input, [
    'airports' => [
        'required',
        'array',
    ],
    'airports.*' => Rule::in(['NYC', 'LIT']),
])->validate();

in_array:anotherfield.*

O campo deve existir na lista de valores de anotherfield.

in_array_keys:value.*

O campo deve ser um array e deve conter pelo menos um dos valores fornecidos como chave:

Validator::make($data, [
    'config' => 'array|in_array_keys:timezone',
])->validate();

integer

O campo deve ser um inteiro.

Use o parâmetro strict para exigir que o tipo do campo seja inteiro; inteiros em string serão inválidos:

Validator::make($data, [
    'age' => 'integer:strict',
])->validate();

[!WARNING]
Esta regra apenas valida se passa no FILTER_VALIDATE_INT do PHP; para tipos numéricos estritos, use junto com numeric.

ip

O campo deve ser um endereço IP válido.

ipv4

O campo deve ser um endereço IPv4 válido.

ipv6

O campo deve ser um endereço IPv6 válido.

json

O campo deve ser uma string JSON válida.

lt:field

O campo deve ser menor que o field fornecido. Ambos os campos devem ter o mesmo tipo. A avaliação para strings, números, arrays e arquivos é a mesma que size.

lte:field

O campo deve ser menor ou igual ao field fornecido. Ambos os campos devem ter o mesmo tipo. A avaliação para strings, números, arrays e arquivos é a mesma que size.

lowercase

O campo deve estar em minúsculas.

list

O campo deve ser um array lista. As chaves do array lista devem ser números consecutivos de 0 a count($array) - 1.

mac_address

O campo deve ser um endereço MAC válido.

max:value

O campo deve ser menor ou igual a value. A avaliação para strings, números, arrays e arquivos é a mesma que size.

max_digits:value

O campo deve ser um inteiro com comprimento não excedendo value.

mimetypes:text/plain,...

Valida que o tipo MIME do arquivo está na lista:

Validator::make($data, [
    'video' => 'mimetypes:video/avi,video/mpeg,video/quicktime',
])->validate();

O tipo MIME é inferido pela leitura do conteúdo do arquivo e pode diferir do MIME fornecido pelo cliente.

mimes:foo,bar,...

Valida que o tipo MIME do arquivo corresponde à extensão fornecida:

Validator::make($data, [
    'photo' => 'mimes:jpg,bmp,png',
])->validate();

Embora os parâmetros sejam extensões, esta regra lê o conteúdo do arquivo para determinar o MIME. Mapeamento extensão-MIME:

https://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types

Tipos MIME e extensões

Esta regra não valida que a "extensão do arquivo" corresponda ao "MIME real". Por exemplo, mimes:png trata photo.txt com conteúdo PNG como válido. Para validar extensão, use extensions.

min:value

O campo deve ser maior ou igual a value. A avaliação para strings, números, arrays e arquivos é a mesma que size.

min_digits:value

O campo deve ser um inteiro com comprimento não inferior a value.

multiple_of:value

O campo deve ser um múltiplo de value.

missing

O campo não deve existir nos dados de entrada.

missing_if:anotherfield,value,...

Quando anotherfield for igual a qualquer value, o campo não deve existir.

missing_unless:anotherfield,value

A menos que anotherfield seja igual a qualquer value, o campo não deve existir.

missing_with:foo,bar,...

Quando qualquer campo especificado existir, o campo não deve existir.

missing_with_all:foo,bar,...

Quando todos os campos especificados existirem, o campo não deve existir.

not_in:foo,bar,...

O campo não deve estar na lista de valores fornecida. Você pode usar Rule::notIn para construir:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'toppings' => [
        'required',
        Rule::notIn(['sprinkles', 'cherries']),
    ],
])->validate();

not_regex:pattern

O campo não deve corresponder à expressão regular fornecida.

Esta regra usa preg_match do PHP. O regex deve ter delimitadores, ex: 'email' => 'not_regex:/^.+$/i'.

[!WARNING]
Ao usar regex/not_regex, se o regex contiver |, use a forma array para evitar conflito com o separador |.

nullable

O campo pode ser null.

numeric

O campo deve ser numérico.

Use o parâmetro strict para permitir apenas tipos inteiro ou float; strings numéricas serão inválidas:

Validator::make($data, [
    'amount' => 'numeric:strict',
])->validate();

present

O campo deve existir nos dados de entrada.

present_if:anotherfield,value,...

Quando anotherfield for igual a qualquer value, o campo deve existir.

present_unless:anotherfield,value

A menos que anotherfield seja igual a qualquer value, o campo deve existir.

present_with:foo,bar,...

Quando qualquer campo especificado existir, o campo deve existir.

present_with_all:foo,bar,...

Quando todos os campos especificados existirem, o campo deve existir.

prohibited

O campo deve estar ausente ou vazio. "Vazio" significa:

prohibited_if:anotherfield,value,...

Quando anotherfield for igual a qualquer value, o campo deve estar ausente ou vazio. "Vazio" significa:

Para condições complexas, use Rule::prohibitedIf:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'role_id' => Rule::prohibitedIf($isAdmin),
])->validate();

Validator::make($data, [
    'role_id' => Rule::prohibitedIf(fn () => $isAdmin),
])->validate();

prohibited_if_accepted:anotherfield,...

Quando anotherfield for "yes", "on", 1, "1", true ou "true", o campo deve estar ausente ou vazio.

prohibited_if_declined:anotherfield,...

Quando anotherfield for "no", "off", 0, "0", false ou "false", o campo deve estar ausente ou vazio.

prohibited_unless:anotherfield,value,...

A menos que anotherfield seja igual a qualquer value, o campo deve estar ausente ou vazio. "Vazio" significa:

prohibits:anotherfield,...

Quando o campo existir e não estiver vazio, todos os campos em anotherfield devem estar ausentes ou vazios. "Vazio" significa:

regex:pattern

O campo deve corresponder à expressão regular fornecida.

Esta regra usa preg_match do PHP. O regex deve ter delimitadores, ex: 'email' => 'regex:/^.+@.+$/i'.

[!WARNING]
Ao usar regex/not_regex, se o regex contiver |, use a forma array para evitar conflito com o separador |.

required

O campo deve existir e não estar vazio. "Vazio" significa:

required_if:anotherfield,value,...

Quando anotherfield for igual a qualquer value, o campo deve existir e não estar vazio.

Para condições complexas, use Rule::requiredIf:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'role_id' => Rule::requiredIf($isAdmin),
])->validate();

Validator::make($data, [
    'role_id' => Rule::requiredIf(fn () => $isAdmin),
])->validate();

required_if_accepted:anotherfield,...

Quando anotherfield for "yes", "on", 1, "1", true ou "true", o campo deve existir e não estar vazio.

required_if_declined:anotherfield,...

Quando anotherfield for "no", "off", 0, "0", false ou "false", o campo deve existir e não estar vazio.

required_unless:anotherfield,value,...

A menos que anotherfield seja igual a qualquer value, o campo deve existir e não estar vazio. Se value for null (ex: required_unless:name,null), o campo pode estar vazio apenas quando o campo de comparação for null ou ausente.

required_with:foo,bar,...

Quando qualquer campo especificado existir e não estiver vazio, o campo deve existir e não estar vazio.

required_with_all:foo,bar,...

Quando todos os campos especificados existirem e não estiverem vazios, o campo deve existir e não estar vazio.

required_without:foo,bar,...

Quando qualquer campo especificado estiver vazio ou ausente, o campo deve existir e não estar vazio.

required_without_all:foo,bar,...

Quando todos os campos especificados estiverem vazios ou ausentes, o campo deve existir e não estar vazio.

required_array_keys:foo,bar,...

O campo deve ser um array e deve conter pelo menos as chaves especificadas.

sometimes

Aplica regras de validação subsequentes apenas quando o campo existir. Comumente usado para campos "opcionais mas devem ser válidos quando presentes":

Validator::make($data, [
    'nickname' => 'sometimes|string|max:20',
])->validate();

same:field

O campo deve ser o mesmo que field.

size:value

O tamanho do campo deve ser igual ao value fornecido. Para strings: contagem de caracteres; para números: inteiro especificado (use com numeric ou integer); para arrays: contagem de elementos; para arquivos: tamanho em KB. Exemplo:

Validator::make($data, [
    'title' => 'size:12',
    'seats' => 'integer|size:10',
    'tags' => 'array|size:5',
    'image' => 'file|size:512',
])->validate();

starts_with:foo,bar,...

O campo deve começar com um dos valores especificados.

string

O campo deve ser uma string. Para permitir null, use junto com nullable.

timezone

O campo deve ser um identificador de fuso horário válido (de DateTimeZone::listIdentifiers). Você pode passar parâmetros suportados por esse método:

Validator::make($data, [
    'timezone' => 'required|timezone:all',
])->validate();

Validator::make($data, [
    'timezone' => 'required|timezone:Africa',
])->validate();

Validator::make($data, [
    'timezone' => 'required|timezone:per_country,US',
])->validate();

unique:table,column

O campo deve ser único na tabela especificada.

Especificar nome de tabela/coluna personalizado:

Você pode especificar o nome da classe do modelo diretamente:

Validator::make($data, [
    'email' => 'unique:app\model\User,email_address',
])->validate();

Você pode especificar o nome da coluna (usa o nome do campo por padrão quando não especificado):

Validator::make($data, [
    'email' => 'unique:users,email_address',
])->validate();

Especificar conexão do banco de dados:

Validator::make($data, [
    'email' => 'unique:connection.users,email_address',
])->validate();

Ignorar ID especificado:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        'required',
        Rule::unique('users')->ignore($user->id),
    ],
])->validate();

[!WARNING]
ignore não deve receber entrada do usuário; use apenas IDs únicos gerados pelo sistema (ID auto-incremento ou UUID do modelo), caso contrário pode haver risco de injeção SQL.

Você também pode passar uma instância do modelo:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users')->ignore($user),
    ],
])->validate();

Se a chave primária não for id, especifique o nome da chave primária:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users')->ignore($user->id, 'user_id'),
    ],
])->validate();

Por padrão usa o nome do campo como coluna única; você também pode especificar o nome da coluna:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users', 'email_address')->ignore($user->id),
    ],
])->validate();

Adicionar condições extras:

use Illuminate\Database\Query\Builder;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users')->where(
            fn (Builder $query) => $query->where('account_id', 1)
        ),
    ],
])->validate();

Ignorar registros com exclusão lógica:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [Rule::unique('users')->withoutTrashed()],
])->validate();

Se a coluna de exclusão lógica não for deleted_at:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [Rule::unique('users')->withoutTrashed('was_deleted_at')],
])->validate();

uppercase

O campo deve estar em maiúsculas.

url

O campo deve ser uma URL válida.

Você pode especificar protocolos permitidos:

Validator::make($data, [
    'url' => 'url:http,https',
    'game' => 'url:minecraft,steam',
])->validate();

ulid

O campo deve ser um ULID válido.

uuid

O campo deve ser um UUID RFC 9562 válido (versão 1, 3, 4, 5, 6, 7 ou 8).

Você pode especificar a versão:

Validator::make($data, [
    'uuid' => 'uuid:4',
])->validate();

Validador top-think/think-validate

Descrição

Validador oficial do ThinkPHP

URL do Projeto

https://github.com/top-think/think-validate

Instalação

composer require topthink/think-validate

Início Rápido

Criar app/index/validate/User.php

<?php
namespace app\index\validate;

use think\Validate;

class User extends Validate
{
    protected $rule =   [
        'name'  => 'require|max:25',
        'age'   => 'number|between:1,120',
        'email' => 'email',    
    ];

    protected $message  =   [
        'name.require' => 'Name is required',
        'name.max'     => 'Name cannot exceed 25 characters',
        'age.number'   => 'Age must be a number',
        'age.between'  => 'Age must be between 1 and 120',
        'email'        => 'Invalid email format',    
    ];

}

Uso

$data = [
    'name'  => 'thinkphp',
    'email' => 'thinkphp@qq.com',
];

$validate = new \app\index\validate\User;

if (!$validate->check($data)) {
    var_dump($validate->getError());
}

Nota
O webman não suporta o método Validate::rule() do think-validate

Validador workerman/validation

Descrição

Este projeto é uma versão localizada de https://github.com/Respect/Validation

URL do Projeto

https://github.com/walkor/validation

Instalação

composer require workerman/validation

Início Rápido

<?php
namespace app\controller;

use support\Request;
use Respect\Validation\Validator as v;
use support\Db;

class IndexController
{
    public function index(Request $request)
    {
        $data = v::input($request->post(), [
            'nickname' => v::length(1, 64)->setName('Nickname'),
            'username' => v::alnum()->length(5, 64)->setName('Username'),
            'password' => v::length(5, 64)->setName('Password')
        ]);
        Db::table('user')->insert($data);
        return json(['code' => 0, 'msg' => 'ok']);
    }
}  

Acesso via jQuery

  $.ajax({
      url : 'http://127.0.0.1:8787',
      type : "post",
      dataType:'json',
      data : {nickname:'Tom', username:'tom cat', password: '123456'}
  });

Resultado:

{"code":500,"msg":"Username may only contain letters (a-z) and numbers (0-9)"}

Explicação:

v::input(array $input, array $rules) valida e coleta dados. Se a validação falhar, lança Respect\Validation\Exceptions\ValidationException; em caso de sucesso retorna os dados validados (array).

Se o código de negócio não capturar a exceção de validação, o framework webman a capturará e retornará JSON (como {"code":500, "msg":"xxx"}) ou uma página de exceção normal com base nos cabeçalhos HTTP. Se o formato da resposta não atender às suas necessidades, você pode capturar ValidationException e retornar dados personalizados, como no exemplo abaixo:

<?php
namespace app\controller;

use support\Request;
use Respect\Validation\Validator as v;
use Respect\Validation\Exceptions\ValidationException;

class IndexController
{
    public function index(Request $request)
    {
        try {
            $data = v::input($request->post(), [
                'username' => v::alnum()->length(5, 64)->setName('Username'),
                'password' => v::length(5, 64)->setName('Password')
            ]);
        } catch (ValidationException $e) {
            return json(['code' => 500, 'msg' => $e->getMessage()]);
        }
        return json(['code' => 0, 'msg' => 'ok', 'data' => $data]);
    }
}

Guia do Validador

use Respect\Validation\Validator as v;

// Validação de regra única
$number = 123;
v::numericVal()->validate($number); // true

// Validação encadeada
$usernameValidator = v::alnum()->noWhitespace()->length(1, 15);
$usernameValidator->validate('alganet'); // true

// Obter primeiro motivo de falha na validação
try {
    $usernameValidator->setName('Username')->check('alg  anet');
} catch (ValidationException $exception) {
    echo $exception->getMessage(); // Username may only contain letters (a-z) and numbers (0-9)
}

// Obter todos os motivos de falha na validação
try {
    $usernameValidator->setName('Username')->assert('alg  anet');
} catch (ValidationException $exception) {
    echo $exception->getFullMessage();
    // Será impresso
    // -  Username must satisfy the following rules
    //     - Username may only contain letters (a-z) and numbers (0-9)
    //     - Username must not contain whitespace

    var_export($exception->getMessages());
    // Será impresso
    // array (
    //   'alnum' => 'Username may only contain letters (a-z) and numbers (0-9)',
    //   'noWhitespace' => 'Username must not contain whitespace',
    // )
}

// Mensagens de erro personalizadas
try {
    $usernameValidator->setName('Username')->assert('alg  anet');
} catch (ValidationException $exception) {
    var_export($exception->getMessages([
        'alnum' => 'Username may only contain letters and numbers',
        'noWhitespace' => 'Username must not contain spaces',
        'length' => 'length satisfies the rule, so this will not be shown'
    ]));
    // Será impresso 
    // array(
    //    'alnum' => 'Username may only contain letters and numbers',
    //    'noWhitespace' => 'Username must not contain spaces'
    // )
}

// Validar objeto
$user = new stdClass;
$user->name = 'Alexandre';
$user->birthdate = '1987-07-01';
$userValidator = v::attribute('name', v::stringType()->length(1, 32))
                ->attribute('birthdate', v::date()->minAge(18));
$userValidator->validate($user); // true

// Validar array
$data = [
    'parentKey' => [
        'field1' => 'value1',
        'field2' => 'value2'
        'field3' => true,
    ]
];
v::key(
    'parentKey',
    v::key('field1', v::stringType())
        ->key('field2', v::stringType())
        ->key('field3', v::boolType())
    )
    ->assert($data); // Também pode usar check() ou validate()

// Validação opcional
v::alpha()->validate(''); // false 
v::alpha()->validate(null); // false 
v::optional(v::alpha())->validate(''); // true
v::optional(v::alpha())->validate(null); // true

// Regra de negação
v::not(v::intVal())->validate(10); // false

Diferença entre os métodos do Validador validate() check() assert()

validate() retorna boolean, não lança exceção

check() lança exceção em falha de validação; obtém o primeiro motivo de falha via $exception->getMessage()

assert() lança exceção em falha de validação; obtém todos os motivos de falha via $exception->getFullMessage()

Regras de Validação Comuns

Alnum() Apenas letras e números

Alpha() Apenas letras

ArrayType() Tipo array

Between(mixed $minimum, mixed $maximum) Valida que a entrada está entre dois valores.

BoolType() Valida tipo boolean

Contains(mixed $expectedValue) Valida que a entrada contém certo valor

ContainsAny(array $needles) Valida que a entrada contém pelo menos um valor definido

Digit() Valida que a entrada contém apenas dígitos

Domain() Valida nome de domínio válido

Email() Valida endereço de e-mail válido

Extension(string $extension) Valida extensão de arquivo

FloatType() Valida tipo float

IntType() Valida tipo inteiro

Ip() Valida endereço IP

Json() Valida dados JSON

Length(int $min, int $max) Valida que o comprimento está dentro do intervalo

LessThan(mixed $compareTo) Valida que o comprimento é menor que o valor fornecido

Lowercase() Valida minúsculas

MacAddress() Valida endereço MAC

NotEmpty() Valida não vazio

NullType() Valida null

Number() Valida número

ObjectType() Valida tipo objeto

StringType() Valida tipo string

Url() Valida URL

Consulte https://respect-validation.readthedocs.io/en/2.0/list-of-rules/ para mais regras de validação.

Mais

Visite https://respect-validation.readthedocs.io/en/2.0/