Entity enfants supprimé losr du Flush

Bonjour,

Dans une boucle j'appel une API pour récupérer une liste d'éléments et les enfants de cette liste.

                        foreach ($listes as $liste) {
                            $listesDTO = new DocuwareListeDTO();
                            $return = $this->docuware->getDocumentForListe($liste["file_cabinet_id"],true);

                            foreach ($return as $docDTO) {
                                $listesDTO->listeDocument->add($docDTO);
                            }
                            if ($log) {
                                $message = "\r\nDes documents ont trouvés";
                                $output->writeln($message);

                                $message = "\r\nDébut de synchronisation des documents";
                                $output->writeln($message);
                            }

                            // TODO : Call méthode SyncFile save $liste["file_cabinet_id"]
                            $this->syncFileDocuware->loadAndSaveFile($log, $listesDTO, $path, $liste["file_cabinet_id"]);
                        }

La méthode loadAnsSaveFile

 public function loadAndSaveFile(bool $log, DocuwareListeDTO $listesDTO, string $path, string $fileCabinetId)
    {

        $directoryPath = $path . '/extranet/' . $fileCabinetId . '/';

        // Vérifier si le répertoire existe déjà
        if (!is_dir($directoryPath)) {
            // Créer le répertoire
            mkdir($directoryPath, 0777, true);
            if ($log) {
                echo "\r\nRépertoire créé avec succès.";
            }
        }
        $listeDocuments = $listesDTO->listeDocument;
        foreach ($listeDocuments as $listeDocument) {
            /** @var  \App\DTO\DocumentDTO $document*/
            foreach ($listeDocument as $document) {

                try {
                    $listeColonnes = new \Doctrine\Common\Collections\ArrayCollection($document->colonnes->toArray());
                    $this->saveData($document, $listeColonnes, $fileCabinetId);

                    $content = $this->docuware->getDocument($document->id, $fileCabinetId);
                    $directoryPathC = $path . '/crypte/' . $fileCabinetId . '/';
                    $directoryPathCrypte = $path . '/crypte/' . $fileCabinetId . '/' . $document->id . '.' . $document->extention;

                    if (!is_dir($directoryPathC)) {
                        // Créer le répertoire
                        mkdir($directoryPathC, 0777, true);
                        if ($log) {
                            echo "\r\nRépertoire créé avec succès.";
                        }
                    }
                    // Chemin complet du fichier sur le serveur
                    $documentPath = $directoryPath  . $document->id . '.' . $document->extention;

                    // Sauvegarde du contenu dans le fichier
                    $result = file_put_contents($documentPath, $content);
                    $this->crypte_fichier($documentPath, $_ENV['AUTO_HEBERGER_SECRET'], $directoryPathCrypte);
                    //$this->decrypte_file($directoryPathCrypte, 'azerty',$documentPath);

                    // Vérification si la sauvegarde a réussi
                    if ($result !== false) {
                        // La sauvegarde a réussi
                        if ($log) {
                            echo "\r\nSauvegarde : " . $documentPath;
                        }
                    } else {
                        // La sauvegarde a échoué
                        if ($log) {
                            echo "\r\nErreur de sauvegarde du fichier : " . $documentPath;
                        }
                    }
                } catch (Exception $ex) {
                    if ($log) {
                        echo $ex;
                    }
                }
            }
        }
        $this->entityManager ->flush();
    }

Ma méthode saveData

 public function saveData(DocumentDTO $object, ArrayCollection $listeColonne, string $fileCabinetId)
    {
        $fileDocument = $this->moduleSynchronisationRepository->findByIdAndFileCabinet($object->id, $fileCabinetId);

        $parsed = $this->commun->get_string_between($object->DWSTOREDATETIME, '(', ')');
        $parsed = preg_replace("/000/", "", $parsed, 1);
        $create = date('d-m-Y H:i:s', $parsed);

        $parsed = $this->commun->get_string_between($object->DWMODDATETIME, '(', ')');
        $parsed = preg_replace("/000/", "", $parsed, 1);
        $modify = date('d-m-Y H:i:s', $parsed);
        $validUntilCreate = new DateTimeImmutable($create);
        $validUntilModify = new DateTimeImmutable($modify);

        if (null === $fileDocument) {
            $fileDocument = new Module_Synchronisation();
        }
        $fileDocument
            ->setFileCabinetId($fileCabinetId)
            ->setIdDocument($object->id)
            ->setExtension($object->extention)
            ->setNumero($object->numero)
            ->setTaille($object->DWDOCSIZE)
            ->setNbpage($object->DWPAGECOUNT)
            ->setDateCreer($validUntilCreate)
            ->setDateSModifier($validUntilModify)
            ->setLien('/' . $fileCabinetId . '/' . $object->id . '.' . $object->extention);

        foreach ($listeColonne as $col) {
            $colonne_sync = $this->moduleSynchronisationColonneRepository->findOneBy(['name' => $col->name, 'module_Synchronisation' => $fileCabinetId],null,null,null);

            if(null === $colonne_sync)
            {
                $colonne_sync = new Module_Synchronisation_Colonne();
                $fileDocument->addModuleSynchronisationColonne($colonne_sync);
            }
            $colonne_sync->setName($col->name);
            $colonne_sync->setValue($col->value);
            $this->entityManager ->persist($colonne_sync);
        }
    }

Mes deux relations enfants parents

class Module_Synchronisation_Colonne
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255)]
    private ?string $name = null;

    #[ORM\Column(length: 4000)]
    private ?string $value = null;

    #[ORM\ManyToOne(inversedBy: 'moduleSynchronisationColonnes', cascade: ["persist", "remove"])]
    #[ORM\JoinColumn(onDelete:"CASCADE")]
    private ?Module_Synchronisation $module_Synchronisation = null;

class Module_Synchronisation
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column]
    private ?int $idDocument = null;

    #[ORM\Column(length: 4000)]
    private ?string $lien = null;

    #[ORM\Column(length: 15)]
    private ?string $extension = null;

    #[ORM\Column(length: 255)]
    private ?string $numero = null;

    #[ORM\Column(length: 255)]
    private ?string $fileCabinetId = null;

    #[ORM\Column]
    private ?int $taille = null;

    #[ORM\Column]
    private ?int $nbpage = null;

    #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
    private ?\DateTimeInterface $dateCreer = null;

    #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
    private ?\DateTimeInterface $dateSModifier = null;

    #[ORM\OneToMany(mappedBy: 'module_Synchronisation', targetEntity: Module_Synchronisation_Colonne::class, cascade: ['persist', 'remove'])]
    private Collection $moduleSynchronisationColonnes;

Ce que je veux

C'est que pour chaque boucle d'origine est d'enregistrer le parent et les enfants

Ce que j'obtiens

Le souci c'est que l'iétration suivante dans ma boucle supprime les entitées enfants de l'éléments de la boucle précédente :(