How to make EntityManager's flush method to flush only certain entity instances?

[MiguelAlcaino]

Hi!
My issue is that EntityManager's flush method is writing in the database all the operations buffered by the persist method. No problem with that, BUT sometimes changes get written in other context (deeper layers of my symfony app) without me knowing about it. Let me show you an example:

class ServiceA{
   public function __construct(private UserRepository $userRepository, EntityManagerInterface $em){}
   
   public function foo(){
      $user = $this->userRepository->find(1);
      $user->setName('newName');
      $this->em->persist($user);
      $this->em->flush();
   }
}

class ServiceB{
    public function __construct(
        private VisitRepository $visitRepository,
        private ServiceA $serviceA,
        private EntityManagerInteface $em
    ){}

    public function bar(){
        $visit = $this->visitRepository->find(2);
        $visit->setSomething(2);
        $this->visitRepository->persist($visit);
        $this->serviceA->foo(); // Inside here the previous persisted instances in this context got flushed by the EntityManager's flush method.

        $this->em->flush(); // In here there's nothing to flush because $visit got flushed inside ServiceA's foo method.
    }
}

The EntityManager flushes everything, then my problem is that sometimes deep services are flushing changes done in other layers of my app without me noticing. So far it has not been a problem for me, but I can see a design problem here (on my side).

How do you tackle this issue? Do you have any design idea to apply to sort this out. Or, is there any way to wrap only certain operations within the flush method so it only writes in the DB the operations of the context?

Ideally I would like to have this behaviour in the previous code:

class ServiceB{
...
public function bar(){
        $visit = $this->visitRepository->find(2);
        $visit->setSomething(2);
        $this->visitRepository->persist($visit);
        $this->serviceA->foo(); // if this flushes something inside it should only flush entities in ServiceA's context

        $this->em->flush(); // it only flushes $visit
    }
...
}

I imagine something like this as a solution to accurate the operations that the Entity flushes:

$otherContextEntityManager->persist($bar);
$entityManagerX->flush(); // Nothing is flushed.
$thisContextEntityManager->persist($something)
$thisContextEntityManager->persist($foo);

$thisContextEntityManager->flush(); // Only $something and $foo get written in the DB

$otherContextEntityManager->persist($james);
$otherContextEntityManager->flush(); // Only $bar and $james get written in the DB.

Maybe to make some EntityManager as a not shared service?

[leberknecht]

Side-note: you only have to call persist when you create new records. When you fetch something from the DB (so the entity is "managed" by the em) and change a property, the em will automatically recognize that there is a diff that needs to be written to the DB when you call flush.

For your problem: you can access the Unit-of-work (which contains all pending operations) via $entityManager->getUnitOfWork() and you can manipulate it. So you could go the other way around and "remove everything i do not want to persist"...which has a super high chance to end up in complex problems. As long as you go with a "i dont change properties of entities that i do not want to have on the DB", it never became a problem for me that flush flushes everything.. Some long time ago flush accepted a parameter to specify the scope though.

Guess thats a semi-helpful answer, sorry for that :/