Casting of models resolved through a relationship

[ahmes]

TL;DR

I would like to define a way for a whole model to be casted to a scalar/object, etc. Similar to an attribute.

Long version

Let's say we have two tables users and a reviews:

	users table
id	int

	reviews table
id	int
user_id	int
starts	float

And we have 2 models:

class User extends \Illuminate\Database\Eloquent\Model
{
    protected $table = 'users';

    protected $casts = [
        'id' => 'int',
    ];

    public function reviews()
    {
        return $this->hasMany(Review::class);
    }
}

and

class Review extends \Illuminate\Database\Eloquent\Model
{
    protected $table = 'reviews';

    protected $casts = [
        'id' => 'int',
        'user_id' => 'int',
        'starts' => 'float',
    ];
}

I would like to get multiple users at one, while also calculating their rating.

I have considered adding an accessor:

public function getRatingAttribute()
{
    return $this->reviews()->average('stars');
}

but it will generate one query ($this->reviews()->average('stars')) for each user. Looking at the accessor documentation it seems that an accessor is something to transform an existing value. on a model (and not a computed value, as i am considering).

Since calculating a rating is a data crunching issue, for which a database is uniquely suited, i can calculate all the ratings for all users like so:

select
    user_id,
    round(avg(reviews.num_stars), 2) as rating
from reviews
    group by user_id;

And the php class equivalent of this sql is (in my humble opinion)

class RatingAttribute extends \Illuminate\Database\Eloquent\Model
{
    protected $table = 'reviews';

    protected $casts = [
        'user_id' => 'int',
        'rating' => 'float',
    ];

    public static function booted()
    {
        static::addGlobalScope('rating', function (Builder $query) {
            $query
                ->groupBy('user_id')
                ->addSelect([
                    'user_id',
                    DB::raw('round(avg(reviews.num_stars), 2) as rating'),
                ]);
        });
    }
}

and i can add this as a relationship on the User::class:

public function rating()
{
    return $this->hasOne(RatingAttribute::class);
}

So that i can get the rating (which is like a "computed" field of the User::class):

User::first()->rating; // lazy load
User::with('rating')->take(100)->get()->each(fn($user) => $user->rating->rating); // eager load

Looking at the documentation a model:

• an object-relational mapper (ORM) that makes it enjoyable to interact with your database (which i need in the RatingAttribute::class)
• is used to interact with that table (which i DO NOT need in the RatingAttribute::class)

I see no need to have a 1:1 for each model to have a corresponding table.

I would like to define a model as being castable when it's resolved as a relationship:

class RatingAttribute extends \Illuminate\Database\Eloquent\Model implements Castable
{
    protected $casts = [
        'user_id' => 'int',
        'rating' => 'float',
    ];

    public function toCast()
    {
        return $this->rating;
    }
}

[Martleby]

What I do for these sorts of "stats" type relationships is create a database view and add a model over it, setting the relationships as appropriate. You can use migrations to manage those views, but you tend to need to create/manage them as statements in the sql of your database, so you lose the DB agnostic nature of Laravel (not a problem in my case).

Another option might be a subquery join on a self-join of the user in the user model.

[ahmes]

Hi @Martleby , thank you for taking the time to look into this.

A sql view for calculating a rating is probably YAGNI at the moment. SQL views are ideal for reusing complex queries and abstracting away that complexity. However calculating a rating is not something that needs to be abstracted.

Using a join is certainly ok to do as an one off thing. But, if done more than once, in multiple places it need to take a "reusable form".

---

If you think about it in a more abstract manner, in the data layer you have:

• models that are based on tables and their respective tables
• data derived/computed from other data (such as a the rating in the simplified example)
• models based on derived tables (sql views)

☝️ all of these are small reusable parts that should be "as props" on a model available to be reused by other components

---

On another note, the example above with creating a model that creates one or more attributes seems to be a legitimate use of the classes in the eloquent namespace. But, since they are attributes (as in a rating is scalar attribute of some model) i am proposing that models retrieved through a relationship can be casted to a scalar or some other type of object. This can enable a whole range of new ways of building stuff.