@calebdw you will probably have a good starting point on this

i suspect this is the related PR...

#54452

You need the generics on the input parameter:

/**
 * @param Builder<static> $query
 * @return Builder<static>
 */
public function scopeSearch(Builder $query, ?string $search = null): Builder
{
	return $query->whereHas('user', static function (Builder $query) use ($search): void {
		$query->search($search);
	});
}

Hi,

I did that but now it says this:

Call to an undefined method Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>::search().

I have a Larastan PR to be able to detect the dynamic generic type: larastan/larastan#2048

It hasn't been merged yet but I've also published it on my fork if you'd like to check it out: https://github.com/calebdw/larastan

A few more notes:

• your type hint of Builder<static> inside the whereHas('user', ...) is incorrect---this is going to have type Builder<User> (whatever the specific model is)
• parameter types are contravarient---that means you can only widen, not narrow---which is why you see the native type PHPStan warning. In this case that's fine to do so but you'll need to manually ignore the warning if you choose to
• the linked PR ([11.x] feat: add better closure typing in QueriesRelationships #54452) takes advantage of relationships that are passed to the method and can figure out the proper inner generics. If you pass strings then there's no way to determine what the inner type is without the Larastan PR ([3.x] feat: support dynamic relation closures larastan/larastan#2048)

All that said, something like this should work out of the box

/**
 * @param Builder<static> $query
 * @return Builder<static>
 */
public function scopeSearch(Builder $query, ?string $search = null): Builder
{
    $user = $query->getModel()->user();

    return $query->whereHas($user, fn ($q) => $q->search($search));
}

Hi,

I'll try it out later today and let you know.. thx!

HI,

I tried the second approach that you mentioned and I managed to fix most of the problems. However, morph relations are still a problem.

Given the example:

public function item(): MorphTo
{
	return $this->morphTo();
}

public function scopeAvailable(Builder $query): Builder
{
	/**
	 * @var Builder<static> $query
	 */
	return $query->whereHas($query->getModel()->item(), static function (Builder $query): void {
		$query->available();
	});
}

scopeAvailable also exists on all morphed models via item relation. PHPstan returns this:

Call to an undefined method Illuminate\Database\Eloquent\Builder<Illuminate\Database\Eloquent\Model>::available().

It's the same when Builder generic is typed as a function input param.

MorphTo is inherently dynamic and there's no way to safely know what model is being returned. If you only have a few models then you could do something like:

/** @return MorphTo<Model1|Model2> */
public function item(): MorphTo
{
    return $this->morphTo();
}

however, you will have to manually ignore the warning that is produced by doing so.

You might have better mileage using the where*Morph* methods:

return $query->whereHasMorph($query->getModel()->item(), [Model1::class, Model2::class], static function (Builder $query): void {
    $query->available();
});

This however, will require the Larastan PR (or my fork) to be able to properly detect the builder type.

This is not a framework issue, but just has to do with properly typing the generics in your code. This issue can be closed but feel free to open discussions at the Larastan repo if you have more questions---I'm happy to help 😃

Thanks for the explanation. So you're saying that there's no way to properly type morphs for now?
I mean I could type all possible models as you said but that's not a solution for this.
I want to be able to properly type relations and not to worry about forgotten model typings on morph definitions.

Morphs are dynamic...how can you know what model it is and that is has the scope you're trying to call?

You can always just manually ignore the PHPStan warning with @phpstan-ignore