Better way to create objects with dependencies in PHP

I am currently working on a PHP project where I need to create objects of a class RelevantClass. I am using Dependency Injection via DI Container.

Underlying Structure

Let's suppose I have the following class structure:

class SomeServiceClass {
   
}

class EntityClass {

}

class RelevantClass {

    /**
    * @Inject
    */
    private SomeServiceClass $service

    public function __construct(EntityClass $entity){
        $this->service = inject(SomeServiceClass::class)
        $this->entity = $entity;
    }

    public function someMethod() : void
    {
        ...
        $this->service->doSomething($this->entity);
        $this->entity->doSomething();
        ...
    }
}

The issue here is that my EntityClassObject needs to be modified by my RelevantClass, as in I can't pass in an injected instance of EntityClass into the constructor of RelevantClass.

The Service class includes some helper methods and other functionality, so it can be injected directly.

Now my question is, how should I instantiate my RelevantClass class?

Approach 1

The way it works right now is that I simply call the constructor:

$entity = ... # Getting the entity from the database

$relevantObject = RelevantClass($entity); # here my service is instantiated by explicitly calling the di container

$relevantObject->someMethod();

That way, my Service is set by the constructor via injection container and my entity is passed through the constructor argument.

Approach 2

Although it is working, I am wondering if it were better practice if I structured my RelevantClass in a way that allows me to instantiate it via DI Container, too?

$entity = ... # Getting the entity from the database

$relevantObject = inject(RelevantClass::class); # this would inject my service class as well
$relevantObject->setEntity($entity);
$relevantObject->someMethod();

Briefly summed up, someMethod needs SomeServiceClass to perform some operations on an EntityClass instance. SomeServiceClass can be injected, while EntityClass cannot.

What is the way to go here? I am aware that both approaches woudl work, but which one of them would be best practice? The project I am currently working on barely uses the constructor to instantiate classes, so I am wondering, whether there are any inherent advantages to the second approach?