Validator::validOrFail() - Returns validated value(s) ...or fails with an Exception.

[camya]

Idea:

Validator::validOrFail() - Returns the validated value on success, throws an Exception on error.

Example:

$uuid = Validator::validOrFail($uuid, 'uuid|exists:users,uuid', Response::HTTP_BAD_REQUEST);

• Shortcut to validate value(s). Throws the assigned exception on failure.
• Primary for validation of essential input parameters in an HTTP API endpoint or a Livewire Action.
• Stops on the first error by default. (stopOnFirstFailure)
• Returns validated value(s) on success.
• Validation error(s) are stored in the exception message.
• Option to set exception via HTTP Status code (e.g. 400) or exception class name (default: Exception::class).

// API endpoint
public function updateUser(string $uuid): string
{
    $validatedUuid = Validator::validOrFail($uuid, 'uuid|exists:users,uuid', Response::HTTP_BAD_REQUEST);

     // ... Only reaches this point if validation is successful. Otherwise an exception was thrown.

    return $validatedUuid;
}

In this case, the submitting user should not get any meaningful error messages as feedback, if the uuid is invalid. The user sees only a "HTTP Status code 400" Error Page.

The developer in DEBUG mode sees the exception which includes the error messages (from $validator->messages()->toJson()).

Heres is how the signature of validOrFail could look like:

Validator::validOrFail(
    mixed $data, 
    array|string $rules,
    int|string $with = Exception::class,
    array|string $messages = [], 
    array|string $customAttributes = [],
)

The default exception thrown by validOrFail() is still the regular Exception. So it's easy to add a try/catch block too.

try {
    $uuid = Validator::validOrFail($uuid, 'uuid|exists:users,uuid');
} catch (Exception $e) {
    // ... so some important things here.
    abort(Response::HTTP_BAD_REQUEST);
}

It's still possible to pass the parameters as an array.

$validated = Validator::validOrFail([
  'uuid' => $uuid,
], [
  'uuid' => [
      'uuid', 
      'exists:users'
  ],
]);

Current workaround without validOrFail(), for example in Livewire

public function updateUser(string $uuid): string
{
  $validator = Validator::make([
      'uuid' => $uuid
  ], [
      'uuid' => [
          'uuid',
          'exists:users',
      ]
  ])->stopOnFirstFailure(true);

  abort_if(
      $validator->fails(),
      Response::HTTP_BAD_REQUEST,
      $validator->messages()->toJson()
  );

  $validated = $validator->validated();

  $validatedUuid = $validated['uuid'];

  // ...

  return $validatedUuid;
}

[camya]

validOrFail() - Userland implementation (hacky code, only to prototype)

Single value validation

$uuid = $this->validOrFail($uuid, 'uuid|exists:users,uuid', Response::HTTP_BAD_REQUEST);

Returns single value or fails with HTTP Response 400

$uuid = $this->validOrFail($uuid, 'uuid|exists:users,uuid');

Returns single value or fails with \Exception

Implementation:

public function validOrFail(
    mixed $data,
    array|string $rules,
    int|string $with = \Exception::class,
    array|string $messages = [],
    array|string $customAttributes = [],
) {

    $returnSingleValue = false;

    if (! is_array($data)) {

        $returnSingleValue = true;

        $data = [$data];
        $rules = [$rules];
        $messages = $messages ? [$messages] : [];
        $customAttributes = $customAttributes ? [$customAttributes] : [];
    }

    $validator = Validator::make($data, $rules, $messages, $customAttributes)->stopOnFirstFailure(true);

    if (is_int($with)) {
        abort_if($validator->fails(), $with, $validator->messages()->toJson());
    } else {
        throw_if($validator->fails(), $with, $validator->messages()->toJson());
    }

    return $returnSingleValue ? $validator->validated()[0] : $validator->validated();
}

Multiple values: It's still possible to pass arrays with multiple values:

$validated = $this->validOrFail([
    'uuid' => $uuid
], [
    'uuid' => [
        'boolean'
    ]
]);

$uuid = $validated['uuid'];

Returns multiple values or fails with \Exception