What is the best approach to handle dependencies in Laravel services with user-specific functionality

Question:

I am building a Laravel application and using services to encapsulate the business logic. I have a UserService class that performs various operations related to a specific user, such as updating the user's profile or retrieving user-specific data.

The question is how to handle the dependency on the User instance within the UserService class. Currently, I have two approaches in mind:

Approach 1: Passing User Argument to the UserService Constructor

In this approach, the UserService constructor accepts a User instance, and the instance is passed to the methods that require user-specific functionality. Here's an example:

namespace App\Services;

use App\Models\User;

class UserService
{
    protected $user;

    public function __construct(User $user)
    {
         $this->user = $user;
     }

     // Methods that use the $user instance
     public function updateUserProfile($data)
     {
         // Perform operations using $this->user
     }

     public function getUserData()
     {
         // Retrieve and process user-specific data using $this->user
     }

     // Other methods...
}

Approach 2: Method Arguments for User Instance

In this approach, the UserService class does not store the User instance internally. Instead, each method expects the User instance as an argument. Here's an example:

namespace App\Services;

use App\Models\User;

class UserService
{
    public function updateUserProfile(User $user, $data)
    {
        // Perform operations using $user
    }

    public function getUserData(User $user)
    {
        // Retrieve and process user-specific data using $user
    }

    // Other methods...
}

Now, I'm seeking advice on the best approach to handle this situation. Here are my problems:

The problems of Approach 1 (Passing User Argument to the UserService Constructor):

(1). I can't use the Laravel service container (type hinting) anymore since the UserService class now expects a User $user argument so I can't do this anymore:

class UserController extends Controller
{
    protected $userService;

    //I can no more do this service container dependency injection  
    
    public function __construct(UserService $userService)
    {
        $this->userService = $userService;
    }

    //...
    //Rest of the controllers' methods
    //...

}

(2). it adds complexity to the Laravel controller: since a controller in Laravel is usually called to perform a decision based on a specific route, it makes sense to use the Request class or request() helper both provided by Laravel. And I thought it makes sense to retrieve the specific User $user that make the request in my laravel controller. But to do this in Laravel you have to interact with the middleware and my controller now looks like this:

class UserController extends Controller
{

    protected UserService $userService;

    public function __construct()
    {
        $this->middleware(function ($request, $next) {
            $this->userSettingsService = new UserService($request->user());
            return $next($request);
        });
    }

    //...
    //Rest of the controllers' methods
    //...
}

The problems of Approach 2 (Method Arguments for User Instance):

(1). it violates the Single Responsibility Principle: If the primary responsibility of the UserService is to perform operations specifically related to a single User, would it make sense to include the User argument in the constructor?

So Laravel experts what is your opinion on this?