How do I add a global scope for dynamic belongsToMany relationships

php
// User.php
class User extends Model
{
    protected static function booted()
    {
        static::addGlobalScope('latestRole', function (Builder $query) {
            $query->with(['roles' => function ($query) {
                $query->latest('pivot.created_at')->take(1);
            }]);
        });
    }

    public function roles()
    {
        return $this->belongsToMany(Role::class)
            ->withPivot('created_at')
            ->withTimestamps();
    }
}

// In your controller
$users = User::all();

foreach ($users as $user) {
    $latestRole = $user->roles->first();
    // Access the latest role for each user
}

In this example, we're adding a global scope to the `User` model that eager loads the latest role for each user.

Here's how it works:

1. In the `booted()` method, we use the `addGlobalScope()` method to add a new global scope called `'latestRole'`.
2. The global scope is a closure that takes a `$query` parameter, which is the query builder instance.
3. Inside the closure, we use the `with()` method to eager load the `roles` relationship, but we also add a constraint to only load the latest role for each user.
4. We use the `latest()` method on the pivot table's `created_at` column to order the roles by the latest assignment, and the `take(1)` method to only load the latest role.
5. In the `roles()` method, we define the `belongsToMany` relationship between the `User` and `Role` models, using the `withPivot()` and `withTimestamps()` methods to include the pivot table columns in the relationship.
6. In the controller, we simply call `User::all()` to fetch all users, and the global scope will automatically eager load the latest role for each user.
7. We can then access the latest role for each user by calling the `roles` property on the `User` model instances, and taking the first (and only) result.

This approach allows you to dynamically load the latest role for each user, without having to perform additional queries. The global scope is executed efficiently within the main query, reducing the number of database calls.

You can apply a similar technique to other types of dynamic relationships, such as `hasMany` or `hasOne`. The key is to use a global scope to eager load the relevant related records based on your specific requirements.