[11.x] Added ModelExists rule

[pascalbaljet]

There is an exists rule to check the existence of a record in the database. You can already pass an Eloquent Model class as the table argument in the Rule::exists() method, but that just extracts the table and connection from the Model. You can apply additional constraints by chaining the where() method, but under the hood, it uses the Illuminate\Database\Query\Builder, not the Illuminate\Database\Eloquent\Builder, so you can't use scopes, for instance.

What we have found in our application is that we are repeating code by writing exists rules and reimplementing the constraints for which we actually already have scopes defined.

This new Rule::modelExists() rule lets you use scopes and other Eloquent Builder features:

Rule::modelExists(User::class)->active()->admin();

By default, it checks the model key (using whereKey()), but you can change that with the optional second argument:

Rule::modelExists(User::class, 'email');

Besides the Model class string, you can also pass a Builder or Model instance:

Rule::modelExists(new User);
Rule::modelExists(User::query()->active());

[Sairahcaz]

Would be super awesome if that one gets merged!

[onlime]

yes, that would be super awesome, indeed!

@pascalbaljet has developed this in my project and we're already using it in a lot of FormRequests, greatly streamlining our codebase. Was looking for this for a long time, as it never felt clean/Laravel-ish to use the In rule as workaround.
I am super happy about this clean and simple implementation. 👏

[Sairahcaz]

The topic has also been discussed a little bit here:
#49831

[newtonjob]

Would really be nice to have!

Shouldn't this ideally go together with the sister ModelUnique rule though?

Also, I'd have loved to see this use the current Rule::exists() signature and intelligently return the proper underlying rule class, based on whether a model class string was passed or not.

[onlime]

@newtonjob

Also, I'd have loved to see this use the current Rule::exists() signature and intelligently return the proper underlying rule class, based on whether a model class string was passed or not.

yes, that would be nice, but it would be a BC break, as Rule::exists() already accepted a model class string and resolved it to the table name (DatabaseRule trait's constructor). So if Rule::exist() would suddenly return the new ModelExists, this would probably not make it into L11.

[pascalbaljet]

Would really be nice to have!

Shouldn't this ideally go together with the sister ModelUnique rule though?

If this PR gets merged, I could do a follow-up PR for a unique equivalent.

Also, I'd have loved to see this use the current Rule::exists() signature and intelligently return the proper underlying rule class, based on whether a model class string was passed or not.

You can already pass a class string to Rule::exists(), which extracts the connection and table from the Model. In some cases, it preserves the class string (for example, when the table is prefixed). Of course I first thought about extending the existing rule, but under the hood, it uses the DatabasePresenceVerifier, which then uses the Illuminate\Database\Query\Builder. It is definitely possible to overcome all of this, but I found it cleaner to create a new rule specifically for Eloquent Models and the Eloquent Builder.

[taylorotwell]

I don't mind this as a concept, but Rule::modelExists is just not the Laravel way. 😔 In my opinion we should adjust Rule::exists in Laravel 12.x.

There could be a way to kinda hack it into Laravel 11.x by using named arguments like Rule::exists(model: Foo::class).

[taylorotwell]

Drafting this for now - mark as ready for review if you make any adjustments noted above.

[Neol3108]

Should this not also be added here?

framework/src/Illuminate/Validation/Validator.php

Line 842 in 81a0b5b

return in_array($rule, ['Unique', 'Exists']) ? ! $this->messages->has($attribute) : true;

[siarheipashkevich]

What about relations?

[pascalbaljet]

It uses the Builder contract (Illuminate\Contracts\Database\Eloquent\Builder) which is implemented by all relation classes.

[siarheipashkevich]

What do you think for adding "optimization" for array validation to avoid many requests to the DB?

For example: 'users.*' => Rule::modelExists($account->users())->many()

when we are calling ->many() method from validation rule then we will get an array of the keys and save the result to the variable, and when validation will running we will check the stored result with the given value...

[siarheipashkevich]

I've implemented the same validation rule in my project, but will happy if it will be exists in the Laravel:

<?php

namespace App\Validation\Rules;

use Closure;
use Illuminate\Contracts\Database\Query\Builder;
use Illuminate\Contracts\Validation\ValidationRule;
use Illuminate\Translation\PotentiallyTranslatedString;

class ModelExists implements ValidationRule
{
    protected bool $many = false;

    protected array $modelIds = [];

    public function __construct(protected Builder $modelQuery, protected $withTrashed = false) {}

    public function many(): self
    {
        $this->many = true;

        $this->modelIds = $this->resolveModelQuery()->pluck('id')->all();

        return $this;
    }

    /**
     * @param Closure(string): PotentiallyTranslatedString $fail
     */
    public function validate(string $attribute, mixed $value, Closure $fail): void
    {
        if (!$this->passed($value)) {
            $fail('validation.exists')->translate();
        }
    }

    protected function passed(mixed $value): bool
    {
        return $this->many
            ? in_array($value, $this->modelIds)
            : $this->resolveModelQuery()->whereKey($value)->exists();
    }

    protected function resolveModelQuery(): Builder
    {
        return $this->modelQuery->when($this->withTrashed, fn (Builder $query) => $query->withTrashed())
            ->clone();
    }
}

[siarheipashkevich]

I think you can remove ['attribute' => $attribute] and leave only ->translate()

[pascalbaljet]

I don't mind this as a concept, but Rule::modelExists is just not the Laravel way. 😔 In my opinion we should adjust Rule::exists in Laravel 12.x.

There could be a way to kinda hack it into Laravel 11.x by using named arguments like Rule::exists(model: Foo::class).

I'll refactor it to use named arguments first, and if you're not happy with it, I can always rework it for Laravel 12 :)